binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2018 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #include <zlib.h>
  47 #ifdef HAVE_WCHAR_H
  48 #include <wchar.h>
  49 #endif
  50
  51 #if __GNUC__ >= 2
  52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  53    as this will allow us to read in and parse 64bit and 32bit ELF files.
  54    Only do this if we believe that the compiler can support a 64 bit
  55    data type.  For now we only rely on GCC being able to do this.  */
  56 #define BFD64
  57 #endif
  58
  59 #include "bfd.h"
  60 #include "bucomm.h"
  61 #include "elfcomm.h"
  62 #include "dwarf.h"
  63
  64 #include "elf/common.h"
  65 #include "elf/external.h"
  66 #include "elf/internal.h"
  67
  68
  69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  70    we can obtain the H8 reloc numbers.  We need these for the
  71    get_reloc_size() function.  We include h8.h again after defining
  72    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  73
  74 #include "elf/h8.h"
  75 #undef _ELF_H8_H
  76
  77 /* Undo the effects of #including reloc-macros.h.  */
  78
  79 #undef START_RELOC_NUMBERS
  80 #undef RELOC_NUMBER
  81 #undef FAKE_RELOC
  82 #undef EMPTY_RELOC
  83 #undef END_RELOC_NUMBERS
  84 #undef _RELOC_MACROS_H
  85
  86 /* The following headers use the elf/reloc-macros.h file to
  87    automatically generate relocation recognition functions
  88    such as elf_mips_reloc_type()  */
  89
  90 #define RELOC_MACROS_GEN_FUNC
  91
  92 #include "elf/aarch64.h"
  93 #include "elf/alpha.h"
  94 #include "elf/arc.h"
  95 #include "elf/arm.h"
  96 #include "elf/avr.h"
  97 #include "elf/bfin.h"
  98 #include "elf/cr16.h"
  99 #include "elf/cris.h"
 100 #include "elf/crx.h"
 101 #include "elf/d10v.h"
 102 #include "elf/d30v.h"
 103 #include "elf/dlx.h"
 104 #include "elf/epiphany.h"
 105 #include "elf/fr30.h"
 106 #include "elf/frv.h"
 107 #include "elf/ft32.h"
 108 #include "elf/h8.h"
 109 #include "elf/hppa.h"
 110 #include "elf/i386.h"
 111 #include "elf/i370.h"
 112 #include "elf/i860.h"
 113 #include "elf/i960.h"
 114 #include "elf/ia64.h"
 115 #include "elf/ip2k.h"
 116 #include "elf/lm32.h"
 117 #include "elf/iq2000.h"
 118 #include "elf/m32c.h"
 119 #include "elf/m32r.h"
 120 #include "elf/m68k.h"
 121 #include "elf/m68hc11.h"
 122 #include "elf/s12z.h"
 123 #include "elf/mcore.h"
 124 #include "elf/mep.h"
 125 #include "elf/metag.h"
 126 #include "elf/microblaze.h"
 127 #include "elf/mips.h"
 128 #include "elf/mmix.h"
 129 #include "elf/mn10200.h"
 130 #include "elf/mn10300.h"
 131 #include "elf/moxie.h"
 132 #include "elf/mt.h"
 133 #include "elf/msp430.h"
 134 #include "elf/nds32.h"
 135 #include "elf/nfp.h"
 136 #include "elf/nios2.h"
 137 #include "elf/or1k.h"
 138 #include "elf/pj.h"
 139 #include "elf/ppc.h"
 140 #include "elf/ppc64.h"
 141 #include "elf/pru.h"
 142 #include "elf/riscv.h"
 143 #include "elf/rl78.h"
 144 #include "elf/rx.h"
 145 #include "elf/s390.h"
 146 #include "elf/score.h"
 147 #include "elf/sh.h"
 148 #include "elf/sparc.h"
 149 #include "elf/spu.h"
 150 #include "elf/tic6x.h"
 151 #include "elf/tilegx.h"
 152 #include "elf/tilepro.h"
 153 #include "elf/v850.h"
 154 #include "elf/vax.h"
 155 #include "elf/visium.h"
 156 #include "elf/wasm32.h"
 157 #include "elf/x86-64.h"
 158 #include "elf/xc16x.h"
 159 #include "elf/xgate.h"
 160 #include "elf/xstormy16.h"
 161 #include "elf/xtensa.h"
 162
 163 #include "getopt.h"
 164 #include "libiberty.h"
 165 #include "safe-ctype.h"
 166 #include "filenames.h"
 167
 168 #ifndef offsetof
 169 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 170 #endif
 171
 172 typedef struct elf_section_list
 173 {
 174   Elf_Internal_Shdr *        hdr;
 175   struct elf_section_list *  next;
 176 } elf_section_list;
 177
 178 /* Flag bits indicating particular types of dump.  */
 179 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 180 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 181 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 182 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 183 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 184
 185 typedef unsigned char dump_type;
 186
 187 /* A linked list of the section names for which dumps were requested.  */
 188 struct dump_list_entry
 189 {
 190   char *                    name;
 191   dump_type                 type;
 192   struct dump_list_entry *  next;
 193 };
 194
 195 typedef struct filedata
 196 {
 197   const char *         file_name;
 198   FILE *               handle;
 199   bfd_size_type        file_size;
 200   Elf_Internal_Ehdr    file_header;
 201   Elf_Internal_Shdr *  section_headers;
 202   Elf_Internal_Phdr *  program_headers;
 203   char *               string_table;
 204   unsigned long        string_table_length;
 205   /* A dynamic array of flags indicating for which sections a dump of
 206      some kind has been requested.  It is reset on a per-object file
 207      basis and then initialised from the cmdline_dump_sects array,
 208      the results of interpreting the -w switch, and the
 209      dump_sects_byname list.  */
 210   dump_type *          dump_sects;
 211   unsigned int         num_dump_sects;
 212 } Filedata;
 213
 214 char * program_name = "readelf";
 215
 216 static unsigned long archive_file_offset;
 217 static unsigned long archive_file_size;
 218 static unsigned long dynamic_addr;
 219 static bfd_size_type dynamic_size;
 220 static size_t dynamic_nent;
 221 static char * dynamic_strings;
 222 static unsigned long dynamic_strings_length;
 223 static unsigned long num_dynamic_syms;
 224 static Elf_Internal_Sym * dynamic_symbols;
 225 static Elf_Internal_Syminfo * dynamic_syminfo;
 226 static unsigned long dynamic_syminfo_offset;
 227 static unsigned int dynamic_syminfo_nent;
 228 static char program_interpreter[PATH_MAX];
 229 static bfd_vma dynamic_info[DT_ENCODING];
 230 static bfd_vma dynamic_info_DT_GNU_HASH;
 231 static bfd_vma version_info[16];
 232 static Elf_Internal_Dyn *  dynamic_section;
 233 static elf_section_list * symtab_shndx_list;
 234 static bfd_boolean show_name = FALSE;
 235 static bfd_boolean do_dynamic = FALSE;
 236 static bfd_boolean do_syms = FALSE;
 237 static bfd_boolean do_dyn_syms = FALSE;
 238 static bfd_boolean do_reloc = FALSE;
 239 static bfd_boolean do_sections = FALSE;
 240 static bfd_boolean do_section_groups = FALSE;
 241 static bfd_boolean do_section_details = FALSE;
 242 static bfd_boolean do_segments = FALSE;
 243 static bfd_boolean do_unwind = FALSE;
 244 static bfd_boolean do_using_dynamic = FALSE;
 245 static bfd_boolean do_header = FALSE;
 246 static bfd_boolean do_dump = FALSE;
 247 static bfd_boolean do_version = FALSE;
 248 static bfd_boolean do_histogram = FALSE;
 249 static bfd_boolean do_debugging = FALSE;
 250 static bfd_boolean do_arch = FALSE;
 251 static bfd_boolean do_notes = FALSE;
 252 static bfd_boolean do_archive_index = FALSE;
 253 static bfd_boolean is_32bit_elf = FALSE;
 254 static bfd_boolean decompress_dumps = FALSE;
 255
 256 struct group_list
 257 {
 258   struct group_list *  next;
 259   unsigned int         section_index;
 260 };
 261
 262 struct group
 263 {
 264   struct group_list *  root;
 265   unsigned int         group_index;
 266 };
 267
 268 static size_t           group_count;
 269 static struct group *   section_groups;
 270 static struct group **  section_headers_groups;
 271
 272 /* A dynamic array of flags indicating for which sections a dump
 273    has been requested via command line switches.  */
 274 static Filedata         cmdline;
 275
 276 static struct dump_list_entry * dump_sects_byname;
 277
 278 /* How to print a vma value.  */
 279 typedef enum print_mode
 280 {
 281   HEX,
 282   DEC,
 283   DEC_5,
 284   UNSIGNED,
 285   PREFIX_HEX,
 286   FULL_HEX,
 287   LONG_HEX
 288 }
 289 print_mode;
 290
 291 /* Versioned symbol info.  */
 292 enum versioned_symbol_info
 293 {
 294   symbol_undefined,
 295   symbol_hidden,
 296   symbol_public
 297 };
 298
 299 static const char * get_symbol_version_string
 300   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 301    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 302
 303 #define UNKNOWN -1
 304
 305 #define SECTION_NAME(X)                                         \
 306   ((X) == NULL ? _("<none>")                                    \
 307    : filedata->string_table == NULL ? _("<no-strings>")         \
 308    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 309   : filedata->string_table + (X)->sh_name))
 310
 311 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 312
 313 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 314   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 315    : get_64bit_elf_symbols (file, section, sym_count))
 316
 317 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 318 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 319    already been called and verified that the string exists.  */
 320 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 321
 322 #define REMOVE_ARCH_BITS(ADDR)                  \
 323   do                                            \
 324     {                                           \
 325       if (filedata->file_header.e_machine == EM_ARM)    \
 326         (ADDR) &= ~1;                           \
 327     }                                           \
 328   while (0)
 329 \f
 330 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 331    BFD_FMA_FMT can't be used in translated strings.  */
 332
 333 static const char *
 334 bfd_vmatoa (char *fmtch, bfd_vma value)
 335 {
 336   /* bfd_vmatoa is used more then once in a printf call for output.
 337      Cycle through an array of buffers.  */
 338   static int buf_pos = 0;
 339   static struct bfd_vmatoa_buf
 340   {
 341     char place[64];
 342   } buf[4];
 343   char *ret;
 344   char fmt[32];
 345
 346   ret = buf[buf_pos++].place;
 347   buf_pos %= ARRAY_SIZE (buf);
 348
 349   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 350   snprintf (ret, sizeof (buf[0].place), fmt, value);
 351   return ret;
 352 }
 353
 354 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 355    OFFSET + the offset of the current archive member, if we are examining an
 356    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 357    allocate a buffer using malloc and fill that.  In either case return the
 358    pointer to the start of the retrieved data or NULL if something went wrong.
 359    If something does go wrong and REASON is not NULL then emit an error
 360    message using REASON as part of the context.  */
 361
 362 static void *
 363 get_data (void *         var,
 364           Filedata *     filedata,
 365           unsigned long  offset,
 366           bfd_size_type  size,
 367           bfd_size_type  nmemb,
 368           const char *   reason)
 369 {
 370   void * mvar;
 371   bfd_size_type amt = size * nmemb;
 372
 373   if (size == 0 || nmemb == 0)
 374     return NULL;
 375
 376   /* If the size_t type is smaller than the bfd_size_type, eg because
 377      you are building a 32-bit tool on a 64-bit host, then make sure
 378      that when the sizes are cast to (size_t) no information is lost.  */
 379   if (sizeof (size_t) < sizeof (bfd_size_type)
 380       && (   (bfd_size_type) ((size_t) size) != size
 381           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 382     {
 383       if (reason)
 384         error (_("Size truncation prevents reading %s"
 385                  " elements of size %s for %s\n"),
 386                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 387       return NULL;
 388     }
 389
 390   /* Check for size overflow.  */
 391   if (amt < nmemb)
 392     {
 393       if (reason)
 394         error (_("Size overflow prevents reading %s"
 395                  " elements of size %s for %s\n"),
 396                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 397       return NULL;
 398     }
 399
 400   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 401      attempting to allocate memory when the read is bound to fail.  */
 402   if (amt > filedata->file_size
 403       || offset + archive_file_offset + amt > filedata->file_size)
 404     {
 405       if (reason)
 406         error (_("Reading %s bytes extends past end of file for %s\n"),
 407                bfd_vmatoa ("u", amt), reason);
 408       return NULL;
 409     }
 410
 411   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 412     {
 413       if (reason)
 414         error (_("Unable to seek to 0x%lx for %s\n"),
 415                archive_file_offset + offset, reason);
 416       return NULL;
 417     }
 418
 419   mvar = var;
 420   if (mvar == NULL)
 421     {
 422       /* Check for overflow.  */
 423       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 424         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 425         mvar = malloc ((size_t) amt + 1);
 426
 427       if (mvar == NULL)
 428         {
 429           if (reason)
 430             error (_("Out of memory allocating %s bytes for %s\n"),
 431                    bfd_vmatoa ("u", amt), reason);
 432           return NULL;
 433         }
 434
 435       ((char *) mvar)[amt] = '\0';
 436     }
 437
 438   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 439     {
 440       if (reason)
 441         error (_("Unable to read in %s bytes of %s\n"),
 442                bfd_vmatoa ("u", amt), reason);
 443       if (mvar != var)
 444         free (mvar);
 445       return NULL;
 446     }
 447
 448   return mvar;
 449 }
 450
 451 /* Print a VMA value in the MODE specified.
 452    Returns the number of characters displayed.  */
 453
 454 static unsigned int
 455 print_vma (bfd_vma vma, print_mode mode)
 456 {
 457   unsigned int nc = 0;
 458
 459   switch (mode)
 460     {
 461     case FULL_HEX:
 462       nc = printf ("0x");
 463       /* Fall through.  */
 464     case LONG_HEX:
 465 #ifdef BFD64
 466       if (is_32bit_elf)
 467         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 468 #endif
 469       printf_vma (vma);
 470       return nc + 16;
 471
 472     case DEC_5:
 473       if (vma <= 99999)
 474         return printf ("%5" BFD_VMA_FMT "d", vma);
 475       /* Fall through.  */
 476     case PREFIX_HEX:
 477       nc = printf ("0x");
 478       /* Fall through.  */
 479     case HEX:
 480       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 481
 482     case DEC:
 483       return printf ("%" BFD_VMA_FMT "d", vma);
 484
 485     case UNSIGNED:
 486       return printf ("%" BFD_VMA_FMT "u", vma);
 487
 488     default:
 489       /* FIXME: Report unrecognised mode ?  */
 490       return 0;
 491     }
 492 }
 493
 494 /* Display a symbol on stdout.  Handles the display of control characters and
 495    multibye characters (assuming the host environment supports them).
 496
 497    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 498
 499    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 500    padding as necessary.
 501
 502    Returns the number of emitted characters.  */
 503
 504 static unsigned int
 505 print_symbol (signed int width, const char *symbol)
 506 {
 507   bfd_boolean extra_padding = FALSE;
 508   signed int num_printed = 0;
 509 #ifdef HAVE_MBSTATE_T
 510   mbstate_t state;
 511 #endif
 512   unsigned int width_remaining;
 513
 514   if (width < 0)
 515     {
 516       /* Keep the width positive.  This helps the code below.  */
 517       width = - width;
 518       extra_padding = TRUE;
 519     }
 520   else if (width == 0)
 521     return 0;
 522
 523   if (do_wide)
 524     /* Set the remaining width to a very large value.
 525        This simplifies the code below.  */
 526     width_remaining = INT_MAX;
 527   else
 528     width_remaining = width;
 529
 530 #ifdef HAVE_MBSTATE_T
 531   /* Initialise the multibyte conversion state.  */
 532   memset (& state, 0, sizeof (state));
 533 #endif
 534
 535   while (width_remaining)
 536     {
 537       size_t  n;
 538       const char c = *symbol++;
 539
 540       if (c == 0)
 541         break;
 542
 543       /* Do not print control characters directly as they can affect terminal
 544          settings.  Such characters usually appear in the names generated
 545          by the assembler for local labels.  */
 546       if (ISCNTRL (c))
 547         {
 548           if (width_remaining < 2)
 549             break;
 550
 551           printf ("^%c", c + 0x40);
 552           width_remaining -= 2;
 553           num_printed += 2;
 554         }
 555       else if (ISPRINT (c))
 556         {
 557           putchar (c);
 558           width_remaining --;
 559           num_printed ++;
 560         }
 561       else
 562         {
 563 #ifdef HAVE_MBSTATE_T
 564           wchar_t w;
 565 #endif
 566           /* Let printf do the hard work of displaying multibyte characters.  */
 567           printf ("%.1s", symbol - 1);
 568           width_remaining --;
 569           num_printed ++;
 570
 571 #ifdef HAVE_MBSTATE_T
 572           /* Try to find out how many bytes made up the character that was
 573              just printed.  Advance the symbol pointer past the bytes that
 574              were displayed.  */
 575           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 576 #else
 577           n = 1;
 578 #endif
 579           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 580             symbol += (n - 1);
 581         }
 582     }
 583
 584   if (extra_padding && num_printed < width)
 585     {
 586       /* Fill in the remaining spaces.  */
 587       printf ("%-*s", width - num_printed, " ");
 588       num_printed = width;
 589     }
 590
 591   return num_printed;
 592 }
 593
 594 /* Returns a pointer to a static buffer containing a printable version of
 595    the given section's name.  Like print_symbol, except that it does not try
 596    to print multibyte characters, it just interprets them as hex values.  */
 597
 598 static const char *
 599 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 600 {
 601 #define MAX_PRINT_SEC_NAME_LEN 128
 602   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 603   const char * name = SECTION_NAME (sec);
 604   char *       buf = sec_name_buf;
 605   char         c;
 606   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 607
 608   while ((c = * name ++) != 0)
 609     {
 610       if (ISCNTRL (c))
 611         {
 612           if (remaining < 2)
 613             break;
 614
 615           * buf ++ = '^';
 616           * buf ++ = c + 0x40;
 617           remaining -= 2;
 618         }
 619       else if (ISPRINT (c))
 620         {
 621           * buf ++ = c;
 622           remaining -= 1;
 623         }
 624       else
 625         {
 626           static char hex[17] = "0123456789ABCDEF";
 627
 628           if (remaining < 4)
 629             break;
 630           * buf ++ = '<';
 631           * buf ++ = hex[(c & 0xf0) >> 4];
 632           * buf ++ = hex[c & 0x0f];
 633           * buf ++ = '>';
 634           remaining -= 4;
 635         }
 636
 637       if (remaining == 0)
 638         break;
 639     }
 640
 641   * buf = 0;
 642   return sec_name_buf;
 643 }
 644
 645 static const char *
 646 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 647 {
 648   if (ndx >= filedata->file_header.e_shnum)
 649     return _("<corrupt>");
 650
 651   return printable_section_name (filedata, filedata->section_headers + ndx);
 652 }
 653
 654 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 655
 656 static Elf_Internal_Shdr *
 657 find_section (Filedata * filedata, const char * name)
 658 {
 659   unsigned int i;
 660
 661   if (filedata->section_headers == NULL)
 662     return NULL;
 663
 664   for (i = 0; i < filedata->file_header.e_shnum; i++)
 665     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 666       return filedata->section_headers + i;
 667
 668   return NULL;
 669 }
 670
 671 /* Return a pointer to a section containing ADDR, or NULL if no such
 672    section exists.  */
 673
 674 static Elf_Internal_Shdr *
 675 find_section_by_address (Filedata * filedata, bfd_vma addr)
 676 {
 677   unsigned int i;
 678
 679   if (filedata->section_headers == NULL)
 680     return NULL;
 681
 682   for (i = 0; i < filedata->file_header.e_shnum; i++)
 683     {
 684       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 685
 686       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 687         return sec;
 688     }
 689
 690   return NULL;
 691 }
 692
 693 static Elf_Internal_Shdr *
 694 find_section_by_type (Filedata * filedata, unsigned int type)
 695 {
 696   unsigned int i;
 697
 698   if (filedata->section_headers == NULL)
 699     return NULL;
 700
 701   for (i = 0; i < filedata->file_header.e_shnum; i++)
 702     {
 703       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 704
 705       if (sec->sh_type == type)
 706         return sec;
 707     }
 708
 709   return NULL;
 710 }
 711
 712 /* Return a pointer to section NAME, or NULL if no such section exists,
 713    restricted to the list of sections given in SET.  */
 714
 715 static Elf_Internal_Shdr *
 716 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 717 {
 718   unsigned int i;
 719
 720   if (filedata->section_headers == NULL)
 721     return NULL;
 722
 723   if (set != NULL)
 724     {
 725       while ((i = *set++) > 0)
 726         {
 727           /* See PR 21156 for a reproducer.  */
 728           if (i >= filedata->file_header.e_shnum)
 729             continue; /* FIXME: Should we issue an error message ?  */
 730
 731           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 732             return filedata->section_headers + i;
 733         }
 734     }
 735
 736   return find_section (filedata, name);
 737 }
 738
 739 /* Read an unsigned LEB128 encoded value from DATA.
 740    Set *LENGTH_RETURN to the number of bytes read.  */
 741
 742 static inline unsigned long
 743 read_uleb128 (unsigned char * data,
 744               unsigned int * length_return,
 745               const unsigned char * const end)
 746 {
 747   return read_leb128 (data, length_return, FALSE, end);
 748 }
 749
 750 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 751    This OS has so many departures from the ELF standard that we test it at
 752    many places.  */
 753
 754 static inline bfd_boolean
 755 is_ia64_vms (Filedata * filedata)
 756 {
 757   return filedata->file_header.e_machine == EM_IA_64
 758     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 759 }
 760
 761 /* Guess the relocation size commonly used by the specific machines.  */
 762
 763 static bfd_boolean
 764 guess_is_rela (unsigned int e_machine)
 765 {
 766   switch (e_machine)
 767     {
 768       /* Targets that use REL relocations.  */
 769     case EM_386:
 770     case EM_IAMCU:
 771     case EM_960:
 772     case EM_ARM:
 773     case EM_D10V:
 774     case EM_CYGNUS_D10V:
 775     case EM_DLX:
 776     case EM_MIPS:
 777     case EM_MIPS_RS3_LE:
 778     case EM_CYGNUS_M32R:
 779     case EM_SCORE:
 780     case EM_XGATE:
 781     case EM_NFP:
 782       return FALSE;
 783
 784       /* Targets that use RELA relocations.  */
 785     case EM_68K:
 786     case EM_860:
 787     case EM_AARCH64:
 788     case EM_ADAPTEVA_EPIPHANY:
 789     case EM_ALPHA:
 790     case EM_ALTERA_NIOS2:
 791     case EM_ARC:
 792     case EM_ARC_COMPACT:
 793     case EM_ARC_COMPACT2:
 794     case EM_AVR:
 795     case EM_AVR_OLD:
 796     case EM_BLACKFIN:
 797     case EM_CR16:
 798     case EM_CRIS:
 799     case EM_CRX:
 800     case EM_D30V:
 801     case EM_CYGNUS_D30V:
 802     case EM_FR30:
 803     case EM_FT32:
 804     case EM_CYGNUS_FR30:
 805     case EM_CYGNUS_FRV:
 806     case EM_H8S:
 807     case EM_H8_300:
 808     case EM_H8_300H:
 809     case EM_IA_64:
 810     case EM_IP2K:
 811     case EM_IP2K_OLD:
 812     case EM_IQ2000:
 813     case EM_LATTICEMICO32:
 814     case EM_M32C_OLD:
 815     case EM_M32C:
 816     case EM_M32R:
 817     case EM_MCORE:
 818     case EM_CYGNUS_MEP:
 819     case EM_METAG:
 820     case EM_MMIX:
 821     case EM_MN10200:
 822     case EM_CYGNUS_MN10200:
 823     case EM_MN10300:
 824     case EM_CYGNUS_MN10300:
 825     case EM_MOXIE:
 826     case EM_MSP430:
 827     case EM_MSP430_OLD:
 828     case EM_MT:
 829     case EM_NDS32:
 830     case EM_NIOS32:
 831     case EM_OR1K:
 832     case EM_PPC64:
 833     case EM_PPC:
 834     case EM_TI_PRU:
 835     case EM_RISCV:
 836     case EM_RL78:
 837     case EM_RX:
 838     case EM_S390:
 839     case EM_S390_OLD:
 840     case EM_SH:
 841     case EM_SPARC:
 842     case EM_SPARC32PLUS:
 843     case EM_SPARCV9:
 844     case EM_SPU:
 845     case EM_TI_C6000:
 846     case EM_TILEGX:
 847     case EM_TILEPRO:
 848     case EM_V800:
 849     case EM_V850:
 850     case EM_CYGNUS_V850:
 851     case EM_VAX:
 852     case EM_VISIUM:
 853     case EM_X86_64:
 854     case EM_L1OM:
 855     case EM_K1OM:
 856     case EM_XSTORMY16:
 857     case EM_XTENSA:
 858     case EM_XTENSA_OLD:
 859     case EM_MICROBLAZE:
 860     case EM_MICROBLAZE_OLD:
 861     case EM_WEBASSEMBLY:
 862       return TRUE;
 863
 864     case EM_68HC05:
 865     case EM_68HC08:
 866     case EM_68HC11:
 867     case EM_68HC16:
 868     case EM_FX66:
 869     case EM_ME16:
 870     case EM_MMA:
 871     case EM_NCPU:
 872     case EM_NDR1:
 873     case EM_PCP:
 874     case EM_ST100:
 875     case EM_ST19:
 876     case EM_ST7:
 877     case EM_ST9PLUS:
 878     case EM_STARCORE:
 879     case EM_SVX:
 880     case EM_TINYJ:
 881     default:
 882       warn (_("Don't know about relocations on this machine architecture\n"));
 883       return FALSE;
 884     }
 885 }
 886
 887 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 888    Returns TRUE upon success, FALSE otherwise.  If successful then a
 889    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 890    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 891    responsibility to free the allocated buffer.  */
 892
 893 static bfd_boolean
 894 slurp_rela_relocs (Filedata *            filedata,
 895                    unsigned long         rel_offset,
 896                    unsigned long         rel_size,
 897                    Elf_Internal_Rela **  relasp,
 898                    unsigned long *       nrelasp)
 899 {
 900   Elf_Internal_Rela * relas;
 901   size_t nrelas;
 902   unsigned int i;
 903
 904   if (is_32bit_elf)
 905     {
 906       Elf32_External_Rela * erelas;
 907
 908       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 909                                                  rel_size, _("32-bit relocation data"));
 910       if (!erelas)
 911         return FALSE;
 912
 913       nrelas = rel_size / sizeof (Elf32_External_Rela);
 914
 915       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 916                                              sizeof (Elf_Internal_Rela));
 917
 918       if (relas == NULL)
 919         {
 920           free (erelas);
 921           error (_("out of memory parsing relocs\n"));
 922           return FALSE;
 923         }
 924
 925       for (i = 0; i < nrelas; i++)
 926         {
 927           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 928           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 929           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 930         }
 931
 932       free (erelas);
 933     }
 934   else
 935     {
 936       Elf64_External_Rela * erelas;
 937
 938       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 939                                                  rel_size, _("64-bit relocation data"));
 940       if (!erelas)
 941         return FALSE;
 942
 943       nrelas = rel_size / sizeof (Elf64_External_Rela);
 944
 945       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 946                                              sizeof (Elf_Internal_Rela));
 947
 948       if (relas == NULL)
 949         {
 950           free (erelas);
 951           error (_("out of memory parsing relocs\n"));
 952           return FALSE;
 953         }
 954
 955       for (i = 0; i < nrelas; i++)
 956         {
 957           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 958           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 959           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 960
 961           /* The #ifdef BFD64 below is to prevent a compile time
 962              warning.  We know that if we do not have a 64 bit data
 963              type that we will never execute this code anyway.  */
 964 #ifdef BFD64
 965           if (filedata->file_header.e_machine == EM_MIPS
 966               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 967             {
 968               /* In little-endian objects, r_info isn't really a
 969                  64-bit little-endian value: it has a 32-bit
 970                  little-endian symbol index followed by four
 971                  individual byte fields.  Reorder INFO
 972                  accordingly.  */
 973               bfd_vma inf = relas[i].r_info;
 974               inf = (((inf & 0xffffffff) << 32)
 975                       | ((inf >> 56) & 0xff)
 976                       | ((inf >> 40) & 0xff00)
 977                       | ((inf >> 24) & 0xff0000)
 978                       | ((inf >> 8) & 0xff000000));
 979               relas[i].r_info = inf;
 980             }
 981 #endif /* BFD64 */
 982         }
 983
 984       free (erelas);
 985     }
 986
 987   *relasp = relas;
 988   *nrelasp = nrelas;
 989   return TRUE;
 990 }
 991
 992 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 993    Returns TRUE upon success, FALSE otherwise.  If successful then a
 994    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 995    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 996    responsibility to free the allocated buffer.  */
 997
 998 static bfd_boolean
 999 slurp_rel_relocs (Filedata *            filedata,
1000                   unsigned long         rel_offset,
1001                   unsigned long         rel_size,
1002                   Elf_Internal_Rela **  relsp,
1003                   unsigned long *       nrelsp)
1004 {
1005   Elf_Internal_Rela * rels;
1006   size_t nrels;
1007   unsigned int i;
1008
1009   if (is_32bit_elf)
1010     {
1011       Elf32_External_Rel * erels;
1012
1013       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1014                                                rel_size, _("32-bit relocation data"));
1015       if (!erels)
1016         return FALSE;
1017
1018       nrels = rel_size / sizeof (Elf32_External_Rel);
1019
1020       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1021
1022       if (rels == NULL)
1023         {
1024           free (erels);
1025           error (_("out of memory parsing relocs\n"));
1026           return FALSE;
1027         }
1028
1029       for (i = 0; i < nrels; i++)
1030         {
1031           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1032           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1033           rels[i].r_addend = 0;
1034         }
1035
1036       free (erels);
1037     }
1038   else
1039     {
1040       Elf64_External_Rel * erels;
1041
1042       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1043                                                rel_size, _("64-bit relocation data"));
1044       if (!erels)
1045         return FALSE;
1046
1047       nrels = rel_size / sizeof (Elf64_External_Rel);
1048
1049       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1050
1051       if (rels == NULL)
1052         {
1053           free (erels);
1054           error (_("out of memory parsing relocs\n"));
1055           return FALSE;
1056         }
1057
1058       for (i = 0; i < nrels; i++)
1059         {
1060           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1061           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1062           rels[i].r_addend = 0;
1063
1064           /* The #ifdef BFD64 below is to prevent a compile time
1065              warning.  We know that if we do not have a 64 bit data
1066              type that we will never execute this code anyway.  */
1067 #ifdef BFD64
1068           if (filedata->file_header.e_machine == EM_MIPS
1069               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1070             {
1071               /* In little-endian objects, r_info isn't really a
1072                  64-bit little-endian value: it has a 32-bit
1073                  little-endian symbol index followed by four
1074                  individual byte fields.  Reorder INFO
1075                  accordingly.  */
1076               bfd_vma inf = rels[i].r_info;
1077               inf = (((inf & 0xffffffff) << 32)
1078                      | ((inf >> 56) & 0xff)
1079                      | ((inf >> 40) & 0xff00)
1080                      | ((inf >> 24) & 0xff0000)
1081                      | ((inf >> 8) & 0xff000000));
1082               rels[i].r_info = inf;
1083             }
1084 #endif /* BFD64 */
1085         }
1086
1087       free (erels);
1088     }
1089
1090   *relsp = rels;
1091   *nrelsp = nrels;
1092   return TRUE;
1093 }
1094
1095 /* Returns the reloc type extracted from the reloc info field.  */
1096
1097 static unsigned int
1098 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1099 {
1100   if (is_32bit_elf)
1101     return ELF32_R_TYPE (reloc_info);
1102
1103   switch (filedata->file_header.e_machine)
1104     {
1105     case EM_MIPS:
1106       /* Note: We assume that reloc_info has already been adjusted for us.  */
1107       return ELF64_MIPS_R_TYPE (reloc_info);
1108
1109     case EM_SPARCV9:
1110       return ELF64_R_TYPE_ID (reloc_info);
1111
1112     default:
1113       return ELF64_R_TYPE (reloc_info);
1114     }
1115 }
1116
1117 /* Return the symbol index extracted from the reloc info field.  */
1118
1119 static bfd_vma
1120 get_reloc_symindex (bfd_vma reloc_info)
1121 {
1122   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1123 }
1124
1125 static inline bfd_boolean
1126 uses_msp430x_relocs (Filedata * filedata)
1127 {
1128   return
1129     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1130     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1131     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1132         /* TI compiler uses ELFOSABI_NONE.  */
1133         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1134 }
1135
1136 /* Display the contents of the relocation data found at the specified
1137    offset.  */
1138
1139 static bfd_boolean
1140 dump_relocations (Filedata *          filedata,
1141                   unsigned long       rel_offset,
1142                   unsigned long       rel_size,
1143                   Elf_Internal_Sym *  symtab,
1144                   unsigned long       nsyms,
1145                   char *              strtab,
1146                   unsigned long       strtablen,
1147                   int                 is_rela,
1148                   bfd_boolean         is_dynsym)
1149 {
1150   unsigned long i;
1151   Elf_Internal_Rela * rels;
1152   bfd_boolean res = TRUE;
1153
1154   if (is_rela == UNKNOWN)
1155     is_rela = guess_is_rela (filedata->file_header.e_machine);
1156
1157   if (is_rela)
1158     {
1159       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1160         return FALSE;
1161     }
1162   else
1163     {
1164       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1165         return FALSE;
1166     }
1167
1168   if (is_32bit_elf)
1169     {
1170       if (is_rela)
1171         {
1172           if (do_wide)
1173             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1174           else
1175             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1176         }
1177       else
1178         {
1179           if (do_wide)
1180             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1181           else
1182             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1183         }
1184     }
1185   else
1186     {
1187       if (is_rela)
1188         {
1189           if (do_wide)
1190             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1191           else
1192             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1193         }
1194       else
1195         {
1196           if (do_wide)
1197             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1198           else
1199             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1200         }
1201     }
1202
1203   for (i = 0; i < rel_size; i++)
1204     {
1205       const char * rtype;
1206       bfd_vma offset;
1207       bfd_vma inf;
1208       bfd_vma symtab_index;
1209       bfd_vma type;
1210
1211       offset = rels[i].r_offset;
1212       inf    = rels[i].r_info;
1213
1214       type = get_reloc_type (filedata, inf);
1215       symtab_index = get_reloc_symindex  (inf);
1216
1217       if (is_32bit_elf)
1218         {
1219           printf ("%8.8lx  %8.8lx ",
1220                   (unsigned long) offset & 0xffffffff,
1221                   (unsigned long) inf & 0xffffffff);
1222         }
1223       else
1224         {
1225 #if BFD_HOST_64BIT_LONG
1226           printf (do_wide
1227                   ? "%16.16lx  %16.16lx "
1228                   : "%12.12lx  %12.12lx ",
1229                   offset, inf);
1230 #elif BFD_HOST_64BIT_LONG_LONG
1231 #ifndef __MSVCRT__
1232           printf (do_wide
1233                   ? "%16.16llx  %16.16llx "
1234                   : "%12.12llx  %12.12llx ",
1235                   offset, inf);
1236 #else
1237           printf (do_wide
1238                   ? "%16.16I64x  %16.16I64x "
1239                   : "%12.12I64x  %12.12I64x ",
1240                   offset, inf);
1241 #endif
1242 #else
1243           printf (do_wide
1244                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1245                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1246                   _bfd_int64_high (offset),
1247                   _bfd_int64_low (offset),
1248                   _bfd_int64_high (inf),
1249                   _bfd_int64_low (inf));
1250 #endif
1251         }
1252
1253       switch (filedata->file_header.e_machine)
1254         {
1255         default:
1256           rtype = NULL;
1257           break;
1258
1259         case EM_AARCH64:
1260           rtype = elf_aarch64_reloc_type (type);
1261           break;
1262
1263         case EM_M32R:
1264         case EM_CYGNUS_M32R:
1265           rtype = elf_m32r_reloc_type (type);
1266           break;
1267
1268         case EM_386:
1269         case EM_IAMCU:
1270           rtype = elf_i386_reloc_type (type);
1271           break;
1272
1273         case EM_68HC11:
1274         case EM_68HC12:
1275           rtype = elf_m68hc11_reloc_type (type);
1276           break;
1277
1278         case EM_S12Z:
1279           rtype = elf_s12z_reloc_type (type);
1280           break;
1281
1282         case EM_68K:
1283           rtype = elf_m68k_reloc_type (type);
1284           break;
1285
1286         case EM_960:
1287           rtype = elf_i960_reloc_type (type);
1288           break;
1289
1290         case EM_AVR:
1291         case EM_AVR_OLD:
1292           rtype = elf_avr_reloc_type (type);
1293           break;
1294
1295         case EM_OLD_SPARCV9:
1296         case EM_SPARC32PLUS:
1297         case EM_SPARCV9:
1298         case EM_SPARC:
1299           rtype = elf_sparc_reloc_type (type);
1300           break;
1301
1302         case EM_SPU:
1303           rtype = elf_spu_reloc_type (type);
1304           break;
1305
1306         case EM_V800:
1307           rtype = v800_reloc_type (type);
1308           break;
1309         case EM_V850:
1310         case EM_CYGNUS_V850:
1311           rtype = v850_reloc_type (type);
1312           break;
1313
1314         case EM_D10V:
1315         case EM_CYGNUS_D10V:
1316           rtype = elf_d10v_reloc_type (type);
1317           break;
1318
1319         case EM_D30V:
1320         case EM_CYGNUS_D30V:
1321           rtype = elf_d30v_reloc_type (type);
1322           break;
1323
1324         case EM_DLX:
1325           rtype = elf_dlx_reloc_type (type);
1326           break;
1327
1328         case EM_SH:
1329           rtype = elf_sh_reloc_type (type);
1330           break;
1331
1332         case EM_MN10300:
1333         case EM_CYGNUS_MN10300:
1334           rtype = elf_mn10300_reloc_type (type);
1335           break;
1336
1337         case EM_MN10200:
1338         case EM_CYGNUS_MN10200:
1339           rtype = elf_mn10200_reloc_type (type);
1340           break;
1341
1342         case EM_FR30:
1343         case EM_CYGNUS_FR30:
1344           rtype = elf_fr30_reloc_type (type);
1345           break;
1346
1347         case EM_CYGNUS_FRV:
1348           rtype = elf_frv_reloc_type (type);
1349           break;
1350
1351         case EM_FT32:
1352           rtype = elf_ft32_reloc_type (type);
1353           break;
1354
1355         case EM_MCORE:
1356           rtype = elf_mcore_reloc_type (type);
1357           break;
1358
1359         case EM_MMIX:
1360           rtype = elf_mmix_reloc_type (type);
1361           break;
1362
1363         case EM_MOXIE:
1364           rtype = elf_moxie_reloc_type (type);
1365           break;
1366
1367         case EM_MSP430:
1368           if (uses_msp430x_relocs (filedata))
1369             {
1370               rtype = elf_msp430x_reloc_type (type);
1371               break;
1372             }
1373           /* Fall through.  */
1374         case EM_MSP430_OLD:
1375           rtype = elf_msp430_reloc_type (type);
1376           break;
1377
1378         case EM_NDS32:
1379           rtype = elf_nds32_reloc_type (type);
1380           break;
1381
1382         case EM_PPC:
1383           rtype = elf_ppc_reloc_type (type);
1384           break;
1385
1386         case EM_PPC64:
1387           rtype = elf_ppc64_reloc_type (type);
1388           break;
1389
1390         case EM_MIPS:
1391         case EM_MIPS_RS3_LE:
1392           rtype = elf_mips_reloc_type (type);
1393           break;
1394
1395         case EM_RISCV:
1396           rtype = elf_riscv_reloc_type (type);
1397           break;
1398
1399         case EM_ALPHA:
1400           rtype = elf_alpha_reloc_type (type);
1401           break;
1402
1403         case EM_ARM:
1404           rtype = elf_arm_reloc_type (type);
1405           break;
1406
1407         case EM_ARC:
1408         case EM_ARC_COMPACT:
1409         case EM_ARC_COMPACT2:
1410           rtype = elf_arc_reloc_type (type);
1411           break;
1412
1413         case EM_PARISC:
1414           rtype = elf_hppa_reloc_type (type);
1415           break;
1416
1417         case EM_H8_300:
1418         case EM_H8_300H:
1419         case EM_H8S:
1420           rtype = elf_h8_reloc_type (type);
1421           break;
1422
1423         case EM_OR1K:
1424           rtype = elf_or1k_reloc_type (type);
1425           break;
1426
1427         case EM_PJ:
1428         case EM_PJ_OLD:
1429           rtype = elf_pj_reloc_type (type);
1430           break;
1431         case EM_IA_64:
1432           rtype = elf_ia64_reloc_type (type);
1433           break;
1434
1435         case EM_CRIS:
1436           rtype = elf_cris_reloc_type (type);
1437           break;
1438
1439         case EM_860:
1440           rtype = elf_i860_reloc_type (type);
1441           break;
1442
1443         case EM_X86_64:
1444         case EM_L1OM:
1445         case EM_K1OM:
1446           rtype = elf_x86_64_reloc_type (type);
1447           break;
1448
1449         case EM_S370:
1450           rtype = i370_reloc_type (type);
1451           break;
1452
1453         case EM_S390_OLD:
1454         case EM_S390:
1455           rtype = elf_s390_reloc_type (type);
1456           break;
1457
1458         case EM_SCORE:
1459           rtype = elf_score_reloc_type (type);
1460           break;
1461
1462         case EM_XSTORMY16:
1463           rtype = elf_xstormy16_reloc_type (type);
1464           break;
1465
1466         case EM_CRX:
1467           rtype = elf_crx_reloc_type (type);
1468           break;
1469
1470         case EM_VAX:
1471           rtype = elf_vax_reloc_type (type);
1472           break;
1473
1474         case EM_VISIUM:
1475           rtype = elf_visium_reloc_type (type);
1476           break;
1477
1478         case EM_ADAPTEVA_EPIPHANY:
1479           rtype = elf_epiphany_reloc_type (type);
1480           break;
1481
1482         case EM_IP2K:
1483         case EM_IP2K_OLD:
1484           rtype = elf_ip2k_reloc_type (type);
1485           break;
1486
1487         case EM_IQ2000:
1488           rtype = elf_iq2000_reloc_type (type);
1489           break;
1490
1491         case EM_XTENSA_OLD:
1492         case EM_XTENSA:
1493           rtype = elf_xtensa_reloc_type (type);
1494           break;
1495
1496         case EM_LATTICEMICO32:
1497           rtype = elf_lm32_reloc_type (type);
1498           break;
1499
1500         case EM_M32C_OLD:
1501         case EM_M32C:
1502           rtype = elf_m32c_reloc_type (type);
1503           break;
1504
1505         case EM_MT:
1506           rtype = elf_mt_reloc_type (type);
1507           break;
1508
1509         case EM_BLACKFIN:
1510           rtype = elf_bfin_reloc_type (type);
1511           break;
1512
1513         case EM_CYGNUS_MEP:
1514           rtype = elf_mep_reloc_type (type);
1515           break;
1516
1517         case EM_CR16:
1518           rtype = elf_cr16_reloc_type (type);
1519           break;
1520
1521         case EM_MICROBLAZE:
1522         case EM_MICROBLAZE_OLD:
1523           rtype = elf_microblaze_reloc_type (type);
1524           break;
1525
1526         case EM_RL78:
1527           rtype = elf_rl78_reloc_type (type);
1528           break;
1529
1530         case EM_RX:
1531           rtype = elf_rx_reloc_type (type);
1532           break;
1533
1534         case EM_METAG:
1535           rtype = elf_metag_reloc_type (type);
1536           break;
1537
1538         case EM_XC16X:
1539         case EM_C166:
1540           rtype = elf_xc16x_reloc_type (type);
1541           break;
1542
1543         case EM_TI_C6000:
1544           rtype = elf_tic6x_reloc_type (type);
1545           break;
1546
1547         case EM_TILEGX:
1548           rtype = elf_tilegx_reloc_type (type);
1549           break;
1550
1551         case EM_TILEPRO:
1552           rtype = elf_tilepro_reloc_type (type);
1553           break;
1554
1555         case EM_WEBASSEMBLY:
1556           rtype = elf_wasm32_reloc_type (type);
1557           break;
1558
1559         case EM_XGATE:
1560           rtype = elf_xgate_reloc_type (type);
1561           break;
1562
1563         case EM_ALTERA_NIOS2:
1564           rtype = elf_nios2_reloc_type (type);
1565           break;
1566
1567         case EM_TI_PRU:
1568           rtype = elf_pru_reloc_type (type);
1569           break;
1570
1571         case EM_NFP:
1572           if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1573             rtype = elf_nfp3200_reloc_type (type);
1574           else
1575             rtype = elf_nfp_reloc_type (type);
1576           break;
1577         }
1578
1579       if (rtype == NULL)
1580         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1581       else
1582         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1583
1584       if (filedata->file_header.e_machine == EM_ALPHA
1585           && rtype != NULL
1586           && streq (rtype, "R_ALPHA_LITUSE")
1587           && is_rela)
1588         {
1589           switch (rels[i].r_addend)
1590             {
1591             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1592             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1593             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1594             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1595             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1596             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1597             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1598             default: rtype = NULL;
1599             }
1600
1601           if (rtype)
1602             printf (" (%s)", rtype);
1603           else
1604             {
1605               putchar (' ');
1606               printf (_("<unknown addend: %lx>"),
1607                       (unsigned long) rels[i].r_addend);
1608               res = FALSE;
1609             }
1610         }
1611       else if (symtab_index)
1612         {
1613           if (symtab == NULL || symtab_index >= nsyms)
1614             {
1615               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1616               res = FALSE;
1617             }
1618           else
1619             {
1620               Elf_Internal_Sym * psym;
1621               const char * version_string;
1622               enum versioned_symbol_info sym_info;
1623               unsigned short vna_other;
1624
1625               psym = symtab + symtab_index;
1626
1627               version_string
1628                 = get_symbol_version_string (filedata, is_dynsym,
1629                                              strtab, strtablen,
1630                                              symtab_index,
1631                                              psym,
1632                                              &sym_info,
1633                                              &vna_other);
1634
1635               printf (" ");
1636
1637               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1638                 {
1639                   const char * name;
1640                   unsigned int len;
1641                   unsigned int width = is_32bit_elf ? 8 : 14;
1642
1643                   /* Relocations against GNU_IFUNC symbols do not use the value
1644                      of the symbol as the address to relocate against.  Instead
1645                      they invoke the function named by the symbol and use its
1646                      result as the address for relocation.
1647
1648                      To indicate this to the user, do not display the value of
1649                      the symbol in the "Symbols's Value" field.  Instead show
1650                      its name followed by () as a hint that the symbol is
1651                      invoked.  */
1652
1653                   if (strtab == NULL
1654                       || psym->st_name == 0
1655                       || psym->st_name >= strtablen)
1656                     name = "??";
1657                   else
1658                     name = strtab + psym->st_name;
1659
1660                   len = print_symbol (width, name);
1661                   if (version_string)
1662                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1663                             version_string);
1664                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1665                 }
1666               else
1667                 {
1668                   print_vma (psym->st_value, LONG_HEX);
1669
1670                   printf (is_32bit_elf ? "   " : " ");
1671                 }
1672
1673               if (psym->st_name == 0)
1674                 {
1675                   const char * sec_name = "<null>";
1676                   char name_buf[40];
1677
1678                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1679                     {
1680                       if (psym->st_shndx < filedata->file_header.e_shnum)
1681                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1682                       else if (psym->st_shndx == SHN_ABS)
1683                         sec_name = "ABS";
1684                       else if (psym->st_shndx == SHN_COMMON)
1685                         sec_name = "COMMON";
1686                       else if ((filedata->file_header.e_machine == EM_MIPS
1687                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1688                                || (filedata->file_header.e_machine == EM_TI_C6000
1689                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1690                         sec_name = "SCOMMON";
1691                       else if (filedata->file_header.e_machine == EM_MIPS
1692                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1693                         sec_name = "SUNDEF";
1694                       else if ((filedata->file_header.e_machine == EM_X86_64
1695                                 || filedata->file_header.e_machine == EM_L1OM
1696                                 || filedata->file_header.e_machine == EM_K1OM)
1697                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1698                         sec_name = "LARGE_COMMON";
1699                       else if (filedata->file_header.e_machine == EM_IA_64
1700                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1701                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1702                         sec_name = "ANSI_COM";
1703                       else if (is_ia64_vms (filedata)
1704                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1705                         sec_name = "VMS_SYMVEC";
1706                       else
1707                         {
1708                           sprintf (name_buf, "<section 0x%x>",
1709                                    (unsigned int) psym->st_shndx);
1710                           sec_name = name_buf;
1711                         }
1712                     }
1713                   print_symbol (22, sec_name);
1714                 }
1715               else if (strtab == NULL)
1716                 printf (_("<string table index: %3ld>"), psym->st_name);
1717               else if (psym->st_name >= strtablen)
1718                 {
1719                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1720                   res = FALSE;
1721                 }
1722               else
1723                 {
1724                   print_symbol (22, strtab + psym->st_name);
1725                   if (version_string)
1726                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1727                             version_string);
1728                 }
1729
1730               if (is_rela)
1731                 {
1732                   bfd_vma off = rels[i].r_addend;
1733
1734                   if ((bfd_signed_vma) off < 0)
1735                     printf (" - %" BFD_VMA_FMT "x", - off);
1736                   else
1737                     printf (" + %" BFD_VMA_FMT "x", off);
1738                 }
1739             }
1740         }
1741       else if (is_rela)
1742         {
1743           bfd_vma off = rels[i].r_addend;
1744
1745           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1746           if ((bfd_signed_vma) off < 0)
1747             printf ("-%" BFD_VMA_FMT "x", - off);
1748           else
1749             printf ("%" BFD_VMA_FMT "x", off);
1750         }
1751
1752       if (filedata->file_header.e_machine == EM_SPARCV9
1753           && rtype != NULL
1754           && streq (rtype, "R_SPARC_OLO10"))
1755         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1756
1757       putchar ('\n');
1758
1759 #ifdef BFD64
1760       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1761         {
1762           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1763           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1764           const char * rtype2 = elf_mips_reloc_type (type2);
1765           const char * rtype3 = elf_mips_reloc_type (type3);
1766
1767           printf ("                    Type2: ");
1768
1769           if (rtype2 == NULL)
1770             printf (_("unrecognized: %-7lx"),
1771                     (unsigned long) type2 & 0xffffffff);
1772           else
1773             printf ("%-17.17s", rtype2);
1774
1775           printf ("\n                    Type3: ");
1776
1777           if (rtype3 == NULL)
1778             printf (_("unrecognized: %-7lx"),
1779                     (unsigned long) type3 & 0xffffffff);
1780           else
1781             printf ("%-17.17s", rtype3);
1782
1783           putchar ('\n');
1784         }
1785 #endif /* BFD64 */
1786     }
1787
1788   free (rels);
1789
1790   return res;
1791 }
1792
1793 static const char *
1794 get_mips_dynamic_type (unsigned long type)
1795 {
1796   switch (type)
1797     {
1798     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1799     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1800     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1801     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1802     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1803     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1804     case DT_MIPS_MSYM: return "MIPS_MSYM";
1805     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1806     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1807     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1808     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1809     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1810     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1811     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1812     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1813     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1814     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1815     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1816     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1817     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1818     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1819     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1820     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1821     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1822     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1823     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1824     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1825     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1826     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1827     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1828     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1829     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1830     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1831     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1832     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1833     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1834     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1835     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1836     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1837     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1838     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1839     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1840     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1841     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1842     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1843     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1844     default:
1845       return NULL;
1846     }
1847 }
1848
1849 static const char *
1850 get_sparc64_dynamic_type (unsigned long type)
1851 {
1852   switch (type)
1853     {
1854     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1855     default:
1856       return NULL;
1857     }
1858 }
1859
1860 static const char *
1861 get_ppc_dynamic_type (unsigned long type)
1862 {
1863   switch (type)
1864     {
1865     case DT_PPC_GOT:    return "PPC_GOT";
1866     case DT_PPC_OPT:    return "PPC_OPT";
1867     default:
1868       return NULL;
1869     }
1870 }
1871
1872 static const char *
1873 get_ppc64_dynamic_type (unsigned long type)
1874 {
1875   switch (type)
1876     {
1877     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1878     case DT_PPC64_OPD:    return "PPC64_OPD";
1879     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1880     case DT_PPC64_OPT:    return "PPC64_OPT";
1881     default:
1882       return NULL;
1883     }
1884 }
1885
1886 static const char *
1887 get_parisc_dynamic_type (unsigned long type)
1888 {
1889   switch (type)
1890     {
1891     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1892     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1893     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1894     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1895     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1896     case DT_HP_PREINIT:         return "HP_PREINIT";
1897     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1898     case DT_HP_NEEDED:          return "HP_NEEDED";
1899     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1900     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1901     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1902     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1903     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1904     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1905     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1906     case DT_HP_FILTERED:        return "HP_FILTERED";
1907     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1908     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1909     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1910     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1911     case DT_PLT:                return "PLT";
1912     case DT_PLT_SIZE:           return "PLT_SIZE";
1913     case DT_DLT:                return "DLT";
1914     case DT_DLT_SIZE:           return "DLT_SIZE";
1915     default:
1916       return NULL;
1917     }
1918 }
1919
1920 static const char *
1921 get_ia64_dynamic_type (unsigned long type)
1922 {
1923   switch (type)
1924     {
1925     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1926     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1927     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1928     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1929     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1930     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1931     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1932     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1933     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1934     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1935     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1936     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1937     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1938     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1939     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1940     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1941     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1942     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1943     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1944     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1945     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1946     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1947     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1948     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1949     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1950     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1951     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1952     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1953     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1954     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1955     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1956     default:
1957       return NULL;
1958     }
1959 }
1960
1961 static const char *
1962 get_solaris_section_type (unsigned long type)
1963 {
1964   switch (type)
1965     {
1966     case 0x6fffffee: return "SUNW_ancillary";
1967     case 0x6fffffef: return "SUNW_capchain";
1968     case 0x6ffffff0: return "SUNW_capinfo";
1969     case 0x6ffffff1: return "SUNW_symsort";
1970     case 0x6ffffff2: return "SUNW_tlssort";
1971     case 0x6ffffff3: return "SUNW_LDYNSYM";
1972     case 0x6ffffff4: return "SUNW_dof";
1973     case 0x6ffffff5: return "SUNW_cap";
1974     case 0x6ffffff6: return "SUNW_SIGNATURE";
1975     case 0x6ffffff7: return "SUNW_ANNOTATE";
1976     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1977     case 0x6ffffff9: return "SUNW_DEBUG";
1978     case 0x6ffffffa: return "SUNW_move";
1979     case 0x6ffffffb: return "SUNW_COMDAT";
1980     case 0x6ffffffc: return "SUNW_syminfo";
1981     case 0x6ffffffd: return "SUNW_verdef";
1982     case 0x6ffffffe: return "SUNW_verneed";
1983     case 0x6fffffff: return "SUNW_versym";
1984     case 0x70000000: return "SPARC_GOTDATA";
1985     default: return NULL;
1986     }
1987 }
1988
1989 static const char *
1990 get_alpha_dynamic_type (unsigned long type)
1991 {
1992   switch (type)
1993     {
1994     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1995     default: return NULL;
1996     }
1997 }
1998
1999 static const char *
2000 get_score_dynamic_type (unsigned long type)
2001 {
2002   switch (type)
2003     {
2004     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2005     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
2006     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
2007     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
2008     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
2009     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
2010     default:                    return NULL;
2011     }
2012 }
2013
2014 static const char *
2015 get_tic6x_dynamic_type (unsigned long type)
2016 {
2017   switch (type)
2018     {
2019     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2020     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2021     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2022     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2023     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2024     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2025     default:                   return NULL;
2026     }
2027 }
2028
2029 static const char *
2030 get_nios2_dynamic_type (unsigned long type)
2031 {
2032   switch (type)
2033     {
2034     case DT_NIOS2_GP: return "NIOS2_GP";
2035     default:          return NULL;
2036     }
2037 }
2038
2039 static const char *
2040 get_solaris_dynamic_type (unsigned long type)
2041 {
2042   switch (type)
2043     {
2044     case 0x6000000d: return "SUNW_AUXILIARY";
2045     case 0x6000000e: return "SUNW_RTLDINF";
2046     case 0x6000000f: return "SUNW_FILTER";
2047     case 0x60000010: return "SUNW_CAP";
2048     case 0x60000011: return "SUNW_SYMTAB";
2049     case 0x60000012: return "SUNW_SYMSZ";
2050     case 0x60000013: return "SUNW_SORTENT";
2051     case 0x60000014: return "SUNW_SYMSORT";
2052     case 0x60000015: return "SUNW_SYMSORTSZ";
2053     case 0x60000016: return "SUNW_TLSSORT";
2054     case 0x60000017: return "SUNW_TLSSORTSZ";
2055     case 0x60000018: return "SUNW_CAPINFO";
2056     case 0x60000019: return "SUNW_STRPAD";
2057     case 0x6000001a: return "SUNW_CAPCHAIN";
2058     case 0x6000001b: return "SUNW_LDMACH";
2059     case 0x6000001d: return "SUNW_CAPCHAINENT";
2060     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2061     case 0x60000021: return "SUNW_PARENT";
2062     case 0x60000023: return "SUNW_ASLR";
2063     case 0x60000025: return "SUNW_RELAX";
2064     case 0x60000029: return "SUNW_NXHEAP";
2065     case 0x6000002b: return "SUNW_NXSTACK";
2066
2067     case 0x70000001: return "SPARC_REGISTER";
2068     case 0x7ffffffd: return "AUXILIARY";
2069     case 0x7ffffffe: return "USED";
2070     case 0x7fffffff: return "FILTER";
2071
2072     default: return NULL;
2073     }
2074 }
2075
2076 static const char *
2077 get_dynamic_type (Filedata * filedata, unsigned long type)
2078 {
2079   static char buff[64];
2080
2081   switch (type)
2082     {
2083     case DT_NULL:       return "NULL";
2084     case DT_NEEDED:     return "NEEDED";
2085     case DT_PLTRELSZ:   return "PLTRELSZ";
2086     case DT_PLTGOT:     return "PLTGOT";
2087     case DT_HASH:       return "HASH";
2088     case DT_STRTAB:     return "STRTAB";
2089     case DT_SYMTAB:     return "SYMTAB";
2090     case DT_RELA:       return "RELA";
2091     case DT_RELASZ:     return "RELASZ";
2092     case DT_RELAENT:    return "RELAENT";
2093     case DT_STRSZ:      return "STRSZ";
2094     case DT_SYMENT:     return "SYMENT";
2095     case DT_INIT:       return "INIT";
2096     case DT_FINI:       return "FINI";
2097     case DT_SONAME:     return "SONAME";
2098     case DT_RPATH:      return "RPATH";
2099     case DT_SYMBOLIC:   return "SYMBOLIC";
2100     case DT_REL:        return "REL";
2101     case DT_RELSZ:      return "RELSZ";
2102     case DT_RELENT:     return "RELENT";
2103     case DT_PLTREL:     return "PLTREL";
2104     case DT_DEBUG:      return "DEBUG";
2105     case DT_TEXTREL:    return "TEXTREL";
2106     case DT_JMPREL:     return "JMPREL";
2107     case DT_BIND_NOW:   return "BIND_NOW";
2108     case DT_INIT_ARRAY: return "INIT_ARRAY";
2109     case DT_FINI_ARRAY: return "FINI_ARRAY";
2110     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2111     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2112     case DT_RUNPATH:    return "RUNPATH";
2113     case DT_FLAGS:      return "FLAGS";
2114
2115     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2116     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2117     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2118
2119     case DT_CHECKSUM:   return "CHECKSUM";
2120     case DT_PLTPADSZ:   return "PLTPADSZ";
2121     case DT_MOVEENT:    return "MOVEENT";
2122     case DT_MOVESZ:     return "MOVESZ";
2123     case DT_FEATURE:    return "FEATURE";
2124     case DT_POSFLAG_1:  return "POSFLAG_1";
2125     case DT_SYMINSZ:    return "SYMINSZ";
2126     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2127
2128     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2129     case DT_CONFIG:     return "CONFIG";
2130     case DT_DEPAUDIT:   return "DEPAUDIT";
2131     case DT_AUDIT:      return "AUDIT";
2132     case DT_PLTPAD:     return "PLTPAD";
2133     case DT_MOVETAB:    return "MOVETAB";
2134     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2135
2136     case DT_VERSYM:     return "VERSYM";
2137
2138     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2139     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2140     case DT_RELACOUNT:  return "RELACOUNT";
2141     case DT_RELCOUNT:   return "RELCOUNT";
2142     case DT_FLAGS_1:    return "FLAGS_1";
2143     case DT_VERDEF:     return "VERDEF";
2144     case DT_VERDEFNUM:  return "VERDEFNUM";
2145     case DT_VERNEED:    return "VERNEED";
2146     case DT_VERNEEDNUM: return "VERNEEDNUM";
2147
2148     case DT_AUXILIARY:  return "AUXILIARY";
2149     case DT_USED:       return "USED";
2150     case DT_FILTER:     return "FILTER";
2151
2152     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2153     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2154     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2155     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2156     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2157     case DT_GNU_HASH:   return "GNU_HASH";
2158
2159     default:
2160       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2161         {
2162           const char * result;
2163
2164           switch (filedata->file_header.e_machine)
2165             {
2166             case EM_MIPS:
2167             case EM_MIPS_RS3_LE:
2168               result = get_mips_dynamic_type (type);
2169               break;
2170             case EM_SPARCV9:
2171               result = get_sparc64_dynamic_type (type);
2172               break;
2173             case EM_PPC:
2174               result = get_ppc_dynamic_type (type);
2175               break;
2176             case EM_PPC64:
2177               result = get_ppc64_dynamic_type (type);
2178               break;
2179             case EM_IA_64:
2180               result = get_ia64_dynamic_type (type);
2181               break;
2182             case EM_ALPHA:
2183               result = get_alpha_dynamic_type (type);
2184               break;
2185             case EM_SCORE:
2186               result = get_score_dynamic_type (type);
2187               break;
2188             case EM_TI_C6000:
2189               result = get_tic6x_dynamic_type (type);
2190               break;
2191             case EM_ALTERA_NIOS2:
2192               result = get_nios2_dynamic_type (type);
2193               break;
2194             default:
2195               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2196                 result = get_solaris_dynamic_type (type);
2197               else
2198                 result = NULL;
2199               break;
2200             }
2201
2202           if (result != NULL)
2203             return result;
2204
2205           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2206         }
2207       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2208                || (filedata->file_header.e_machine == EM_PARISC
2209                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2210         {
2211           const char * result;
2212
2213           switch (filedata->file_header.e_machine)
2214             {
2215             case EM_PARISC:
2216               result = get_parisc_dynamic_type (type);
2217               break;
2218             case EM_IA_64:
2219               result = get_ia64_dynamic_type (type);
2220               break;
2221             default:
2222               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2223                 result = get_solaris_dynamic_type (type);
2224               else
2225                 result = NULL;
2226               break;
2227             }
2228
2229           if (result != NULL)
2230             return result;
2231
2232           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2233                     type);
2234         }
2235       else
2236         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2237
2238       return buff;
2239     }
2240 }
2241
2242 static char *
2243 get_file_type (unsigned e_type)
2244 {
2245   static char buff[32];
2246
2247   switch (e_type)
2248     {
2249     case ET_NONE: return _("NONE (None)");
2250     case ET_REL:  return _("REL (Relocatable file)");
2251     case ET_EXEC: return _("EXEC (Executable file)");
2252     case ET_DYN:  return _("DYN (Shared object file)");
2253     case ET_CORE: return _("CORE (Core file)");
2254
2255     default:
2256       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2257         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2258       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2259         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2260       else
2261         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2262       return buff;
2263     }
2264 }
2265
2266 static char *
2267 get_machine_name (unsigned e_machine)
2268 {
2269   static char buff[64]; /* XXX */
2270
2271   switch (e_machine)
2272     {
2273       /* Please keep this switch table sorted by increasing EM_ value.  */
2274       /* 0 */
2275     case EM_NONE:               return _("None");
2276     case EM_M32:                return "WE32100";
2277     case EM_SPARC:              return "Sparc";
2278     case EM_386:                return "Intel 80386";
2279     case EM_68K:                return "MC68000";
2280     case EM_88K:                return "MC88000";
2281     case EM_IAMCU:              return "Intel MCU";
2282     case EM_860:                return "Intel 80860";
2283     case EM_MIPS:               return "MIPS R3000";
2284     case EM_S370:               return "IBM System/370";
2285       /* 10 */
2286     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2287     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2288     case EM_PARISC:             return "HPPA";
2289     case EM_VPP550:             return "Fujitsu VPP500";
2290     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2291     case EM_960:                return "Intel 80960";
2292     case EM_PPC:                return "PowerPC";
2293       /* 20 */
2294     case EM_PPC64:              return "PowerPC64";
2295     case EM_S390_OLD:
2296     case EM_S390:               return "IBM S/390";
2297     case EM_SPU:                return "SPU";
2298       /* 30 */
2299     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2300     case EM_FR20:               return "Fujitsu FR20";
2301     case EM_RH32:               return "TRW RH32";
2302     case EM_MCORE:              return "MCORE";
2303       /* 40 */
2304     case EM_ARM:                return "ARM";
2305     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2306     case EM_SH:                 return "Renesas / SuperH SH";
2307     case EM_SPARCV9:            return "Sparc v9";
2308     case EM_TRICORE:            return "Siemens Tricore";
2309     case EM_ARC:                return "ARC";
2310     case EM_H8_300:             return "Renesas H8/300";
2311     case EM_H8_300H:            return "Renesas H8/300H";
2312     case EM_H8S:                return "Renesas H8S";
2313     case EM_H8_500:             return "Renesas H8/500";
2314       /* 50 */
2315     case EM_IA_64:              return "Intel IA-64";
2316     case EM_MIPS_X:             return "Stanford MIPS-X";
2317     case EM_COLDFIRE:           return "Motorola Coldfire";
2318     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2319     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2320     case EM_PCP:                return "Siemens PCP";
2321     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2322     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2323     case EM_STARCORE:           return "Motorola Star*Core processor";
2324     case EM_ME16:               return "Toyota ME16 processor";
2325       /* 60 */
2326     case EM_ST100:              return "STMicroelectronics ST100 processor";
2327     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2328     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2329     case EM_PDSP:               return "Sony DSP processor";
2330     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2331     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2332     case EM_FX66:               return "Siemens FX66 microcontroller";
2333     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2334     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2335     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2336       /* 70 */
2337     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2338     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2339     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2340     case EM_SVX:                return "Silicon Graphics SVx";
2341     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2342     case EM_VAX:                return "Digital VAX";
2343     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2344     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2345     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2346     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2347       /* 80 */
2348     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2349     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2350     case EM_PRISM:              return "Vitesse Prism";
2351     case EM_AVR_OLD:
2352     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2353     case EM_CYGNUS_FR30:
2354     case EM_FR30:               return "Fujitsu FR30";
2355     case EM_CYGNUS_D10V:
2356     case EM_D10V:               return "d10v";
2357     case EM_CYGNUS_D30V:
2358     case EM_D30V:               return "d30v";
2359     case EM_CYGNUS_V850:
2360     case EM_V850:               return "Renesas V850";
2361     case EM_CYGNUS_M32R:
2362     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2363     case EM_CYGNUS_MN10300:
2364     case EM_MN10300:            return "mn10300";
2365       /* 90 */
2366     case EM_CYGNUS_MN10200:
2367     case EM_MN10200:            return "mn10200";
2368     case EM_PJ:                 return "picoJava";
2369     case EM_OR1K:               return "OpenRISC 1000";
2370     case EM_ARC_COMPACT:        return "ARCompact";
2371     case EM_XTENSA_OLD:
2372     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2373     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2374     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2375     case EM_NS32K:              return "National Semiconductor 32000 series";
2376     case EM_TPC:                return "Tenor Network TPC processor";
2377     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2378       /* 100 */
2379     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2380     case EM_IP2K_OLD:
2381     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2382     case EM_MAX:                return "MAX Processor";
2383     case EM_CR:                 return "National Semiconductor CompactRISC";
2384     case EM_F2MC16:             return "Fujitsu F2MC16";
2385     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2386     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2387     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2388     case EM_SEP:                return "Sharp embedded microprocessor";
2389     case EM_ARCA:               return "Arca RISC microprocessor";
2390       /* 110 */
2391     case EM_UNICORE:            return "Unicore";
2392     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2393     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2394     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2395     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2396     case EM_XGATE:              return "Motorola XGATE embedded processor";
2397     case EM_C166:
2398     case EM_XC16X:              return "Infineon Technologies xc16x";
2399     case EM_M16C:               return "Renesas M16C series microprocessors";
2400     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2401     case EM_CE:                 return "Freescale Communication Engine RISC core";
2402       /* 120 */
2403     case EM_M32C:               return "Renesas M32c";
2404       /* 130 */
2405     case EM_TSK3000:            return "Altium TSK3000 core";
2406     case EM_RS08:               return "Freescale RS08 embedded processor";
2407     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2408     case EM_SCORE:              return "SUNPLUS S+Core";
2409     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2410     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2411     case EM_LATTICEMICO32:      return "Lattice Mico32";
2412     case EM_SE_C17:             return "Seiko Epson C17 family";
2413       /* 140 */
2414     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2415     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2416     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2417     case EM_TI_PRU:             return "TI PRU I/O processor";
2418       /* 160 */
2419     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2420     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2421     case EM_R32C:               return "Renesas R32C series microprocessors";
2422     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2423     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2424     case EM_8051:               return "Intel 8051 and variants";
2425     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2426     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2427     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2428     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2429       /* 170 */
2430     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2431     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2432     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2433     case EM_RX:                 return "Renesas RX";
2434     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2435     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2436     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2437     case EM_CR16:
2438     case EM_MICROBLAZE:
2439     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2440     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2441     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2442       /* 180 */
2443     case EM_L1OM:               return "Intel L1OM";
2444     case EM_K1OM:               return "Intel K1OM";
2445     case EM_INTEL182:           return "Intel (reserved)";
2446     case EM_AARCH64:            return "AArch64";
2447     case EM_ARM184:             return "ARM (reserved)";
2448     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2449     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2450     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2451     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2452       /* 190 */
2453     case EM_CUDA:               return "NVIDIA CUDA architecture";
2454     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2455     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2456     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2457     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2458     case EM_ARC_COMPACT2:       return "ARCv2";
2459     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2460     case EM_RL78:               return "Renesas RL78";
2461     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2462     case EM_78K0R:              return "Renesas 78K0R";
2463       /* 200 */
2464     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2465     case EM_BA1:                return "Beyond BA1 CPU architecture";
2466     case EM_BA2:                return "Beyond BA2 CPU architecture";
2467     case EM_XCORE:              return "XMOS xCORE processor family";
2468     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2469       /* 210 */
2470     case EM_KM32:               return "KM211 KM32 32-bit processor";
2471     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2472     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2473     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2474     case EM_KVARC:              return "KM211 KVARC processor";
2475     case EM_CDP:                return "Paneve CDP architecture family";
2476     case EM_COGE:               return "Cognitive Smart Memory Processor";
2477     case EM_COOL:               return "Bluechip Systems CoolEngine";
2478     case EM_NORC:               return "Nanoradio Optimized RISC";
2479     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2480       /* 220 */
2481     case EM_Z80:                return "Zilog Z80";
2482     case EM_VISIUM:             return "CDS VISIUMcore processor";
2483     case EM_FT32:               return "FTDI Chip FT32";
2484     case EM_MOXIE:              return "Moxie";
2485     case EM_AMDGPU:             return "AMD GPU";
2486     case EM_RISCV:              return "RISC-V";
2487     case EM_LANAI:              return "Lanai 32-bit processor";
2488     case EM_BPF:                return "Linux BPF";
2489     case EM_NFP:                return "Netronome Flow Processor";
2490
2491       /* Large numbers...  */
2492     case EM_MT:                 return "Morpho Techologies MT processor";
2493     case EM_ALPHA:              return "Alpha";
2494     case EM_WEBASSEMBLY:        return "Web Assembly";
2495     case EM_DLX:                return "OpenDLX";
2496     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2497     case EM_IQ2000:             return "Vitesse IQ2000";
2498     case EM_M32C_OLD:
2499     case EM_NIOS32:             return "Altera Nios";
2500     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2501     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2502     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2503     case EM_S12Z:               return "Freescale S12Z";
2504
2505     default:
2506       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2507       return buff;
2508     }
2509 }
2510
2511 static void
2512 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2513 {
2514   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2515      other compilers don't a specific architecture type in the e_flags, and
2516      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2517      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2518      architectures.
2519
2520      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2521      but also sets a specific architecture type in the e_flags field.
2522
2523      However, when decoding the flags we don't worry if we see an
2524      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2525      ARCEM architecture type.  */
2526
2527   switch (e_flags & EF_ARC_MACH_MSK)
2528     {
2529       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2530     case EF_ARC_CPU_ARCV2EM:
2531       strcat (buf, ", ARC EM");
2532       break;
2533     case EF_ARC_CPU_ARCV2HS:
2534       strcat (buf, ", ARC HS");
2535       break;
2536
2537       /* We only expect these to occur for EM_ARC_COMPACT.  */
2538     case E_ARC_MACH_ARC600:
2539       strcat (buf, ", ARC600");
2540       break;
2541     case E_ARC_MACH_ARC601:
2542       strcat (buf, ", ARC601");
2543       break;
2544     case E_ARC_MACH_ARC700:
2545       strcat (buf, ", ARC700");
2546       break;
2547
2548       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2549          new ELF with new architecture being read by an old version of
2550          readelf, or (c) An ELF built with non-GNU compiler that does not
2551          set the architecture in the e_flags.  */
2552     default:
2553       if (e_machine == EM_ARC_COMPACT)
2554         strcat (buf, ", Unknown ARCompact");
2555       else
2556         strcat (buf, ", Unknown ARC");
2557       break;
2558     }
2559
2560   switch (e_flags & EF_ARC_OSABI_MSK)
2561     {
2562     case E_ARC_OSABI_ORIG:
2563       strcat (buf, ", (ABI:legacy)");
2564       break;
2565     case E_ARC_OSABI_V2:
2566       strcat (buf, ", (ABI:v2)");
2567       break;
2568       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2569     case E_ARC_OSABI_V3:
2570       strcat (buf, ", v3 no-legacy-syscalls ABI");
2571       break;
2572     case E_ARC_OSABI_V4:
2573       strcat (buf, ", v4 ABI");
2574       break;
2575     default:
2576       strcat (buf, ", unrecognised ARC OSABI flag");
2577       break;
2578     }
2579 }
2580
2581 static void
2582 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2583 {
2584   unsigned eabi;
2585   bfd_boolean unknown = FALSE;
2586
2587   eabi = EF_ARM_EABI_VERSION (e_flags);
2588   e_flags &= ~ EF_ARM_EABIMASK;
2589
2590   /* Handle "generic" ARM flags.  */
2591   if (e_flags & EF_ARM_RELEXEC)
2592     {
2593       strcat (buf, ", relocatable executable");
2594       e_flags &= ~ EF_ARM_RELEXEC;
2595     }
2596
2597   if (e_flags & EF_ARM_PIC)
2598     {
2599       strcat (buf, ", position independent");
2600       e_flags &= ~ EF_ARM_PIC;
2601     }
2602
2603   /* Now handle EABI specific flags.  */
2604   switch (eabi)
2605     {
2606     default:
2607       strcat (buf, ", <unrecognized EABI>");
2608       if (e_flags)
2609         unknown = TRUE;
2610       break;
2611
2612     case EF_ARM_EABI_VER1:
2613       strcat (buf, ", Version1 EABI");
2614       while (e_flags)
2615         {
2616           unsigned flag;
2617
2618           /* Process flags one bit at a time.  */
2619           flag = e_flags & - e_flags;
2620           e_flags &= ~ flag;
2621
2622           switch (flag)
2623             {
2624             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2625               strcat (buf, ", sorted symbol tables");
2626               break;
2627
2628             default:
2629               unknown = TRUE;
2630               break;
2631             }
2632         }
2633       break;
2634
2635     case EF_ARM_EABI_VER2:
2636       strcat (buf, ", Version2 EABI");
2637       while (e_flags)
2638         {
2639           unsigned flag;
2640
2641           /* Process flags one bit at a time.  */
2642           flag = e_flags & - e_flags;
2643           e_flags &= ~ flag;
2644
2645           switch (flag)
2646             {
2647             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2648               strcat (buf, ", sorted symbol tables");
2649               break;
2650
2651             case EF_ARM_DYNSYMSUSESEGIDX:
2652               strcat (buf, ", dynamic symbols use segment index");
2653               break;
2654
2655             case EF_ARM_MAPSYMSFIRST:
2656               strcat (buf, ", mapping symbols precede others");
2657               break;
2658
2659             default:
2660               unknown = TRUE;
2661               break;
2662             }
2663         }
2664       break;
2665
2666     case EF_ARM_EABI_VER3:
2667       strcat (buf, ", Version3 EABI");
2668       break;
2669
2670     case EF_ARM_EABI_VER4:
2671       strcat (buf, ", Version4 EABI");
2672       while (e_flags)
2673         {
2674           unsigned flag;
2675
2676           /* Process flags one bit at a time.  */
2677           flag = e_flags & - e_flags;
2678           e_flags &= ~ flag;
2679
2680           switch (flag)
2681             {
2682             case EF_ARM_BE8:
2683               strcat (buf, ", BE8");
2684               break;
2685
2686             case EF_ARM_LE8:
2687               strcat (buf, ", LE8");
2688               break;
2689
2690             default:
2691               unknown = TRUE;
2692               break;
2693             }
2694         }
2695       break;
2696
2697     case EF_ARM_EABI_VER5:
2698       strcat (buf, ", Version5 EABI");
2699       while (e_flags)
2700         {
2701           unsigned flag;
2702
2703           /* Process flags one bit at a time.  */
2704           flag = e_flags & - e_flags;
2705           e_flags &= ~ flag;
2706
2707           switch (flag)
2708             {
2709             case EF_ARM_BE8:
2710               strcat (buf, ", BE8");
2711               break;
2712
2713             case EF_ARM_LE8:
2714               strcat (buf, ", LE8");
2715               break;
2716
2717             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2718               strcat (buf, ", soft-float ABI");
2719               break;
2720
2721             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2722               strcat (buf, ", hard-float ABI");
2723               break;
2724
2725             default:
2726               unknown = TRUE;
2727               break;
2728             }
2729         }
2730       break;
2731
2732     case EF_ARM_EABI_UNKNOWN:
2733       strcat (buf, ", GNU EABI");
2734       while (e_flags)
2735         {
2736           unsigned flag;
2737
2738           /* Process flags one bit at a time.  */
2739           flag = e_flags & - e_flags;
2740           e_flags &= ~ flag;
2741
2742           switch (flag)
2743             {
2744             case EF_ARM_INTERWORK:
2745               strcat (buf, ", interworking enabled");
2746               break;
2747
2748             case EF_ARM_APCS_26:
2749               strcat (buf, ", uses APCS/26");
2750               break;
2751
2752             case EF_ARM_APCS_FLOAT:
2753               strcat (buf, ", uses APCS/float");
2754               break;
2755
2756             case EF_ARM_PIC:
2757               strcat (buf, ", position independent");
2758               break;
2759
2760             case EF_ARM_ALIGN8:
2761               strcat (buf, ", 8 bit structure alignment");
2762               break;
2763
2764             case EF_ARM_NEW_ABI:
2765               strcat (buf, ", uses new ABI");
2766               break;
2767
2768             case EF_ARM_OLD_ABI:
2769               strcat (buf, ", uses old ABI");
2770               break;
2771
2772             case EF_ARM_SOFT_FLOAT:
2773               strcat (buf, ", software FP");
2774               break;
2775
2776             case EF_ARM_VFP_FLOAT:
2777               strcat (buf, ", VFP");
2778               break;
2779
2780             case EF_ARM_MAVERICK_FLOAT:
2781               strcat (buf, ", Maverick FP");
2782               break;
2783
2784             default:
2785               unknown = TRUE;
2786               break;
2787             }
2788         }
2789     }
2790
2791   if (unknown)
2792     strcat (buf,_(", <unknown>"));
2793 }
2794
2795 static void
2796 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2797 {
2798   --size; /* Leave space for null terminator.  */
2799
2800   switch (e_flags & EF_AVR_MACH)
2801     {
2802     case E_AVR_MACH_AVR1:
2803       strncat (buf, ", avr:1", size);
2804       break;
2805     case E_AVR_MACH_AVR2:
2806       strncat (buf, ", avr:2", size);
2807       break;
2808     case E_AVR_MACH_AVR25:
2809       strncat (buf, ", avr:25", size);
2810       break;
2811     case E_AVR_MACH_AVR3:
2812       strncat (buf, ", avr:3", size);
2813       break;
2814     case E_AVR_MACH_AVR31:
2815       strncat (buf, ", avr:31", size);
2816       break;
2817     case E_AVR_MACH_AVR35:
2818       strncat (buf, ", avr:35", size);
2819       break;
2820     case E_AVR_MACH_AVR4:
2821       strncat (buf, ", avr:4", size);
2822       break;
2823     case E_AVR_MACH_AVR5:
2824       strncat (buf, ", avr:5", size);
2825       break;
2826     case E_AVR_MACH_AVR51:
2827       strncat (buf, ", avr:51", size);
2828       break;
2829     case E_AVR_MACH_AVR6:
2830       strncat (buf, ", avr:6", size);
2831       break;
2832     case E_AVR_MACH_AVRTINY:
2833       strncat (buf, ", avr:100", size);
2834       break;
2835     case E_AVR_MACH_XMEGA1:
2836       strncat (buf, ", avr:101", size);
2837       break;
2838     case E_AVR_MACH_XMEGA2:
2839       strncat (buf, ", avr:102", size);
2840       break;
2841     case E_AVR_MACH_XMEGA3:
2842       strncat (buf, ", avr:103", size);
2843       break;
2844     case E_AVR_MACH_XMEGA4:
2845       strncat (buf, ", avr:104", size);
2846       break;
2847     case E_AVR_MACH_XMEGA5:
2848       strncat (buf, ", avr:105", size);
2849       break;
2850     case E_AVR_MACH_XMEGA6:
2851       strncat (buf, ", avr:106", size);
2852       break;
2853     case E_AVR_MACH_XMEGA7:
2854       strncat (buf, ", avr:107", size);
2855       break;
2856     default:
2857       strncat (buf, ", avr:<unknown>", size);
2858       break;
2859     }
2860
2861   size -= strlen (buf);
2862   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2863     strncat (buf, ", link-relax", size);
2864 }
2865
2866 static void
2867 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2868 {
2869   unsigned abi;
2870   unsigned arch;
2871   unsigned config;
2872   unsigned version;
2873   bfd_boolean has_fpu = FALSE;
2874   unsigned int r = 0;
2875
2876   static const char *ABI_STRINGS[] =
2877   {
2878     "ABI v0", /* use r5 as return register; only used in N1213HC */
2879     "ABI v1", /* use r0 as return register */
2880     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2881     "ABI v2fp", /* for FPU */
2882     "AABI",
2883     "ABI2 FP+"
2884   };
2885   static const char *VER_STRINGS[] =
2886   {
2887     "Andes ELF V1.3 or older",
2888     "Andes ELF V1.3.1",
2889     "Andes ELF V1.4"
2890   };
2891   static const char *ARCH_STRINGS[] =
2892   {
2893     "",
2894     "Andes Star v1.0",
2895     "Andes Star v2.0",
2896     "Andes Star v3.0",
2897     "Andes Star v3.0m"
2898   };
2899
2900   abi = EF_NDS_ABI & e_flags;
2901   arch = EF_NDS_ARCH & e_flags;
2902   config = EF_NDS_INST & e_flags;
2903   version = EF_NDS32_ELF_VERSION & e_flags;
2904
2905   memset (buf, 0, size);
2906
2907   switch (abi)
2908     {
2909     case E_NDS_ABI_V0:
2910     case E_NDS_ABI_V1:
2911     case E_NDS_ABI_V2:
2912     case E_NDS_ABI_V2FP:
2913     case E_NDS_ABI_AABI:
2914     case E_NDS_ABI_V2FP_PLUS:
2915       /* In case there are holes in the array.  */
2916       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2917       break;
2918
2919     default:
2920       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2921       break;
2922     }
2923
2924   switch (version)
2925     {
2926     case E_NDS32_ELF_VER_1_2:
2927     case E_NDS32_ELF_VER_1_3:
2928     case E_NDS32_ELF_VER_1_4:
2929       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2930       break;
2931
2932     default:
2933       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2934       break;
2935     }
2936
2937   if (E_NDS_ABI_V0 == abi)
2938     {
2939       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2940       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2941       if (arch == E_NDS_ARCH_STAR_V1_0)
2942         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2943       return;
2944     }
2945
2946   switch (arch)
2947     {
2948     case E_NDS_ARCH_STAR_V1_0:
2949     case E_NDS_ARCH_STAR_V2_0:
2950     case E_NDS_ARCH_STAR_V3_0:
2951     case E_NDS_ARCH_STAR_V3_M:
2952       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2953       break;
2954
2955     default:
2956       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2957       /* ARCH version determines how the e_flags are interpreted.
2958          If it is unknown, we cannot proceed.  */
2959       return;
2960     }
2961
2962   /* Newer ABI; Now handle architecture specific flags.  */
2963   if (arch == E_NDS_ARCH_STAR_V1_0)
2964     {
2965       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2966         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2967
2968       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2969         r += snprintf (buf + r, size -r, ", MAC");
2970
2971       if (config & E_NDS32_HAS_DIV_INST)
2972         r += snprintf (buf + r, size -r, ", DIV");
2973
2974       if (config & E_NDS32_HAS_16BIT_INST)
2975         r += snprintf (buf + r, size -r, ", 16b");
2976     }
2977   else
2978     {
2979       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2980         {
2981           if (version <= E_NDS32_ELF_VER_1_3)
2982             r += snprintf (buf + r, size -r, ", [B8]");
2983           else
2984             r += snprintf (buf + r, size -r, ", EX9");
2985         }
2986
2987       if (config & E_NDS32_HAS_MAC_DX_INST)
2988         r += snprintf (buf + r, size -r, ", MAC_DX");
2989
2990       if (config & E_NDS32_HAS_DIV_DX_INST)
2991         r += snprintf (buf + r, size -r, ", DIV_DX");
2992
2993       if (config & E_NDS32_HAS_16BIT_INST)
2994         {
2995           if (version <= E_NDS32_ELF_VER_1_3)
2996             r += snprintf (buf + r, size -r, ", 16b");
2997           else
2998             r += snprintf (buf + r, size -r, ", IFC");
2999         }
3000     }
3001
3002   if (config & E_NDS32_HAS_EXT_INST)
3003     r += snprintf (buf + r, size -r, ", PERF1");
3004
3005   if (config & E_NDS32_HAS_EXT2_INST)
3006     r += snprintf (buf + r, size -r, ", PERF2");
3007
3008   if (config & E_NDS32_HAS_FPU_INST)
3009     {
3010       has_fpu = TRUE;
3011       r += snprintf (buf + r, size -r, ", FPU_SP");
3012     }
3013
3014   if (config & E_NDS32_HAS_FPU_DP_INST)
3015     {
3016       has_fpu = TRUE;
3017       r += snprintf (buf + r, size -r, ", FPU_DP");
3018     }
3019
3020   if (config & E_NDS32_HAS_FPU_MAC_INST)
3021     {
3022       has_fpu = TRUE;
3023       r += snprintf (buf + r, size -r, ", FPU_MAC");
3024     }
3025
3026   if (has_fpu)
3027     {
3028       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3029         {
3030         case E_NDS32_FPU_REG_8SP_4DP:
3031           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3032           break;
3033         case E_NDS32_FPU_REG_16SP_8DP:
3034           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3035           break;
3036         case E_NDS32_FPU_REG_32SP_16DP:
3037           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3038           break;
3039         case E_NDS32_FPU_REG_32SP_32DP:
3040           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3041           break;
3042         }
3043     }
3044
3045   if (config & E_NDS32_HAS_AUDIO_INST)
3046     r += snprintf (buf + r, size -r, ", AUDIO");
3047
3048   if (config & E_NDS32_HAS_STRING_INST)
3049     r += snprintf (buf + r, size -r, ", STR");
3050
3051   if (config & E_NDS32_HAS_REDUCED_REGS)
3052     r += snprintf (buf + r, size -r, ", 16REG");
3053
3054   if (config & E_NDS32_HAS_VIDEO_INST)
3055     {
3056       if (version <= E_NDS32_ELF_VER_1_3)
3057         r += snprintf (buf + r, size -r, ", VIDEO");
3058       else
3059         r += snprintf (buf + r, size -r, ", SATURATION");
3060     }
3061
3062   if (config & E_NDS32_HAS_ENCRIPT_INST)
3063     r += snprintf (buf + r, size -r, ", ENCRP");
3064
3065   if (config & E_NDS32_HAS_L2C_INST)
3066     r += snprintf (buf + r, size -r, ", L2C");
3067 }
3068
3069 static char *
3070 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3071 {
3072   static char buf[1024];
3073
3074   buf[0] = '\0';
3075
3076   if (e_flags)
3077     {
3078       switch (e_machine)
3079         {
3080         default:
3081           break;
3082
3083         case EM_ARC_COMPACT2:
3084         case EM_ARC_COMPACT:
3085           decode_ARC_machine_flags (e_flags, e_machine, buf);
3086           break;
3087
3088         case EM_ARM:
3089           decode_ARM_machine_flags (e_flags, buf);
3090           break;
3091
3092         case EM_AVR:
3093           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3094           break;
3095
3096         case EM_BLACKFIN:
3097           if (e_flags & EF_BFIN_PIC)
3098             strcat (buf, ", PIC");
3099
3100           if (e_flags & EF_BFIN_FDPIC)
3101             strcat (buf, ", FDPIC");
3102
3103           if (e_flags & EF_BFIN_CODE_IN_L1)
3104             strcat (buf, ", code in L1");
3105
3106           if (e_flags & EF_BFIN_DATA_IN_L1)
3107             strcat (buf, ", data in L1");
3108
3109           break;
3110
3111         case EM_CYGNUS_FRV:
3112           switch (e_flags & EF_FRV_CPU_MASK)
3113             {
3114             case EF_FRV_CPU_GENERIC:
3115               break;
3116
3117             default:
3118               strcat (buf, ", fr???");
3119               break;
3120
3121             case EF_FRV_CPU_FR300:
3122               strcat (buf, ", fr300");
3123               break;
3124
3125             case EF_FRV_CPU_FR400:
3126               strcat (buf, ", fr400");
3127               break;
3128             case EF_FRV_CPU_FR405:
3129               strcat (buf, ", fr405");
3130               break;
3131
3132             case EF_FRV_CPU_FR450:
3133               strcat (buf, ", fr450");
3134               break;
3135
3136             case EF_FRV_CPU_FR500:
3137               strcat (buf, ", fr500");
3138               break;
3139             case EF_FRV_CPU_FR550:
3140               strcat (buf, ", fr550");
3141               break;
3142
3143             case EF_FRV_CPU_SIMPLE:
3144               strcat (buf, ", simple");
3145               break;
3146             case EF_FRV_CPU_TOMCAT:
3147               strcat (buf, ", tomcat");
3148               break;
3149             }
3150           break;
3151
3152         case EM_68K:
3153           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3154             strcat (buf, ", m68000");
3155           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3156             strcat (buf, ", cpu32");
3157           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3158             strcat (buf, ", fido_a");
3159           else
3160             {
3161               char const * isa = _("unknown");
3162               char const * mac = _("unknown mac");
3163               char const * additional = NULL;
3164
3165               switch (e_flags & EF_M68K_CF_ISA_MASK)
3166                 {
3167                 case EF_M68K_CF_ISA_A_NODIV:
3168                   isa = "A";
3169                   additional = ", nodiv";
3170                   break;
3171                 case EF_M68K_CF_ISA_A:
3172                   isa = "A";
3173                   break;
3174                 case EF_M68K_CF_ISA_A_PLUS:
3175                   isa = "A+";
3176                   break;
3177                 case EF_M68K_CF_ISA_B_NOUSP:
3178                   isa = "B";
3179                   additional = ", nousp";
3180                   break;
3181                 case EF_M68K_CF_ISA_B:
3182                   isa = "B";
3183                   break;
3184                 case EF_M68K_CF_ISA_C:
3185                   isa = "C";
3186                   break;
3187                 case EF_M68K_CF_ISA_C_NODIV:
3188                   isa = "C";
3189                   additional = ", nodiv";
3190                   break;
3191                 }
3192               strcat (buf, ", cf, isa ");
3193               strcat (buf, isa);
3194               if (additional)
3195                 strcat (buf, additional);
3196               if (e_flags & EF_M68K_CF_FLOAT)
3197                 strcat (buf, ", float");
3198               switch (e_flags & EF_M68K_CF_MAC_MASK)
3199                 {
3200                 case 0:
3201                   mac = NULL;
3202                   break;
3203                 case EF_M68K_CF_MAC:
3204                   mac = "mac";
3205                   break;
3206                 case EF_M68K_CF_EMAC:
3207                   mac = "emac";
3208                   break;
3209                 case EF_M68K_CF_EMAC_B:
3210                   mac = "emac_b";
3211                   break;
3212                 }
3213               if (mac)
3214                 {
3215                   strcat (buf, ", ");
3216                   strcat (buf, mac);
3217                 }
3218             }
3219           break;
3220
3221         case EM_CYGNUS_MEP:
3222           switch (e_flags & EF_MEP_CPU_MASK)
3223             {
3224             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3225             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3226             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3227             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3228             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3229             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3230             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3231             }
3232
3233           switch (e_flags & EF_MEP_COP_MASK)
3234             {
3235             case EF_MEP_COP_NONE: break;
3236             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3237             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3238             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3239             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3240             default: strcat (buf, _("<unknown MeP copro type>")); break;
3241             }
3242
3243           if (e_flags & EF_MEP_LIBRARY)
3244             strcat (buf, ", Built for Library");
3245
3246           if (e_flags & EF_MEP_INDEX_MASK)
3247             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3248                      e_flags & EF_MEP_INDEX_MASK);
3249
3250           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3251             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3252                      e_flags & ~ EF_MEP_ALL_FLAGS);
3253           break;
3254
3255         case EM_PPC:
3256           if (e_flags & EF_PPC_EMB)
3257             strcat (buf, ", emb");
3258
3259           if (e_flags & EF_PPC_RELOCATABLE)
3260             strcat (buf, _(", relocatable"));
3261
3262           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3263             strcat (buf, _(", relocatable-lib"));
3264           break;
3265
3266         case EM_PPC64:
3267           if (e_flags & EF_PPC64_ABI)
3268             {
3269               char abi[] = ", abiv0";
3270
3271               abi[6] += e_flags & EF_PPC64_ABI;
3272               strcat (buf, abi);
3273             }
3274           break;
3275
3276         case EM_V800:
3277           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3278             strcat (buf, ", RH850 ABI");
3279
3280           if (e_flags & EF_V800_850E3)
3281             strcat (buf, ", V3 architecture");
3282
3283           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3284             strcat (buf, ", FPU not used");
3285
3286           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3287             strcat (buf, ", regmode: COMMON");
3288
3289           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3290             strcat (buf, ", r4 not used");
3291
3292           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3293             strcat (buf, ", r30 not used");
3294
3295           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3296             strcat (buf, ", r5 not used");
3297
3298           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3299             strcat (buf, ", r2 not used");
3300
3301           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3302             {
3303               switch (e_flags & - e_flags)
3304                 {
3305                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3306                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3307                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3308                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3309                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3310                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3311                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3312                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3313                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3314                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3315                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3316                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3317                 default: break;
3318                 }
3319             }
3320           break;
3321
3322         case EM_V850:
3323         case EM_CYGNUS_V850:
3324           switch (e_flags & EF_V850_ARCH)
3325             {
3326             case E_V850E3V5_ARCH:
3327               strcat (buf, ", v850e3v5");
3328               break;
3329             case E_V850E2V3_ARCH:
3330               strcat (buf, ", v850e2v3");
3331               break;
3332             case E_V850E2_ARCH:
3333               strcat (buf, ", v850e2");
3334               break;
3335             case E_V850E1_ARCH:
3336               strcat (buf, ", v850e1");
3337               break;
3338             case E_V850E_ARCH:
3339               strcat (buf, ", v850e");
3340               break;
3341             case E_V850_ARCH:
3342               strcat (buf, ", v850");
3343               break;
3344             default:
3345               strcat (buf, _(", unknown v850 architecture variant"));
3346               break;
3347             }
3348           break;
3349
3350         case EM_M32R:
3351         case EM_CYGNUS_M32R:
3352           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3353             strcat (buf, ", m32r");
3354           break;
3355
3356         case EM_MIPS:
3357         case EM_MIPS_RS3_LE:
3358           if (e_flags & EF_MIPS_NOREORDER)
3359             strcat (buf, ", noreorder");
3360
3361           if (e_flags & EF_MIPS_PIC)
3362             strcat (buf, ", pic");
3363
3364           if (e_flags & EF_MIPS_CPIC)
3365             strcat (buf, ", cpic");
3366
3367           if (e_flags & EF_MIPS_UCODE)
3368             strcat (buf, ", ugen_reserved");
3369
3370           if (e_flags & EF_MIPS_ABI2)
3371             strcat (buf, ", abi2");
3372
3373           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3374             strcat (buf, ", odk first");
3375
3376           if (e_flags & EF_MIPS_32BITMODE)
3377             strcat (buf, ", 32bitmode");
3378
3379           if (e_flags & EF_MIPS_NAN2008)
3380             strcat (buf, ", nan2008");
3381
3382           if (e_flags & EF_MIPS_FP64)
3383             strcat (buf, ", fp64");
3384
3385           switch ((e_flags & EF_MIPS_MACH))
3386             {
3387             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3388             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3389             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3390             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3391             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3392             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3393             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3394             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3395             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3396             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3397             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3398             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3399             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3400             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3401             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3402             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3403             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3404             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3405             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3406             case 0:
3407             /* We simply ignore the field in this case to avoid confusion:
3408                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3409                extension.  */
3410               break;
3411             default: strcat (buf, _(", unknown CPU")); break;
3412             }
3413
3414           switch ((e_flags & EF_MIPS_ABI))
3415             {
3416             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3417             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3418             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3419             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3420             case 0:
3421             /* We simply ignore the field in this case to avoid confusion:
3422                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3423                This means it is likely to be an o32 file, but not for
3424                sure.  */
3425               break;
3426             default: strcat (buf, _(", unknown ABI")); break;
3427             }
3428
3429           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3430             strcat (buf, ", mdmx");
3431
3432           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3433             strcat (buf, ", mips16");
3434
3435           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3436             strcat (buf, ", micromips");
3437
3438           switch ((e_flags & EF_MIPS_ARCH))
3439             {
3440             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3441             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3442             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3443             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3444             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3445             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3446             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3447             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3448             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3449             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3450             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3451             default: strcat (buf, _(", unknown ISA")); break;
3452             }
3453           break;
3454
3455         case EM_NDS32:
3456           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3457           break;
3458
3459         case EM_NFP:
3460           switch (EF_NFP_MACH (e_flags))
3461             {
3462             case E_NFP_MACH_3200:
3463               strcat (buf, ", NFP-32xx");
3464               break;
3465             case E_NFP_MACH_6000:
3466               strcat (buf, ", NFP-6xxx");
3467               break;
3468             }
3469           break;
3470
3471         case EM_RISCV:
3472           if (e_flags & EF_RISCV_RVC)
3473             strcat (buf, ", RVC");
3474
3475           if (e_flags & EF_RISCV_RVE)
3476             strcat (buf, ", RVE");
3477
3478           switch (e_flags & EF_RISCV_FLOAT_ABI)
3479             {
3480             case EF_RISCV_FLOAT_ABI_SOFT:
3481               strcat (buf, ", soft-float ABI");
3482               break;
3483
3484             case EF_RISCV_FLOAT_ABI_SINGLE:
3485               strcat (buf, ", single-float ABI");
3486               break;
3487
3488             case EF_RISCV_FLOAT_ABI_DOUBLE:
3489               strcat (buf, ", double-float ABI");
3490               break;
3491
3492             case EF_RISCV_FLOAT_ABI_QUAD:
3493               strcat (buf, ", quad-float ABI");
3494               break;
3495             }
3496           break;
3497
3498         case EM_SH:
3499           switch ((e_flags & EF_SH_MACH_MASK))
3500             {
3501             case EF_SH1: strcat (buf, ", sh1"); break;
3502             case EF_SH2: strcat (buf, ", sh2"); break;
3503             case EF_SH3: strcat (buf, ", sh3"); break;
3504             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3505             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3506             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3507             case EF_SH3E: strcat (buf, ", sh3e"); break;
3508             case EF_SH4: strcat (buf, ", sh4"); break;
3509             case EF_SH5: strcat (buf, ", sh5"); break;
3510             case EF_SH2E: strcat (buf, ", sh2e"); break;
3511             case EF_SH4A: strcat (buf, ", sh4a"); break;
3512             case EF_SH2A: strcat (buf, ", sh2a"); break;
3513             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3514             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3515             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3516             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3517             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3518             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3519             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3520             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3521             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3522             default: strcat (buf, _(", unknown ISA")); break;
3523             }
3524
3525           if (e_flags & EF_SH_PIC)
3526             strcat (buf, ", pic");
3527
3528           if (e_flags & EF_SH_FDPIC)
3529             strcat (buf, ", fdpic");
3530           break;
3531
3532         case EM_OR1K:
3533           if (e_flags & EF_OR1K_NODELAY)
3534             strcat (buf, ", no delay");
3535           break;
3536
3537         case EM_SPARCV9:
3538           if (e_flags & EF_SPARC_32PLUS)
3539             strcat (buf, ", v8+");
3540
3541           if (e_flags & EF_SPARC_SUN_US1)
3542             strcat (buf, ", ultrasparcI");
3543
3544           if (e_flags & EF_SPARC_SUN_US3)
3545             strcat (buf, ", ultrasparcIII");
3546
3547           if (e_flags & EF_SPARC_HAL_R1)
3548             strcat (buf, ", halr1");
3549
3550           if (e_flags & EF_SPARC_LEDATA)
3551             strcat (buf, ", ledata");
3552
3553           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3554             strcat (buf, ", tso");
3555
3556           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3557             strcat (buf, ", pso");
3558
3559           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3560             strcat (buf, ", rmo");
3561           break;
3562
3563         case EM_PARISC:
3564           switch (e_flags & EF_PARISC_ARCH)
3565             {
3566             case EFA_PARISC_1_0:
3567               strcpy (buf, ", PA-RISC 1.0");
3568               break;
3569             case EFA_PARISC_1_1:
3570               strcpy (buf, ", PA-RISC 1.1");
3571               break;
3572             case EFA_PARISC_2_0:
3573               strcpy (buf, ", PA-RISC 2.0");
3574               break;
3575             default:
3576               break;
3577             }
3578           if (e_flags & EF_PARISC_TRAPNIL)
3579             strcat (buf, ", trapnil");
3580           if (e_flags & EF_PARISC_EXT)
3581             strcat (buf, ", ext");
3582           if (e_flags & EF_PARISC_LSB)
3583             strcat (buf, ", lsb");
3584           if (e_flags & EF_PARISC_WIDE)
3585             strcat (buf, ", wide");
3586           if (e_flags & EF_PARISC_NO_KABP)
3587             strcat (buf, ", no kabp");
3588           if (e_flags & EF_PARISC_LAZYSWAP)
3589             strcat (buf, ", lazyswap");
3590           break;
3591
3592         case EM_PJ:
3593         case EM_PJ_OLD:
3594           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3595             strcat (buf, ", new calling convention");
3596
3597           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3598             strcat (buf, ", gnu calling convention");
3599           break;
3600
3601         case EM_IA_64:
3602           if ((e_flags & EF_IA_64_ABI64))
3603             strcat (buf, ", 64-bit");
3604           else
3605             strcat (buf, ", 32-bit");
3606           if ((e_flags & EF_IA_64_REDUCEDFP))
3607             strcat (buf, ", reduced fp model");
3608           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3609             strcat (buf, ", no function descriptors, constant gp");
3610           else if ((e_flags & EF_IA_64_CONS_GP))
3611             strcat (buf, ", constant gp");
3612           if ((e_flags & EF_IA_64_ABSOLUTE))
3613             strcat (buf, ", absolute");
3614           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3615             {
3616               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3617                 strcat (buf, ", vms_linkages");
3618               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3619                 {
3620                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3621                   break;
3622                 case EF_IA_64_VMS_COMCOD_WARNING:
3623                   strcat (buf, ", warning");
3624                   break;
3625                 case EF_IA_64_VMS_COMCOD_ERROR:
3626                   strcat (buf, ", error");
3627                   break;
3628                 case EF_IA_64_VMS_COMCOD_ABORT:
3629                   strcat (buf, ", abort");
3630                   break;
3631                 default:
3632                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3633                         e_flags & EF_IA_64_VMS_COMCOD);
3634                   strcat (buf, ", <unknown>");
3635                 }
3636             }
3637           break;
3638
3639         case EM_VAX:
3640           if ((e_flags & EF_VAX_NONPIC))
3641             strcat (buf, ", non-PIC");
3642           if ((e_flags & EF_VAX_DFLOAT))
3643             strcat (buf, ", D-Float");
3644           if ((e_flags & EF_VAX_GFLOAT))
3645             strcat (buf, ", G-Float");
3646           break;
3647
3648         case EM_VISIUM:
3649           if (e_flags & EF_VISIUM_ARCH_MCM)
3650             strcat (buf, ", mcm");
3651           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3652             strcat (buf, ", mcm24");
3653           if (e_flags & EF_VISIUM_ARCH_GR6)
3654             strcat (buf, ", gr6");
3655           break;
3656
3657         case EM_RL78:
3658           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3659             {
3660             case E_FLAG_RL78_ANY_CPU: break;
3661             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3662             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3663             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3664             }
3665           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3666             strcat (buf, ", 64-bit doubles");
3667           break;
3668
3669         case EM_RX:
3670           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3671             strcat (buf, ", 64-bit doubles");
3672           if (e_flags & E_FLAG_RX_DSP)
3673             strcat (buf, ", dsp");
3674           if (e_flags & E_FLAG_RX_PID)
3675             strcat (buf, ", pid");
3676           if (e_flags & E_FLAG_RX_ABI)
3677             strcat (buf, ", RX ABI");
3678           if (e_flags & E_FLAG_RX_SINSNS_SET)
3679             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3680                     ? ", uses String instructions" : ", bans String instructions");
3681           if (e_flags & E_FLAG_RX_V2)
3682             strcat (buf, ", V2");
3683           break;
3684
3685         case EM_S390:
3686           if (e_flags & EF_S390_HIGH_GPRS)
3687             strcat (buf, ", highgprs");
3688           break;
3689
3690         case EM_TI_C6000:
3691           if ((e_flags & EF_C6000_REL))
3692             strcat (buf, ", relocatable module");
3693           break;
3694
3695         case EM_MSP430:
3696           strcat (buf, _(": architecture variant: "));
3697           switch (e_flags & EF_MSP430_MACH)
3698             {
3699             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3700             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3701             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3702             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3703             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3704             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3705             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3706             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3707             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3708             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3709             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3710             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3711             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3712             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3713             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3714             default:
3715               strcat (buf, _(": unknown")); break;
3716             }
3717
3718           if (e_flags & ~ EF_MSP430_MACH)
3719             strcat (buf, _(": unknown extra flag bits also present"));
3720         }
3721     }
3722
3723   return buf;
3724 }
3725
3726 static const char *
3727 get_osabi_name (Filedata * filedata, unsigned int osabi)
3728 {
3729   static char buff[32];
3730
3731   switch (osabi)
3732     {
3733     case ELFOSABI_NONE:         return "UNIX - System V";
3734     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3735     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3736     case ELFOSABI_GNU:          return "UNIX - GNU";
3737     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3738     case ELFOSABI_AIX:          return "UNIX - AIX";
3739     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3740     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3741     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3742     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3743     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3744     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3745     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3746     case ELFOSABI_AROS:         return "AROS";
3747     case ELFOSABI_FENIXOS:      return "FenixOS";
3748     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3749     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3750     default:
3751       if (osabi >= 64)
3752         switch (filedata->file_header.e_machine)
3753           {
3754           case EM_ARM:
3755             switch (osabi)
3756               {
3757               case ELFOSABI_ARM:        return "ARM";
3758               case ELFOSABI_ARM_FDPIC:  return "ARM FDPIC";
3759               default:
3760                 break;
3761               }
3762             break;
3763
3764           case EM_MSP430:
3765           case EM_MSP430_OLD:
3766           case EM_VISIUM:
3767             switch (osabi)
3768               {
3769               case ELFOSABI_STANDALONE: return _("Standalone App");
3770               default:
3771                 break;
3772               }
3773             break;
3774
3775           case EM_TI_C6000:
3776             switch (osabi)
3777               {
3778               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3779               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3780               default:
3781                 break;
3782               }
3783             break;
3784
3785           default:
3786             break;
3787           }
3788       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3789       return buff;
3790     }
3791 }
3792
3793 static const char *
3794 get_aarch64_segment_type (unsigned long type)
3795 {
3796   switch (type)
3797     {
3798     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3799     default:                  return NULL;
3800     }
3801 }
3802
3803 static const char *
3804 get_arm_segment_type (unsigned long type)
3805 {
3806   switch (type)
3807     {
3808     case PT_ARM_EXIDX: return "EXIDX";
3809     default:           return NULL;
3810     }
3811 }
3812
3813 static const char *
3814 get_s390_segment_type (unsigned long type)
3815 {
3816   switch (type)
3817     {
3818     case PT_S390_PGSTE: return "S390_PGSTE";
3819     default:            return NULL;
3820     }
3821 }
3822
3823 static const char *
3824 get_mips_segment_type (unsigned long type)
3825 {
3826   switch (type)
3827     {
3828     case PT_MIPS_REGINFO:   return "REGINFO";
3829     case PT_MIPS_RTPROC:    return "RTPROC";
3830     case PT_MIPS_OPTIONS:   return "OPTIONS";
3831     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3832     default:                return NULL;
3833     }
3834 }
3835
3836 static const char *
3837 get_parisc_segment_type (unsigned long type)
3838 {
3839   switch (type)
3840     {
3841     case PT_HP_TLS:             return "HP_TLS";
3842     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3843     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3844     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3845     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3846     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3847     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3848     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3849     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3850     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3851     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3852     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3853     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3854     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3855     case PT_HP_STACK:           return "HP_STACK";
3856     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3857     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3858     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3859     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3860     default:                    return NULL;
3861     }
3862 }
3863
3864 static const char *
3865 get_ia64_segment_type (unsigned long type)
3866 {
3867   switch (type)
3868     {
3869     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3870     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3871     case PT_HP_TLS:             return "HP_TLS";
3872     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3873     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3874     case PT_IA_64_HP_STACK:     return "HP_STACK";
3875     default:                    return NULL;
3876     }
3877 }
3878
3879 static const char *
3880 get_tic6x_segment_type (unsigned long type)
3881 {
3882   switch (type)
3883     {
3884     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3885     default:               return NULL;
3886     }
3887 }
3888
3889 static const char *
3890 get_solaris_segment_type (unsigned long type)
3891 {
3892   switch (type)
3893     {
3894     case 0x6464e550: return "PT_SUNW_UNWIND";
3895     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3896     case 0x6ffffff7: return "PT_LOSUNW";
3897     case 0x6ffffffa: return "PT_SUNWBSS";
3898     case 0x6ffffffb: return "PT_SUNWSTACK";
3899     case 0x6ffffffc: return "PT_SUNWDTRACE";
3900     case 0x6ffffffd: return "PT_SUNWCAP";
3901     case 0x6fffffff: return "PT_HISUNW";
3902     default:         return NULL;
3903     }
3904 }
3905
3906 static const char *
3907 get_segment_type (Filedata * filedata, unsigned long p_type)
3908 {
3909   static char buff[32];
3910
3911   switch (p_type)
3912     {
3913     case PT_NULL:       return "NULL";
3914     case PT_LOAD:       return "LOAD";
3915     case PT_DYNAMIC:    return "DYNAMIC";
3916     case PT_INTERP:     return "INTERP";
3917     case PT_NOTE:       return "NOTE";
3918     case PT_SHLIB:      return "SHLIB";
3919     case PT_PHDR:       return "PHDR";
3920     case PT_TLS:        return "TLS";
3921     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3922     case PT_GNU_STACK:  return "GNU_STACK";
3923     case PT_GNU_RELRO:  return "GNU_RELRO";
3924
3925     default:
3926       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3927         {
3928           sprintf (buff, "GNU_MBIND+%#lx",
3929                    p_type - PT_GNU_MBIND_LO);
3930         }
3931       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3932         {
3933           const char * result;
3934
3935           switch (filedata->file_header.e_machine)
3936             {
3937             case EM_AARCH64:
3938               result = get_aarch64_segment_type (p_type);
3939               break;
3940             case EM_ARM:
3941               result = get_arm_segment_type (p_type);
3942               break;
3943             case EM_MIPS:
3944             case EM_MIPS_RS3_LE:
3945               result = get_mips_segment_type (p_type);
3946               break;
3947             case EM_PARISC:
3948               result = get_parisc_segment_type (p_type);
3949               break;
3950             case EM_IA_64:
3951               result = get_ia64_segment_type (p_type);
3952               break;
3953             case EM_TI_C6000:
3954               result = get_tic6x_segment_type (p_type);
3955               break;
3956             case EM_S390:
3957             case EM_S390_OLD:
3958               result = get_s390_segment_type (p_type);
3959               break;
3960             default:
3961               result = NULL;
3962               break;
3963             }
3964
3965           if (result != NULL)
3966             return result;
3967
3968           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3969         }
3970       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3971         {
3972           const char * result;
3973
3974           switch (filedata->file_header.e_machine)
3975             {
3976             case EM_PARISC:
3977               result = get_parisc_segment_type (p_type);
3978               break;
3979             case EM_IA_64:
3980               result = get_ia64_segment_type (p_type);
3981               break;
3982             default:
3983               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3984                 result = get_solaris_segment_type (p_type);
3985               else
3986                 result = NULL;
3987               break;
3988             }
3989
3990           if (result != NULL)
3991             return result;
3992
3993           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3994         }
3995       else
3996         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3997
3998       return buff;
3999     }
4000 }
4001
4002 static const char *
4003 get_arc_section_type_name (unsigned int sh_type)
4004 {
4005   switch (sh_type)
4006     {
4007     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
4008     default:
4009       break;
4010     }
4011   return NULL;
4012 }
4013
4014 static const char *
4015 get_mips_section_type_name (unsigned int sh_type)
4016 {
4017   switch (sh_type)
4018     {
4019     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
4020     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
4021     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
4022     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
4023     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
4024     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
4025     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
4026     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
4027     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
4028     case SHT_MIPS_RELD:          return "MIPS_RELD";
4029     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
4030     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
4031     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
4032     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
4033     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
4034     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
4035     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
4036     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
4037     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
4038     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4039     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4040     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4041     case SHT_MIPS_LINE:          return "MIPS_LINE";
4042     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4043     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4044     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4045     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4046     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4047     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4048     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4049     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4050     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4051     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4052     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4053     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4054     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4055     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4056     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4057     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4058     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4059     default:
4060       break;
4061     }
4062   return NULL;
4063 }
4064
4065 static const char *
4066 get_parisc_section_type_name (unsigned int sh_type)
4067 {
4068   switch (sh_type)
4069     {
4070     case SHT_PARISC_EXT:        return "PARISC_EXT";
4071     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4072     case SHT_PARISC_DOC:        return "PARISC_DOC";
4073     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4074     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4075     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4076     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4077     default:                    return NULL;
4078     }
4079 }
4080
4081 static const char *
4082 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4083 {
4084   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4085   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4086     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4087
4088   switch (sh_type)
4089     {
4090     case SHT_IA_64_EXT:                return "IA_64_EXT";
4091     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4092     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4093     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4094     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4095     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4096     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4097     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4098     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4099     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4100     default:
4101       break;
4102     }
4103   return NULL;
4104 }
4105
4106 static const char *
4107 get_x86_64_section_type_name (unsigned int sh_type)
4108 {
4109   switch (sh_type)
4110     {
4111     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4112     default:                    return NULL;
4113     }
4114 }
4115
4116 static const char *
4117 get_aarch64_section_type_name (unsigned int sh_type)
4118 {
4119   switch (sh_type)
4120     {
4121     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4122     default:                     return NULL;
4123     }
4124 }
4125
4126 static const char *
4127 get_arm_section_type_name (unsigned int sh_type)
4128 {
4129   switch (sh_type)
4130     {
4131     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4132     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4133     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4134     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4135     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4136     default:                      return NULL;
4137     }
4138 }
4139
4140 static const char *
4141 get_tic6x_section_type_name (unsigned int sh_type)
4142 {
4143   switch (sh_type)
4144     {
4145     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4146     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4147     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4148     case SHT_TI_ICODE:          return "TI_ICODE";
4149     case SHT_TI_XREF:           return "TI_XREF";
4150     case SHT_TI_HANDLER:        return "TI_HANDLER";
4151     case SHT_TI_INITINFO:       return "TI_INITINFO";
4152     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4153     default:                    return NULL;
4154     }
4155 }
4156
4157 static const char *
4158 get_msp430x_section_type_name (unsigned int sh_type)
4159 {
4160   switch (sh_type)
4161     {
4162     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4163     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4164     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4165     default:                      return NULL;
4166     }
4167 }
4168
4169 static const char *
4170 get_nfp_section_type_name (unsigned int sh_type)
4171 {
4172   switch (sh_type)
4173     {
4174     case SHT_NFP_MECONFIG:      return "NFP_MECONFIG";
4175     case SHT_NFP_INITREG:       return "NFP_INITREG";
4176     case SHT_NFP_UDEBUG:        return "NFP_UDEBUG";
4177     default:                    return NULL;
4178     }
4179 }
4180
4181 static const char *
4182 get_v850_section_type_name (unsigned int sh_type)
4183 {
4184   switch (sh_type)
4185     {
4186     case SHT_V850_SCOMMON:  return "V850 Small Common";
4187     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4188     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4189     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4190     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4191     default:                return NULL;
4192     }
4193 }
4194
4195 static const char *
4196 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4197 {
4198   static char buff[32];
4199   const char * result;
4200
4201   switch (sh_type)
4202     {
4203     case SHT_NULL:              return "NULL";
4204     case SHT_PROGBITS:          return "PROGBITS";
4205     case SHT_SYMTAB:            return "SYMTAB";
4206     case SHT_STRTAB:            return "STRTAB";
4207     case SHT_RELA:              return "RELA";
4208     case SHT_HASH:              return "HASH";
4209     case SHT_DYNAMIC:           return "DYNAMIC";
4210     case SHT_NOTE:              return "NOTE";
4211     case SHT_NOBITS:            return "NOBITS";
4212     case SHT_REL:               return "REL";
4213     case SHT_SHLIB:             return "SHLIB";
4214     case SHT_DYNSYM:            return "DYNSYM";
4215     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4216     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4217     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4218     case SHT_GNU_HASH:          return "GNU_HASH";
4219     case SHT_GROUP:             return "GROUP";
4220     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
4221     case SHT_GNU_verdef:        return "VERDEF";
4222     case SHT_GNU_verneed:       return "VERNEED";
4223     case SHT_GNU_versym:        return "VERSYM";
4224     case 0x6ffffff0:            return "VERSYM";
4225     case 0x6ffffffc:            return "VERDEF";
4226     case 0x7ffffffd:            return "AUXILIARY";
4227     case 0x7fffffff:            return "FILTER";
4228     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4229
4230     default:
4231       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4232         {
4233           switch (filedata->file_header.e_machine)
4234             {
4235             case EM_ARC:
4236             case EM_ARC_COMPACT:
4237             case EM_ARC_COMPACT2:
4238               result = get_arc_section_type_name (sh_type);
4239               break;
4240             case EM_MIPS:
4241             case EM_MIPS_RS3_LE:
4242               result = get_mips_section_type_name (sh_type);
4243               break;
4244             case EM_PARISC:
4245               result = get_parisc_section_type_name (sh_type);
4246               break;
4247             case EM_IA_64:
4248               result = get_ia64_section_type_name (filedata, sh_type);
4249               break;
4250             case EM_X86_64:
4251             case EM_L1OM:
4252             case EM_K1OM:
4253               result = get_x86_64_section_type_name (sh_type);
4254               break;
4255             case EM_AARCH64:
4256               result = get_aarch64_section_type_name (sh_type);
4257               break;
4258             case EM_ARM:
4259               result = get_arm_section_type_name (sh_type);
4260               break;
4261             case EM_TI_C6000:
4262               result = get_tic6x_section_type_name (sh_type);
4263               break;
4264             case EM_MSP430:
4265               result = get_msp430x_section_type_name (sh_type);
4266               break;
4267             case EM_NFP:
4268               result = get_nfp_section_type_name (sh_type);
4269               break;
4270             case EM_V800:
4271             case EM_V850:
4272             case EM_CYGNUS_V850:
4273               result = get_v850_section_type_name (sh_type);
4274               break;
4275             default:
4276               result = NULL;
4277               break;
4278             }
4279
4280           if (result != NULL)
4281             return result;
4282
4283           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4284         }
4285       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4286         {
4287           switch (filedata->file_header.e_machine)
4288             {
4289             case EM_IA_64:
4290               result = get_ia64_section_type_name (filedata, sh_type);
4291               break;
4292             default:
4293               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4294                 result = get_solaris_section_type (sh_type);
4295               else
4296                 {
4297                   switch (sh_type)
4298                     {
4299                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4300                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4301                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4302                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4303                     default:
4304                       result = NULL;
4305                       break;
4306                     }
4307                 }
4308               break;
4309             }
4310
4311           if (result != NULL)
4312             return result;
4313
4314           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4315         }
4316       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4317         {
4318           switch (filedata->file_header.e_machine)
4319             {
4320             case EM_V800:
4321             case EM_V850:
4322             case EM_CYGNUS_V850:
4323               result = get_v850_section_type_name (sh_type);
4324               break;
4325             default:
4326               result = NULL;
4327               break;
4328             }
4329
4330           if (result != NULL)
4331             return result;
4332
4333           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4334         }
4335       else
4336         /* This message is probably going to be displayed in a 15
4337            character wide field, so put the hex value first.  */
4338         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4339
4340       return buff;
4341     }
4342 }
4343
4344 #define OPTION_DEBUG_DUMP       512
4345 #define OPTION_DYN_SYMS         513
4346 #define OPTION_DWARF_DEPTH      514
4347 #define OPTION_DWARF_START      515
4348 #define OPTION_DWARF_CHECK      516
4349
4350 static struct option options[] =
4351 {
4352   {"all",              no_argument, 0, 'a'},
4353   {"file-header",      no_argument, 0, 'h'},
4354   {"program-headers",  no_argument, 0, 'l'},
4355   {"headers",          no_argument, 0, 'e'},
4356   {"histogram",        no_argument, 0, 'I'},
4357   {"segments",         no_argument, 0, 'l'},
4358   {"sections",         no_argument, 0, 'S'},
4359   {"section-headers",  no_argument, 0, 'S'},
4360   {"section-groups",   no_argument, 0, 'g'},
4361   {"section-details",  no_argument, 0, 't'},
4362   {"full-section-name",no_argument, 0, 'N'},
4363   {"symbols",          no_argument, 0, 's'},
4364   {"syms",             no_argument, 0, 's'},
4365   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4366   {"relocs",           no_argument, 0, 'r'},
4367   {"notes",            no_argument, 0, 'n'},
4368   {"dynamic",          no_argument, 0, 'd'},
4369   {"arch-specific",    no_argument, 0, 'A'},
4370   {"version-info",     no_argument, 0, 'V'},
4371   {"use-dynamic",      no_argument, 0, 'D'},
4372   {"unwind",           no_argument, 0, 'u'},
4373   {"archive-index",    no_argument, 0, 'c'},
4374   {"hex-dump",         required_argument, 0, 'x'},
4375   {"relocated-dump",   required_argument, 0, 'R'},
4376   {"string-dump",      required_argument, 0, 'p'},
4377   {"decompress",       no_argument, 0, 'z'},
4378 #ifdef SUPPORT_DISASSEMBLY
4379   {"instruction-dump", required_argument, 0, 'i'},
4380 #endif
4381   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4382
4383   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4384   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4385   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4386
4387   {"version",          no_argument, 0, 'v'},
4388   {"wide",             no_argument, 0, 'W'},
4389   {"help",             no_argument, 0, 'H'},
4390   {0,                  no_argument, 0, 0}
4391 };
4392
4393 static void
4394 usage (FILE * stream)
4395 {
4396   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4397   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4398   fprintf (stream, _(" Options are:\n\
4399   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4400   -h --file-header       Display the ELF file header\n\
4401   -l --program-headers   Display the program headers\n\
4402      --segments          An alias for --program-headers\n\
4403   -S --section-headers   Display the sections' header\n\
4404      --sections          An alias for --section-headers\n\
4405   -g --section-groups    Display the section groups\n\
4406   -t --section-details   Display the section details\n\
4407   -e --headers           Equivalent to: -h -l -S\n\
4408   -s --syms              Display the symbol table\n\
4409      --symbols           An alias for --syms\n\
4410   --dyn-syms             Display the dynamic symbol table\n\
4411   -n --notes             Display the core notes (if present)\n\
4412   -r --relocs            Display the relocations (if present)\n\
4413   -u --unwind            Display the unwind info (if present)\n\
4414   -d --dynamic           Display the dynamic section (if present)\n\
4415   -V --version-info      Display the version sections (if present)\n\
4416   -A --arch-specific     Display architecture specific information (if any)\n\
4417   -c --archive-index     Display the symbol/file index in an archive\n\
4418   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4419   -x --hex-dump=<number|name>\n\
4420                          Dump the contents of section <number|name> as bytes\n\
4421   -p --string-dump=<number|name>\n\
4422                          Dump the contents of section <number|name> as strings\n\
4423   -R --relocated-dump=<number|name>\n\
4424                          Dump the contents of section <number|name> as relocated bytes\n\
4425   -z --decompress        Decompress section before dumping it\n\
4426   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4427   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4428                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4429                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4430                =addr,=cu_index,=links,=follow-links]\n\
4431                          Display the contents of DWARF debug sections\n"));
4432   fprintf (stream, _("\
4433   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4434   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4435                          or deeper\n"));
4436 #ifdef SUPPORT_DISASSEMBLY
4437   fprintf (stream, _("\
4438   -i --instruction-dump=<number|name>\n\
4439                          Disassemble the contents of section <number|name>\n"));
4440 #endif
4441   fprintf (stream, _("\
4442   -I --histogram         Display histogram of bucket list lengths\n\
4443   -W --wide              Allow output width to exceed 80 characters\n\
4444   @<file>                Read options from <file>\n\
4445   -H --help              Display this information\n\
4446   -v --version           Display the version number of readelf\n"));
4447
4448   if (REPORT_BUGS_TO[0] && stream == stdout)
4449     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4450
4451   exit (stream == stdout ? 0 : 1);
4452 }
4453
4454 /* Record the fact that the user wants the contents of section number
4455    SECTION to be displayed using the method(s) encoded as flags bits
4456    in TYPE.  Note, TYPE can be zero if we are creating the array for
4457    the first time.  */
4458
4459 static void
4460 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4461 {
4462   if (section >= filedata->num_dump_sects)
4463     {
4464       dump_type * new_dump_sects;
4465
4466       new_dump_sects = (dump_type *) calloc (section + 1,
4467                                              sizeof (* new_dump_sects));
4468
4469       if (new_dump_sects == NULL)
4470         error (_("Out of memory allocating dump request table.\n"));
4471       else
4472         {
4473           if (filedata->dump_sects)
4474             {
4475               /* Copy current flag settings.  */
4476               memcpy (new_dump_sects, filedata->dump_sects,
4477                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4478
4479               free (filedata->dump_sects);
4480             }
4481
4482           filedata->dump_sects = new_dump_sects;
4483           filedata->num_dump_sects = section + 1;
4484         }
4485     }
4486
4487   if (filedata->dump_sects)
4488     filedata->dump_sects[section] |= type;
4489 }
4490
4491 /* Request a dump by section name.  */
4492
4493 static void
4494 request_dump_byname (const char * section, dump_type type)
4495 {
4496   struct dump_list_entry * new_request;
4497
4498   new_request = (struct dump_list_entry *)
4499       malloc (sizeof (struct dump_list_entry));
4500   if (!new_request)
4501     error (_("Out of memory allocating dump request table.\n"));
4502
4503   new_request->name = strdup (section);
4504   if (!new_request->name)
4505     error (_("Out of memory allocating dump request table.\n"));
4506
4507   new_request->type = type;
4508
4509   new_request->next = dump_sects_byname;
4510   dump_sects_byname = new_request;
4511 }
4512
4513 static inline void
4514 request_dump (Filedata * filedata, dump_type type)
4515 {
4516   int section;
4517   char * cp;
4518
4519   do_dump++;
4520   section = strtoul (optarg, & cp, 0);
4521
4522   if (! *cp && section >= 0)
4523     request_dump_bynumber (filedata, section, type);
4524   else
4525     request_dump_byname (optarg, type);
4526 }
4527
4528 static void
4529 parse_args (Filedata * filedata, int argc, char ** argv)
4530 {
4531   int c;
4532
4533   if (argc < 2)
4534     usage (stderr);
4535
4536   while ((c = getopt_long
4537           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4538     {
4539       switch (c)
4540         {
4541         case 0:
4542           /* Long options.  */
4543           break;
4544         case 'H':
4545           usage (stdout);
4546           break;
4547
4548         case 'a':
4549           do_syms = TRUE;
4550           do_reloc = TRUE;
4551           do_unwind = TRUE;
4552           do_dynamic = TRUE;
4553           do_header = TRUE;
4554           do_sections = TRUE;
4555           do_section_groups = TRUE;
4556           do_segments = TRUE;
4557           do_version = TRUE;
4558           do_histogram = TRUE;
4559           do_arch = TRUE;
4560           do_notes = TRUE;
4561           break;
4562         case 'g':
4563           do_section_groups = TRUE;
4564           break;
4565         case 't':
4566         case 'N':
4567           do_sections = TRUE;
4568           do_section_details = TRUE;
4569           break;
4570         case 'e':
4571           do_header = TRUE;
4572           do_sections = TRUE;
4573           do_segments = TRUE;
4574           break;
4575         case 'A':
4576           do_arch = TRUE;
4577           break;
4578         case 'D':
4579           do_using_dynamic = TRUE;
4580           break;
4581         case 'r':
4582           do_reloc = TRUE;
4583           break;
4584         case 'u':
4585           do_unwind = TRUE;
4586           break;
4587         case 'h':
4588           do_header = TRUE;
4589           break;
4590         case 'l':
4591           do_segments = TRUE;
4592           break;
4593         case 's':
4594           do_syms = TRUE;
4595           break;
4596         case 'S':
4597           do_sections = TRUE;
4598           break;
4599         case 'd':
4600           do_dynamic = TRUE;
4601           break;
4602         case 'I':
4603           do_histogram = TRUE;
4604           break;
4605         case 'n':
4606           do_notes = TRUE;
4607           break;
4608         case 'c':
4609           do_archive_index = TRUE;
4610           break;
4611         case 'x':
4612           request_dump (filedata, HEX_DUMP);
4613           break;
4614         case 'p':
4615           request_dump (filedata, STRING_DUMP);
4616           break;
4617         case 'R':
4618           request_dump (filedata, RELOC_DUMP);
4619           break;
4620         case 'z':
4621           decompress_dumps = TRUE;
4622           break;
4623         case 'w':
4624           do_dump = TRUE;
4625           if (optarg == 0)
4626             {
4627               do_debugging = TRUE;
4628               dwarf_select_sections_all ();
4629             }
4630           else
4631             {
4632               do_debugging = FALSE;
4633               dwarf_select_sections_by_letters (optarg);
4634             }
4635           break;
4636         case OPTION_DEBUG_DUMP:
4637           do_dump = TRUE;
4638           if (optarg == 0)
4639             do_debugging = TRUE;
4640           else
4641             {
4642               do_debugging = FALSE;
4643               dwarf_select_sections_by_names (optarg);
4644             }
4645           break;
4646         case OPTION_DWARF_DEPTH:
4647           {
4648             char *cp;
4649
4650             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4651           }
4652           break;
4653         case OPTION_DWARF_START:
4654           {
4655             char *cp;
4656
4657             dwarf_start_die = strtoul (optarg, & cp, 0);
4658           }
4659           break;
4660         case OPTION_DWARF_CHECK:
4661           dwarf_check = TRUE;
4662           break;
4663         case OPTION_DYN_SYMS:
4664           do_dyn_syms = TRUE;
4665           break;
4666 #ifdef SUPPORT_DISASSEMBLY
4667         case 'i':
4668           request_dump (filedata, DISASS_DUMP);
4669           break;
4670 #endif
4671         case 'v':
4672           print_version (program_name);
4673           break;
4674         case 'V':
4675           do_version = TRUE;
4676           break;
4677         case 'W':
4678           do_wide = TRUE;
4679           break;
4680         default:
4681           /* xgettext:c-format */
4682           error (_("Invalid option '-%c'\n"), c);
4683           /* Fall through.  */
4684         case '?':
4685           usage (stderr);
4686         }
4687     }
4688
4689   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4690       && !do_segments && !do_header && !do_dump && !do_version
4691       && !do_histogram && !do_debugging && !do_arch && !do_notes
4692       && !do_section_groups && !do_archive_index
4693       && !do_dyn_syms)
4694     usage (stderr);
4695 }
4696
4697 static const char *
4698 get_elf_class (unsigned int elf_class)
4699 {
4700   static char buff[32];
4701
4702   switch (elf_class)
4703     {
4704     case ELFCLASSNONE: return _("none");
4705     case ELFCLASS32:   return "ELF32";
4706     case ELFCLASS64:   return "ELF64";
4707     default:
4708       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4709       return buff;
4710     }
4711 }
4712
4713 static const char *
4714 get_data_encoding (unsigned int encoding)
4715 {
4716   static char buff[32];
4717
4718   switch (encoding)
4719     {
4720     case ELFDATANONE: return _("none");
4721     case ELFDATA2LSB: return _("2's complement, little endian");
4722     case ELFDATA2MSB: return _("2's complement, big endian");
4723     default:
4724       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4725       return buff;
4726     }
4727 }
4728
4729 /* Decode the data held in 'filedata->file_header'.  */
4730
4731 static bfd_boolean
4732 process_file_header (Filedata * filedata)
4733 {
4734   Elf_Internal_Ehdr * header = & filedata->file_header;
4735
4736   if (   header->e_ident[EI_MAG0] != ELFMAG0
4737       || header->e_ident[EI_MAG1] != ELFMAG1
4738       || header->e_ident[EI_MAG2] != ELFMAG2
4739       || header->e_ident[EI_MAG3] != ELFMAG3)
4740     {
4741       error
4742         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4743       return FALSE;
4744     }
4745
4746   init_dwarf_regnames (header->e_machine);
4747
4748   if (do_header)
4749     {
4750       unsigned i;
4751
4752       printf (_("ELF Header:\n"));
4753       printf (_("  Magic:   "));
4754       for (i = 0; i < EI_NIDENT; i++)
4755         printf ("%2.2x ", header->e_ident[i]);
4756       printf ("\n");
4757       printf (_("  Class:                             %s\n"),
4758               get_elf_class (header->e_ident[EI_CLASS]));
4759       printf (_("  Data:                              %s\n"),
4760               get_data_encoding (header->e_ident[EI_DATA]));
4761       printf (_("  Version:                           %d %s\n"),
4762               header->e_ident[EI_VERSION],
4763               (header->e_ident[EI_VERSION] == EV_CURRENT
4764                ? "(current)"
4765                : (header->e_ident[EI_VERSION] != EV_NONE
4766                   ? _("<unknown: %lx>")
4767                   : "")));
4768       printf (_("  OS/ABI:                            %s\n"),
4769               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4770       printf (_("  ABI Version:                       %d\n"),
4771               header->e_ident[EI_ABIVERSION]);
4772       printf (_("  Type:                              %s\n"),
4773               get_file_type (header->e_type));
4774       printf (_("  Machine:                           %s\n"),
4775               get_machine_name (header->e_machine));
4776       printf (_("  Version:                           0x%lx\n"),
4777               (unsigned long) header->e_version);
4778
4779       printf (_("  Entry point address:               "));
4780       print_vma ((bfd_vma) header->e_entry, PREFIX_HEX);
4781       printf (_("\n  Start of program headers:          "));
4782       print_vma ((bfd_vma) header->e_phoff, DEC);
4783       printf (_(" (bytes into file)\n  Start of section headers:          "));
4784       print_vma ((bfd_vma) header->e_shoff, DEC);
4785       printf (_(" (bytes into file)\n"));
4786
4787       printf (_("  Flags:                             0x%lx%s\n"),
4788               (unsigned long) header->e_flags,
4789               get_machine_flags (filedata, header->e_flags, header->e_machine));
4790       printf (_("  Size of this header:               %ld (bytes)\n"),
4791               (long) header->e_ehsize);
4792       printf (_("  Size of program headers:           %ld (bytes)\n"),
4793               (long) header->e_phentsize);
4794       printf (_("  Number of program headers:         %ld"),
4795               (long) header->e_phnum);
4796       if (filedata->section_headers != NULL
4797           && header->e_phnum == PN_XNUM
4798           && filedata->section_headers[0].sh_info != 0)
4799         printf (" (%ld)", (long) filedata->section_headers[0].sh_info);
4800       putc ('\n', stdout);
4801       printf (_("  Size of section headers:           %ld (bytes)\n"),
4802               (long) header->e_shentsize);
4803       printf (_("  Number of section headers:         %ld"),
4804               (long) header->e_shnum);
4805       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4806         printf (" (%ld)", (long) filedata->section_headers[0].sh_size);
4807       putc ('\n', stdout);
4808       printf (_("  Section header string table index: %ld"),
4809               (long) header->e_shstrndx);
4810       if (filedata->section_headers != NULL
4811           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4812         printf (" (%u)", filedata->section_headers[0].sh_link);
4813       else if (header->e_shstrndx != SHN_UNDEF
4814                && header->e_shstrndx >= header->e_shnum)
4815         printf (_(" <corrupt: out of range>"));
4816       putc ('\n', stdout);
4817     }
4818
4819   if (filedata->section_headers != NULL)
4820     {
4821       if (header->e_phnum == PN_XNUM
4822           && filedata->section_headers[0].sh_info != 0)
4823         header->e_phnum = filedata->section_headers[0].sh_info;
4824       if (header->e_shnum == SHN_UNDEF)
4825         header->e_shnum = filedata->section_headers[0].sh_size;
4826       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4827         header->e_shstrndx = filedata->section_headers[0].sh_link;
4828       if (header->e_shstrndx >= header->e_shnum)
4829         header->e_shstrndx = SHN_UNDEF;
4830       free (filedata->section_headers);
4831       filedata->section_headers = NULL;
4832     }
4833
4834   return TRUE;
4835 }
4836
4837 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4838    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4839
4840 static bfd_boolean
4841 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4842 {
4843   Elf32_External_Phdr * phdrs;
4844   Elf32_External_Phdr * external;
4845   Elf_Internal_Phdr *   internal;
4846   unsigned int i;
4847   unsigned int size = filedata->file_header.e_phentsize;
4848   unsigned int num  = filedata->file_header.e_phnum;
4849
4850   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4851   if (size == 0 || num == 0)
4852     return FALSE;
4853   if (size < sizeof * phdrs)
4854     {
4855       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4856       return FALSE;
4857     }
4858   if (size > sizeof * phdrs)
4859     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4860
4861   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4862                                             size, num, _("program headers"));
4863   if (phdrs == NULL)
4864     return FALSE;
4865
4866   for (i = 0, internal = pheaders, external = phdrs;
4867        i < filedata->file_header.e_phnum;
4868        i++, internal++, external++)
4869     {
4870       internal->p_type   = BYTE_GET (external->p_type);
4871       internal->p_offset = BYTE_GET (external->p_offset);
4872       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4873       internal->p_paddr  = BYTE_GET (external->p_paddr);
4874       internal->p_filesz = BYTE_GET (external->p_filesz);
4875       internal->p_memsz  = BYTE_GET (external->p_memsz);
4876       internal->p_flags  = BYTE_GET (external->p_flags);
4877       internal->p_align  = BYTE_GET (external->p_align);
4878     }
4879
4880   free (phdrs);
4881   return TRUE;
4882 }
4883
4884 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4885    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4886
4887 static bfd_boolean
4888 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4889 {
4890   Elf64_External_Phdr * phdrs;
4891   Elf64_External_Phdr * external;
4892   Elf_Internal_Phdr *   internal;
4893   unsigned int i;
4894   unsigned int size = filedata->file_header.e_phentsize;
4895   unsigned int num  = filedata->file_header.e_phnum;
4896
4897   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4898   if (size == 0 || num == 0)
4899     return FALSE;
4900   if (size < sizeof * phdrs)
4901     {
4902       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4903       return FALSE;
4904     }
4905   if (size > sizeof * phdrs)
4906     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4907
4908   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4909                                             size, num, _("program headers"));
4910   if (!phdrs)
4911     return FALSE;
4912
4913   for (i = 0, internal = pheaders, external = phdrs;
4914        i < filedata->file_header.e_phnum;
4915        i++, internal++, external++)
4916     {
4917       internal->p_type   = BYTE_GET (external->p_type);
4918       internal->p_flags  = BYTE_GET (external->p_flags);
4919       internal->p_offset = BYTE_GET (external->p_offset);
4920       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4921       internal->p_paddr  = BYTE_GET (external->p_paddr);
4922       internal->p_filesz = BYTE_GET (external->p_filesz);
4923       internal->p_memsz  = BYTE_GET (external->p_memsz);
4924       internal->p_align  = BYTE_GET (external->p_align);
4925     }
4926
4927   free (phdrs);
4928   return TRUE;
4929 }
4930
4931 /* Returns TRUE if the program headers were read into `program_headers'.  */
4932
4933 static bfd_boolean
4934 get_program_headers (Filedata * filedata)
4935 {
4936   Elf_Internal_Phdr * phdrs;
4937
4938   /* Check cache of prior read.  */
4939   if (filedata->program_headers != NULL)
4940     return TRUE;
4941
4942   /* Be kind to memory checkers by looking for
4943      e_phnum values which we know must be invalid.  */
4944   if (filedata->file_header.e_phnum
4945       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4946       >= filedata->file_size)
4947     {
4948       error (_("Too many program headers - %#x - the file is not that big\n"),
4949              filedata->file_header.e_phnum);
4950       return FALSE;
4951     }
4952
4953   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4954                                          sizeof (Elf_Internal_Phdr));
4955   if (phdrs == NULL)
4956     {
4957       error (_("Out of memory reading %u program headers\n"),
4958              filedata->file_header.e_phnum);
4959       return FALSE;
4960     }
4961
4962   if (is_32bit_elf
4963       ? get_32bit_program_headers (filedata, phdrs)
4964       : get_64bit_program_headers (filedata, phdrs))
4965     {
4966       filedata->program_headers = phdrs;
4967       return TRUE;
4968     }
4969
4970   free (phdrs);
4971   return FALSE;
4972 }
4973
4974 /* Returns TRUE if the program headers were loaded.  */
4975
4976 static bfd_boolean
4977 process_program_headers (Filedata * filedata)
4978 {
4979   Elf_Internal_Phdr * segment;
4980   unsigned int i;
4981   Elf_Internal_Phdr * previous_load = NULL;
4982
4983   if (filedata->file_header.e_phnum == 0)
4984     {
4985       /* PR binutils/12467.  */
4986       if (filedata->file_header.e_phoff != 0)
4987         {
4988           warn (_("possibly corrupt ELF header - it has a non-zero program"
4989                   " header offset, but no program headers\n"));
4990           return FALSE;
4991         }
4992       else if (do_segments)
4993         printf (_("\nThere are no program headers in this file.\n"));
4994       return TRUE;
4995     }
4996
4997   if (do_segments && !do_header)
4998     {
4999       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5000       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5001       printf (ngettext ("There is %d program header, starting at offset %s\n",
5002                         "There are %d program headers, starting at offset %s\n",
5003                         filedata->file_header.e_phnum),
5004               filedata->file_header.e_phnum,
5005               bfd_vmatoa ("u", filedata->file_header.e_phoff));
5006     }
5007
5008   if (! get_program_headers (filedata))
5009     return TRUE;
5010
5011   if (do_segments)
5012     {
5013       if (filedata->file_header.e_phnum > 1)
5014         printf (_("\nProgram Headers:\n"));
5015       else
5016         printf (_("\nProgram Headers:\n"));
5017
5018       if (is_32bit_elf)
5019         printf
5020           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
5021       else if (do_wide)
5022         printf
5023           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
5024       else
5025         {
5026           printf
5027             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
5028           printf
5029             (_("                 FileSiz            MemSiz              Flags  Align\n"));
5030         }
5031     }
5032
5033   dynamic_addr = 0;
5034   dynamic_size = 0;
5035
5036   for (i = 0, segment = filedata->program_headers;
5037        i < filedata->file_header.e_phnum;
5038        i++, segment++)
5039     {
5040       if (do_segments)
5041         {
5042           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
5043
5044           if (is_32bit_elf)
5045             {
5046               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5047               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5048               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5049               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5050               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5051               printf ("%c%c%c ",
5052                       (segment->p_flags & PF_R ? 'R' : ' '),
5053                       (segment->p_flags & PF_W ? 'W' : ' '),
5054                       (segment->p_flags & PF_X ? 'E' : ' '));
5055               printf ("%#lx", (unsigned long) segment->p_align);
5056             }
5057           else if (do_wide)
5058             {
5059               if ((unsigned long) segment->p_offset == segment->p_offset)
5060                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5061               else
5062                 {
5063                   print_vma (segment->p_offset, FULL_HEX);
5064                   putchar (' ');
5065                 }
5066
5067               print_vma (segment->p_vaddr, FULL_HEX);
5068               putchar (' ');
5069               print_vma (segment->p_paddr, FULL_HEX);
5070               putchar (' ');
5071
5072               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5073                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5074               else
5075                 {
5076                   print_vma (segment->p_filesz, FULL_HEX);
5077                   putchar (' ');
5078                 }
5079
5080               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5081                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5082               else
5083                 {
5084                   print_vma (segment->p_memsz, FULL_HEX);
5085                 }
5086
5087               printf (" %c%c%c ",
5088                       (segment->p_flags & PF_R ? 'R' : ' '),
5089                       (segment->p_flags & PF_W ? 'W' : ' '),
5090                       (segment->p_flags & PF_X ? 'E' : ' '));
5091
5092               if ((unsigned long) segment->p_align == segment->p_align)
5093                 printf ("%#lx", (unsigned long) segment->p_align);
5094               else
5095                 {
5096                   print_vma (segment->p_align, PREFIX_HEX);
5097                 }
5098             }
5099           else
5100             {
5101               print_vma (segment->p_offset, FULL_HEX);
5102               putchar (' ');
5103               print_vma (segment->p_vaddr, FULL_HEX);
5104               putchar (' ');
5105               print_vma (segment->p_paddr, FULL_HEX);
5106               printf ("\n                 ");
5107               print_vma (segment->p_filesz, FULL_HEX);
5108               putchar (' ');
5109               print_vma (segment->p_memsz, FULL_HEX);
5110               printf ("  %c%c%c    ",
5111                       (segment->p_flags & PF_R ? 'R' : ' '),
5112                       (segment->p_flags & PF_W ? 'W' : ' '),
5113                       (segment->p_flags & PF_X ? 'E' : ' '));
5114               print_vma (segment->p_align, PREFIX_HEX);
5115             }
5116
5117           putc ('\n', stdout);
5118         }
5119
5120       switch (segment->p_type)
5121         {
5122         case PT_LOAD:
5123 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5124          required by the ELF standard, several programs, including the Linux
5125          kernel, make use of non-ordered segments.  */
5126           if (previous_load
5127               && previous_load->p_vaddr > segment->p_vaddr)
5128             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5129 #endif
5130           if (segment->p_memsz < segment->p_filesz)
5131             error (_("the segment's file size is larger than its memory size\n"));
5132           previous_load = segment;
5133           break;
5134
5135         case PT_PHDR:
5136           /* PR 20815 - Verify that the program header is loaded into memory.  */
5137           if (i > 0 && previous_load != NULL)
5138             error (_("the PHDR segment must occur before any LOAD segment\n"));
5139           if (filedata->file_header.e_machine != EM_PARISC)
5140             {
5141               unsigned int j;
5142
5143               for (j = 1; j < filedata->file_header.e_phnum; j++)
5144                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5145                     && (filedata->program_headers[j].p_vaddr
5146                         + filedata->program_headers[j].p_memsz)
5147                     >= (segment->p_vaddr + segment->p_filesz))
5148                   break;
5149               if (j == filedata->file_header.e_phnum)
5150                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5151             }
5152           break;
5153
5154         case PT_DYNAMIC:
5155           if (dynamic_addr)
5156             error (_("more than one dynamic segment\n"));
5157
5158           /* By default, assume that the .dynamic section is the first
5159              section in the DYNAMIC segment.  */
5160           dynamic_addr = segment->p_offset;
5161           dynamic_size = segment->p_filesz;
5162
5163           /* Try to locate the .dynamic section. If there is
5164              a section header table, we can easily locate it.  */
5165           if (filedata->section_headers != NULL)
5166             {
5167               Elf_Internal_Shdr * sec;
5168
5169               sec = find_section (filedata, ".dynamic");
5170               if (sec == NULL || sec->sh_size == 0)
5171                 {
5172                   /* A corresponding .dynamic section is expected, but on
5173                      IA-64/OpenVMS it is OK for it to be missing.  */
5174                   if (!is_ia64_vms (filedata))
5175                     error (_("no .dynamic section in the dynamic segment\n"));
5176                   break;
5177                 }
5178
5179               if (sec->sh_type == SHT_NOBITS)
5180                 {
5181                   dynamic_size = 0;
5182                   break;
5183                 }
5184
5185               dynamic_addr = sec->sh_offset;
5186               dynamic_size = sec->sh_size;
5187
5188               if (dynamic_addr < segment->p_offset
5189                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5190                 warn (_("the .dynamic section is not contained"
5191                         " within the dynamic segment\n"));
5192               else if (dynamic_addr > segment->p_offset)
5193                 warn (_("the .dynamic section is not the first section"
5194                         " in the dynamic segment.\n"));
5195             }
5196
5197           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5198              segment.  Check this after matching against the section headers
5199              so we don't warn on debuginfo file (which have NOBITS .dynamic
5200              sections).  */
5201           if (dynamic_addr + dynamic_size >= filedata->file_size)
5202             {
5203               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5204               dynamic_addr = dynamic_size = 0;
5205             }
5206           break;
5207
5208         case PT_INTERP:
5209           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5210                      SEEK_SET))
5211             error (_("Unable to find program interpreter name\n"));
5212           else
5213             {
5214               char fmt [32];
5215               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5216
5217               if (ret >= (int) sizeof (fmt) || ret < 0)
5218                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5219
5220               program_interpreter[0] = 0;
5221               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5222                 error (_("Unable to read program interpreter name\n"));
5223
5224               if (do_segments)
5225                 printf (_("      [Requesting program interpreter: %s]\n"),
5226                     program_interpreter);
5227             }
5228           break;
5229         }
5230     }
5231
5232   if (do_segments
5233       && filedata->section_headers != NULL
5234       && filedata->string_table != NULL)
5235     {
5236       printf (_("\n Section to Segment mapping:\n"));
5237       printf (_("  Segment Sections...\n"));
5238
5239       for (i = 0; i < filedata->file_header.e_phnum; i++)
5240         {
5241           unsigned int j;
5242           Elf_Internal_Shdr * section;
5243
5244           segment = filedata->program_headers + i;
5245           section = filedata->section_headers + 1;
5246
5247           printf ("   %2.2d     ", i);
5248
5249           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5250             {
5251               if (!ELF_TBSS_SPECIAL (section, segment)
5252                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5253                 printf ("%s ", printable_section_name (filedata, section));
5254             }
5255
5256           putc ('\n',stdout);
5257         }
5258     }
5259
5260   return TRUE;
5261 }
5262
5263
5264 /* Find the file offset corresponding to VMA by using the program headers.  */
5265
5266 static long
5267 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5268 {
5269   Elf_Internal_Phdr * seg;
5270
5271   if (! get_program_headers (filedata))
5272     {
5273       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5274       return (long) vma;
5275     }
5276
5277   for (seg = filedata->program_headers;
5278        seg < filedata->program_headers + filedata->file_header.e_phnum;
5279        ++seg)
5280     {
5281       if (seg->p_type != PT_LOAD)
5282         continue;
5283
5284       if (vma >= (seg->p_vaddr & -seg->p_align)
5285           && vma + size <= seg->p_vaddr + seg->p_filesz)
5286         return vma - seg->p_vaddr + seg->p_offset;
5287     }
5288
5289   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5290         (unsigned long) vma);
5291   return (long) vma;
5292 }
5293
5294
5295 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5296    If PROBE is true, this is just a probe and we do not generate any error
5297    messages if the load fails.  */
5298
5299 static bfd_boolean
5300 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5301 {
5302   Elf32_External_Shdr * shdrs;
5303   Elf_Internal_Shdr *   internal;
5304   unsigned int          i;
5305   unsigned int          size = filedata->file_header.e_shentsize;
5306   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5307
5308   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5309   if (size == 0 || num == 0)
5310     return FALSE;
5311   if (size < sizeof * shdrs)
5312     {
5313       if (! probe)
5314         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5315       return FALSE;
5316     }
5317   if (!probe && size > sizeof * shdrs)
5318     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5319
5320   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5321                                             size, num,
5322                                             probe ? NULL : _("section headers"));
5323   if (shdrs == NULL)
5324     return FALSE;
5325
5326   free (filedata->section_headers);
5327   filedata->section_headers = (Elf_Internal_Shdr *)
5328     cmalloc (num, sizeof (Elf_Internal_Shdr));
5329   if (filedata->section_headers == NULL)
5330     {
5331       if (!probe)
5332         error (_("Out of memory reading %u section headers\n"), num);
5333       return FALSE;
5334     }
5335
5336   for (i = 0, internal = filedata->section_headers;
5337        i < num;
5338        i++, internal++)
5339     {
5340       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5341       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5342       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5343       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5344       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5345       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5346       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5347       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5348       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5349       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5350       if (!probe && internal->sh_link > num)
5351         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5352       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5353         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5354     }
5355
5356   free (shdrs);
5357   return TRUE;
5358 }
5359
5360 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5361
5362 static bfd_boolean
5363 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5364 {
5365   Elf64_External_Shdr *  shdrs;
5366   Elf_Internal_Shdr *    internal;
5367   unsigned int           i;
5368   unsigned int           size = filedata->file_header.e_shentsize;
5369   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5370
5371   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5372   if (size == 0 || num == 0)
5373     return FALSE;
5374
5375   if (size < sizeof * shdrs)
5376     {
5377       if (! probe)
5378         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5379       return FALSE;
5380     }
5381
5382   if (! probe && size > sizeof * shdrs)
5383     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5384
5385   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5386                                             filedata->file_header.e_shoff,
5387                                             size, num,
5388                                             probe ? NULL : _("section headers"));
5389   if (shdrs == NULL)
5390     return FALSE;
5391
5392   free (filedata->section_headers);
5393   filedata->section_headers = (Elf_Internal_Shdr *)
5394     cmalloc (num, sizeof (Elf_Internal_Shdr));
5395   if (filedata->section_headers == NULL)
5396     {
5397       if (! probe)
5398         error (_("Out of memory reading %u section headers\n"), num);
5399       return FALSE;
5400     }
5401
5402   for (i = 0, internal = filedata->section_headers;
5403        i < num;
5404        i++, internal++)
5405     {
5406       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5407       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5408       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5409       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5410       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5411       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5412       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5413       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5414       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5415       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5416       if (!probe && internal->sh_link > num)
5417         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5418       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5419         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5420     }
5421
5422   free (shdrs);
5423   return TRUE;
5424 }
5425
5426 static Elf_Internal_Sym *
5427 get_32bit_elf_symbols (Filedata *           filedata,
5428                        Elf_Internal_Shdr *  section,
5429                        unsigned long *      num_syms_return)
5430 {
5431   unsigned long number = 0;
5432   Elf32_External_Sym * esyms = NULL;
5433   Elf_External_Sym_Shndx * shndx = NULL;
5434   Elf_Internal_Sym * isyms = NULL;
5435   Elf_Internal_Sym * psym;
5436   unsigned int j;
5437
5438   if (section->sh_size == 0)
5439     {
5440       if (num_syms_return != NULL)
5441         * num_syms_return = 0;
5442       return NULL;
5443     }
5444
5445   /* Run some sanity checks first.  */
5446   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5447     {
5448       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5449              printable_section_name (filedata, section),
5450              (unsigned long) section->sh_entsize);
5451       goto exit_point;
5452     }
5453
5454   if (section->sh_size > filedata->file_size)
5455     {
5456       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5457              printable_section_name (filedata, section),
5458              (unsigned long) section->sh_size);
5459       goto exit_point;
5460     }
5461
5462   number = section->sh_size / section->sh_entsize;
5463
5464   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5465     {
5466       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5467              (unsigned long) section->sh_size,
5468              printable_section_name (filedata, section),
5469              (unsigned long) section->sh_entsize);
5470       goto exit_point;
5471     }
5472
5473   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5474                                            section->sh_size, _("symbols"));
5475   if (esyms == NULL)
5476     goto exit_point;
5477
5478   {
5479     elf_section_list * entry;
5480
5481     shndx = NULL;
5482     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5483       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5484         {
5485           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5486                                                        entry->hdr->sh_offset,
5487                                                        1, entry->hdr->sh_size,
5488                                                        _("symbol table section indicies"));
5489           if (shndx == NULL)
5490             goto exit_point;
5491           /* PR17531: file: heap-buffer-overflow */
5492           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5493             {
5494               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5495                      printable_section_name (filedata, entry->hdr),
5496                      (unsigned long) entry->hdr->sh_size,
5497                      (unsigned long) section->sh_size);
5498               goto exit_point;
5499             }
5500         }
5501   }
5502
5503   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5504
5505   if (isyms == NULL)
5506     {
5507       error (_("Out of memory reading %lu symbols\n"),
5508              (unsigned long) number);
5509       goto exit_point;
5510     }
5511
5512   for (j = 0, psym = isyms; j < number; j++, psym++)
5513     {
5514       psym->st_name  = BYTE_GET (esyms[j].st_name);
5515       psym->st_value = BYTE_GET (esyms[j].st_value);
5516       psym->st_size  = BYTE_GET (esyms[j].st_size);
5517       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5518       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5519         psym->st_shndx
5520           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5521       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5522         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5523       psym->st_info  = BYTE_GET (esyms[j].st_info);
5524       psym->st_other = BYTE_GET (esyms[j].st_other);
5525     }
5526
5527  exit_point:
5528   if (shndx != NULL)
5529     free (shndx);
5530   if (esyms != NULL)
5531     free (esyms);
5532
5533   if (num_syms_return != NULL)
5534     * num_syms_return = isyms == NULL ? 0 : number;
5535
5536   return isyms;
5537 }
5538
5539 static Elf_Internal_Sym *
5540 get_64bit_elf_symbols (Filedata *           filedata,
5541                        Elf_Internal_Shdr *  section,
5542                        unsigned long *      num_syms_return)
5543 {
5544   unsigned long number = 0;
5545   Elf64_External_Sym * esyms = NULL;
5546   Elf_External_Sym_Shndx * shndx = NULL;
5547   Elf_Internal_Sym * isyms = NULL;
5548   Elf_Internal_Sym * psym;
5549   unsigned int j;
5550
5551   if (section->sh_size == 0)
5552     {
5553       if (num_syms_return != NULL)
5554         * num_syms_return = 0;
5555       return NULL;
5556     }
5557
5558   /* Run some sanity checks first.  */
5559   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5560     {
5561       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5562              printable_section_name (filedata, section),
5563              (unsigned long) section->sh_entsize);
5564       goto exit_point;
5565     }
5566
5567   if (section->sh_size > filedata->file_size)
5568     {
5569       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5570              printable_section_name (filedata, section),
5571              (unsigned long) section->sh_size);
5572       goto exit_point;
5573     }
5574
5575   number = section->sh_size / section->sh_entsize;
5576
5577   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5578     {
5579       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5580              (unsigned long) section->sh_size,
5581              printable_section_name (filedata, section),
5582              (unsigned long) section->sh_entsize);
5583       goto exit_point;
5584     }
5585
5586   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5587                                            section->sh_size, _("symbols"));
5588   if (!esyms)
5589     goto exit_point;
5590
5591   {
5592     elf_section_list * entry;
5593
5594     shndx = NULL;
5595     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5596       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5597         {
5598           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5599                                                        entry->hdr->sh_offset,
5600                                                        1, entry->hdr->sh_size,
5601                                                        _("symbol table section indicies"));
5602           if (shndx == NULL)
5603             goto exit_point;
5604           /* PR17531: file: heap-buffer-overflow */
5605           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5606             {
5607               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5608                      printable_section_name (filedata, entry->hdr),
5609                      (unsigned long) entry->hdr->sh_size,
5610                      (unsigned long) section->sh_size);
5611               goto exit_point;
5612             }
5613         }
5614   }
5615
5616   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5617
5618   if (isyms == NULL)
5619     {
5620       error (_("Out of memory reading %lu symbols\n"),
5621              (unsigned long) number);
5622       goto exit_point;
5623     }
5624
5625   for (j = 0, psym = isyms; j < number; j++, psym++)
5626     {
5627       psym->st_name  = BYTE_GET (esyms[j].st_name);
5628       psym->st_info  = BYTE_GET (esyms[j].st_info);
5629       psym->st_other = BYTE_GET (esyms[j].st_other);
5630       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5631
5632       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5633         psym->st_shndx
5634           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5635       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5636         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5637
5638       psym->st_value = BYTE_GET (esyms[j].st_value);
5639       psym->st_size  = BYTE_GET (esyms[j].st_size);
5640     }
5641
5642  exit_point:
5643   if (shndx != NULL)
5644     free (shndx);
5645   if (esyms != NULL)
5646     free (esyms);
5647
5648   if (num_syms_return != NULL)
5649     * num_syms_return = isyms == NULL ? 0 : number;
5650
5651   return isyms;
5652 }
5653
5654 static const char *
5655 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5656 {
5657   static char buff[1024];
5658   char * p = buff;
5659   unsigned int field_size = is_32bit_elf ? 8 : 16;
5660   signed int sindex;
5661   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5662   bfd_vma os_flags = 0;
5663   bfd_vma proc_flags = 0;
5664   bfd_vma unknown_flags = 0;
5665   static const struct
5666     {
5667       const char * str;
5668       unsigned int len;
5669     }
5670   flags [] =
5671     {
5672       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5673       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5674       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5675       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5676       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5677       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5678       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5679       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5680       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5681       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5682       /* IA-64 specific.  */
5683       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5684       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5685       /* IA-64 OpenVMS specific.  */
5686       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5687       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5688       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5689       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5690       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5691       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5692       /* Generic.  */
5693       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5694       /* SPARC specific.  */
5695       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5696       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5697       /* ARM specific.  */
5698       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5699       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5700       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5701       /* GNU specific.  */
5702       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5703       /* VLE specific.  */
5704       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5705     };
5706
5707   if (do_section_details)
5708     {
5709       sprintf (buff, "[%*.*lx]: ",
5710                field_size, field_size, (unsigned long) sh_flags);
5711       p += field_size + 4;
5712     }
5713
5714   while (sh_flags)
5715     {
5716       bfd_vma flag;
5717
5718       flag = sh_flags & - sh_flags;
5719       sh_flags &= ~ flag;
5720
5721       if (do_section_details)
5722         {
5723           switch (flag)
5724             {
5725             case SHF_WRITE:             sindex = 0; break;
5726             case SHF_ALLOC:             sindex = 1; break;
5727             case SHF_EXECINSTR:         sindex = 2; break;
5728             case SHF_MERGE:             sindex = 3; break;
5729             case SHF_STRINGS:           sindex = 4; break;
5730             case SHF_INFO_LINK:         sindex = 5; break;
5731             case SHF_LINK_ORDER:        sindex = 6; break;
5732             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5733             case SHF_GROUP:             sindex = 8; break;
5734             case SHF_TLS:               sindex = 9; break;
5735             case SHF_EXCLUDE:           sindex = 18; break;
5736             case SHF_COMPRESSED:        sindex = 20; break;
5737             case SHF_GNU_MBIND:         sindex = 24; break;
5738
5739             default:
5740               sindex = -1;
5741               switch (filedata->file_header.e_machine)
5742                 {
5743                 case EM_IA_64:
5744                   if (flag == SHF_IA_64_SHORT)
5745                     sindex = 10;
5746                   else if (flag == SHF_IA_64_NORECOV)
5747                     sindex = 11;
5748 #ifdef BFD64
5749                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5750                     switch (flag)
5751                       {
5752                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5753                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5754                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5755                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5756                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5757                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5758                       default:                        break;
5759                       }
5760 #endif
5761                   break;
5762
5763                 case EM_386:
5764                 case EM_IAMCU:
5765                 case EM_X86_64:
5766                 case EM_L1OM:
5767                 case EM_K1OM:
5768                 case EM_OLD_SPARCV9:
5769                 case EM_SPARC32PLUS:
5770                 case EM_SPARCV9:
5771                 case EM_SPARC:
5772                   if (flag == SHF_ORDERED)
5773                     sindex = 19;
5774                   break;
5775
5776                 case EM_ARM:
5777                   switch (flag)
5778                     {
5779                     case SHF_ENTRYSECT: sindex = 21; break;
5780                     case SHF_ARM_PURECODE: sindex = 22; break;
5781                     case SHF_COMDEF: sindex = 23; break;
5782                     default: break;
5783                     }
5784                   break;
5785                 case EM_PPC:
5786                   if (flag == SHF_PPC_VLE)
5787                     sindex = 25;
5788                   break;
5789
5790                 default:
5791                   break;
5792                 }
5793             }
5794
5795           if (sindex != -1)
5796             {
5797               if (p != buff + field_size + 4)
5798                 {
5799                   if (size < (10 + 2))
5800                     {
5801                       warn (_("Internal error: not enough buffer room for section flag info"));
5802                       return _("<unknown>");
5803                     }
5804                   size -= 2;
5805                   *p++ = ',';
5806                   *p++ = ' ';
5807                 }
5808
5809               size -= flags [sindex].len;
5810               p = stpcpy (p, flags [sindex].str);
5811             }
5812           else if (flag & SHF_MASKOS)
5813             os_flags |= flag;
5814           else if (flag & SHF_MASKPROC)
5815             proc_flags |= flag;
5816           else
5817             unknown_flags |= flag;
5818         }
5819       else
5820         {
5821           switch (flag)
5822             {
5823             case SHF_WRITE:             *p = 'W'; break;
5824             case SHF_ALLOC:             *p = 'A'; break;
5825             case SHF_EXECINSTR:         *p = 'X'; break;
5826             case SHF_MERGE:             *p = 'M'; break;
5827             case SHF_STRINGS:           *p = 'S'; break;
5828             case SHF_INFO_LINK:         *p = 'I'; break;
5829             case SHF_LINK_ORDER:        *p = 'L'; break;
5830             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5831             case SHF_GROUP:             *p = 'G'; break;
5832             case SHF_TLS:               *p = 'T'; break;
5833             case SHF_EXCLUDE:           *p = 'E'; break;
5834             case SHF_COMPRESSED:        *p = 'C'; break;
5835             case SHF_GNU_MBIND:         *p = 'D'; break;
5836
5837             default:
5838               if ((filedata->file_header.e_machine == EM_X86_64
5839                    || filedata->file_header.e_machine == EM_L1OM
5840                    || filedata->file_header.e_machine == EM_K1OM)
5841                   && flag == SHF_X86_64_LARGE)
5842                 *p = 'l';
5843               else if (filedata->file_header.e_machine == EM_ARM
5844                        && flag == SHF_ARM_PURECODE)
5845                   *p = 'y';
5846               else if (filedata->file_header.e_machine == EM_PPC
5847                        && flag == SHF_PPC_VLE)
5848                   *p = 'v';
5849               else if (flag & SHF_MASKOS)
5850                 {
5851                   *p = 'o';
5852                   sh_flags &= ~ SHF_MASKOS;
5853                 }
5854               else if (flag & SHF_MASKPROC)
5855                 {
5856                   *p = 'p';
5857                   sh_flags &= ~ SHF_MASKPROC;
5858                 }
5859               else
5860                 *p = 'x';
5861               break;
5862             }
5863           p++;
5864         }
5865     }
5866
5867   if (do_section_details)
5868     {
5869       if (os_flags)
5870         {
5871           size -= 5 + field_size;
5872           if (p != buff + field_size + 4)
5873             {
5874               if (size < (2 + 1))
5875                 {
5876                   warn (_("Internal error: not enough buffer room for section flag info"));
5877                   return _("<unknown>");
5878                 }
5879               size -= 2;
5880               *p++ = ',';
5881               *p++ = ' ';
5882             }
5883           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5884                    (unsigned long) os_flags);
5885           p += 5 + field_size;
5886         }
5887       if (proc_flags)
5888         {
5889           size -= 7 + field_size;
5890           if (p != buff + field_size + 4)
5891             {
5892               if (size < (2 + 1))
5893                 {
5894                   warn (_("Internal error: not enough buffer room for section flag info"));
5895                   return _("<unknown>");
5896                 }
5897               size -= 2;
5898               *p++ = ',';
5899               *p++ = ' ';
5900             }
5901           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5902                    (unsigned long) proc_flags);
5903           p += 7 + field_size;
5904         }
5905       if (unknown_flags)
5906         {
5907           size -= 10 + field_size;
5908           if (p != buff + field_size + 4)
5909             {
5910               if (size < (2 + 1))
5911                 {
5912                   warn (_("Internal error: not enough buffer room for section flag info"));
5913                   return _("<unknown>");
5914                 }
5915               size -= 2;
5916               *p++ = ',';
5917               *p++ = ' ';
5918             }
5919           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5920                    (unsigned long) unknown_flags);
5921           p += 10 + field_size;
5922         }
5923     }
5924
5925   *p = '\0';
5926   return buff;
5927 }
5928
5929 static unsigned int
5930 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5931 {
5932   if (is_32bit_elf)
5933     {
5934       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5935
5936       if (size < sizeof (* echdr))
5937         {
5938           error (_("Compressed section is too small even for a compression header\n"));
5939           return 0;
5940         }
5941
5942       chdr->ch_type = BYTE_GET (echdr->ch_type);
5943       chdr->ch_size = BYTE_GET (echdr->ch_size);
5944       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5945       return sizeof (*echdr);
5946     }
5947   else
5948     {
5949       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5950
5951       if (size < sizeof (* echdr))
5952         {
5953           error (_("Compressed section is too small even for a compression header\n"));
5954           return 0;
5955         }
5956
5957       chdr->ch_type = BYTE_GET (echdr->ch_type);
5958       chdr->ch_size = BYTE_GET (echdr->ch_size);
5959       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5960       return sizeof (*echdr);
5961     }
5962 }
5963
5964 static bfd_boolean
5965 process_section_headers (Filedata * filedata)
5966 {
5967   Elf_Internal_Shdr * section;
5968   unsigned int i;
5969
5970   filedata->section_headers = NULL;
5971
5972   if (filedata->file_header.e_shnum == 0)
5973     {
5974       /* PR binutils/12467.  */
5975       if (filedata->file_header.e_shoff != 0)
5976         {
5977           warn (_("possibly corrupt ELF file header - it has a non-zero"
5978                   " section header offset, but no section headers\n"));
5979           return FALSE;
5980         }
5981       else if (do_sections)
5982         printf (_("\nThere are no sections in this file.\n"));
5983
5984       return TRUE;
5985     }
5986
5987   if (do_sections && !do_header)
5988     printf (ngettext ("There is %d section header, "
5989                       "starting at offset 0x%lx:\n",
5990                       "There are %d section headers, "
5991                       "starting at offset 0x%lx:\n",
5992                       filedata->file_header.e_shnum),
5993             filedata->file_header.e_shnum,
5994             (unsigned long) filedata->file_header.e_shoff);
5995
5996   if (is_32bit_elf)
5997     {
5998       if (! get_32bit_section_headers (filedata, FALSE))
5999         return FALSE;
6000     }
6001   else
6002     {
6003       if (! get_64bit_section_headers (filedata, FALSE))
6004         return FALSE;
6005     }
6006
6007   /* Read in the string table, so that we have names to display.  */
6008   if (filedata->file_header.e_shstrndx != SHN_UNDEF
6009        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6010     {
6011       section = filedata->section_headers + filedata->file_header.e_shstrndx;
6012
6013       if (section->sh_size != 0)
6014         {
6015           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6016                                                       1, section->sh_size,
6017                                                       _("string table"));
6018
6019           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6020         }
6021     }
6022
6023   /* Scan the sections for the dynamic symbol table
6024      and dynamic string table and debug sections.  */
6025   dynamic_symbols = NULL;
6026   dynamic_strings = NULL;
6027   dynamic_syminfo = NULL;
6028   symtab_shndx_list = NULL;
6029
6030   eh_addr_size = is_32bit_elf ? 4 : 8;
6031   switch (filedata->file_header.e_machine)
6032     {
6033     case EM_MIPS:
6034     case EM_MIPS_RS3_LE:
6035       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6036          FDE addresses.  However, the ABI also has a semi-official ILP32
6037          variant for which the normal FDE address size rules apply.
6038
6039          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6040          section, where XX is the size of longs in bits.  Unfortunately,
6041          earlier compilers provided no way of distinguishing ILP32 objects
6042          from LP64 objects, so if there's any doubt, we should assume that
6043          the official LP64 form is being used.  */
6044       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6045           && find_section (filedata, ".gcc_compiled_long32") == NULL)
6046         eh_addr_size = 8;
6047       break;
6048
6049     case EM_H8_300:
6050     case EM_H8_300H:
6051       switch (filedata->file_header.e_flags & EF_H8_MACH)
6052         {
6053         case E_H8_MACH_H8300:
6054         case E_H8_MACH_H8300HN:
6055         case E_H8_MACH_H8300SN:
6056         case E_H8_MACH_H8300SXN:
6057           eh_addr_size = 2;
6058           break;
6059         case E_H8_MACH_H8300H:
6060         case E_H8_MACH_H8300S:
6061         case E_H8_MACH_H8300SX:
6062           eh_addr_size = 4;
6063           break;
6064         }
6065       break;
6066
6067     case EM_M32C_OLD:
6068     case EM_M32C:
6069       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6070         {
6071         case EF_M32C_CPU_M16C:
6072           eh_addr_size = 2;
6073           break;
6074         }
6075       break;
6076     }
6077
6078 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6079   do                                                                    \
6080     {                                                                   \
6081       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6082       if (section->sh_entsize != expected_entsize)                      \
6083         {                                                               \
6084           char buf[40];                                                 \
6085           sprintf_vma (buf, section->sh_entsize);                       \
6086           /* Note: coded this way so that there is a single string for  \
6087              translation.  */ \
6088           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6089           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6090                    (unsigned) expected_entsize);                        \
6091           section->sh_entsize = expected_entsize;                       \
6092         }                                                               \
6093     }                                                                   \
6094   while (0)
6095
6096 #define CHECK_ENTSIZE(section, i, type)                                 \
6097   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6098                         sizeof (Elf64_External_##type))
6099
6100   for (i = 0, section = filedata->section_headers;
6101        i < filedata->file_header.e_shnum;
6102        i++, section++)
6103     {
6104       char * name = SECTION_NAME (section);
6105
6106       if (section->sh_type == SHT_DYNSYM)
6107         {
6108           if (dynamic_symbols != NULL)
6109             {
6110               error (_("File contains multiple dynamic symbol tables\n"));
6111               continue;
6112             }
6113
6114           CHECK_ENTSIZE (section, i, Sym);
6115           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6116         }
6117       else if (section->sh_type == SHT_STRTAB
6118                && streq (name, ".dynstr"))
6119         {
6120           if (dynamic_strings != NULL)
6121             {
6122               error (_("File contains multiple dynamic string tables\n"));
6123               continue;
6124             }
6125
6126           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6127                                                1, section->sh_size,
6128                                                _("dynamic strings"));
6129           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6130         }
6131       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6132         {
6133           elf_section_list * entry = xmalloc (sizeof * entry);
6134
6135           entry->hdr = section;
6136           entry->next = symtab_shndx_list;
6137           symtab_shndx_list = entry;
6138         }
6139       else if (section->sh_type == SHT_SYMTAB)
6140         CHECK_ENTSIZE (section, i, Sym);
6141       else if (section->sh_type == SHT_GROUP)
6142         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6143       else if (section->sh_type == SHT_REL)
6144         CHECK_ENTSIZE (section, i, Rel);
6145       else if (section->sh_type == SHT_RELA)
6146         CHECK_ENTSIZE (section, i, Rela);
6147       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6148                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6149                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6150                 || do_debug_str || do_debug_loc || do_debug_ranges
6151                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6152                && (const_strneq (name, ".debug_")
6153                    || const_strneq (name, ".zdebug_")))
6154         {
6155           if (name[1] == 'z')
6156             name += sizeof (".zdebug_") - 1;
6157           else
6158             name += sizeof (".debug_") - 1;
6159
6160           if (do_debugging
6161               || (do_debug_info     && const_strneq (name, "info"))
6162               || (do_debug_info     && const_strneq (name, "types"))
6163               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6164               || (do_debug_lines    && strcmp (name, "line") == 0)
6165               || (do_debug_lines    && const_strneq (name, "line."))
6166               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6167               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6168               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6169               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6170               || (do_debug_aranges  && const_strneq (name, "aranges"))
6171               || (do_debug_ranges   && const_strneq (name, "ranges"))
6172               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6173               || (do_debug_frames   && const_strneq (name, "frame"))
6174               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6175               || (do_debug_macinfo  && const_strneq (name, "macro"))
6176               || (do_debug_str      && const_strneq (name, "str"))
6177               || (do_debug_loc      && const_strneq (name, "loc"))
6178               || (do_debug_loc      && const_strneq (name, "loclists"))
6179               || (do_debug_addr     && const_strneq (name, "addr"))
6180               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6181               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6182               )
6183             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6184         }
6185       /* Linkonce section to be combined with .debug_info at link time.  */
6186       else if ((do_debugging || do_debug_info)
6187                && const_strneq (name, ".gnu.linkonce.wi."))
6188         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6189       else if (do_debug_frames && streq (name, ".eh_frame"))
6190         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6191       else if (do_gdb_index && (streq (name, ".gdb_index")
6192                                 || streq (name, ".debug_names")))
6193         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6194       /* Trace sections for Itanium VMS.  */
6195       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6196                 || do_trace_aranges)
6197                && const_strneq (name, ".trace_"))
6198         {
6199           name += sizeof (".trace_") - 1;
6200
6201           if (do_debugging
6202               || (do_trace_info     && streq (name, "info"))
6203               || (do_trace_abbrevs  && streq (name, "abbrev"))
6204               || (do_trace_aranges  && streq (name, "aranges"))
6205               )
6206             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6207         }
6208       else if ((do_debugging || do_debug_links)
6209                && (const_strneq (name, ".gnu_debuglink")
6210                    || const_strneq (name, ".gnu_debugaltlink")))
6211         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6212     }
6213
6214   if (! do_sections)
6215     return TRUE;
6216
6217   if (filedata->file_header.e_shnum > 1)
6218     printf (_("\nSection Headers:\n"));
6219   else
6220     printf (_("\nSection Header:\n"));
6221
6222   if (is_32bit_elf)
6223     {
6224       if (do_section_details)
6225         {
6226           printf (_("  [Nr] Name\n"));
6227           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6228         }
6229       else
6230         printf
6231           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6232     }
6233   else if (do_wide)
6234     {
6235       if (do_section_details)
6236         {
6237           printf (_("  [Nr] Name\n"));
6238           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6239         }
6240       else
6241         printf
6242           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6243     }
6244   else
6245     {
6246       if (do_section_details)
6247         {
6248           printf (_("  [Nr] Name\n"));
6249           printf (_("       Type              Address          Offset            Link\n"));
6250           printf (_("       Size              EntSize          Info              Align\n"));
6251         }
6252       else
6253         {
6254           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6255           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6256         }
6257     }
6258
6259   if (do_section_details)
6260     printf (_("       Flags\n"));
6261
6262   for (i = 0, section = filedata->section_headers;
6263        i < filedata->file_header.e_shnum;
6264        i++, section++)
6265     {
6266       /* Run some sanity checks on the section header.  */
6267
6268       /* Check the sh_link field.  */
6269       switch (section->sh_type)
6270         {
6271         case SHT_SYMTAB_SHNDX:
6272         case SHT_GROUP:
6273         case SHT_HASH:
6274         case SHT_GNU_HASH:
6275         case SHT_GNU_versym:
6276         case SHT_REL:
6277         case SHT_RELA:
6278           if (section->sh_link < 1
6279               || section->sh_link >= filedata->file_header.e_shnum
6280               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6281                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6282             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6283                   i, section->sh_link);
6284           break;
6285
6286         case SHT_DYNAMIC:
6287         case SHT_SYMTAB:
6288         case SHT_DYNSYM:
6289         case SHT_GNU_verneed:
6290         case SHT_GNU_verdef:
6291         case SHT_GNU_LIBLIST:
6292           if (section->sh_link < 1
6293               || section->sh_link >= filedata->file_header.e_shnum
6294               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6295             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6296                   i, section->sh_link);
6297           break;
6298
6299         case SHT_INIT_ARRAY:
6300         case SHT_FINI_ARRAY:
6301         case SHT_PREINIT_ARRAY:
6302           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6303             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6304                   i, section->sh_link);
6305           break;
6306
6307         default:
6308           /* FIXME: Add support for target specific section types.  */
6309 #if 0     /* Currently we do not check other section types as there are too
6310              many special cases.  Stab sections for example have a type
6311              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6312              section.  */
6313           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6314             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6315                   i, section->sh_link);
6316 #endif
6317           break;
6318         }
6319
6320       /* Check the sh_info field.  */
6321       switch (section->sh_type)
6322         {
6323         case SHT_REL:
6324         case SHT_RELA:
6325           if (section->sh_info < 1
6326               || section->sh_info >= filedata->file_header.e_shnum
6327               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6328                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6329                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6330                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6331                   /* FIXME: Are other section types valid ?  */
6332                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6333             {
6334               if (section->sh_info == 0
6335                   && (filedata->file_header.e_type == ET_EXEC
6336                       || filedata->file_header.e_type == ET_DYN
6337                       /* These next two tests may be redundant, but
6338                          they have been left in for paranoia's sake.  */
6339                       || streq (SECTION_NAME (section), ".rel.dyn")
6340                       || streq (SECTION_NAME (section), ".rela.dyn")))
6341                 /* Dynamic relocations apply to segments, not sections, so
6342                    they do not need an sh_info value.  */
6343                 ;
6344               else
6345                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6346                       i, section->sh_info);
6347             }
6348           break;
6349
6350         case SHT_DYNAMIC:
6351         case SHT_HASH:
6352         case SHT_SYMTAB_SHNDX:
6353         case SHT_INIT_ARRAY:
6354         case SHT_FINI_ARRAY:
6355         case SHT_PREINIT_ARRAY:
6356           if (section->sh_info != 0)
6357             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6358                   i, section->sh_info);
6359           break;
6360
6361         case SHT_GROUP:
6362         case SHT_SYMTAB:
6363         case SHT_DYNSYM:
6364           /* A symbol index - we assume that it is valid.  */
6365           break;
6366
6367         default:
6368           /* FIXME: Add support for target specific section types.  */
6369           if (section->sh_type == SHT_NOBITS)
6370             /* NOBITS section headers with non-zero sh_info fields can be
6371                created when a binary is stripped of everything but its debug
6372                information.  The stripped sections have their headers
6373                preserved but their types set to SHT_NOBITS.  So do not check
6374                this type of section.  */
6375             ;
6376           else if (section->sh_flags & SHF_INFO_LINK)
6377             {
6378               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6379                 warn (_("[%2u]: Expected link to another section in info field"), i);
6380             }
6381           else if (section->sh_type < SHT_LOOS
6382                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6383                    && section->sh_info != 0)
6384             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6385                   i, section->sh_info);
6386           break;
6387         }
6388
6389       /* Check the sh_size field.  */
6390       if (section->sh_size > filedata->file_size
6391           && section->sh_type != SHT_NOBITS
6392           && section->sh_type != SHT_NULL
6393           && section->sh_type < SHT_LOOS)
6394         warn (_("Size of section %u is larger than the entire file!\n"), i);
6395
6396       printf ("  [%2u] ", i);
6397       if (do_section_details)
6398         printf ("%s\n      ", printable_section_name (filedata, section));
6399       else
6400         print_symbol (-17, SECTION_NAME (section));
6401
6402       printf (do_wide ? " %-15s " : " %-15.15s ",
6403               get_section_type_name (filedata, section->sh_type));
6404
6405       if (is_32bit_elf)
6406         {
6407           const char * link_too_big = NULL;
6408
6409           print_vma (section->sh_addr, LONG_HEX);
6410
6411           printf ( " %6.6lx %6.6lx %2.2lx",
6412                    (unsigned long) section->sh_offset,
6413                    (unsigned long) section->sh_size,
6414                    (unsigned long) section->sh_entsize);
6415
6416           if (do_section_details)
6417             fputs ("  ", stdout);
6418           else
6419             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6420
6421           if (section->sh_link >= filedata->file_header.e_shnum)
6422             {
6423               link_too_big = "";
6424               /* The sh_link value is out of range.  Normally this indicates
6425                  an error but it can have special values in Solaris binaries.  */
6426               switch (filedata->file_header.e_machine)
6427                 {
6428                 case EM_386:
6429                 case EM_IAMCU:
6430                 case EM_X86_64:
6431                 case EM_L1OM:
6432                 case EM_K1OM:
6433                 case EM_OLD_SPARCV9:
6434                 case EM_SPARC32PLUS:
6435                 case EM_SPARCV9:
6436                 case EM_SPARC:
6437                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6438                     link_too_big = "BEFORE";
6439                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6440                     link_too_big = "AFTER";
6441                   break;
6442                 default:
6443                   break;
6444                 }
6445             }
6446
6447           if (do_section_details)
6448             {
6449               if (link_too_big != NULL && * link_too_big)
6450                 printf ("<%s> ", link_too_big);
6451               else
6452                 printf ("%2u ", section->sh_link);
6453               printf ("%3u %2lu\n", section->sh_info,
6454                       (unsigned long) section->sh_addralign);
6455             }
6456           else
6457             printf ("%2u %3u %2lu\n",
6458                     section->sh_link,
6459                     section->sh_info,
6460                     (unsigned long) section->sh_addralign);
6461
6462           if (link_too_big && ! * link_too_big)
6463             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6464                   i, section->sh_link);
6465         }
6466       else if (do_wide)
6467         {
6468           print_vma (section->sh_addr, LONG_HEX);
6469
6470           if ((long) section->sh_offset == section->sh_offset)
6471             printf (" %6.6lx", (unsigned long) section->sh_offset);
6472           else
6473             {
6474               putchar (' ');
6475               print_vma (section->sh_offset, LONG_HEX);
6476             }
6477
6478           if ((unsigned long) section->sh_size == section->sh_size)
6479             printf (" %6.6lx", (unsigned long) section->sh_size);
6480           else
6481             {
6482               putchar (' ');
6483               print_vma (section->sh_size, LONG_HEX);
6484             }
6485
6486           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6487             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6488           else
6489             {
6490               putchar (' ');
6491               print_vma (section->sh_entsize, LONG_HEX);
6492             }
6493
6494           if (do_section_details)
6495             fputs ("  ", stdout);
6496           else
6497             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6498
6499           printf ("%2u %3u ", section->sh_link, section->sh_info);
6500
6501           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6502             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6503           else
6504             {
6505               print_vma (section->sh_addralign, DEC);
6506               putchar ('\n');
6507             }
6508         }
6509       else if (do_section_details)
6510         {
6511           printf ("       %-15.15s  ",
6512                   get_section_type_name (filedata, section->sh_type));
6513           print_vma (section->sh_addr, LONG_HEX);
6514           if ((long) section->sh_offset == section->sh_offset)
6515             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6516           else
6517             {
6518               printf ("  ");
6519               print_vma (section->sh_offset, LONG_HEX);
6520             }
6521           printf ("  %u\n       ", section->sh_link);
6522           print_vma (section->sh_size, LONG_HEX);
6523           putchar (' ');
6524           print_vma (section->sh_entsize, LONG_HEX);
6525
6526           printf ("  %-16u  %lu\n",
6527                   section->sh_info,
6528                   (unsigned long) section->sh_addralign);
6529         }
6530       else
6531         {
6532           putchar (' ');
6533           print_vma (section->sh_addr, LONG_HEX);
6534           if ((long) section->sh_offset == section->sh_offset)
6535             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6536           else
6537             {
6538               printf ("  ");
6539               print_vma (section->sh_offset, LONG_HEX);
6540             }
6541           printf ("\n       ");
6542           print_vma (section->sh_size, LONG_HEX);
6543           printf ("  ");
6544           print_vma (section->sh_entsize, LONG_HEX);
6545
6546           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6547
6548           printf ("     %2u   %3u     %lu\n",
6549                   section->sh_link,
6550                   section->sh_info,
6551                   (unsigned long) section->sh_addralign);
6552         }
6553
6554       if (do_section_details)
6555         {
6556           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6557           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6558             {
6559               /* Minimum section size is 12 bytes for 32-bit compression
6560                  header + 12 bytes for compressed data header.  */
6561               unsigned char buf[24];
6562
6563               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6564               if (get_data (&buf, filedata, section->sh_offset, 1,
6565                             sizeof (buf), _("compression header")))
6566                 {
6567                   Elf_Internal_Chdr chdr;
6568
6569                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6570
6571                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6572                     printf ("       ZLIB, ");
6573                   else
6574                     printf (_("       [<unknown>: 0x%x], "),
6575                             chdr.ch_type);
6576                   print_vma (chdr.ch_size, LONG_HEX);
6577                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6578                 }
6579             }
6580         }
6581     }
6582
6583   if (!do_section_details)
6584     {
6585       /* The ordering of the letters shown here matches the ordering of the
6586          corresponding SHF_xxx values, and hence the order in which these
6587          letters will be displayed to the user.  */
6588       printf (_("Key to Flags:\n\
6589   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6590   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6591   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6592       if (filedata->file_header.e_machine == EM_X86_64
6593           || filedata->file_header.e_machine == EM_L1OM
6594           || filedata->file_header.e_machine == EM_K1OM)
6595         printf (_("l (large), "));
6596       else if (filedata->file_header.e_machine == EM_ARM)
6597         printf (_("y (purecode), "));
6598       else if (filedata->file_header.e_machine == EM_PPC)
6599         printf (_("v (VLE), "));
6600       printf ("p (processor specific)\n");
6601     }
6602
6603   return TRUE;
6604 }
6605
6606 static const char *
6607 get_group_flags (unsigned int flags)
6608 {
6609   static char buff[128];
6610
6611   if (flags == 0)
6612     return "";
6613   else if (flags == GRP_COMDAT)
6614     return "COMDAT ";
6615
6616   snprintf (buff, 14, _("[0x%x: "), flags);
6617
6618   flags &= ~ GRP_COMDAT;
6619   if (flags & GRP_MASKOS)
6620     {
6621       strcat (buff, "<OS specific>");
6622       flags &= ~ GRP_MASKOS;
6623     }
6624
6625   if (flags & GRP_MASKPROC)
6626     {
6627       strcat (buff, "<PROC specific>");
6628       flags &= ~ GRP_MASKPROC;
6629     }
6630
6631   if (flags)
6632     strcat (buff, "<unknown>");
6633
6634   strcat (buff, "]");
6635   return buff;
6636 }
6637
6638 static bfd_boolean
6639 process_section_groups (Filedata * filedata)
6640 {
6641   Elf_Internal_Shdr * section;
6642   unsigned int i;
6643   struct group * group;
6644   Elf_Internal_Shdr * symtab_sec;
6645   Elf_Internal_Shdr * strtab_sec;
6646   Elf_Internal_Sym * symtab;
6647   unsigned long num_syms;
6648   char * strtab;
6649   size_t strtab_size;
6650
6651   /* Don't process section groups unless needed.  */
6652   if (!do_unwind && !do_section_groups)
6653     return TRUE;
6654
6655   if (filedata->file_header.e_shnum == 0)
6656     {
6657       if (do_section_groups)
6658         printf (_("\nThere are no sections to group in this file.\n"));
6659
6660       return TRUE;
6661     }
6662
6663   if (filedata->section_headers == NULL)
6664     {
6665       error (_("Section headers are not available!\n"));
6666       /* PR 13622: This can happen with a corrupt ELF header.  */
6667       return FALSE;
6668     }
6669
6670   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6671                                                      sizeof (struct group *));
6672
6673   if (section_headers_groups == NULL)
6674     {
6675       error (_("Out of memory reading %u section group headers\n"),
6676              filedata->file_header.e_shnum);
6677       return FALSE;
6678     }
6679
6680   /* Scan the sections for the group section.  */
6681   group_count = 0;
6682   for (i = 0, section = filedata->section_headers;
6683        i < filedata->file_header.e_shnum;
6684        i++, section++)
6685     if (section->sh_type == SHT_GROUP)
6686       group_count++;
6687
6688   if (group_count == 0)
6689     {
6690       if (do_section_groups)
6691         printf (_("\nThere are no section groups in this file.\n"));
6692
6693       return TRUE;
6694     }
6695
6696   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6697
6698   if (section_groups == NULL)
6699     {
6700       error (_("Out of memory reading %lu groups\n"),
6701              (unsigned long) group_count);
6702       return FALSE;
6703     }
6704
6705   symtab_sec = NULL;
6706   strtab_sec = NULL;
6707   symtab = NULL;
6708   num_syms = 0;
6709   strtab = NULL;
6710   strtab_size = 0;
6711   for (i = 0, section = filedata->section_headers, group = section_groups;
6712        i < filedata->file_header.e_shnum;
6713        i++, section++)
6714     {
6715       if (section->sh_type == SHT_GROUP)
6716         {
6717           const char * name = printable_section_name (filedata, section);
6718           const char * group_name;
6719           unsigned char * start;
6720           unsigned char * indices;
6721           unsigned int entry, j, size;
6722           Elf_Internal_Shdr * sec;
6723           Elf_Internal_Sym * sym;
6724
6725           /* Get the symbol table.  */
6726           if (section->sh_link >= filedata->file_header.e_shnum
6727               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6728                   != SHT_SYMTAB))
6729             {
6730               error (_("Bad sh_link in group section `%s'\n"), name);
6731               continue;
6732             }
6733
6734           if (symtab_sec != sec)
6735             {
6736               symtab_sec = sec;
6737               if (symtab)
6738                 free (symtab);
6739               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6740             }
6741
6742           if (symtab == NULL)
6743             {
6744               error (_("Corrupt header in group section `%s'\n"), name);
6745               continue;
6746             }
6747
6748           if (section->sh_info >= num_syms)
6749             {
6750               error (_("Bad sh_info in group section `%s'\n"), name);
6751               continue;
6752             }
6753
6754           sym = symtab + section->sh_info;
6755
6756           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6757             {
6758               if (sym->st_shndx == 0
6759                   || sym->st_shndx >= filedata->file_header.e_shnum)
6760                 {
6761                   error (_("Bad sh_info in group section `%s'\n"), name);
6762                   continue;
6763                 }
6764
6765               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6766               strtab_sec = NULL;
6767               if (strtab)
6768                 free (strtab);
6769               strtab = NULL;
6770               strtab_size = 0;
6771             }
6772           else
6773             {
6774               /* Get the string table.  */
6775               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6776                 {
6777                   strtab_sec = NULL;
6778                   if (strtab)
6779                     free (strtab);
6780                   strtab = NULL;
6781                   strtab_size = 0;
6782                 }
6783               else if (strtab_sec
6784                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6785                 {
6786                   strtab_sec = sec;
6787                   if (strtab)
6788                     free (strtab);
6789
6790                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6791                                               1, strtab_sec->sh_size,
6792                                               _("string table"));
6793                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6794                 }
6795               group_name = sym->st_name < strtab_size
6796                 ? strtab + sym->st_name : _("<corrupt>");
6797             }
6798
6799           /* PR 17531: file: loop.  */
6800           if (section->sh_entsize > section->sh_size)
6801             {
6802               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6803                      printable_section_name (filedata, section),
6804                      (unsigned long) section->sh_entsize,
6805                      (unsigned long) section->sh_size);
6806               break;
6807             }
6808
6809           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6810                                               1, section->sh_size,
6811                                               _("section data"));
6812           if (start == NULL)
6813             continue;
6814
6815           indices = start;
6816           size = (section->sh_size / section->sh_entsize) - 1;
6817           entry = byte_get (indices, 4);
6818           indices += 4;
6819
6820           if (do_section_groups)
6821             {
6822               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6823                       get_group_flags (entry), i, name, group_name, size);
6824
6825               printf (_("   [Index]    Name\n"));
6826             }
6827
6828           group->group_index = i;
6829
6830           for (j = 0; j < size; j++)
6831             {
6832               struct group_list * g;
6833
6834               entry = byte_get (indices, 4);
6835               indices += 4;
6836
6837               if (entry >= filedata->file_header.e_shnum)
6838                 {
6839                   static unsigned num_group_errors = 0;
6840
6841                   if (num_group_errors ++ < 10)
6842                     {
6843                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6844                              entry, i, filedata->file_header.e_shnum - 1);
6845                       if (num_group_errors == 10)
6846                         warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6847                     }
6848                   continue;
6849                 }
6850
6851               if (section_headers_groups [entry] != NULL)
6852                 {
6853                   if (entry)
6854                     {
6855                       static unsigned num_errs = 0;
6856
6857                       if (num_errs ++ < 10)
6858                         {
6859                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6860                                  entry, i,
6861                                  section_headers_groups [entry]->group_index);
6862                           if (num_errs == 10)
6863                             warn (_("Further error messages about already contained group sections suppressed\n"));
6864                         }
6865                       continue;
6866                     }
6867                   else
6868                     {
6869                       /* Intel C/C++ compiler may put section 0 in a
6870                          section group.  We just warn it the first time
6871                          and ignore it afterwards.  */
6872                       static bfd_boolean warned = FALSE;
6873                       if (!warned)
6874                         {
6875                           error (_("section 0 in group section [%5u]\n"),
6876                                  section_headers_groups [entry]->group_index);
6877                           warned = TRUE;
6878                         }
6879                     }
6880                 }
6881
6882               section_headers_groups [entry] = group;
6883
6884               if (do_section_groups)
6885                 {
6886                   sec = filedata->section_headers + entry;
6887                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6888                 }
6889
6890               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6891               g->section_index = entry;
6892               g->next = group->root;
6893               group->root = g;
6894             }
6895
6896           if (start)
6897             free (start);
6898
6899           group++;
6900         }
6901     }
6902
6903   if (symtab)
6904     free (symtab);
6905   if (strtab)
6906     free (strtab);
6907   return TRUE;
6908 }
6909
6910 /* Data used to display dynamic fixups.  */
6911
6912 struct ia64_vms_dynfixup
6913 {
6914   bfd_vma needed_ident;         /* Library ident number.  */
6915   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6916   bfd_vma fixup_needed;         /* Index of the library.  */
6917   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6918   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6919 };
6920
6921 /* Data used to display dynamic relocations.  */
6922
6923 struct ia64_vms_dynimgrela
6924 {
6925   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6926   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6927 };
6928
6929 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6930    library).  */
6931
6932 static bfd_boolean
6933 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6934                               struct ia64_vms_dynfixup *  fixup,
6935                               const char *                strtab,
6936                               unsigned int                strtab_sz)
6937 {
6938   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6939   long i;
6940   const char * lib_name;
6941
6942   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6943                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6944                    _("dynamic section image fixups"));
6945   if (!imfs)
6946     return FALSE;
6947
6948   if (fixup->needed < strtab_sz)
6949     lib_name = strtab + fixup->needed;
6950   else
6951     {
6952       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6953             (unsigned long) fixup->needed);
6954       lib_name = "???";
6955     }
6956   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6957           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6958   printf
6959     (_("Seg Offset           Type                             SymVec DataType\n"));
6960
6961   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6962     {
6963       unsigned int type;
6964       const char *rtype;
6965
6966       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6967       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6968       type = BYTE_GET (imfs [i].type);
6969       rtype = elf_ia64_reloc_type (type);
6970       if (rtype == NULL)
6971         printf (" 0x%08x                       ", type);
6972       else
6973         printf (" %-32s ", rtype);
6974       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6975       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6976     }
6977
6978   free (imfs);
6979   return TRUE;
6980 }
6981
6982 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6983
6984 static bfd_boolean
6985 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
6986 {
6987   Elf64_External_VMS_IMAGE_RELA *imrs;
6988   long i;
6989
6990   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
6991                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6992                    _("dynamic section image relocations"));
6993   if (!imrs)
6994     return FALSE;
6995
6996   printf (_("\nImage relocs\n"));
6997   printf
6998     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6999
7000   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7001     {
7002       unsigned int type;
7003       const char *rtype;
7004
7005       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7006       printf ("%08" BFD_VMA_FMT "x ",
7007               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7008       type = BYTE_GET (imrs [i].type);
7009       rtype = elf_ia64_reloc_type (type);
7010       if (rtype == NULL)
7011         printf ("0x%08x                      ", type);
7012       else
7013         printf ("%-31s ", rtype);
7014       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7015       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7016       printf ("%08" BFD_VMA_FMT "x\n",
7017               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7018     }
7019
7020   free (imrs);
7021   return TRUE;
7022 }
7023
7024 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
7025
7026 static bfd_boolean
7027 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7028 {
7029   struct ia64_vms_dynfixup fixup;
7030   struct ia64_vms_dynimgrela imgrela;
7031   Elf_Internal_Dyn *entry;
7032   bfd_vma strtab_off = 0;
7033   bfd_vma strtab_sz = 0;
7034   char *strtab = NULL;
7035   bfd_boolean res = TRUE;
7036
7037   memset (&fixup, 0, sizeof (fixup));
7038   memset (&imgrela, 0, sizeof (imgrela));
7039
7040   /* Note: the order of the entries is specified by the OpenVMS specs.  */
7041   for (entry = dynamic_section;
7042        entry < dynamic_section + dynamic_nent;
7043        entry++)
7044     {
7045       switch (entry->d_tag)
7046         {
7047         case DT_IA_64_VMS_STRTAB_OFFSET:
7048           strtab_off = entry->d_un.d_val;
7049           break;
7050         case DT_STRSZ:
7051           strtab_sz = entry->d_un.d_val;
7052           if (strtab == NULL)
7053             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7054                                1, strtab_sz, _("dynamic string section"));
7055           break;
7056
7057         case DT_IA_64_VMS_NEEDED_IDENT:
7058           fixup.needed_ident = entry->d_un.d_val;
7059           break;
7060         case DT_NEEDED:
7061           fixup.needed = entry->d_un.d_val;
7062           break;
7063         case DT_IA_64_VMS_FIXUP_NEEDED:
7064           fixup.fixup_needed = entry->d_un.d_val;
7065           break;
7066         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7067           fixup.fixup_rela_cnt = entry->d_un.d_val;
7068           break;
7069         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7070           fixup.fixup_rela_off = entry->d_un.d_val;
7071           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7072             res = FALSE;
7073           break;
7074         case DT_IA_64_VMS_IMG_RELA_CNT:
7075           imgrela.img_rela_cnt = entry->d_un.d_val;
7076           break;
7077         case DT_IA_64_VMS_IMG_RELA_OFF:
7078           imgrela.img_rela_off = entry->d_un.d_val;
7079           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7080             res = FALSE;
7081           break;
7082
7083         default:
7084           break;
7085         }
7086     }
7087
7088   if (strtab != NULL)
7089     free (strtab);
7090
7091   return res;
7092 }
7093
7094 static struct
7095 {
7096   const char * name;
7097   int reloc;
7098   int size;
7099   int rela;
7100 }
7101   dynamic_relocations [] =
7102 {
7103   { "REL", DT_REL, DT_RELSZ, FALSE },
7104   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7105   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7106 };
7107
7108 /* Process the reloc section.  */
7109
7110 static bfd_boolean
7111 process_relocs (Filedata * filedata)
7112 {
7113   unsigned long rel_size;
7114   unsigned long rel_offset;
7115
7116   if (!do_reloc)
7117     return TRUE;
7118
7119   if (do_using_dynamic)
7120     {
7121       int          is_rela;
7122       const char * name;
7123       bfd_boolean  has_dynamic_reloc;
7124       unsigned int i;
7125
7126       has_dynamic_reloc = FALSE;
7127
7128       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7129         {
7130           is_rela = dynamic_relocations [i].rela;
7131           name = dynamic_relocations [i].name;
7132           rel_size = dynamic_info [dynamic_relocations [i].size];
7133           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7134
7135           if (rel_size)
7136             has_dynamic_reloc = TRUE;
7137
7138           if (is_rela == UNKNOWN)
7139             {
7140               if (dynamic_relocations [i].reloc == DT_JMPREL)
7141                 switch (dynamic_info[DT_PLTREL])
7142                   {
7143                   case DT_REL:
7144                     is_rela = FALSE;
7145                     break;
7146                   case DT_RELA:
7147                     is_rela = TRUE;
7148                     break;
7149                   }
7150             }
7151
7152           if (rel_size)
7153             {
7154               printf
7155                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7156                  name, rel_offset, rel_size);
7157
7158               dump_relocations (filedata,
7159                                 offset_from_vma (filedata, rel_offset, rel_size),
7160                                 rel_size,
7161                                 dynamic_symbols, num_dynamic_syms,
7162                                 dynamic_strings, dynamic_strings_length,
7163                                 is_rela, TRUE /* is_dynamic */);
7164             }
7165         }
7166
7167       if (is_ia64_vms (filedata))
7168         if (process_ia64_vms_dynamic_relocs (filedata))
7169           has_dynamic_reloc = TRUE;
7170
7171       if (! has_dynamic_reloc)
7172         printf (_("\nThere are no dynamic relocations in this file.\n"));
7173     }
7174   else
7175     {
7176       Elf_Internal_Shdr * section;
7177       unsigned long i;
7178       bfd_boolean found = FALSE;
7179
7180       for (i = 0, section = filedata->section_headers;
7181            i < filedata->file_header.e_shnum;
7182            i++, section++)
7183         {
7184           if (   section->sh_type != SHT_RELA
7185               && section->sh_type != SHT_REL)
7186             continue;
7187
7188           rel_offset = section->sh_offset;
7189           rel_size   = section->sh_size;
7190
7191           if (rel_size)
7192             {
7193               Elf_Internal_Shdr * strsec;
7194               int is_rela;
7195               unsigned long num_rela;
7196
7197               printf (_("\nRelocation section "));
7198
7199               if (filedata->string_table == NULL)
7200                 printf ("%d", section->sh_name);
7201               else
7202                 printf ("'%s'", printable_section_name (filedata, section));
7203
7204               num_rela = rel_size / section->sh_entsize;
7205               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7206                                 " at offset 0x%lx contains %lu entries:\n",
7207                                 num_rela),
7208                       rel_offset, num_rela);
7209
7210               is_rela = section->sh_type == SHT_RELA;
7211
7212               if (section->sh_link != 0
7213                   && section->sh_link < filedata->file_header.e_shnum)
7214                 {
7215                   Elf_Internal_Shdr * symsec;
7216                   Elf_Internal_Sym *  symtab;
7217                   unsigned long nsyms;
7218                   unsigned long strtablen = 0;
7219                   char * strtab = NULL;
7220
7221                   symsec = filedata->section_headers + section->sh_link;
7222                   if (symsec->sh_type != SHT_SYMTAB
7223                       && symsec->sh_type != SHT_DYNSYM)
7224                     continue;
7225
7226                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7227
7228                   if (symtab == NULL)
7229                     continue;
7230
7231                   if (symsec->sh_link != 0
7232                       && symsec->sh_link < filedata->file_header.e_shnum)
7233                     {
7234                       strsec = filedata->section_headers + symsec->sh_link;
7235
7236                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7237                                                   1, strsec->sh_size,
7238                                                   _("string table"));
7239                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7240                     }
7241
7242                   dump_relocations (filedata, rel_offset, rel_size,
7243                                     symtab, nsyms, strtab, strtablen,
7244                                     is_rela,
7245                                     symsec->sh_type == SHT_DYNSYM);
7246                   if (strtab)
7247                     free (strtab);
7248                   free (symtab);
7249                 }
7250               else
7251                 dump_relocations (filedata, rel_offset, rel_size,
7252                                   NULL, 0, NULL, 0, is_rela,
7253                                   FALSE /* is_dynamic */);
7254
7255               found = TRUE;
7256             }
7257         }
7258
7259       if (! found)
7260         {
7261           /* Users sometimes forget the -D option, so try to be helpful.  */
7262           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7263             {
7264               if (dynamic_info [dynamic_relocations [i].size])
7265                 {
7266                   printf (_("\nThere are no static relocations in this file."));
7267                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7268
7269                   break;
7270                 }
7271             }
7272           if (i == ARRAY_SIZE (dynamic_relocations))
7273             printf (_("\nThere are no relocations in this file.\n"));
7274         }
7275     }
7276
7277   return TRUE;
7278 }
7279
7280 /* An absolute address consists of a section and an offset.  If the
7281    section is NULL, the offset itself is the address, otherwise, the
7282    address equals to LOAD_ADDRESS(section) + offset.  */
7283
7284 struct absaddr
7285 {
7286   unsigned short section;
7287   bfd_vma offset;
7288 };
7289
7290 #define ABSADDR(a) \
7291   ((a).section \
7292    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7293    : (a).offset)
7294
7295 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7296    name, if found, and the offset from the symbol to ADDR.  */
7297
7298 static void
7299 find_symbol_for_address (Filedata *          filedata,
7300                          Elf_Internal_Sym *  symtab,
7301                          unsigned long       nsyms,
7302                          const char *        strtab,
7303                          unsigned long       strtab_size,
7304                          struct absaddr      addr,
7305                          const char **       symname,
7306                          bfd_vma *           offset)
7307 {
7308   bfd_vma dist = 0x100000;
7309   Elf_Internal_Sym * sym;
7310   Elf_Internal_Sym * beg;
7311   Elf_Internal_Sym * end;
7312   Elf_Internal_Sym * best = NULL;
7313
7314   REMOVE_ARCH_BITS (addr.offset);
7315   beg = symtab;
7316   end = symtab + nsyms;
7317
7318   while (beg < end)
7319     {
7320       bfd_vma value;
7321
7322       sym = beg + (end - beg) / 2;
7323
7324       value = sym->st_value;
7325       REMOVE_ARCH_BITS (value);
7326
7327       if (sym->st_name != 0
7328           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7329           && addr.offset >= value
7330           && addr.offset - value < dist)
7331         {
7332           best = sym;
7333           dist = addr.offset - value;
7334           if (!dist)
7335             break;
7336         }
7337
7338       if (addr.offset < value)
7339         end = sym;
7340       else
7341         beg = sym + 1;
7342     }
7343
7344   if (best)
7345     {
7346       *symname = (best->st_name >= strtab_size
7347                   ? _("<corrupt>") : strtab + best->st_name);
7348       *offset = dist;
7349       return;
7350     }
7351
7352   *symname = NULL;
7353   *offset = addr.offset;
7354 }
7355
7356 static /* signed */ int
7357 symcmp (const void *p, const void *q)
7358 {
7359   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7360   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7361
7362   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7363 }
7364
7365 /* Process the unwind section.  */
7366
7367 #include "unwind-ia64.h"
7368
7369 struct ia64_unw_table_entry
7370 {
7371   struct absaddr start;
7372   struct absaddr end;
7373   struct absaddr info;
7374 };
7375
7376 struct ia64_unw_aux_info
7377 {
7378   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7379   unsigned long                 table_len;      /* Length of unwind table.  */
7380   unsigned char *               info;           /* Unwind info.  */
7381   unsigned long                 info_size;      /* Size of unwind info.  */
7382   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7383   bfd_vma                       seg_base;       /* Starting address of segment.  */
7384   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7385   unsigned long                 nsyms;          /* Number of symbols.  */
7386   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7387   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7388   char *                        strtab;         /* The string table.  */
7389   unsigned long                 strtab_size;    /* Size of string table.  */
7390 };
7391
7392 static bfd_boolean
7393 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7394 {
7395   struct ia64_unw_table_entry * tp;
7396   unsigned long j, nfuns;
7397   int in_body;
7398   bfd_boolean res = TRUE;
7399
7400   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7401   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7402     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7403       aux->funtab[nfuns++] = aux->symtab[j];
7404   aux->nfuns = nfuns;
7405   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7406
7407   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7408     {
7409       bfd_vma stamp;
7410       bfd_vma offset;
7411       const unsigned char * dp;
7412       const unsigned char * head;
7413       const unsigned char * end;
7414       const char * procname;
7415
7416       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7417                                aux->strtab_size, tp->start, &procname, &offset);
7418
7419       fputs ("\n<", stdout);
7420
7421       if (procname)
7422         {
7423           fputs (procname, stdout);
7424
7425           if (offset)
7426             printf ("+%lx", (unsigned long) offset);
7427         }
7428
7429       fputs (">: [", stdout);
7430       print_vma (tp->start.offset, PREFIX_HEX);
7431       fputc ('-', stdout);
7432       print_vma (tp->end.offset, PREFIX_HEX);
7433       printf ("], info at +0x%lx\n",
7434               (unsigned long) (tp->info.offset - aux->seg_base));
7435
7436       /* PR 17531: file: 86232b32.  */
7437       if (aux->info == NULL)
7438         continue;
7439
7440       /* PR 17531: file: 0997b4d1.  */
7441       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7442         {
7443           warn (_("Invalid offset %lx in table entry %ld\n"),
7444                 (long) tp->info.offset, (long) (tp - aux->table));
7445           res = FALSE;
7446           continue;
7447         }
7448
7449       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7450       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7451
7452       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7453               (unsigned) UNW_VER (stamp),
7454               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7455               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7456               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7457               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7458
7459       if (UNW_VER (stamp) != 1)
7460         {
7461           printf (_("\tUnknown version.\n"));
7462           continue;
7463         }
7464
7465       in_body = 0;
7466       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7467       /* PR 17531: file: 16ceda89.  */
7468       if (end > aux->info + aux->info_size)
7469         end = aux->info + aux->info_size;
7470       for (dp = head + 8; dp < end;)
7471         dp = unw_decode (dp, in_body, & in_body, end);
7472     }
7473
7474   free (aux->funtab);
7475
7476   return res;
7477 }
7478
7479 static bfd_boolean
7480 slurp_ia64_unwind_table (Filedata *                  filedata,
7481                          struct ia64_unw_aux_info *  aux,
7482                          Elf_Internal_Shdr *         sec)
7483 {
7484   unsigned long size, nrelas, i;
7485   Elf_Internal_Phdr * seg;
7486   struct ia64_unw_table_entry * tep;
7487   Elf_Internal_Shdr * relsec;
7488   Elf_Internal_Rela * rela;
7489   Elf_Internal_Rela * rp;
7490   unsigned char * table;
7491   unsigned char * tp;
7492   Elf_Internal_Sym * sym;
7493   const char * relname;
7494
7495   aux->table_len = 0;
7496
7497   /* First, find the starting address of the segment that includes
7498      this section: */
7499
7500   if (filedata->file_header.e_phnum)
7501     {
7502       if (! get_program_headers (filedata))
7503           return FALSE;
7504
7505       for (seg = filedata->program_headers;
7506            seg < filedata->program_headers + filedata->file_header.e_phnum;
7507            ++seg)
7508         {
7509           if (seg->p_type != PT_LOAD)
7510             continue;
7511
7512           if (sec->sh_addr >= seg->p_vaddr
7513               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7514             {
7515               aux->seg_base = seg->p_vaddr;
7516               break;
7517             }
7518         }
7519     }
7520
7521   /* Second, build the unwind table from the contents of the unwind section:  */
7522   size = sec->sh_size;
7523   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7524                                       _("unwind table"));
7525   if (!table)
7526     return FALSE;
7527
7528   aux->table_len = size / (3 * eh_addr_size);
7529   aux->table = (struct ia64_unw_table_entry *)
7530     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7531   tep = aux->table;
7532
7533   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7534     {
7535       tep->start.section = SHN_UNDEF;
7536       tep->end.section   = SHN_UNDEF;
7537       tep->info.section  = SHN_UNDEF;
7538       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7539       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7540       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7541       tep->start.offset += aux->seg_base;
7542       tep->end.offset   += aux->seg_base;
7543       tep->info.offset  += aux->seg_base;
7544     }
7545   free (table);
7546
7547   /* Third, apply any relocations to the unwind table:  */
7548   for (relsec = filedata->section_headers;
7549        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7550        ++relsec)
7551     {
7552       if (relsec->sh_type != SHT_RELA
7553           || relsec->sh_info >= filedata->file_header.e_shnum
7554           || filedata->section_headers + relsec->sh_info != sec)
7555         continue;
7556
7557       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7558                               & rela, & nrelas))
7559         {
7560           free (aux->table);
7561           aux->table = NULL;
7562           aux->table_len = 0;
7563           return FALSE;
7564         }
7565
7566       for (rp = rela; rp < rela + nrelas; ++rp)
7567         {
7568           relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7569           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7570
7571           /* PR 17531: file: 9fa67536.  */
7572           if (relname == NULL)
7573             {
7574               warn (_("Skipping unknown relocation type: %u\n"),
7575                     get_reloc_type (filedata, rp->r_info));
7576               continue;
7577             }
7578
7579           if (! const_strneq (relname, "R_IA64_SEGREL"))
7580             {
7581               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7582               continue;
7583             }
7584
7585           i = rp->r_offset / (3 * eh_addr_size);
7586
7587           /* PR 17531: file: 5bc8d9bf.  */
7588           if (i >= aux->table_len)
7589             {
7590               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7591               continue;
7592             }
7593
7594           switch (rp->r_offset / eh_addr_size % 3)
7595             {
7596             case 0:
7597               aux->table[i].start.section = sym->st_shndx;
7598               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7599               break;
7600             case 1:
7601               aux->table[i].end.section   = sym->st_shndx;
7602               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7603               break;
7604             case 2:
7605               aux->table[i].info.section  = sym->st_shndx;
7606               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7607               break;
7608             default:
7609               break;
7610             }
7611         }
7612
7613       free (rela);
7614     }
7615
7616   return TRUE;
7617 }
7618
7619 static bfd_boolean
7620 ia64_process_unwind (Filedata * filedata)
7621 {
7622   Elf_Internal_Shdr * sec;
7623   Elf_Internal_Shdr * unwsec = NULL;
7624   Elf_Internal_Shdr * strsec;
7625   unsigned long i, unwcount = 0, unwstart = 0;
7626   struct ia64_unw_aux_info aux;
7627   bfd_boolean res = TRUE;
7628
7629   memset (& aux, 0, sizeof (aux));
7630
7631   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7632     {
7633       if (sec->sh_type == SHT_SYMTAB
7634           && sec->sh_link < filedata->file_header.e_shnum)
7635         {
7636           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7637
7638           strsec = filedata->section_headers + sec->sh_link;
7639           if (aux.strtab != NULL)
7640             {
7641               error (_("Multiple auxillary string tables encountered\n"));
7642               free (aux.strtab);
7643               res = FALSE;
7644             }
7645           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7646                                           1, strsec->sh_size,
7647                                           _("string table"));
7648           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7649         }
7650       else if (sec->sh_type == SHT_IA_64_UNWIND)
7651         unwcount++;
7652     }
7653
7654   if (!unwcount)
7655     printf (_("\nThere are no unwind sections in this file.\n"));
7656
7657   while (unwcount-- > 0)
7658     {
7659       char * suffix;
7660       size_t len, len2;
7661
7662       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7663            i < filedata->file_header.e_shnum; ++i, ++sec)
7664         if (sec->sh_type == SHT_IA_64_UNWIND)
7665           {
7666             unwsec = sec;
7667             break;
7668           }
7669       /* We have already counted the number of SHT_IA64_UNWIND
7670          sections so the loop above should never fail.  */
7671       assert (unwsec != NULL);
7672
7673       unwstart = i + 1;
7674       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7675
7676       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7677         {
7678           /* We need to find which section group it is in.  */
7679           struct group_list * g;
7680
7681           if (section_headers_groups == NULL
7682               || section_headers_groups [i] == NULL)
7683             i = filedata->file_header.e_shnum;
7684           else
7685             {
7686               g = section_headers_groups [i]->root;
7687
7688               for (; g != NULL; g = g->next)
7689                 {
7690                   sec = filedata->section_headers + g->section_index;
7691
7692                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7693                     break;
7694                 }
7695
7696               if (g == NULL)
7697                 i = filedata->file_header.e_shnum;
7698             }
7699         }
7700       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7701         {
7702           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7703           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7704           suffix = SECTION_NAME (unwsec) + len;
7705           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7706                ++i, ++sec)
7707             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7708                 && streq (SECTION_NAME (sec) + len2, suffix))
7709               break;
7710         }
7711       else
7712         {
7713           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7714              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7715           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7716           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7717           suffix = "";
7718           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7719             suffix = SECTION_NAME (unwsec) + len;
7720           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7721                ++i, ++sec)
7722             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7723                 && streq (SECTION_NAME (sec) + len2, suffix))
7724               break;
7725         }
7726
7727       if (i == filedata->file_header.e_shnum)
7728         {
7729           printf (_("\nCould not find unwind info section for "));
7730
7731           if (filedata->string_table == NULL)
7732             printf ("%d", unwsec->sh_name);
7733           else
7734             printf ("'%s'", printable_section_name (filedata, unwsec));
7735         }
7736       else
7737         {
7738           aux.info_addr = sec->sh_addr;
7739           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7740                                                  sec->sh_size,
7741                                                  _("unwind info"));
7742           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7743
7744           printf (_("\nUnwind section "));
7745
7746           if (filedata->string_table == NULL)
7747             printf ("%d", unwsec->sh_name);
7748           else
7749             printf ("'%s'", printable_section_name (filedata, unwsec));
7750
7751           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7752                   (unsigned long) unwsec->sh_offset,
7753                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7754
7755           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7756               && aux.table_len > 0)
7757             dump_ia64_unwind (filedata, & aux);
7758
7759           if (aux.table)
7760             free ((char *) aux.table);
7761           if (aux.info)
7762             free ((char *) aux.info);
7763           aux.table = NULL;
7764           aux.info = NULL;
7765         }
7766     }
7767
7768   if (aux.symtab)
7769     free (aux.symtab);
7770   if (aux.strtab)
7771     free ((char *) aux.strtab);
7772
7773   return res;
7774 }
7775
7776 struct hppa_unw_table_entry
7777 {
7778   struct absaddr start;
7779   struct absaddr end;
7780   unsigned int Cannot_unwind:1;                 /* 0 */
7781   unsigned int Millicode:1;                     /* 1 */
7782   unsigned int Millicode_save_sr0:1;            /* 2 */
7783   unsigned int Region_description:2;            /* 3..4 */
7784   unsigned int reserved1:1;                     /* 5 */
7785   unsigned int Entry_SR:1;                      /* 6 */
7786   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7787   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7788   unsigned int Args_stored:1;                   /* 16 */
7789   unsigned int Variable_Frame:1;                /* 17 */
7790   unsigned int Separate_Package_Body:1;         /* 18 */
7791   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7792   unsigned int Stack_Overflow_Check:1;          /* 20 */
7793   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7794   unsigned int Ada_Region:1;                    /* 22 */
7795   unsigned int cxx_info:1;                      /* 23 */
7796   unsigned int cxx_try_catch:1;                 /* 24 */
7797   unsigned int sched_entry_seq:1;               /* 25 */
7798   unsigned int reserved2:1;                     /* 26 */
7799   unsigned int Save_SP:1;                       /* 27 */
7800   unsigned int Save_RP:1;                       /* 28 */
7801   unsigned int Save_MRP_in_frame:1;             /* 29 */
7802   unsigned int extn_ptr_defined:1;              /* 30 */
7803   unsigned int Cleanup_defined:1;               /* 31 */
7804
7805   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7806   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7807   unsigned int Large_frame:1;                   /* 2 */
7808   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7809   unsigned int reserved4:1;                     /* 4 */
7810   unsigned int Total_frame_size:27;             /* 5..31 */
7811 };
7812
7813 struct hppa_unw_aux_info
7814 {
7815   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7816   unsigned long                  table_len;     /* Length of unwind table.  */
7817   bfd_vma                        seg_base;      /* Starting address of segment.  */
7818   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7819   unsigned long                  nsyms;         /* Number of symbols.  */
7820   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7821   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7822   char *                         strtab;        /* The string table.  */
7823   unsigned long                  strtab_size;   /* Size of string table.  */
7824 };
7825
7826 static bfd_boolean
7827 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7828 {
7829   struct hppa_unw_table_entry * tp;
7830   unsigned long j, nfuns;
7831   bfd_boolean res = TRUE;
7832
7833   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7834   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7835     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7836       aux->funtab[nfuns++] = aux->symtab[j];
7837   aux->nfuns = nfuns;
7838   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7839
7840   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7841     {
7842       bfd_vma offset;
7843       const char * procname;
7844
7845       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7846                                aux->strtab_size, tp->start, &procname,
7847                                &offset);
7848
7849       fputs ("\n<", stdout);
7850
7851       if (procname)
7852         {
7853           fputs (procname, stdout);
7854
7855           if (offset)
7856             printf ("+%lx", (unsigned long) offset);
7857         }
7858
7859       fputs (">: [", stdout);
7860       print_vma (tp->start.offset, PREFIX_HEX);
7861       fputc ('-', stdout);
7862       print_vma (tp->end.offset, PREFIX_HEX);
7863       printf ("]\n\t");
7864
7865 #define PF(_m) if (tp->_m) printf (#_m " ");
7866 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7867       PF(Cannot_unwind);
7868       PF(Millicode);
7869       PF(Millicode_save_sr0);
7870       /* PV(Region_description);  */
7871       PF(Entry_SR);
7872       PV(Entry_FR);
7873       PV(Entry_GR);
7874       PF(Args_stored);
7875       PF(Variable_Frame);
7876       PF(Separate_Package_Body);
7877       PF(Frame_Extension_Millicode);
7878       PF(Stack_Overflow_Check);
7879       PF(Two_Instruction_SP_Increment);
7880       PF(Ada_Region);
7881       PF(cxx_info);
7882       PF(cxx_try_catch);
7883       PF(sched_entry_seq);
7884       PF(Save_SP);
7885       PF(Save_RP);
7886       PF(Save_MRP_in_frame);
7887       PF(extn_ptr_defined);
7888       PF(Cleanup_defined);
7889       PF(MPE_XL_interrupt_marker);
7890       PF(HP_UX_interrupt_marker);
7891       PF(Large_frame);
7892       PF(Pseudo_SP_Set);
7893       PV(Total_frame_size);
7894 #undef PF
7895 #undef PV
7896     }
7897
7898   printf ("\n");
7899
7900   free (aux->funtab);
7901
7902   return res;
7903 }
7904
7905 static bfd_boolean
7906 slurp_hppa_unwind_table (Filedata *                  filedata,
7907                          struct hppa_unw_aux_info *  aux,
7908                          Elf_Internal_Shdr *         sec)
7909 {
7910   unsigned long size, unw_ent_size, nentries, nrelas, i;
7911   Elf_Internal_Phdr * seg;
7912   struct hppa_unw_table_entry * tep;
7913   Elf_Internal_Shdr * relsec;
7914   Elf_Internal_Rela * rela;
7915   Elf_Internal_Rela * rp;
7916   unsigned char * table;
7917   unsigned char * tp;
7918   Elf_Internal_Sym * sym;
7919   const char * relname;
7920
7921   /* First, find the starting address of the segment that includes
7922      this section.  */
7923   if (filedata->file_header.e_phnum)
7924     {
7925       if (! get_program_headers (filedata))
7926         return FALSE;
7927
7928       for (seg = filedata->program_headers;
7929            seg < filedata->program_headers + filedata->file_header.e_phnum;
7930            ++seg)
7931         {
7932           if (seg->p_type != PT_LOAD)
7933             continue;
7934
7935           if (sec->sh_addr >= seg->p_vaddr
7936               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7937             {
7938               aux->seg_base = seg->p_vaddr;
7939               break;
7940             }
7941         }
7942     }
7943
7944   /* Second, build the unwind table from the contents of the unwind
7945      section.  */
7946   size = sec->sh_size;
7947   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7948                                       _("unwind table"));
7949   if (!table)
7950     return FALSE;
7951
7952   unw_ent_size = 16;
7953   nentries = size / unw_ent_size;
7954   size = unw_ent_size * nentries;
7955
7956   tep = aux->table = (struct hppa_unw_table_entry *)
7957       xcmalloc (nentries, sizeof (aux->table[0]));
7958
7959   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7960     {
7961       unsigned int tmp1, tmp2;
7962
7963       tep->start.section = SHN_UNDEF;
7964       tep->end.section   = SHN_UNDEF;
7965
7966       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7967       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7968       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7969       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7970
7971       tep->start.offset += aux->seg_base;
7972       tep->end.offset   += aux->seg_base;
7973
7974       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7975       tep->Millicode = (tmp1 >> 30) & 0x1;
7976       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7977       tep->Region_description = (tmp1 >> 27) & 0x3;
7978       tep->reserved1 = (tmp1 >> 26) & 0x1;
7979       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7980       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7981       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7982       tep->Args_stored = (tmp1 >> 15) & 0x1;
7983       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7984       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7985       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7986       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7987       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7988       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7989       tep->cxx_info = (tmp1 >> 8) & 0x1;
7990       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7991       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7992       tep->reserved2 = (tmp1 >> 5) & 0x1;
7993       tep->Save_SP = (tmp1 >> 4) & 0x1;
7994       tep->Save_RP = (tmp1 >> 3) & 0x1;
7995       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7996       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7997       tep->Cleanup_defined = tmp1 & 0x1;
7998
7999       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8000       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8001       tep->Large_frame = (tmp2 >> 29) & 0x1;
8002       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8003       tep->reserved4 = (tmp2 >> 27) & 0x1;
8004       tep->Total_frame_size = tmp2 & 0x7ffffff;
8005     }
8006   free (table);
8007
8008   /* Third, apply any relocations to the unwind table.  */
8009   for (relsec = filedata->section_headers;
8010        relsec < filedata->section_headers + filedata->file_header.e_shnum;
8011        ++relsec)
8012     {
8013       if (relsec->sh_type != SHT_RELA
8014           || relsec->sh_info >= filedata->file_header.e_shnum
8015           || filedata->section_headers + relsec->sh_info != sec)
8016         continue;
8017
8018       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8019                               & rela, & nrelas))
8020         return FALSE;
8021
8022       for (rp = rela; rp < rela + nrelas; ++rp)
8023         {
8024           relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
8025           sym = aux->symtab + get_reloc_symindex (rp->r_info);
8026
8027           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
8028           if (! const_strneq (relname, "R_PARISC_SEGREL"))
8029             {
8030               warn (_("Skipping unexpected relocation type %s\n"), relname);
8031               continue;
8032             }
8033
8034           i = rp->r_offset / unw_ent_size;
8035
8036           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
8037             {
8038             case 0:
8039               aux->table[i].start.section = sym->st_shndx;
8040               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
8041               break;
8042             case 1:
8043               aux->table[i].end.section   = sym->st_shndx;
8044               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
8045               break;
8046             default:
8047               break;
8048             }
8049         }
8050
8051       free (rela);
8052     }
8053
8054   aux->table_len = nentries;
8055
8056   return TRUE;
8057 }
8058
8059 static bfd_boolean
8060 hppa_process_unwind (Filedata * filedata)
8061 {
8062   struct hppa_unw_aux_info aux;
8063   Elf_Internal_Shdr * unwsec = NULL;
8064   Elf_Internal_Shdr * strsec;
8065   Elf_Internal_Shdr * sec;
8066   unsigned long i;
8067   bfd_boolean res = TRUE;
8068
8069   if (filedata->string_table == NULL)
8070     return FALSE;
8071
8072   memset (& aux, 0, sizeof (aux));
8073
8074   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8075     {
8076       if (sec->sh_type == SHT_SYMTAB
8077           && sec->sh_link < filedata->file_header.e_shnum)
8078         {
8079           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8080
8081           strsec = filedata->section_headers + sec->sh_link;
8082           if (aux.strtab != NULL)
8083             {
8084               error (_("Multiple auxillary string tables encountered\n"));
8085               free (aux.strtab);
8086               res = FALSE;
8087             }
8088           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8089                                           1, strsec->sh_size,
8090                                           _("string table"));
8091           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8092         }
8093       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8094         unwsec = sec;
8095     }
8096
8097   if (!unwsec)
8098     printf (_("\nThere are no unwind sections in this file.\n"));
8099
8100   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8101     {
8102       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8103         {
8104           unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8105
8106           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8107                             "contains %lu entry:\n",
8108                             "\nUnwind section '%s' at offset 0x%lx "
8109                             "contains %lu entries:\n",
8110                             num_unwind),
8111                   printable_section_name (filedata, sec),
8112                   (unsigned long) sec->sh_offset,
8113                   num_unwind);
8114
8115           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8116             res = FALSE;
8117
8118           if (aux.table_len > 0)
8119             {
8120               if (! dump_hppa_unwind (filedata, &aux))
8121                 res = FALSE;
8122             }
8123
8124           if (aux.table)
8125             free ((char *) aux.table);
8126           aux.table = NULL;
8127         }
8128     }
8129
8130   if (aux.symtab)
8131     free (aux.symtab);
8132   if (aux.strtab)
8133     free ((char *) aux.strtab);
8134
8135   return res;
8136 }
8137
8138 struct arm_section
8139 {
8140   unsigned char *      data;            /* The unwind data.  */
8141   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8142   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8143   unsigned long        nrelas;          /* The number of relocations.  */
8144   unsigned int         rel_type;        /* REL or RELA ?  */
8145   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8146 };
8147
8148 struct arm_unw_aux_info
8149 {
8150   Filedata *          filedata;         /* The file containing the unwind sections.  */
8151   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8152   unsigned long       nsyms;            /* Number of symbols.  */
8153   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8154   unsigned long       nfuns;            /* Number of these symbols.  */
8155   char *              strtab;           /* The file's string table.  */
8156   unsigned long       strtab_size;      /* Size of string table.  */
8157 };
8158
8159 static const char *
8160 arm_print_vma_and_name (Filedata *                 filedata,
8161                         struct arm_unw_aux_info *  aux,
8162                         bfd_vma                    fn,
8163                         struct absaddr             addr)
8164 {
8165   const char *procname;
8166   bfd_vma sym_offset;
8167
8168   if (addr.section == SHN_UNDEF)
8169     addr.offset = fn;
8170
8171   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8172                            aux->strtab_size, addr, &procname,
8173                            &sym_offset);
8174
8175   print_vma (fn, PREFIX_HEX);
8176
8177   if (procname)
8178     {
8179       fputs (" <", stdout);
8180       fputs (procname, stdout);
8181
8182       if (sym_offset)
8183         printf ("+0x%lx", (unsigned long) sym_offset);
8184       fputc ('>', stdout);
8185     }
8186
8187   return procname;
8188 }
8189
8190 static void
8191 arm_free_section (struct arm_section *arm_sec)
8192 {
8193   if (arm_sec->data != NULL)
8194     free (arm_sec->data);
8195
8196   if (arm_sec->rela != NULL)
8197     free (arm_sec->rela);
8198 }
8199
8200 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8201       cached section and install SEC instead.
8202    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8203       and return its valued in * WORDP, relocating if necessary.
8204    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8205       relocation's offset in ADDR.
8206    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8207       into the string table of the symbol associated with the reloc.  If no
8208       reloc was applied store -1 there.
8209    5) Return TRUE upon success, FALSE otherwise.  */
8210
8211 static bfd_boolean
8212 get_unwind_section_word (Filedata *                 filedata,
8213                          struct arm_unw_aux_info *  aux,
8214                          struct arm_section *       arm_sec,
8215                          Elf_Internal_Shdr *        sec,
8216                          bfd_vma                    word_offset,
8217                          unsigned int *             wordp,
8218                          struct absaddr *           addr,
8219                          bfd_vma *                  sym_name)
8220 {
8221   Elf_Internal_Rela *rp;
8222   Elf_Internal_Sym *sym;
8223   const char * relname;
8224   unsigned int word;
8225   bfd_boolean wrapped;
8226
8227   if (sec == NULL || arm_sec == NULL)
8228     return FALSE;
8229
8230   addr->section = SHN_UNDEF;
8231   addr->offset = 0;
8232
8233   if (sym_name != NULL)
8234     *sym_name = (bfd_vma) -1;
8235
8236   /* If necessary, update the section cache.  */
8237   if (sec != arm_sec->sec)
8238     {
8239       Elf_Internal_Shdr *relsec;
8240
8241       arm_free_section (arm_sec);
8242
8243       arm_sec->sec = sec;
8244       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8245                                 sec->sh_size, _("unwind data"));
8246       arm_sec->rela = NULL;
8247       arm_sec->nrelas = 0;
8248
8249       for (relsec = filedata->section_headers;
8250            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8251            ++relsec)
8252         {
8253           if (relsec->sh_info >= filedata->file_header.e_shnum
8254               || filedata->section_headers + relsec->sh_info != sec
8255               /* PR 15745: Check the section type as well.  */
8256               || (relsec->sh_type != SHT_REL
8257                   && relsec->sh_type != SHT_RELA))
8258             continue;
8259
8260           arm_sec->rel_type = relsec->sh_type;
8261           if (relsec->sh_type == SHT_REL)
8262             {
8263               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8264                                      relsec->sh_size,
8265                                      & arm_sec->rela, & arm_sec->nrelas))
8266                 return FALSE;
8267             }
8268           else /* relsec->sh_type == SHT_RELA */
8269             {
8270               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8271                                       relsec->sh_size,
8272                                       & arm_sec->rela, & arm_sec->nrelas))
8273                 return FALSE;
8274             }
8275           break;
8276         }
8277
8278       arm_sec->next_rela = arm_sec->rela;
8279     }
8280
8281   /* If there is no unwind data we can do nothing.  */
8282   if (arm_sec->data == NULL)
8283     return FALSE;
8284
8285   /* If the offset is invalid then fail.  */
8286   if (/* PR 21343 *//* PR 18879 */
8287       sec->sh_size < 4
8288       || word_offset > (sec->sh_size - 4)
8289       || ((bfd_signed_vma) word_offset) < 0)
8290     return FALSE;
8291
8292   /* Get the word at the required offset.  */
8293   word = byte_get (arm_sec->data + word_offset, 4);
8294
8295   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8296   if (arm_sec->rela == NULL)
8297     {
8298       * wordp = word;
8299       return TRUE;
8300     }
8301
8302   /* Look through the relocs to find the one that applies to the provided offset.  */
8303   wrapped = FALSE;
8304   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8305     {
8306       bfd_vma prelval, offset;
8307
8308       if (rp->r_offset > word_offset && !wrapped)
8309         {
8310           rp = arm_sec->rela;
8311           wrapped = TRUE;
8312         }
8313       if (rp->r_offset > word_offset)
8314         break;
8315
8316       if (rp->r_offset & 3)
8317         {
8318           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8319                 (unsigned long) rp->r_offset);
8320           continue;
8321         }
8322
8323       if (rp->r_offset < word_offset)
8324         continue;
8325
8326       /* PR 17531: file: 027-161405-0.004  */
8327       if (aux->symtab == NULL)
8328         continue;
8329
8330       if (arm_sec->rel_type == SHT_REL)
8331         {
8332           offset = word & 0x7fffffff;
8333           if (offset & 0x40000000)
8334             offset |= ~ (bfd_vma) 0x7fffffff;
8335         }
8336       else if (arm_sec->rel_type == SHT_RELA)
8337         offset = rp->r_addend;
8338       else
8339         {
8340           error (_("Unknown section relocation type %d encountered\n"),
8341                  arm_sec->rel_type);
8342           break;
8343         }
8344
8345       /* PR 17531 file: 027-1241568-0.004.  */
8346       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8347         {
8348           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8349                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8350           break;
8351         }
8352
8353       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8354       offset += sym->st_value;
8355       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8356
8357       /* Check that we are processing the expected reloc type.  */
8358       if (filedata->file_header.e_machine == EM_ARM)
8359         {
8360           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8361           if (relname == NULL)
8362             {
8363               warn (_("Skipping unknown ARM relocation type: %d\n"),
8364                     (int) ELF32_R_TYPE (rp->r_info));
8365               continue;
8366             }
8367
8368           if (streq (relname, "R_ARM_NONE"))
8369               continue;
8370
8371           if (! streq (relname, "R_ARM_PREL31"))
8372             {
8373               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8374               continue;
8375             }
8376         }
8377       else if (filedata->file_header.e_machine == EM_TI_C6000)
8378         {
8379           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8380           if (relname == NULL)
8381             {
8382               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8383                     (int) ELF32_R_TYPE (rp->r_info));
8384               continue;
8385             }
8386
8387           if (streq (relname, "R_C6000_NONE"))
8388             continue;
8389
8390           if (! streq (relname, "R_C6000_PREL31"))
8391             {
8392               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8393               continue;
8394             }
8395
8396           prelval >>= 1;
8397         }
8398       else
8399         {
8400           /* This function currently only supports ARM and TI unwinders.  */
8401           warn (_("Only TI and ARM unwinders are currently supported\n"));
8402           break;
8403         }
8404
8405       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8406       addr->section = sym->st_shndx;
8407       addr->offset = offset;
8408
8409       if (sym_name)
8410         * sym_name = sym->st_name;
8411       break;
8412     }
8413
8414   *wordp = word;
8415   arm_sec->next_rela = rp;
8416
8417   return TRUE;
8418 }
8419
8420 static const char *tic6x_unwind_regnames[16] =
8421 {
8422   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8423   "A14", "A13", "A12", "A11", "A10",
8424   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8425 };
8426
8427 static void
8428 decode_tic6x_unwind_regmask (unsigned int mask)
8429 {
8430   int i;
8431
8432   for (i = 12; mask; mask >>= 1, i--)
8433     {
8434       if (mask & 1)
8435         {
8436           fputs (tic6x_unwind_regnames[i], stdout);
8437           if (mask > 1)
8438             fputs (", ", stdout);
8439         }
8440     }
8441 }
8442
8443 #define ADVANCE                                                 \
8444   if (remaining == 0 && more_words)                             \
8445     {                                                           \
8446       data_offset += 4;                                         \
8447       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8448                                      data_offset, & word, & addr, NULL))        \
8449         return FALSE;                                           \
8450       remaining = 4;                                            \
8451       more_words--;                                             \
8452     }                                                           \
8453
8454 #define GET_OP(OP)                      \
8455   ADVANCE;                              \
8456   if (remaining)                        \
8457     {                                   \
8458       remaining--;                      \
8459       (OP) = word >> 24;                \
8460       word <<= 8;                       \
8461     }                                   \
8462   else                                  \
8463     {                                   \
8464       printf (_("[Truncated opcode]\n"));       \
8465       return FALSE;                     \
8466     }                                   \
8467   printf ("0x%02x ", OP)
8468
8469 static bfd_boolean
8470 decode_arm_unwind_bytecode (Filedata *                 filedata,
8471                             struct arm_unw_aux_info *  aux,
8472                             unsigned int               word,
8473                             unsigned int               remaining,
8474                             unsigned int               more_words,
8475                             bfd_vma                    data_offset,
8476                             Elf_Internal_Shdr *        data_sec,
8477                             struct arm_section *       data_arm_sec)
8478 {
8479   struct absaddr addr;
8480   bfd_boolean res = TRUE;
8481
8482   /* Decode the unwinding instructions.  */
8483   while (1)
8484     {
8485       unsigned int op, op2;
8486
8487       ADVANCE;
8488       if (remaining == 0)
8489         break;
8490       remaining--;
8491       op = word >> 24;
8492       word <<= 8;
8493
8494       printf ("  0x%02x ", op);
8495
8496       if ((op & 0xc0) == 0x00)
8497         {
8498           int offset = ((op & 0x3f) << 2) + 4;
8499
8500           printf ("     vsp = vsp + %d", offset);
8501         }
8502       else if ((op & 0xc0) == 0x40)
8503         {
8504           int offset = ((op & 0x3f) << 2) + 4;
8505
8506           printf ("     vsp = vsp - %d", offset);
8507         }
8508       else if ((op & 0xf0) == 0x80)
8509         {
8510           GET_OP (op2);
8511           if (op == 0x80 && op2 == 0)
8512             printf (_("Refuse to unwind"));
8513           else
8514             {
8515               unsigned int mask = ((op & 0x0f) << 8) | op2;
8516               bfd_boolean first = TRUE;
8517               int i;
8518
8519               printf ("pop {");
8520               for (i = 0; i < 12; i++)
8521                 if (mask & (1 << i))
8522                   {
8523                     if (first)
8524                       first = FALSE;
8525                     else
8526                       printf (", ");
8527                     printf ("r%d", 4 + i);
8528                   }
8529               printf ("}");
8530             }
8531         }
8532       else if ((op & 0xf0) == 0x90)
8533         {
8534           if (op == 0x9d || op == 0x9f)
8535             printf (_("     [Reserved]"));
8536           else
8537             printf ("     vsp = r%d", op & 0x0f);
8538         }
8539       else if ((op & 0xf0) == 0xa0)
8540         {
8541           int end = 4 + (op & 0x07);
8542           bfd_boolean first = TRUE;
8543           int i;
8544
8545           printf ("     pop {");
8546           for (i = 4; i <= end; i++)
8547             {
8548               if (first)
8549                 first = FALSE;
8550               else
8551                 printf (", ");
8552               printf ("r%d", i);
8553             }
8554           if (op & 0x08)
8555             {
8556               if (!first)
8557                 printf (", ");
8558               printf ("r14");
8559             }
8560           printf ("}");
8561         }
8562       else if (op == 0xb0)
8563         printf (_("     finish"));
8564       else if (op == 0xb1)
8565         {
8566           GET_OP (op2);
8567           if (op2 == 0 || (op2 & 0xf0) != 0)
8568             printf (_("[Spare]"));
8569           else
8570             {
8571               unsigned int mask = op2 & 0x0f;
8572               bfd_boolean first = TRUE;
8573               int i;
8574
8575               printf ("pop {");
8576               for (i = 0; i < 12; i++)
8577                 if (mask & (1 << i))
8578                   {
8579                     if (first)
8580                       first = FALSE;
8581                     else
8582                       printf (", ");
8583                     printf ("r%d", i);
8584                   }
8585               printf ("}");
8586             }
8587         }
8588       else if (op == 0xb2)
8589         {
8590           unsigned char buf[9];
8591           unsigned int i, len;
8592           unsigned long offset;
8593
8594           for (i = 0; i < sizeof (buf); i++)
8595             {
8596               GET_OP (buf[i]);
8597               if ((buf[i] & 0x80) == 0)
8598                 break;
8599             }
8600           if (i == sizeof (buf))
8601             {
8602               error (_("corrupt change to vsp"));
8603               res = FALSE;
8604             }
8605           else
8606             {
8607               offset = read_uleb128 (buf, &len, buf + i + 1);
8608               assert (len == i + 1);
8609               offset = offset * 4 + 0x204;
8610               printf ("vsp = vsp + %ld", offset);
8611             }
8612         }
8613       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8614         {
8615           unsigned int first, last;
8616
8617           GET_OP (op2);
8618           first = op2 >> 4;
8619           last = op2 & 0x0f;
8620           if (op == 0xc8)
8621             first = first + 16;
8622           printf ("pop {D%d", first);
8623           if (last)
8624             printf ("-D%d", first + last);
8625           printf ("}");
8626         }
8627       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8628         {
8629           unsigned int count = op & 0x07;
8630
8631           printf ("pop {D8");
8632           if (count)
8633             printf ("-D%d", 8 + count);
8634           printf ("}");
8635         }
8636       else if (op >= 0xc0 && op <= 0xc5)
8637         {
8638           unsigned int count = op & 0x07;
8639
8640           printf ("     pop {wR10");
8641           if (count)
8642             printf ("-wR%d", 10 + count);
8643           printf ("}");
8644         }
8645       else if (op == 0xc6)
8646         {
8647           unsigned int first, last;
8648
8649           GET_OP (op2);
8650           first = op2 >> 4;
8651           last = op2 & 0x0f;
8652           printf ("pop {wR%d", first);
8653           if (last)
8654             printf ("-wR%d", first + last);
8655           printf ("}");
8656         }
8657       else if (op == 0xc7)
8658         {
8659           GET_OP (op2);
8660           if (op2 == 0 || (op2 & 0xf0) != 0)
8661             printf (_("[Spare]"));
8662           else
8663             {
8664               unsigned int mask = op2 & 0x0f;
8665               bfd_boolean first = TRUE;
8666               int i;
8667
8668               printf ("pop {");
8669               for (i = 0; i < 4; i++)
8670                 if (mask & (1 << i))
8671                   {
8672                     if (first)
8673                       first = FALSE;
8674                     else
8675                       printf (", ");
8676                     printf ("wCGR%d", i);
8677                   }
8678               printf ("}");
8679             }
8680         }
8681       else
8682         {
8683           printf (_("     [unsupported opcode]"));
8684           res = FALSE;
8685         }
8686
8687       printf ("\n");
8688     }
8689
8690   return res;
8691 }
8692
8693 static bfd_boolean
8694 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8695                               struct arm_unw_aux_info *  aux,
8696                               unsigned int               word,
8697                               unsigned int               remaining,
8698                               unsigned int               more_words,
8699                               bfd_vma                    data_offset,
8700                               Elf_Internal_Shdr *        data_sec,
8701                               struct arm_section *       data_arm_sec)
8702 {
8703   struct absaddr addr;
8704
8705   /* Decode the unwinding instructions.  */
8706   while (1)
8707     {
8708       unsigned int op, op2;
8709
8710       ADVANCE;
8711       if (remaining == 0)
8712         break;
8713       remaining--;
8714       op = word >> 24;
8715       word <<= 8;
8716
8717       printf ("  0x%02x ", op);
8718
8719       if ((op & 0xc0) == 0x00)
8720         {
8721           int offset = ((op & 0x3f) << 3) + 8;
8722           printf ("     sp = sp + %d", offset);
8723         }
8724       else if ((op & 0xc0) == 0x80)
8725         {
8726           GET_OP (op2);
8727           if (op == 0x80 && op2 == 0)
8728             printf (_("Refuse to unwind"));
8729           else
8730             {
8731               unsigned int mask = ((op & 0x1f) << 8) | op2;
8732               if (op & 0x20)
8733                 printf ("pop compact {");
8734               else
8735                 printf ("pop {");
8736
8737               decode_tic6x_unwind_regmask (mask);
8738               printf("}");
8739             }
8740         }
8741       else if ((op & 0xf0) == 0xc0)
8742         {
8743           unsigned int reg;
8744           unsigned int nregs;
8745           unsigned int i;
8746           const char *name;
8747           struct
8748           {
8749             unsigned int offset;
8750             unsigned int reg;
8751           } regpos[16];
8752
8753           /* Scan entire instruction first so that GET_OP output is not
8754              interleaved with disassembly.  */
8755           nregs = 0;
8756           for (i = 0; nregs < (op & 0xf); i++)
8757             {
8758               GET_OP (op2);
8759               reg = op2 >> 4;
8760               if (reg != 0xf)
8761                 {
8762                   regpos[nregs].offset = i * 2;
8763                   regpos[nregs].reg = reg;
8764                   nregs++;
8765                 }
8766
8767               reg = op2 & 0xf;
8768               if (reg != 0xf)
8769                 {
8770                   regpos[nregs].offset = i * 2 + 1;
8771                   regpos[nregs].reg = reg;
8772                   nregs++;
8773                 }
8774             }
8775
8776           printf (_("pop frame {"));
8777           reg = nregs - 1;
8778           for (i = i * 2; i > 0; i--)
8779             {
8780               if (regpos[reg].offset == i - 1)
8781                 {
8782                   name = tic6x_unwind_regnames[regpos[reg].reg];
8783                   if (reg > 0)
8784                     reg--;
8785                 }
8786               else
8787                 name = _("[pad]");
8788
8789               fputs (name, stdout);
8790               if (i > 1)
8791                 printf (", ");
8792             }
8793
8794           printf ("}");
8795         }
8796       else if (op == 0xd0)
8797         printf ("     MOV FP, SP");
8798       else if (op == 0xd1)
8799         printf ("     __c6xabi_pop_rts");
8800       else if (op == 0xd2)
8801         {
8802           unsigned char buf[9];
8803           unsigned int i, len;
8804           unsigned long offset;
8805
8806           for (i = 0; i < sizeof (buf); i++)
8807             {
8808               GET_OP (buf[i]);
8809               if ((buf[i] & 0x80) == 0)
8810                 break;
8811             }
8812           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8813           if (i == sizeof (buf))
8814             {
8815               warn (_("Corrupt stack pointer adjustment detected\n"));
8816               return FALSE;
8817             }
8818
8819           offset = read_uleb128 (buf, &len, buf + i + 1);
8820           assert (len == i + 1);
8821           offset = offset * 8 + 0x408;
8822           printf (_("sp = sp + %ld"), offset);
8823         }
8824       else if ((op & 0xf0) == 0xe0)
8825         {
8826           if ((op & 0x0f) == 7)
8827             printf ("     RETURN");
8828           else
8829             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8830         }
8831       else
8832         {
8833           printf (_("     [unsupported opcode]"));
8834         }
8835       putchar ('\n');
8836     }
8837
8838   return TRUE;
8839 }
8840
8841 static bfd_vma
8842 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8843 {
8844   bfd_vma offset;
8845
8846   offset = word & 0x7fffffff;
8847   if (offset & 0x40000000)
8848     offset |= ~ (bfd_vma) 0x7fffffff;
8849
8850   if (filedata->file_header.e_machine == EM_TI_C6000)
8851     offset <<= 1;
8852
8853   return offset + where;
8854 }
8855
8856 static bfd_boolean
8857 decode_arm_unwind (Filedata *                 filedata,
8858                    struct arm_unw_aux_info *  aux,
8859                    unsigned int               word,
8860                    unsigned int               remaining,
8861                    bfd_vma                    data_offset,
8862                    Elf_Internal_Shdr *        data_sec,
8863                    struct arm_section *       data_arm_sec)
8864 {
8865   int per_index;
8866   unsigned int more_words = 0;
8867   struct absaddr addr;
8868   bfd_vma sym_name = (bfd_vma) -1;
8869   bfd_boolean res = TRUE;
8870
8871   if (remaining == 0)
8872     {
8873       /* Fetch the first word.
8874          Note - when decoding an object file the address extracted
8875          here will always be 0.  So we also pass in the sym_name
8876          parameter so that we can find the symbol associated with
8877          the personality routine.  */
8878       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8879                                      & word, & addr, & sym_name))
8880         return FALSE;
8881
8882       remaining = 4;
8883     }
8884
8885   if ((word & 0x80000000) == 0)
8886     {
8887       /* Expand prel31 for personality routine.  */
8888       bfd_vma fn;
8889       const char *procname;
8890
8891       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8892       printf (_("  Personality routine: "));
8893       if (fn == 0
8894           && addr.section == SHN_UNDEF && addr.offset == 0
8895           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8896         {
8897           procname = aux->strtab + sym_name;
8898           print_vma (fn, PREFIX_HEX);
8899           if (procname)
8900             {
8901               fputs (" <", stdout);
8902               fputs (procname, stdout);
8903               fputc ('>', stdout);
8904             }
8905         }
8906       else
8907         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8908       fputc ('\n', stdout);
8909
8910       /* The GCC personality routines use the standard compact
8911          encoding, starting with one byte giving the number of
8912          words.  */
8913       if (procname != NULL
8914           && (const_strneq (procname, "__gcc_personality_v0")
8915               || const_strneq (procname, "__gxx_personality_v0")
8916               || const_strneq (procname, "__gcj_personality_v0")
8917               || const_strneq (procname, "__gnu_objc_personality_v0")))
8918         {
8919           remaining = 0;
8920           more_words = 1;
8921           ADVANCE;
8922           if (!remaining)
8923             {
8924               printf (_("  [Truncated data]\n"));
8925               return FALSE;
8926             }
8927           more_words = word >> 24;
8928           word <<= 8;
8929           remaining--;
8930           per_index = -1;
8931         }
8932       else
8933         return TRUE;
8934     }
8935   else
8936     {
8937       /* ARM EHABI Section 6.3:
8938
8939          An exception-handling table entry for the compact model looks like:
8940
8941            31 30-28 27-24 23-0
8942            -- ----- ----- ----
8943             1   0   index Data for personalityRoutine[index]    */
8944
8945       if (filedata->file_header.e_machine == EM_ARM
8946           && (word & 0x70000000))
8947         {
8948           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8949           res = FALSE;
8950         }
8951
8952       per_index = (word >> 24) & 0x7f;
8953       printf (_("  Compact model index: %d\n"), per_index);
8954       if (per_index == 0)
8955         {
8956           more_words = 0;
8957           word <<= 8;
8958           remaining--;
8959         }
8960       else if (per_index < 3)
8961         {
8962           more_words = (word >> 16) & 0xff;
8963           word <<= 16;
8964           remaining -= 2;
8965         }
8966     }
8967
8968   switch (filedata->file_header.e_machine)
8969     {
8970     case EM_ARM:
8971       if (per_index < 3)
8972         {
8973           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
8974                                             data_offset, data_sec, data_arm_sec))
8975             res = FALSE;
8976         }
8977       else
8978         {
8979           warn (_("Unknown ARM compact model index encountered\n"));
8980           printf (_("  [reserved]\n"));
8981           res = FALSE;
8982         }
8983       break;
8984
8985     case EM_TI_C6000:
8986       if (per_index < 3)
8987         {
8988           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
8989                                               data_offset, data_sec, data_arm_sec))
8990             res = FALSE;
8991         }
8992       else if (per_index < 5)
8993         {
8994           if (((word >> 17) & 0x7f) == 0x7f)
8995             printf (_("  Restore stack from frame pointer\n"));
8996           else
8997             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8998           printf (_("  Registers restored: "));
8999           if (per_index == 4)
9000             printf (" (compact) ");
9001           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9002           putchar ('\n');
9003           printf (_("  Return register: %s\n"),
9004                   tic6x_unwind_regnames[word & 0xf]);
9005         }
9006       else
9007         printf (_("  [reserved (%d)]\n"), per_index);
9008       break;
9009
9010     default:
9011       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9012              filedata->file_header.e_machine);
9013       res = FALSE;
9014     }
9015
9016   /* Decode the descriptors.  Not implemented.  */
9017
9018   return res;
9019 }
9020
9021 static bfd_boolean
9022 dump_arm_unwind (Filedata *                 filedata,
9023                  struct arm_unw_aux_info *  aux,
9024                  Elf_Internal_Shdr *        exidx_sec)
9025 {
9026   struct arm_section exidx_arm_sec, extab_arm_sec;
9027   unsigned int i, exidx_len;
9028   unsigned long j, nfuns;
9029   bfd_boolean res = TRUE;
9030
9031   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9032   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9033   exidx_len = exidx_sec->sh_size / 8;
9034
9035   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9036   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9037     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9038       aux->funtab[nfuns++] = aux->symtab[j];
9039   aux->nfuns = nfuns;
9040   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9041
9042   for (i = 0; i < exidx_len; i++)
9043     {
9044       unsigned int exidx_fn, exidx_entry;
9045       struct absaddr fn_addr, entry_addr;
9046       bfd_vma fn;
9047
9048       fputc ('\n', stdout);
9049
9050       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9051                                      8 * i, & exidx_fn, & fn_addr, NULL)
9052           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9053                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9054         {
9055           free (aux->funtab);
9056           arm_free_section (& exidx_arm_sec);
9057           arm_free_section (& extab_arm_sec);
9058           return FALSE;
9059         }
9060
9061       /* ARM EHABI, Section 5:
9062          An index table entry consists of 2 words.
9063          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9064       if (exidx_fn & 0x80000000)
9065         {
9066           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9067           res = FALSE;
9068         }
9069
9070       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9071
9072       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9073       fputs (": ", stdout);
9074
9075       if (exidx_entry == 1)
9076         {
9077           print_vma (exidx_entry, PREFIX_HEX);
9078           fputs (" [cantunwind]\n", stdout);
9079         }
9080       else if (exidx_entry & 0x80000000)
9081         {
9082           print_vma (exidx_entry, PREFIX_HEX);
9083           fputc ('\n', stdout);
9084           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9085         }
9086       else
9087         {
9088           bfd_vma table, table_offset = 0;
9089           Elf_Internal_Shdr *table_sec;
9090
9091           fputs ("@", stdout);
9092           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9093           print_vma (table, PREFIX_HEX);
9094           printf ("\n");
9095
9096           /* Locate the matching .ARM.extab.  */
9097           if (entry_addr.section != SHN_UNDEF
9098               && entry_addr.section < filedata->file_header.e_shnum)
9099             {
9100               table_sec = filedata->section_headers + entry_addr.section;
9101               table_offset = entry_addr.offset;
9102               /* PR 18879 */
9103               if (table_offset > table_sec->sh_size
9104                   || ((bfd_signed_vma) table_offset) < 0)
9105                 {
9106                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9107                         (unsigned long) table_offset,
9108                         printable_section_name (filedata, table_sec));
9109                   res = FALSE;
9110                   continue;
9111                 }
9112             }
9113           else
9114             {
9115               table_sec = find_section_by_address (filedata, table);
9116               if (table_sec != NULL)
9117                 table_offset = table - table_sec->sh_addr;
9118             }
9119
9120           if (table_sec == NULL)
9121             {
9122               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9123                     (unsigned long) table);
9124               res = FALSE;
9125               continue;
9126             }
9127
9128           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9129                                    &extab_arm_sec))
9130             res = FALSE;
9131         }
9132     }
9133
9134   printf ("\n");
9135
9136   free (aux->funtab);
9137   arm_free_section (&exidx_arm_sec);
9138   arm_free_section (&extab_arm_sec);
9139
9140   return res;
9141 }
9142
9143 /* Used for both ARM and C6X unwinding tables.  */
9144
9145 static bfd_boolean
9146 arm_process_unwind (Filedata * filedata)
9147 {
9148   struct arm_unw_aux_info aux;
9149   Elf_Internal_Shdr *unwsec = NULL;
9150   Elf_Internal_Shdr *strsec;
9151   Elf_Internal_Shdr *sec;
9152   unsigned long i;
9153   unsigned int sec_type;
9154   bfd_boolean res = TRUE;
9155
9156   switch (filedata->file_header.e_machine)
9157     {
9158     case EM_ARM:
9159       sec_type = SHT_ARM_EXIDX;
9160       break;
9161
9162     case EM_TI_C6000:
9163       sec_type = SHT_C6000_UNWIND;
9164       break;
9165
9166     default:
9167       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9168              filedata->file_header.e_machine);
9169       return FALSE;
9170     }
9171
9172   if (filedata->string_table == NULL)
9173     return FALSE;
9174
9175   memset (& aux, 0, sizeof (aux));
9176   aux.filedata = filedata;
9177
9178   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9179     {
9180       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9181         {
9182           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9183
9184           strsec = filedata->section_headers + sec->sh_link;
9185
9186           /* PR binutils/17531 file: 011-12666-0.004.  */
9187           if (aux.strtab != NULL)
9188             {
9189               error (_("Multiple string tables found in file.\n"));
9190               free (aux.strtab);
9191               res = FALSE;
9192             }
9193           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9194                                  1, strsec->sh_size, _("string table"));
9195           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9196         }
9197       else if (sec->sh_type == sec_type)
9198         unwsec = sec;
9199     }
9200
9201   if (unwsec == NULL)
9202     printf (_("\nThere are no unwind sections in this file.\n"));
9203   else
9204     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9205       {
9206         if (sec->sh_type == sec_type)
9207           {
9208             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9209             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9210                               "contains %lu entry:\n",
9211                               "\nUnwind section '%s' at offset 0x%lx "
9212                               "contains %lu entries:\n",
9213                               num_unwind),
9214                     printable_section_name (filedata, sec),
9215                     (unsigned long) sec->sh_offset,
9216                     num_unwind);
9217
9218             if (! dump_arm_unwind (filedata, &aux, sec))
9219               res = FALSE;
9220           }
9221       }
9222
9223   if (aux.symtab)
9224     free (aux.symtab);
9225   if (aux.strtab)
9226     free ((char *) aux.strtab);
9227
9228   return res;
9229 }
9230
9231 static bfd_boolean
9232 process_unwind (Filedata * filedata)
9233 {
9234   struct unwind_handler
9235   {
9236     unsigned int machtype;
9237     bfd_boolean (* handler)(Filedata *);
9238   } handlers[] =
9239   {
9240     { EM_ARM, arm_process_unwind },
9241     { EM_IA_64, ia64_process_unwind },
9242     { EM_PARISC, hppa_process_unwind },
9243     { EM_TI_C6000, arm_process_unwind },
9244     { 0, NULL }
9245   };
9246   int i;
9247
9248   if (!do_unwind)
9249     return TRUE;
9250
9251   for (i = 0; handlers[i].handler != NULL; i++)
9252     if (filedata->file_header.e_machine == handlers[i].machtype)
9253       return handlers[i].handler (filedata);
9254
9255   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9256           get_machine_name (filedata->file_header.e_machine));
9257   return TRUE;
9258 }
9259
9260 static void
9261 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9262 {
9263   switch (entry->d_tag)
9264     {
9265     case DT_MIPS_FLAGS:
9266       if (entry->d_un.d_val == 0)
9267         printf (_("NONE"));
9268       else
9269         {
9270           static const char * opts[] =
9271           {
9272             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9273             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9274             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9275             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9276             "RLD_ORDER_SAFE"
9277           };
9278           unsigned int cnt;
9279           bfd_boolean first = TRUE;
9280
9281           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9282             if (entry->d_un.d_val & (1 << cnt))
9283               {
9284                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9285                 first = FALSE;
9286               }
9287         }
9288       break;
9289
9290     case DT_MIPS_IVERSION:
9291       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9292         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9293       else
9294         {
9295           char buf[40];
9296           sprintf_vma (buf, entry->d_un.d_ptr);
9297           /* Note: coded this way so that there is a single string for translation.  */
9298           printf (_("<corrupt: %s>"), buf);
9299         }
9300       break;
9301
9302     case DT_MIPS_TIME_STAMP:
9303       {
9304         char timebuf[128];
9305         struct tm * tmp;
9306         time_t atime = entry->d_un.d_val;
9307
9308         tmp = gmtime (&atime);
9309         /* PR 17531: file: 6accc532.  */
9310         if (tmp == NULL)
9311           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9312         else
9313           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9314                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9315                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9316         printf (_("Time Stamp: %s"), timebuf);
9317       }
9318       break;
9319
9320     case DT_MIPS_RLD_VERSION:
9321     case DT_MIPS_LOCAL_GOTNO:
9322     case DT_MIPS_CONFLICTNO:
9323     case DT_MIPS_LIBLISTNO:
9324     case DT_MIPS_SYMTABNO:
9325     case DT_MIPS_UNREFEXTNO:
9326     case DT_MIPS_HIPAGENO:
9327     case DT_MIPS_DELTA_CLASS_NO:
9328     case DT_MIPS_DELTA_INSTANCE_NO:
9329     case DT_MIPS_DELTA_RELOC_NO:
9330     case DT_MIPS_DELTA_SYM_NO:
9331     case DT_MIPS_DELTA_CLASSSYM_NO:
9332     case DT_MIPS_COMPACT_SIZE:
9333       print_vma (entry->d_un.d_val, DEC);
9334       break;
9335
9336     default:
9337       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9338     }
9339     putchar ('\n');
9340 }
9341
9342 static void
9343 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9344 {
9345   switch (entry->d_tag)
9346     {
9347     case DT_HP_DLD_FLAGS:
9348       {
9349         static struct
9350         {
9351           long int bit;
9352           const char * str;
9353         }
9354         flags[] =
9355         {
9356           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9357           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9358           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9359           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9360           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9361           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9362           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9363           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9364           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9365           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9366           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9367           { DT_HP_GST, "HP_GST" },
9368           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9369           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9370           { DT_HP_NODELETE, "HP_NODELETE" },
9371           { DT_HP_GROUP, "HP_GROUP" },
9372           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9373         };
9374         bfd_boolean first = TRUE;
9375         size_t cnt;
9376         bfd_vma val = entry->d_un.d_val;
9377
9378         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9379           if (val & flags[cnt].bit)
9380             {
9381               if (! first)
9382                 putchar (' ');
9383               fputs (flags[cnt].str, stdout);
9384               first = FALSE;
9385               val ^= flags[cnt].bit;
9386             }
9387
9388         if (val != 0 || first)
9389           {
9390             if (! first)
9391               putchar (' ');
9392             print_vma (val, HEX);
9393           }
9394       }
9395       break;
9396
9397     default:
9398       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9399       break;
9400     }
9401   putchar ('\n');
9402 }
9403
9404 #ifdef BFD64
9405
9406 /* VMS vs Unix time offset and factor.  */
9407
9408 #define VMS_EPOCH_OFFSET 35067168000000000LL
9409 #define VMS_GRANULARITY_FACTOR 10000000
9410
9411 /* Display a VMS time in a human readable format.  */
9412
9413 static void
9414 print_vms_time (bfd_int64_t vmstime)
9415 {
9416   struct tm *tm;
9417   time_t unxtime;
9418
9419   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9420   tm = gmtime (&unxtime);
9421   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9422           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9423           tm->tm_hour, tm->tm_min, tm->tm_sec);
9424 }
9425 #endif /* BFD64 */
9426
9427 static void
9428 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9429 {
9430   switch (entry->d_tag)
9431     {
9432     case DT_IA_64_PLT_RESERVE:
9433       /* First 3 slots reserved.  */
9434       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9435       printf (" -- ");
9436       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9437       break;
9438
9439     case DT_IA_64_VMS_LINKTIME:
9440 #ifdef BFD64
9441       print_vms_time (entry->d_un.d_val);
9442 #endif
9443       break;
9444
9445     case DT_IA_64_VMS_LNKFLAGS:
9446       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9447       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9448         printf (" CALL_DEBUG");
9449       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9450         printf (" NOP0BUFS");
9451       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9452         printf (" P0IMAGE");
9453       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9454         printf (" MKTHREADS");
9455       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9456         printf (" UPCALLS");
9457       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9458         printf (" IMGSTA");
9459       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9460         printf (" INITIALIZE");
9461       if (entry->d_un.d_val & VMS_LF_MAIN)
9462         printf (" MAIN");
9463       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9464         printf (" EXE_INIT");
9465       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9466         printf (" TBK_IN_IMG");
9467       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9468         printf (" DBG_IN_IMG");
9469       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9470         printf (" TBK_IN_DSF");
9471       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9472         printf (" DBG_IN_DSF");
9473       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9474         printf (" SIGNATURES");
9475       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9476         printf (" REL_SEG_OFF");
9477       break;
9478
9479     default:
9480       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9481       break;
9482     }
9483   putchar ('\n');
9484 }
9485
9486 static bfd_boolean
9487 get_32bit_dynamic_section (Filedata * filedata)
9488 {
9489   Elf32_External_Dyn * edyn;
9490   Elf32_External_Dyn * ext;
9491   Elf_Internal_Dyn * entry;
9492
9493   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9494                                           dynamic_size, _("dynamic section"));
9495   if (!edyn)
9496     return FALSE;
9497
9498   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9499      might not have the luxury of section headers.  Look for the DT_NULL
9500      terminator to determine the number of entries.  */
9501   for (ext = edyn, dynamic_nent = 0;
9502        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9503        ext++)
9504     {
9505       dynamic_nent++;
9506       if (BYTE_GET (ext->d_tag) == DT_NULL)
9507         break;
9508     }
9509
9510   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9511                                                   sizeof (* entry));
9512   if (dynamic_section == NULL)
9513     {
9514       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9515              (unsigned long) dynamic_nent);
9516       free (edyn);
9517       return FALSE;
9518     }
9519
9520   for (ext = edyn, entry = dynamic_section;
9521        entry < dynamic_section + dynamic_nent;
9522        ext++, entry++)
9523     {
9524       entry->d_tag      = BYTE_GET (ext->d_tag);
9525       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9526     }
9527
9528   free (edyn);
9529
9530   return TRUE;
9531 }
9532
9533 static bfd_boolean
9534 get_64bit_dynamic_section (Filedata * filedata)
9535 {
9536   Elf64_External_Dyn * edyn;
9537   Elf64_External_Dyn * ext;
9538   Elf_Internal_Dyn * entry;
9539
9540   /* Read in the data.  */
9541   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9542                                           dynamic_size, _("dynamic section"));
9543   if (!edyn)
9544     return FALSE;
9545
9546   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9547      might not have the luxury of section headers.  Look for the DT_NULL
9548      terminator to determine the number of entries.  */
9549   for (ext = edyn, dynamic_nent = 0;
9550        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9551        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9552        ext++)
9553     {
9554       dynamic_nent++;
9555       if (BYTE_GET (ext->d_tag) == DT_NULL)
9556         break;
9557     }
9558
9559   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9560                                                   sizeof (* entry));
9561   if (dynamic_section == NULL)
9562     {
9563       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9564              (unsigned long) dynamic_nent);
9565       free (edyn);
9566       return FALSE;
9567     }
9568
9569   /* Convert from external to internal formats.  */
9570   for (ext = edyn, entry = dynamic_section;
9571        entry < dynamic_section + dynamic_nent;
9572        ext++, entry++)
9573     {
9574       entry->d_tag      = BYTE_GET (ext->d_tag);
9575       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9576     }
9577
9578   free (edyn);
9579
9580   return TRUE;
9581 }
9582
9583 static void
9584 print_dynamic_flags (bfd_vma flags)
9585 {
9586   bfd_boolean first = TRUE;
9587
9588   while (flags)
9589     {
9590       bfd_vma flag;
9591
9592       flag = flags & - flags;
9593       flags &= ~ flag;
9594
9595       if (first)
9596         first = FALSE;
9597       else
9598         putc (' ', stdout);
9599
9600       switch (flag)
9601         {
9602         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9603         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9604         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9605         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9606         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9607         default:                fputs (_("unknown"), stdout); break;
9608         }
9609     }
9610   puts ("");
9611 }
9612
9613 /* Parse and display the contents of the dynamic section.  */
9614
9615 static bfd_boolean
9616 process_dynamic_section (Filedata * filedata)
9617 {
9618   Elf_Internal_Dyn * entry;
9619
9620   if (dynamic_size == 0)
9621     {
9622       if (do_dynamic)
9623         printf (_("\nThere is no dynamic section in this file.\n"));
9624
9625       return TRUE;
9626     }
9627
9628   if (is_32bit_elf)
9629     {
9630       if (! get_32bit_dynamic_section (filedata))
9631         return FALSE;
9632     }
9633   else
9634     {
9635       if (! get_64bit_dynamic_section (filedata))
9636         return FALSE;
9637     }
9638
9639   /* Find the appropriate symbol table.  */
9640   if (dynamic_symbols == NULL)
9641     {
9642       for (entry = dynamic_section;
9643            entry < dynamic_section + dynamic_nent;
9644            ++entry)
9645         {
9646           Elf_Internal_Shdr section;
9647
9648           if (entry->d_tag != DT_SYMTAB)
9649             continue;
9650
9651           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9652
9653           /* Since we do not know how big the symbol table is,
9654              we default to reading in the entire file (!) and
9655              processing that.  This is overkill, I know, but it
9656              should work.  */
9657           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9658           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9659             {
9660               /* See PR 21379 for a reproducer.  */
9661               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9662               return FALSE;
9663             }
9664
9665           if (archive_file_offset != 0)
9666             section.sh_size = archive_file_size - section.sh_offset;
9667           else
9668             section.sh_size = filedata->file_size - section.sh_offset;
9669
9670           if (is_32bit_elf)
9671             section.sh_entsize = sizeof (Elf32_External_Sym);
9672           else
9673             section.sh_entsize = sizeof (Elf64_External_Sym);
9674           section.sh_name = filedata->string_table_length;
9675
9676           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9677           if (num_dynamic_syms < 1)
9678             {
9679               error (_("Unable to determine the number of symbols to load\n"));
9680               continue;
9681             }
9682         }
9683     }
9684
9685   /* Similarly find a string table.  */
9686   if (dynamic_strings == NULL)
9687     {
9688       for (entry = dynamic_section;
9689            entry < dynamic_section + dynamic_nent;
9690            ++entry)
9691         {
9692           unsigned long offset;
9693           long str_tab_len;
9694
9695           if (entry->d_tag != DT_STRTAB)
9696             continue;
9697
9698           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9699
9700           /* Since we do not know how big the string table is,
9701              we default to reading in the entire file (!) and
9702              processing that.  This is overkill, I know, but it
9703              should work.  */
9704
9705           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9706
9707           if (archive_file_offset != 0)
9708             str_tab_len = archive_file_size - offset;
9709           else
9710             str_tab_len = filedata->file_size - offset;
9711
9712           if (str_tab_len < 1)
9713             {
9714               error
9715                 (_("Unable to determine the length of the dynamic string table\n"));
9716               continue;
9717             }
9718
9719           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9720                                                str_tab_len,
9721                                                _("dynamic string table"));
9722           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9723           break;
9724         }
9725     }
9726
9727   /* And find the syminfo section if available.  */
9728   if (dynamic_syminfo == NULL)
9729     {
9730       unsigned long syminsz = 0;
9731
9732       for (entry = dynamic_section;
9733            entry < dynamic_section + dynamic_nent;
9734            ++entry)
9735         {
9736           if (entry->d_tag == DT_SYMINENT)
9737             {
9738               /* Note: these braces are necessary to avoid a syntax
9739                  error from the SunOS4 C compiler.  */
9740               /* PR binutils/17531: A corrupt file can trigger this test.
9741                  So do not use an assert, instead generate an error message.  */
9742               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9743                 error (_("Bad value (%d) for SYMINENT entry\n"),
9744                        (int) entry->d_un.d_val);
9745             }
9746           else if (entry->d_tag == DT_SYMINSZ)
9747             syminsz = entry->d_un.d_val;
9748           else if (entry->d_tag == DT_SYMINFO)
9749             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9750                                                       syminsz);
9751         }
9752
9753       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9754         {
9755           Elf_External_Syminfo * extsyminfo;
9756           Elf_External_Syminfo * extsym;
9757           Elf_Internal_Syminfo * syminfo;
9758
9759           /* There is a syminfo section.  Read the data.  */
9760           extsyminfo = (Elf_External_Syminfo *)
9761               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9762                         _("symbol information"));
9763           if (!extsyminfo)
9764             return FALSE;
9765
9766           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9767           if (dynamic_syminfo == NULL)
9768             {
9769               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9770                      (unsigned long) syminsz);
9771               return FALSE;
9772             }
9773
9774           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9775           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9776                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9777                ++syminfo, ++extsym)
9778             {
9779               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9780               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9781             }
9782
9783           free (extsyminfo);
9784         }
9785     }
9786
9787   if (do_dynamic && dynamic_addr)
9788     printf (ngettext ("\nDynamic section at offset 0x%lx "
9789                       "contains %lu entry:\n",
9790                       "\nDynamic section at offset 0x%lx "
9791                       "contains %lu entries:\n",
9792                       dynamic_nent),
9793             dynamic_addr, (unsigned long) dynamic_nent);
9794   if (do_dynamic)
9795     printf (_("  Tag        Type                         Name/Value\n"));
9796
9797   for (entry = dynamic_section;
9798        entry < dynamic_section + dynamic_nent;
9799        entry++)
9800     {
9801       if (do_dynamic)
9802         {
9803           const char * dtype;
9804
9805           putchar (' ');
9806           print_vma (entry->d_tag, FULL_HEX);
9807           dtype = get_dynamic_type (filedata, entry->d_tag);
9808           printf (" (%s)%*s", dtype,
9809                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9810         }
9811
9812       switch (entry->d_tag)
9813         {
9814         case DT_FLAGS:
9815           if (do_dynamic)
9816             print_dynamic_flags (entry->d_un.d_val);
9817           break;
9818
9819         case DT_AUXILIARY:
9820         case DT_FILTER:
9821         case DT_CONFIG:
9822         case DT_DEPAUDIT:
9823         case DT_AUDIT:
9824           if (do_dynamic)
9825             {
9826               switch (entry->d_tag)
9827                 {
9828                 case DT_AUXILIARY:
9829                   printf (_("Auxiliary library"));
9830                   break;
9831
9832                 case DT_FILTER:
9833                   printf (_("Filter library"));
9834                   break;
9835
9836                 case DT_CONFIG:
9837                   printf (_("Configuration file"));
9838                   break;
9839
9840                 case DT_DEPAUDIT:
9841                   printf (_("Dependency audit library"));
9842                   break;
9843
9844                 case DT_AUDIT:
9845                   printf (_("Audit library"));
9846                   break;
9847                 }
9848
9849               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9850                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9851               else
9852                 {
9853                   printf (": ");
9854                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9855                   putchar ('\n');
9856                 }
9857             }
9858           break;
9859
9860         case DT_FEATURE:
9861           if (do_dynamic)
9862             {
9863               printf (_("Flags:"));
9864
9865               if (entry->d_un.d_val == 0)
9866                 printf (_(" None\n"));
9867               else
9868                 {
9869                   unsigned long int val = entry->d_un.d_val;
9870
9871                   if (val & DTF_1_PARINIT)
9872                     {
9873                       printf (" PARINIT");
9874                       val ^= DTF_1_PARINIT;
9875                     }
9876                   if (val & DTF_1_CONFEXP)
9877                     {
9878                       printf (" CONFEXP");
9879                       val ^= DTF_1_CONFEXP;
9880                     }
9881                   if (val != 0)
9882                     printf (" %lx", val);
9883                   puts ("");
9884                 }
9885             }
9886           break;
9887
9888         case DT_POSFLAG_1:
9889           if (do_dynamic)
9890             {
9891               printf (_("Flags:"));
9892
9893               if (entry->d_un.d_val == 0)
9894                 printf (_(" None\n"));
9895               else
9896                 {
9897                   unsigned long int val = entry->d_un.d_val;
9898
9899                   if (val & DF_P1_LAZYLOAD)
9900                     {
9901                       printf (" LAZYLOAD");
9902                       val ^= DF_P1_LAZYLOAD;
9903                     }
9904                   if (val & DF_P1_GROUPPERM)
9905                     {
9906                       printf (" GROUPPERM");
9907                       val ^= DF_P1_GROUPPERM;
9908                     }
9909                   if (val != 0)
9910                     printf (" %lx", val);
9911                   puts ("");
9912                 }
9913             }
9914           break;
9915
9916         case DT_FLAGS_1:
9917           if (do_dynamic)
9918             {
9919               printf (_("Flags:"));
9920               if (entry->d_un.d_val == 0)
9921                 printf (_(" None\n"));
9922               else
9923                 {
9924                   unsigned long int val = entry->d_un.d_val;
9925
9926                   if (val & DF_1_NOW)
9927                     {
9928                       printf (" NOW");
9929                       val ^= DF_1_NOW;
9930                     }
9931                   if (val & DF_1_GLOBAL)
9932                     {
9933                       printf (" GLOBAL");
9934                       val ^= DF_1_GLOBAL;
9935                     }
9936                   if (val & DF_1_GROUP)
9937                     {
9938                       printf (" GROUP");
9939                       val ^= DF_1_GROUP;
9940                     }
9941                   if (val & DF_1_NODELETE)
9942                     {
9943                       printf (" NODELETE");
9944                       val ^= DF_1_NODELETE;
9945                     }
9946                   if (val & DF_1_LOADFLTR)
9947                     {
9948                       printf (" LOADFLTR");
9949                       val ^= DF_1_LOADFLTR;
9950                     }
9951                   if (val & DF_1_INITFIRST)
9952                     {
9953                       printf (" INITFIRST");
9954                       val ^= DF_1_INITFIRST;
9955                     }
9956                   if (val & DF_1_NOOPEN)
9957                     {
9958                       printf (" NOOPEN");
9959                       val ^= DF_1_NOOPEN;
9960                     }
9961                   if (val & DF_1_ORIGIN)
9962                     {
9963                       printf (" ORIGIN");
9964                       val ^= DF_1_ORIGIN;
9965                     }
9966                   if (val & DF_1_DIRECT)
9967                     {
9968                       printf (" DIRECT");
9969                       val ^= DF_1_DIRECT;
9970                     }
9971                   if (val & DF_1_TRANS)
9972                     {
9973                       printf (" TRANS");
9974                       val ^= DF_1_TRANS;
9975                     }
9976                   if (val & DF_1_INTERPOSE)
9977                     {
9978                       printf (" INTERPOSE");
9979                       val ^= DF_1_INTERPOSE;
9980                     }
9981                   if (val & DF_1_NODEFLIB)
9982                     {
9983                       printf (" NODEFLIB");
9984                       val ^= DF_1_NODEFLIB;
9985                     }
9986                   if (val & DF_1_NODUMP)
9987                     {
9988                       printf (" NODUMP");
9989                       val ^= DF_1_NODUMP;
9990                     }
9991                   if (val & DF_1_CONFALT)
9992                     {
9993                       printf (" CONFALT");
9994                       val ^= DF_1_CONFALT;
9995                     }
9996                   if (val & DF_1_ENDFILTEE)
9997                     {
9998                       printf (" ENDFILTEE");
9999                       val ^= DF_1_ENDFILTEE;
10000                     }
10001                   if (val & DF_1_DISPRELDNE)
10002                     {
10003                       printf (" DISPRELDNE");
10004                       val ^= DF_1_DISPRELDNE;
10005                     }
10006                   if (val & DF_1_DISPRELPND)
10007                     {
10008                       printf (" DISPRELPND");
10009                       val ^= DF_1_DISPRELPND;
10010                     }
10011                   if (val & DF_1_NODIRECT)
10012                     {
10013                       printf (" NODIRECT");
10014                       val ^= DF_1_NODIRECT;
10015                     }
10016                   if (val & DF_1_IGNMULDEF)
10017                     {
10018                       printf (" IGNMULDEF");
10019                       val ^= DF_1_IGNMULDEF;
10020                     }
10021                   if (val & DF_1_NOKSYMS)
10022                     {
10023                       printf (" NOKSYMS");
10024                       val ^= DF_1_NOKSYMS;
10025                     }
10026                   if (val & DF_1_NOHDR)
10027                     {
10028                       printf (" NOHDR");
10029                       val ^= DF_1_NOHDR;
10030                     }
10031                   if (val & DF_1_EDITED)
10032                     {
10033                       printf (" EDITED");
10034                       val ^= DF_1_EDITED;
10035                     }
10036                   if (val & DF_1_NORELOC)
10037                     {
10038                       printf (" NORELOC");
10039                       val ^= DF_1_NORELOC;
10040                     }
10041                   if (val & DF_1_SYMINTPOSE)
10042                     {
10043                       printf (" SYMINTPOSE");
10044                       val ^= DF_1_SYMINTPOSE;
10045                     }
10046                   if (val & DF_1_GLOBAUDIT)
10047                     {
10048                       printf (" GLOBAUDIT");
10049                       val ^= DF_1_GLOBAUDIT;
10050                     }
10051                   if (val & DF_1_SINGLETON)
10052                     {
10053                       printf (" SINGLETON");
10054                       val ^= DF_1_SINGLETON;
10055                     }
10056                   if (val & DF_1_STUB)
10057                     {
10058                       printf (" STUB");
10059                       val ^= DF_1_STUB;
10060                     }
10061                   if (val & DF_1_PIE)
10062                     {
10063                       printf (" PIE");
10064                       val ^= DF_1_PIE;
10065                     }
10066                   if (val & DF_1_KMOD)
10067                     {
10068                       printf (" KMOD");
10069                       val ^= DF_1_KMOD;
10070                     }
10071                   if (val & DF_1_WEAKFILTER)
10072                     {
10073                       printf (" WEAKFILTER");
10074                       val ^= DF_1_WEAKFILTER;
10075                     }
10076                   if (val & DF_1_NOCOMMON)
10077                     {
10078                       printf (" NOCOMMON");
10079                       val ^= DF_1_NOCOMMON;
10080                     }
10081                   if (val != 0)
10082                     printf (" %lx", val);
10083                   puts ("");
10084                 }
10085             }
10086           break;
10087
10088         case DT_PLTREL:
10089           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10090           if (do_dynamic)
10091             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10092           break;
10093
10094         case DT_NULL    :
10095         case DT_NEEDED  :
10096         case DT_PLTGOT  :
10097         case DT_HASH    :
10098         case DT_STRTAB  :
10099         case DT_SYMTAB  :
10100         case DT_RELA    :
10101         case DT_INIT    :
10102         case DT_FINI    :
10103         case DT_SONAME  :
10104         case DT_RPATH   :
10105         case DT_SYMBOLIC:
10106         case DT_REL     :
10107         case DT_DEBUG   :
10108         case DT_TEXTREL :
10109         case DT_JMPREL  :
10110         case DT_RUNPATH :
10111           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10112
10113           if (do_dynamic)
10114             {
10115               char * name;
10116
10117               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10118                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10119               else
10120                 name = NULL;
10121
10122               if (name)
10123                 {
10124                   switch (entry->d_tag)
10125                     {
10126                     case DT_NEEDED:
10127                       printf (_("Shared library: [%s]"), name);
10128
10129                       if (streq (name, program_interpreter))
10130                         printf (_(" program interpreter"));
10131                       break;
10132
10133                     case DT_SONAME:
10134                       printf (_("Library soname: [%s]"), name);
10135                       break;
10136
10137                     case DT_RPATH:
10138                       printf (_("Library rpath: [%s]"), name);
10139                       break;
10140
10141                     case DT_RUNPATH:
10142                       printf (_("Library runpath: [%s]"), name);
10143                       break;
10144
10145                     default:
10146                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10147                       break;
10148                     }
10149                 }
10150               else
10151                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10152
10153               putchar ('\n');
10154             }
10155           break;
10156
10157         case DT_PLTRELSZ:
10158         case DT_RELASZ  :
10159         case DT_STRSZ   :
10160         case DT_RELSZ   :
10161         case DT_RELAENT :
10162         case DT_SYMENT  :
10163         case DT_RELENT  :
10164           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10165           /* Fall through.  */
10166         case DT_PLTPADSZ:
10167         case DT_MOVEENT :
10168         case DT_MOVESZ  :
10169         case DT_INIT_ARRAYSZ:
10170         case DT_FINI_ARRAYSZ:
10171         case DT_GNU_CONFLICTSZ:
10172         case DT_GNU_LIBLISTSZ:
10173           if (do_dynamic)
10174             {
10175               print_vma (entry->d_un.d_val, UNSIGNED);
10176               printf (_(" (bytes)\n"));
10177             }
10178           break;
10179
10180         case DT_VERDEFNUM:
10181         case DT_VERNEEDNUM:
10182         case DT_RELACOUNT:
10183         case DT_RELCOUNT:
10184           if (do_dynamic)
10185             {
10186               print_vma (entry->d_un.d_val, UNSIGNED);
10187               putchar ('\n');
10188             }
10189           break;
10190
10191         case DT_SYMINSZ:
10192         case DT_SYMINENT:
10193         case DT_SYMINFO:
10194         case DT_USED:
10195         case DT_INIT_ARRAY:
10196         case DT_FINI_ARRAY:
10197           if (do_dynamic)
10198             {
10199               if (entry->d_tag == DT_USED
10200                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10201                 {
10202                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10203
10204                   if (*name)
10205                     {
10206                       printf (_("Not needed object: [%s]\n"), name);
10207                       break;
10208                     }
10209                 }
10210
10211               print_vma (entry->d_un.d_val, PREFIX_HEX);
10212               putchar ('\n');
10213             }
10214           break;
10215
10216         case DT_BIND_NOW:
10217           /* The value of this entry is ignored.  */
10218           if (do_dynamic)
10219             putchar ('\n');
10220           break;
10221
10222         case DT_GNU_PRELINKED:
10223           if (do_dynamic)
10224             {
10225               struct tm * tmp;
10226               time_t atime = entry->d_un.d_val;
10227
10228               tmp = gmtime (&atime);
10229               /* PR 17533 file: 041-1244816-0.004.  */
10230               if (tmp == NULL)
10231                 printf (_("<corrupt time val: %lx"),
10232                         (unsigned long) atime);
10233               else
10234                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10235                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10236                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10237
10238             }
10239           break;
10240
10241         case DT_GNU_HASH:
10242           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10243           if (do_dynamic)
10244             {
10245               print_vma (entry->d_un.d_val, PREFIX_HEX);
10246               putchar ('\n');
10247             }
10248           break;
10249
10250         default:
10251           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10252             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10253               entry->d_un.d_val;
10254
10255           if (do_dynamic)
10256             {
10257               switch (filedata->file_header.e_machine)
10258                 {
10259                 case EM_MIPS:
10260                 case EM_MIPS_RS3_LE:
10261                   dynamic_section_mips_val (entry);
10262                   break;
10263                 case EM_PARISC:
10264                   dynamic_section_parisc_val (entry);
10265                   break;
10266                 case EM_IA_64:
10267                   dynamic_section_ia64_val (entry);
10268                   break;
10269                 default:
10270                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10271                   putchar ('\n');
10272                 }
10273             }
10274           break;
10275         }
10276     }
10277
10278   return TRUE;
10279 }
10280
10281 static char *
10282 get_ver_flags (unsigned int flags)
10283 {
10284   static char buff[128];
10285
10286   buff[0] = 0;
10287
10288   if (flags == 0)
10289     return _("none");
10290
10291   if (flags & VER_FLG_BASE)
10292     strcat (buff, "BASE");
10293
10294   if (flags & VER_FLG_WEAK)
10295     {
10296       if (flags & VER_FLG_BASE)
10297         strcat (buff, " | ");
10298
10299       strcat (buff, "WEAK");
10300     }
10301
10302   if (flags & VER_FLG_INFO)
10303     {
10304       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10305         strcat (buff, " | ");
10306
10307       strcat (buff, "INFO");
10308     }
10309
10310   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10311     {
10312       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10313         strcat (buff, " | ");
10314
10315       strcat (buff, _("<unknown>"));
10316     }
10317
10318   return buff;
10319 }
10320
10321 /* Display the contents of the version sections.  */
10322
10323 static bfd_boolean
10324 process_version_sections (Filedata * filedata)
10325 {
10326   Elf_Internal_Shdr * section;
10327   unsigned i;
10328   bfd_boolean found = FALSE;
10329
10330   if (! do_version)
10331     return TRUE;
10332
10333   for (i = 0, section = filedata->section_headers;
10334        i < filedata->file_header.e_shnum;
10335        i++, section++)
10336     {
10337       switch (section->sh_type)
10338         {
10339         case SHT_GNU_verdef:
10340           {
10341             Elf_External_Verdef * edefs;
10342             unsigned long idx;
10343             unsigned long cnt;
10344             char * endbuf;
10345
10346             found = TRUE;
10347
10348             printf (ngettext ("\nVersion definition section '%s' "
10349                               "contains %u entry:\n",
10350                               "\nVersion definition section '%s' "
10351                               "contains %u entries:\n",
10352                               section->sh_info),
10353                     printable_section_name (filedata, section),
10354                     section->sh_info);
10355
10356             printf (_("  Addr: 0x"));
10357             printf_vma (section->sh_addr);
10358             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10359                     (unsigned long) section->sh_offset, section->sh_link,
10360                     printable_section_name_from_index (filedata, section->sh_link));
10361
10362             edefs = (Elf_External_Verdef *)
10363                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10364                           _("version definition section"));
10365             if (!edefs)
10366               break;
10367             endbuf = (char *) edefs + section->sh_size;
10368
10369             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10370               {
10371                 char * vstart;
10372                 Elf_External_Verdef * edef;
10373                 Elf_Internal_Verdef ent;
10374                 Elf_External_Verdaux * eaux;
10375                 Elf_Internal_Verdaux aux;
10376                 unsigned long isum;
10377                 int j;
10378
10379                 vstart = ((char *) edefs) + idx;
10380                 if (vstart + sizeof (*edef) > endbuf)
10381                   break;
10382
10383                 edef = (Elf_External_Verdef *) vstart;
10384
10385                 ent.vd_version = BYTE_GET (edef->vd_version);
10386                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10387                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10388                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10389                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10390                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10391                 ent.vd_next    = BYTE_GET (edef->vd_next);
10392
10393                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10394                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10395
10396                 printf (_("  Index: %d  Cnt: %d  "),
10397                         ent.vd_ndx, ent.vd_cnt);
10398
10399                 /* Check for overflow.  */
10400                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10401                   break;
10402
10403                 vstart += ent.vd_aux;
10404
10405                 if (vstart + sizeof (*eaux) > endbuf)
10406                   break;
10407                 eaux = (Elf_External_Verdaux *) vstart;
10408
10409                 aux.vda_name = BYTE_GET (eaux->vda_name);
10410                 aux.vda_next = BYTE_GET (eaux->vda_next);
10411
10412                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10413                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10414                 else
10415                   printf (_("Name index: %ld\n"), aux.vda_name);
10416
10417                 isum = idx + ent.vd_aux;
10418
10419                 for (j = 1; j < ent.vd_cnt; j++)
10420                   {
10421                     if (aux.vda_next < sizeof (*eaux)
10422                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10423                       {
10424                         warn (_("Invalid vda_next field of %lx\n"),
10425                               aux.vda_next);
10426                         j = ent.vd_cnt;
10427                         break;
10428                       }
10429                     /* Check for overflow.  */
10430                     if (aux.vda_next > (size_t) (endbuf - vstart))
10431                       break;
10432
10433                     isum   += aux.vda_next;
10434                     vstart += aux.vda_next;
10435
10436                     if (vstart + sizeof (*eaux) > endbuf)
10437                       break;
10438                     eaux = (Elf_External_Verdaux *) vstart;
10439
10440                     aux.vda_name = BYTE_GET (eaux->vda_name);
10441                     aux.vda_next = BYTE_GET (eaux->vda_next);
10442
10443                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10444                       printf (_("  %#06lx: Parent %d: %s\n"),
10445                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10446                     else
10447                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10448                               isum, j, aux.vda_name);
10449                   }
10450
10451                 if (j < ent.vd_cnt)
10452                   printf (_("  Version def aux past end of section\n"));
10453
10454                 /* PR 17531:
10455                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10456                 if (ent.vd_next < sizeof (*edef)
10457                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10458                   {
10459                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10460                     cnt = section->sh_info;
10461                     break;
10462                   }
10463                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10464                   break;
10465
10466                 idx += ent.vd_next;
10467               }
10468
10469             if (cnt < section->sh_info)
10470               printf (_("  Version definition past end of section\n"));
10471
10472             free (edefs);
10473           }
10474           break;
10475
10476         case SHT_GNU_verneed:
10477           {
10478             Elf_External_Verneed * eneed;
10479             unsigned long idx;
10480             unsigned long cnt;
10481             char * endbuf;
10482
10483             found = TRUE;
10484
10485             printf (ngettext ("\nVersion needs section '%s' "
10486                               "contains %u entry:\n",
10487                               "\nVersion needs section '%s' "
10488                               "contains %u entries:\n",
10489                               section->sh_info),
10490                     printable_section_name (filedata, section), section->sh_info);
10491
10492             printf (_(" Addr: 0x"));
10493             printf_vma (section->sh_addr);
10494             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10495                     (unsigned long) section->sh_offset, section->sh_link,
10496                     printable_section_name_from_index (filedata, section->sh_link));
10497
10498             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10499                                                        section->sh_offset, 1,
10500                                                        section->sh_size,
10501                                                        _("Version Needs section"));
10502             if (!eneed)
10503               break;
10504             endbuf = (char *) eneed + section->sh_size;
10505
10506             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10507               {
10508                 Elf_External_Verneed * entry;
10509                 Elf_Internal_Verneed ent;
10510                 unsigned long isum;
10511                 int j;
10512                 char * vstart;
10513
10514                 vstart = ((char *) eneed) + idx;
10515                 if (vstart + sizeof (*entry) > endbuf)
10516                   break;
10517
10518                 entry = (Elf_External_Verneed *) vstart;
10519
10520                 ent.vn_version = BYTE_GET (entry->vn_version);
10521                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10522                 ent.vn_file    = BYTE_GET (entry->vn_file);
10523                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10524                 ent.vn_next    = BYTE_GET (entry->vn_next);
10525
10526                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10527
10528                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10529                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10530                 else
10531                   printf (_("  File: %lx"), ent.vn_file);
10532
10533                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10534
10535                 /* Check for overflow.  */
10536                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10537                   break;
10538                 vstart += ent.vn_aux;
10539
10540                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10541                   {
10542                     Elf_External_Vernaux * eaux;
10543                     Elf_Internal_Vernaux aux;
10544
10545                     if (vstart + sizeof (*eaux) > endbuf)
10546                       break;
10547                     eaux = (Elf_External_Vernaux *) vstart;
10548
10549                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10550                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10551                     aux.vna_other = BYTE_GET (eaux->vna_other);
10552                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10553                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10554
10555                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10556                       printf (_("  %#06lx:   Name: %s"),
10557                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10558                     else
10559                       printf (_("  %#06lx:   Name index: %lx"),
10560                               isum, aux.vna_name);
10561
10562                     printf (_("  Flags: %s  Version: %d\n"),
10563                             get_ver_flags (aux.vna_flags), aux.vna_other);
10564
10565                     if (aux.vna_next < sizeof (*eaux)
10566                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10567                       {
10568                         warn (_("Invalid vna_next field of %lx\n"),
10569                               aux.vna_next);
10570                         j = ent.vn_cnt;
10571                         break;
10572                       }
10573                     /* Check for overflow.  */
10574                     if (aux.vna_next > (size_t) (endbuf - vstart))
10575                       break;
10576                     isum   += aux.vna_next;
10577                     vstart += aux.vna_next;
10578                   }
10579
10580                 if (j < ent.vn_cnt)
10581                   warn (_("Missing Version Needs auxillary information\n"));
10582
10583                 if (ent.vn_next < sizeof (*entry)
10584                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10585                   {
10586                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10587                     cnt = section->sh_info;
10588                     break;
10589                   }
10590                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10591                   break;
10592                 idx += ent.vn_next;
10593               }
10594
10595             if (cnt < section->sh_info)
10596               warn (_("Missing Version Needs information\n"));
10597
10598             free (eneed);
10599           }
10600           break;
10601
10602         case SHT_GNU_versym:
10603           {
10604             Elf_Internal_Shdr * link_section;
10605             size_t total;
10606             unsigned int cnt;
10607             unsigned char * edata;
10608             unsigned short * data;
10609             char * strtab;
10610             Elf_Internal_Sym * symbols;
10611             Elf_Internal_Shdr * string_sec;
10612             unsigned long num_syms;
10613             long off;
10614
10615             if (section->sh_link >= filedata->file_header.e_shnum)
10616               break;
10617
10618             link_section = filedata->section_headers + section->sh_link;
10619             total = section->sh_size / sizeof (Elf_External_Versym);
10620
10621             if (link_section->sh_link >= filedata->file_header.e_shnum)
10622               break;
10623
10624             found = TRUE;
10625
10626             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10627             if (symbols == NULL)
10628               break;
10629
10630             string_sec = filedata->section_headers + link_section->sh_link;
10631
10632             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10633                                         string_sec->sh_size,
10634                                         _("version string table"));
10635             if (!strtab)
10636               {
10637                 free (symbols);
10638                 break;
10639               }
10640
10641             printf (ngettext ("\nVersion symbols section '%s' "
10642                               "contains %lu entry:\n",
10643                               "\nVersion symbols section '%s' "
10644                               "contains %lu entries:\n",
10645                               total),
10646                     printable_section_name (filedata, section), (unsigned long) total);
10647
10648             printf (_(" Addr: "));
10649             printf_vma (section->sh_addr);
10650             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10651                     (unsigned long) section->sh_offset, section->sh_link,
10652                     printable_section_name (filedata, link_section));
10653
10654             off = offset_from_vma (filedata,
10655                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10656                                    total * sizeof (short));
10657             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10658                                                 sizeof (short),
10659                                                 _("version symbol data"));
10660             if (!edata)
10661               {
10662                 free (strtab);
10663                 free (symbols);
10664                 break;
10665               }
10666
10667             data = (short unsigned int *) cmalloc (total, sizeof (short));
10668
10669             for (cnt = total; cnt --;)
10670               data[cnt] = byte_get (edata + cnt * sizeof (short),
10671                                     sizeof (short));
10672
10673             free (edata);
10674
10675             for (cnt = 0; cnt < total; cnt += 4)
10676               {
10677                 int j, nn;
10678                 char *name;
10679                 char *invalid = _("*invalid*");
10680
10681                 printf ("  %03x:", cnt);
10682
10683                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10684                   switch (data[cnt + j])
10685                     {
10686                     case 0:
10687                       fputs (_("   0 (*local*)    "), stdout);
10688                       break;
10689
10690                     case 1:
10691                       fputs (_("   1 (*global*)   "), stdout);
10692                       break;
10693
10694                     default:
10695                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10696                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10697
10698                       /* If this index value is greater than the size of the symbols
10699                          array, break to avoid an out-of-bounds read.  */
10700                       if ((unsigned long)(cnt + j) >= num_syms)
10701                         {
10702                           warn (_("invalid index into symbol array\n"));
10703                           break;
10704                         }
10705
10706                       name = NULL;
10707                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10708                         {
10709                           Elf_Internal_Verneed ivn;
10710                           unsigned long offset;
10711
10712                           offset = offset_from_vma
10713                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10714                              sizeof (Elf_External_Verneed));
10715
10716                           do
10717                             {
10718                               Elf_Internal_Vernaux ivna;
10719                               Elf_External_Verneed evn;
10720                               Elf_External_Vernaux evna;
10721                               unsigned long a_off;
10722
10723                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10724                                             _("version need")) == NULL)
10725                                 break;
10726
10727                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10728                               ivn.vn_next = BYTE_GET (evn.vn_next);
10729
10730                               a_off = offset + ivn.vn_aux;
10731
10732                               do
10733                                 {
10734                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10735                                                 1, _("version need aux (2)")) == NULL)
10736                                     {
10737                                       ivna.vna_next  = 0;
10738                                       ivna.vna_other = 0;
10739                                     }
10740                                   else
10741                                     {
10742                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10743                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10744                                     }
10745
10746                                   a_off += ivna.vna_next;
10747                                 }
10748                               while (ivna.vna_other != data[cnt + j]
10749                                      && ivna.vna_next != 0);
10750
10751                               if (ivna.vna_other == data[cnt + j])
10752                                 {
10753                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10754
10755                                   if (ivna.vna_name >= string_sec->sh_size)
10756                                     name = invalid;
10757                                   else
10758                                     name = strtab + ivna.vna_name;
10759                                   break;
10760                                 }
10761
10762                               offset += ivn.vn_next;
10763                             }
10764                           while (ivn.vn_next);
10765                         }
10766
10767                       if (data[cnt + j] != 0x8001
10768                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10769                         {
10770                           Elf_Internal_Verdef ivd;
10771                           Elf_External_Verdef evd;
10772                           unsigned long offset;
10773
10774                           offset = offset_from_vma
10775                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10776                              sizeof evd);
10777
10778                           do
10779                             {
10780                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10781                                             _("version def")) == NULL)
10782                                 {
10783                                   ivd.vd_next = 0;
10784                                   /* PR 17531: file: 046-1082287-0.004.  */
10785                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10786                                   break;
10787                                 }
10788                               else
10789                                 {
10790                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10791                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10792                                 }
10793
10794                               offset += ivd.vd_next;
10795                             }
10796                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10797                                  && ivd.vd_next != 0);
10798
10799                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10800                             {
10801                               Elf_External_Verdaux evda;
10802                               Elf_Internal_Verdaux ivda;
10803
10804                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10805
10806                               if (get_data (&evda, filedata,
10807                                             offset - ivd.vd_next + ivd.vd_aux,
10808                                             sizeof (evda), 1,
10809                                             _("version def aux")) == NULL)
10810                                 break;
10811
10812                               ivda.vda_name = BYTE_GET (evda.vda_name);
10813
10814                               if (ivda.vda_name >= string_sec->sh_size)
10815                                 name = invalid;
10816                               else if (name != NULL && name != invalid)
10817                                 name = _("*both*");
10818                               else
10819                                 name = strtab + ivda.vda_name;
10820                             }
10821                         }
10822                       if (name != NULL)
10823                         nn += printf ("(%s%-*s",
10824                                       name,
10825                                       12 - (int) strlen (name),
10826                                       ")");
10827
10828                       if (nn < 18)
10829                         printf ("%*c", 18 - nn, ' ');
10830                     }
10831
10832                 putchar ('\n');
10833               }
10834
10835             free (data);
10836             free (strtab);
10837             free (symbols);
10838           }
10839           break;
10840
10841         default:
10842           break;
10843         }
10844     }
10845
10846   if (! found)
10847     printf (_("\nNo version information found in this file.\n"));
10848
10849   return TRUE;
10850 }
10851
10852 static const char *
10853 get_symbol_binding (Filedata * filedata, unsigned int binding)
10854 {
10855   static char buff[32];
10856
10857   switch (binding)
10858     {
10859     case STB_LOCAL:     return "LOCAL";
10860     case STB_GLOBAL:    return "GLOBAL";
10861     case STB_WEAK:      return "WEAK";
10862     default:
10863       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10864         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10865                   binding);
10866       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10867         {
10868           if (binding == STB_GNU_UNIQUE
10869               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10870                   /* GNU is still using the default value 0.  */
10871                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10872             return "UNIQUE";
10873           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10874         }
10875       else
10876         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10877       return buff;
10878     }
10879 }
10880
10881 static const char *
10882 get_symbol_type (Filedata * filedata, unsigned int type)
10883 {
10884   static char buff[32];
10885
10886   switch (type)
10887     {
10888     case STT_NOTYPE:    return "NOTYPE";
10889     case STT_OBJECT:    return "OBJECT";
10890     case STT_FUNC:      return "FUNC";
10891     case STT_SECTION:   return "SECTION";
10892     case STT_FILE:      return "FILE";
10893     case STT_COMMON:    return "COMMON";
10894     case STT_TLS:       return "TLS";
10895     case STT_RELC:      return "RELC";
10896     case STT_SRELC:     return "SRELC";
10897     default:
10898       if (type >= STT_LOPROC && type <= STT_HIPROC)
10899         {
10900           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10901             return "THUMB_FUNC";
10902
10903           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10904             return "REGISTER";
10905
10906           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10907             return "PARISC_MILLI";
10908
10909           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10910         }
10911       else if (type >= STT_LOOS && type <= STT_HIOS)
10912         {
10913           if (filedata->file_header.e_machine == EM_PARISC)
10914             {
10915               if (type == STT_HP_OPAQUE)
10916                 return "HP_OPAQUE";
10917               if (type == STT_HP_STUB)
10918                 return "HP_STUB";
10919             }
10920
10921           if (type == STT_GNU_IFUNC
10922               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10923                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10924                   /* GNU is still using the default value 0.  */
10925                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10926             return "IFUNC";
10927
10928           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10929         }
10930       else
10931         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10932       return buff;
10933     }
10934 }
10935
10936 static const char *
10937 get_symbol_visibility (unsigned int visibility)
10938 {
10939   switch (visibility)
10940     {
10941     case STV_DEFAULT:   return "DEFAULT";
10942     case STV_INTERNAL:  return "INTERNAL";
10943     case STV_HIDDEN:    return "HIDDEN";
10944     case STV_PROTECTED: return "PROTECTED";
10945     default:
10946       error (_("Unrecognized visibility value: %u"), visibility);
10947       return _("<unknown>");
10948     }
10949 }
10950
10951 static const char *
10952 get_solaris_symbol_visibility (unsigned int visibility)
10953 {
10954   switch (visibility)
10955     {
10956     case 4: return "EXPORTED";
10957     case 5: return "SINGLETON";
10958     case 6: return "ELIMINATE";
10959     default: return get_symbol_visibility (visibility);
10960     }
10961 }
10962
10963 static const char *
10964 get_mips_symbol_other (unsigned int other)
10965 {
10966   switch (other)
10967     {
10968     case STO_OPTIONAL:      return "OPTIONAL";
10969     case STO_MIPS_PLT:      return "MIPS PLT";
10970     case STO_MIPS_PIC:      return "MIPS PIC";
10971     case STO_MICROMIPS:     return "MICROMIPS";
10972     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10973     case STO_MIPS16:        return "MIPS16";
10974     default:                return NULL;
10975     }
10976 }
10977
10978 static const char *
10979 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
10980 {
10981   if (is_ia64_vms (filedata))
10982     {
10983       static char res[32];
10984
10985       res[0] = 0;
10986
10987       /* Function types is for images and .STB files only.  */
10988       switch (filedata->file_header.e_type)
10989         {
10990         case ET_DYN:
10991         case ET_EXEC:
10992           switch (VMS_ST_FUNC_TYPE (other))
10993             {
10994             case VMS_SFT_CODE_ADDR:
10995               strcat (res, " CA");
10996               break;
10997             case VMS_SFT_SYMV_IDX:
10998               strcat (res, " VEC");
10999               break;
11000             case VMS_SFT_FD:
11001               strcat (res, " FD");
11002               break;
11003             case VMS_SFT_RESERVE:
11004               strcat (res, " RSV");
11005               break;
11006             default:
11007               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11008                     VMS_ST_FUNC_TYPE (other));
11009               strcat (res, " <unknown>");
11010               break;
11011             }
11012           break;
11013         default:
11014           break;
11015         }
11016       switch (VMS_ST_LINKAGE (other))
11017         {
11018         case VMS_STL_IGNORE:
11019           strcat (res, " IGN");
11020           break;
11021         case VMS_STL_RESERVE:
11022           strcat (res, " RSV");
11023           break;
11024         case VMS_STL_STD:
11025           strcat (res, " STD");
11026           break;
11027         case VMS_STL_LNK:
11028           strcat (res, " LNK");
11029           break;
11030         default:
11031           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11032                 VMS_ST_LINKAGE (other));
11033           strcat (res, " <unknown>");
11034           break;
11035         }
11036
11037       if (res[0] != 0)
11038         return res + 1;
11039       else
11040         return res;
11041     }
11042   return NULL;
11043 }
11044
11045 static const char *
11046 get_ppc64_symbol_other (unsigned int other)
11047 {
11048   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
11049     {
11050       static char buf[32];
11051       snprintf (buf, sizeof buf, _("<localentry>: %d"),
11052                 PPC64_LOCAL_ENTRY_OFFSET (other));
11053       return buf;
11054     }
11055   return NULL;
11056 }
11057
11058 static const char *
11059 get_symbol_other (Filedata * filedata, unsigned int other)
11060 {
11061   const char * result = NULL;
11062   static char buff [32];
11063
11064   if (other == 0)
11065     return "";
11066
11067   switch (filedata->file_header.e_machine)
11068     {
11069     case EM_MIPS:
11070       result = get_mips_symbol_other (other);
11071       break;
11072     case EM_IA_64:
11073       result = get_ia64_symbol_other (filedata, other);
11074       break;
11075     case EM_PPC64:
11076       result = get_ppc64_symbol_other (other);
11077       break;
11078     default:
11079       result = NULL;
11080       break;
11081     }
11082
11083   if (result)
11084     return result;
11085
11086   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11087   return buff;
11088 }
11089
11090 static const char *
11091 get_symbol_index_type (Filedata * filedata, unsigned int type)
11092 {
11093   static char buff[32];
11094
11095   switch (type)
11096     {
11097     case SHN_UNDEF:     return "UND";
11098     case SHN_ABS:       return "ABS";
11099     case SHN_COMMON:    return "COM";
11100     default:
11101       if (type == SHN_IA_64_ANSI_COMMON
11102           && filedata->file_header.e_machine == EM_IA_64
11103           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11104         return "ANSI_COM";
11105       else if ((filedata->file_header.e_machine == EM_X86_64
11106                 || filedata->file_header.e_machine == EM_L1OM
11107                 || filedata->file_header.e_machine == EM_K1OM)
11108                && type == SHN_X86_64_LCOMMON)
11109         return "LARGE_COM";
11110       else if ((type == SHN_MIPS_SCOMMON
11111                 && filedata->file_header.e_machine == EM_MIPS)
11112                || (type == SHN_TIC6X_SCOMMON
11113                    && filedata->file_header.e_machine == EM_TI_C6000))
11114         return "SCOM";
11115       else if (type == SHN_MIPS_SUNDEFINED
11116                && filedata->file_header.e_machine == EM_MIPS)
11117         return "SUND";
11118       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11119         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11120       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11121         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11122       else if (type >= SHN_LORESERVE)
11123         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11124       else if (type >= filedata->file_header.e_shnum)
11125         sprintf (buff, _("bad section index[%3d]"), type);
11126       else
11127         sprintf (buff, "%3d", type);
11128       break;
11129     }
11130
11131   return buff;
11132 }
11133
11134 static bfd_vma *
11135 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11136 {
11137   unsigned char * e_data;
11138   bfd_vma * i_data;
11139
11140   /* If the size_t type is smaller than the bfd_size_type, eg because
11141      you are building a 32-bit tool on a 64-bit host, then make sure
11142      that when (number) is cast to (size_t) no information is lost.  */
11143   if (sizeof (size_t) < sizeof (bfd_size_type)
11144       && (bfd_size_type) ((size_t) number) != number)
11145     {
11146       error (_("Size truncation prevents reading %s elements of size %u\n"),
11147              bfd_vmatoa ("u", number), ent_size);
11148       return NULL;
11149     }
11150
11151   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11152      attempting to allocate memory when the read is bound to fail.  */
11153   if (ent_size * number > filedata->file_size)
11154     {
11155       error (_("Invalid number of dynamic entries: %s\n"),
11156              bfd_vmatoa ("u", number));
11157       return NULL;
11158     }
11159
11160   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11161   if (e_data == NULL)
11162     {
11163       error (_("Out of memory reading %s dynamic entries\n"),
11164              bfd_vmatoa ("u", number));
11165       return NULL;
11166     }
11167
11168   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11169     {
11170       error (_("Unable to read in %s bytes of dynamic data\n"),
11171              bfd_vmatoa ("u", number * ent_size));
11172       free (e_data);
11173       return NULL;
11174     }
11175
11176   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11177   if (i_data == NULL)
11178     {
11179       error (_("Out of memory allocating space for %s dynamic entries\n"),
11180              bfd_vmatoa ("u", number));
11181       free (e_data);
11182       return NULL;
11183     }
11184
11185   while (number--)
11186     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11187
11188   free (e_data);
11189
11190   return i_data;
11191 }
11192
11193 static void
11194 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11195 {
11196   Elf_Internal_Sym * psym;
11197   int n;
11198
11199   n = print_vma (si, DEC_5);
11200   if (n < 5)
11201     fputs (&"     "[n], stdout);
11202   printf (" %3lu: ", hn);
11203
11204   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11205     {
11206       printf (_("<No info available for dynamic symbol number %lu>\n"),
11207               (unsigned long) si);
11208       return;
11209     }
11210
11211   psym = dynamic_symbols + si;
11212   print_vma (psym->st_value, LONG_HEX);
11213   putchar (' ');
11214   print_vma (psym->st_size, DEC_5);
11215
11216   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11217   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11218
11219   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11220     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11221   else
11222     {
11223       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11224
11225       printf (" %-7s",  get_symbol_visibility (vis));
11226       /* Check to see if any other bits in the st_other field are set.
11227          Note - displaying this information disrupts the layout of the
11228          table being generated, but for the moment this case is very
11229          rare.  */
11230       if (psym->st_other ^ vis)
11231         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11232     }
11233
11234   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11235   if (VALID_DYNAMIC_NAME (psym->st_name))
11236     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11237   else
11238     printf (_(" <corrupt: %14ld>"), psym->st_name);
11239   putchar ('\n');
11240 }
11241
11242 static const char *
11243 get_symbol_version_string (Filedata *                   filedata,
11244                            bfd_boolean                  is_dynsym,
11245                            const char *                 strtab,
11246                            unsigned long int            strtab_size,
11247                            unsigned int                 si,
11248                            Elf_Internal_Sym *           psym,
11249                            enum versioned_symbol_info * sym_info,
11250                            unsigned short *             vna_other)
11251 {
11252   unsigned char data[2];
11253   unsigned short vers_data;
11254   unsigned long offset;
11255
11256   if (!is_dynsym
11257       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11258     return NULL;
11259
11260   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11261                             sizeof data + si * sizeof (vers_data));
11262
11263   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11264                 sizeof (data), 1, _("version data")) == NULL)
11265     return NULL;
11266
11267   vers_data = byte_get (data, 2);
11268
11269   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11270     return NULL;
11271
11272   /* Usually we'd only see verdef for defined symbols, and verneed for
11273      undefined symbols.  However, symbols defined by the linker in
11274      .dynbss for variables copied from a shared library in order to
11275      avoid text relocations are defined yet have verneed.  We could
11276      use a heuristic to detect the special case, for example, check
11277      for verneed first on symbols defined in SHT_NOBITS sections, but
11278      it is simpler and more reliable to just look for both verdef and
11279      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11280
11281   if (psym->st_shndx != SHN_UNDEF
11282       && vers_data != 0x8001
11283       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11284     {
11285       Elf_Internal_Verdef ivd;
11286       Elf_Internal_Verdaux ivda;
11287       Elf_External_Verdaux evda;
11288       unsigned long off;
11289
11290       off = offset_from_vma (filedata,
11291                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11292                              sizeof (Elf_External_Verdef));
11293
11294       do
11295         {
11296           Elf_External_Verdef evd;
11297
11298           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11299                         _("version def")) == NULL)
11300             {
11301               ivd.vd_ndx = 0;
11302               ivd.vd_aux = 0;
11303               ivd.vd_next = 0;
11304               ivd.vd_flags = 0;
11305             }
11306           else
11307             {
11308               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11309               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11310               ivd.vd_next = BYTE_GET (evd.vd_next);
11311               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11312             }
11313
11314           off += ivd.vd_next;
11315         }
11316       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11317
11318       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11319         {
11320           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11321             return NULL;
11322
11323           off -= ivd.vd_next;
11324           off += ivd.vd_aux;
11325
11326           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11327                         _("version def aux")) != NULL)
11328             {
11329               ivda.vda_name = BYTE_GET (evda.vda_name);
11330
11331               if (psym->st_name != ivda.vda_name)
11332                 {
11333                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11334                                ? symbol_hidden : symbol_public);
11335                   return (ivda.vda_name < strtab_size
11336                           ? strtab + ivda.vda_name : _("<corrupt>"));
11337                 }
11338             }
11339         }
11340     }
11341
11342   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11343     {
11344       Elf_External_Verneed evn;
11345       Elf_Internal_Verneed ivn;
11346       Elf_Internal_Vernaux ivna;
11347
11348       offset = offset_from_vma (filedata,
11349                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11350                                 sizeof evn);
11351       do
11352         {
11353           unsigned long vna_off;
11354
11355           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11356                         _("version need")) == NULL)
11357             {
11358               ivna.vna_next = 0;
11359               ivna.vna_other = 0;
11360               ivna.vna_name = 0;
11361               break;
11362             }
11363
11364           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11365           ivn.vn_next = BYTE_GET (evn.vn_next);
11366
11367           vna_off = offset + ivn.vn_aux;
11368
11369           do
11370             {
11371               Elf_External_Vernaux evna;
11372
11373               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11374                             _("version need aux (3)")) == NULL)
11375                 {
11376                   ivna.vna_next = 0;
11377                   ivna.vna_other = 0;
11378                   ivna.vna_name = 0;
11379                 }
11380               else
11381                 {
11382                   ivna.vna_other = BYTE_GET (evna.vna_other);
11383                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11384                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11385                 }
11386
11387               vna_off += ivna.vna_next;
11388             }
11389           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11390
11391           if (ivna.vna_other == vers_data)
11392             break;
11393
11394           offset += ivn.vn_next;
11395         }
11396       while (ivn.vn_next != 0);
11397
11398       if (ivna.vna_other == vers_data)
11399         {
11400           *sym_info = symbol_undefined;
11401           *vna_other = ivna.vna_other;
11402           return (ivna.vna_name < strtab_size
11403                   ? strtab + ivna.vna_name : _("<corrupt>"));
11404         }
11405     }
11406   return NULL;
11407 }
11408
11409 /* Dump the symbol table.  */
11410 static bfd_boolean
11411 process_symbol_table (Filedata * filedata)
11412 {
11413   Elf_Internal_Shdr * section;
11414   bfd_size_type nbuckets = 0;
11415   bfd_size_type nchains = 0;
11416   bfd_vma * buckets = NULL;
11417   bfd_vma * chains = NULL;
11418   bfd_vma ngnubuckets = 0;
11419   bfd_vma * gnubuckets = NULL;
11420   bfd_vma * gnuchains = NULL;
11421   bfd_vma gnusymidx = 0;
11422   bfd_size_type ngnuchains = 0;
11423
11424   if (!do_syms && !do_dyn_syms && !do_histogram)
11425     return TRUE;
11426
11427   if (dynamic_info[DT_HASH]
11428       && (do_histogram
11429           || (do_using_dynamic
11430               && !do_dyn_syms
11431               && dynamic_strings != NULL)))
11432     {
11433       unsigned char nb[8];
11434       unsigned char nc[8];
11435       unsigned int hash_ent_size = 4;
11436
11437       if ((filedata->file_header.e_machine == EM_ALPHA
11438            || filedata->file_header.e_machine == EM_S390
11439            || filedata->file_header.e_machine == EM_S390_OLD)
11440           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11441         hash_ent_size = 8;
11442
11443       if (fseek (filedata->handle,
11444                  (archive_file_offset
11445                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11446                                      sizeof nb + sizeof nc)),
11447                  SEEK_SET))
11448         {
11449           error (_("Unable to seek to start of dynamic information\n"));
11450           goto no_hash;
11451         }
11452
11453       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11454         {
11455           error (_("Failed to read in number of buckets\n"));
11456           goto no_hash;
11457         }
11458
11459       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11460         {
11461           error (_("Failed to read in number of chains\n"));
11462           goto no_hash;
11463         }
11464
11465       nbuckets = byte_get (nb, hash_ent_size);
11466       nchains  = byte_get (nc, hash_ent_size);
11467
11468       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11469       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11470
11471     no_hash:
11472       if (buckets == NULL || chains == NULL)
11473         {
11474           if (do_using_dynamic)
11475             return FALSE;
11476           free (buckets);
11477           free (chains);
11478           buckets = NULL;
11479           chains = NULL;
11480           nbuckets = 0;
11481           nchains = 0;
11482         }
11483     }
11484
11485   if (dynamic_info_DT_GNU_HASH
11486       && (do_histogram
11487           || (do_using_dynamic
11488               && !do_dyn_syms
11489               && dynamic_strings != NULL)))
11490     {
11491       unsigned char nb[16];
11492       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11493       bfd_vma buckets_vma;
11494
11495       if (fseek (filedata->handle,
11496                  (archive_file_offset
11497                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11498                                      sizeof nb)),
11499                  SEEK_SET))
11500         {
11501           error (_("Unable to seek to start of dynamic information\n"));
11502           goto no_gnu_hash;
11503         }
11504
11505       if (fread (nb, 16, 1, filedata->handle) != 1)
11506         {
11507           error (_("Failed to read in number of buckets\n"));
11508           goto no_gnu_hash;
11509         }
11510
11511       ngnubuckets = byte_get (nb, 4);
11512       gnusymidx = byte_get (nb + 4, 4);
11513       bitmaskwords = byte_get (nb + 8, 4);
11514       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11515       if (is_32bit_elf)
11516         buckets_vma += bitmaskwords * 4;
11517       else
11518         buckets_vma += bitmaskwords * 8;
11519
11520       if (fseek (filedata->handle,
11521                  (archive_file_offset
11522                   + offset_from_vma (filedata, buckets_vma, 4)),
11523                  SEEK_SET))
11524         {
11525           error (_("Unable to seek to start of dynamic information\n"));
11526           goto no_gnu_hash;
11527         }
11528
11529       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11530
11531       if (gnubuckets == NULL)
11532         goto no_gnu_hash;
11533
11534       for (i = 0; i < ngnubuckets; i++)
11535         if (gnubuckets[i] != 0)
11536           {
11537             if (gnubuckets[i] < gnusymidx)
11538               return FALSE;
11539
11540             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11541               maxchain = gnubuckets[i];
11542           }
11543
11544       if (maxchain == 0xffffffff)
11545         goto no_gnu_hash;
11546
11547       maxchain -= gnusymidx;
11548
11549       if (fseek (filedata->handle,
11550                  (archive_file_offset
11551                   + offset_from_vma (filedata, buckets_vma
11552                                            + 4 * (ngnubuckets + maxchain), 4)),
11553                  SEEK_SET))
11554         {
11555           error (_("Unable to seek to start of dynamic information\n"));
11556           goto no_gnu_hash;
11557         }
11558
11559       do
11560         {
11561           if (fread (nb, 4, 1, filedata->handle) != 1)
11562             {
11563               error (_("Failed to determine last chain length\n"));
11564               goto no_gnu_hash;
11565             }
11566
11567           if (maxchain + 1 == 0)
11568             goto no_gnu_hash;
11569
11570           ++maxchain;
11571         }
11572       while ((byte_get (nb, 4) & 1) == 0);
11573
11574       if (fseek (filedata->handle,
11575                  (archive_file_offset
11576                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11577                  SEEK_SET))
11578         {
11579           error (_("Unable to seek to start of dynamic information\n"));
11580           goto no_gnu_hash;
11581         }
11582
11583       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11584       ngnuchains = maxchain;
11585
11586     no_gnu_hash:
11587       if (gnuchains == NULL)
11588         {
11589           free (gnubuckets);
11590           gnubuckets = NULL;
11591           ngnubuckets = 0;
11592           if (do_using_dynamic)
11593             return FALSE;
11594         }
11595     }
11596
11597   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11598       && do_syms
11599       && do_using_dynamic
11600       && dynamic_strings != NULL
11601       && dynamic_symbols != NULL)
11602     {
11603       unsigned long hn;
11604
11605       if (dynamic_info[DT_HASH])
11606         {
11607           bfd_vma si;
11608           char *visited;
11609
11610           printf (_("\nSymbol table for image:\n"));
11611           if (is_32bit_elf)
11612             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11613           else
11614             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11615
11616           visited = xcmalloc (nchains, 1);
11617           memset (visited, 0, nchains);
11618           for (hn = 0; hn < nbuckets; hn++)
11619             {
11620               for (si = buckets[hn]; si > 0; si = chains[si])
11621                 {
11622                   print_dynamic_symbol (filedata, si, hn);
11623                   if (si >= nchains || visited[si])
11624                     {
11625                       error (_("histogram chain is corrupt\n"));
11626                       break;
11627                     }
11628                   visited[si] = 1;
11629                 }
11630             }
11631           free (visited);
11632         }
11633
11634       if (dynamic_info_DT_GNU_HASH)
11635         {
11636           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11637           if (is_32bit_elf)
11638             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11639           else
11640             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11641
11642           for (hn = 0; hn < ngnubuckets; ++hn)
11643             if (gnubuckets[hn] != 0)
11644               {
11645                 bfd_vma si = gnubuckets[hn];
11646                 bfd_vma off = si - gnusymidx;
11647
11648                 do
11649                   {
11650                     print_dynamic_symbol (filedata, si, hn);
11651                     si++;
11652                   }
11653                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11654               }
11655         }
11656     }
11657   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11658            && filedata->section_headers != NULL)
11659     {
11660       unsigned int i;
11661
11662       for (i = 0, section = filedata->section_headers;
11663            i < filedata->file_header.e_shnum;
11664            i++, section++)
11665         {
11666           unsigned int si;
11667           char * strtab = NULL;
11668           unsigned long int strtab_size = 0;
11669           Elf_Internal_Sym * symtab;
11670           Elf_Internal_Sym * psym;
11671           unsigned long num_syms;
11672
11673           if ((section->sh_type != SHT_SYMTAB
11674                && section->sh_type != SHT_DYNSYM)
11675               || (!do_syms
11676                   && section->sh_type == SHT_SYMTAB))
11677             continue;
11678
11679           if (section->sh_entsize == 0)
11680             {
11681               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11682                       printable_section_name (filedata, section));
11683               continue;
11684             }
11685
11686           num_syms = section->sh_size / section->sh_entsize;
11687           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11688                             "\nSymbol table '%s' contains %lu entries:\n",
11689                             num_syms),
11690                   printable_section_name (filedata, section),
11691                   num_syms);
11692
11693           if (is_32bit_elf)
11694             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11695           else
11696             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11697
11698           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11699           if (symtab == NULL)
11700             continue;
11701
11702           if (section->sh_link == filedata->file_header.e_shstrndx)
11703             {
11704               strtab = filedata->string_table;
11705               strtab_size = filedata->string_table_length;
11706             }
11707           else if (section->sh_link < filedata->file_header.e_shnum)
11708             {
11709               Elf_Internal_Shdr * string_sec;
11710
11711               string_sec = filedata->section_headers + section->sh_link;
11712
11713               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11714                                           1, string_sec->sh_size,
11715                                           _("string table"));
11716               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11717             }
11718
11719           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11720             {
11721               const char *version_string;
11722               enum versioned_symbol_info sym_info;
11723               unsigned short vna_other;
11724
11725               printf ("%6d: ", si);
11726               print_vma (psym->st_value, LONG_HEX);
11727               putchar (' ');
11728               print_vma (psym->st_size, DEC_5);
11729               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11730               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11731               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11732                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11733               else
11734                 {
11735                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11736
11737                   printf (" %-7s", get_symbol_visibility (vis));
11738                   /* Check to see if any other bits in the st_other field are set.
11739                      Note - displaying this information disrupts the layout of the
11740                      table being generated, but for the moment this case is very rare.  */
11741                   if (psym->st_other ^ vis)
11742                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11743                 }
11744               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11745               print_symbol (25, psym->st_name < strtab_size
11746                             ? strtab + psym->st_name : _("<corrupt>"));
11747
11748               version_string
11749                 = get_symbol_version_string (filedata,
11750                                              section->sh_type == SHT_DYNSYM,
11751                                              strtab, strtab_size, si,
11752                                              psym, &sym_info, &vna_other);
11753               if (version_string)
11754                 {
11755                   if (sym_info == symbol_undefined)
11756                     printf ("@%s (%d)", version_string, vna_other);
11757                   else
11758                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11759                             version_string);
11760                 }
11761
11762               putchar ('\n');
11763
11764               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11765                   && si >= section->sh_info
11766                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11767                   && filedata->file_header.e_machine != EM_MIPS
11768                   /* Solaris binaries have been found to violate this requirement as
11769                      well.  Not sure if this is a bug or an ABI requirement.  */
11770                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11771                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11772                       si, printable_section_name (filedata, section), section->sh_info);
11773             }
11774
11775           free (symtab);
11776           if (strtab != filedata->string_table)
11777             free (strtab);
11778         }
11779     }
11780   else if (do_syms)
11781     printf
11782       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11783
11784   if (do_histogram && buckets != NULL)
11785     {
11786       unsigned long * lengths;
11787       unsigned long * counts;
11788       unsigned long hn;
11789       bfd_vma si;
11790       unsigned long maxlength = 0;
11791       unsigned long nzero_counts = 0;
11792       unsigned long nsyms = 0;
11793       char *visited;
11794
11795       printf (ngettext ("\nHistogram for bucket list length "
11796                         "(total of %lu bucket):\n",
11797                         "\nHistogram for bucket list length "
11798                         "(total of %lu buckets):\n",
11799                         (unsigned long) nbuckets),
11800               (unsigned long) nbuckets);
11801
11802       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11803       if (lengths == NULL)
11804         {
11805           error (_("Out of memory allocating space for histogram buckets\n"));
11806           return FALSE;
11807         }
11808       visited = xcmalloc (nchains, 1);
11809       memset (visited, 0, nchains);
11810
11811       printf (_(" Length  Number     %% of total  Coverage\n"));
11812       for (hn = 0; hn < nbuckets; ++hn)
11813         {
11814           for (si = buckets[hn]; si > 0; si = chains[si])
11815             {
11816               ++nsyms;
11817               if (maxlength < ++lengths[hn])
11818                 ++maxlength;
11819               if (si >= nchains || visited[si])
11820                 {
11821                   error (_("histogram chain is corrupt\n"));
11822                   break;
11823                 }
11824               visited[si] = 1;
11825             }
11826         }
11827       free (visited);
11828
11829       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11830       if (counts == NULL)
11831         {
11832           free (lengths);
11833           error (_("Out of memory allocating space for histogram counts\n"));
11834           return FALSE;
11835         }
11836
11837       for (hn = 0; hn < nbuckets; ++hn)
11838         ++counts[lengths[hn]];
11839
11840       if (nbuckets > 0)
11841         {
11842           unsigned long i;
11843           printf ("      0  %-10lu (%5.1f%%)\n",
11844                   counts[0], (counts[0] * 100.0) / nbuckets);
11845           for (i = 1; i <= maxlength; ++i)
11846             {
11847               nzero_counts += counts[i] * i;
11848               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11849                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11850                       (nzero_counts * 100.0) / nsyms);
11851             }
11852         }
11853
11854       free (counts);
11855       free (lengths);
11856     }
11857
11858   if (buckets != NULL)
11859     {
11860       free (buckets);
11861       free (chains);
11862     }
11863
11864   if (do_histogram && gnubuckets != NULL)
11865     {
11866       unsigned long * lengths;
11867       unsigned long * counts;
11868       unsigned long hn;
11869       unsigned long maxlength = 0;
11870       unsigned long nzero_counts = 0;
11871       unsigned long nsyms = 0;
11872
11873       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11874                         "(total of %lu bucket):\n",
11875                         "\nHistogram for `.gnu.hash' bucket list length "
11876                         "(total of %lu buckets):\n",
11877                         (unsigned long) ngnubuckets),
11878               (unsigned long) ngnubuckets);
11879
11880       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11881       if (lengths == NULL)
11882         {
11883           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11884           return FALSE;
11885         }
11886
11887       printf (_(" Length  Number     %% of total  Coverage\n"));
11888
11889       for (hn = 0; hn < ngnubuckets; ++hn)
11890         if (gnubuckets[hn] != 0)
11891           {
11892             bfd_vma off, length = 1;
11893
11894             for (off = gnubuckets[hn] - gnusymidx;
11895                  /* PR 17531 file: 010-77222-0.004.  */
11896                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11897                  ++off)
11898               ++length;
11899             lengths[hn] = length;
11900             if (length > maxlength)
11901               maxlength = length;
11902             nsyms += length;
11903           }
11904
11905       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11906       if (counts == NULL)
11907         {
11908           free (lengths);
11909           error (_("Out of memory allocating space for gnu histogram counts\n"));
11910           return FALSE;
11911         }
11912
11913       for (hn = 0; hn < ngnubuckets; ++hn)
11914         ++counts[lengths[hn]];
11915
11916       if (ngnubuckets > 0)
11917         {
11918           unsigned long j;
11919           printf ("      0  %-10lu (%5.1f%%)\n",
11920                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11921           for (j = 1; j <= maxlength; ++j)
11922             {
11923               nzero_counts += counts[j] * j;
11924               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11925                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11926                       (nzero_counts * 100.0) / nsyms);
11927             }
11928         }
11929
11930       free (counts);
11931       free (lengths);
11932       free (gnubuckets);
11933       free (gnuchains);
11934     }
11935
11936   return TRUE;
11937 }
11938
11939 static bfd_boolean
11940 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11941 {
11942   unsigned int i;
11943
11944   if (dynamic_syminfo == NULL
11945       || !do_dynamic)
11946     /* No syminfo, this is ok.  */
11947     return TRUE;
11948
11949   /* There better should be a dynamic symbol section.  */
11950   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11951     return FALSE;
11952
11953   if (dynamic_addr)
11954     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11955                       "contains %d entry:\n",
11956                       "\nDynamic info segment at offset 0x%lx "
11957                       "contains %d entries:\n",
11958                       dynamic_syminfo_nent),
11959             dynamic_syminfo_offset, dynamic_syminfo_nent);
11960
11961   printf (_(" Num: Name                           BoundTo     Flags\n"));
11962   for (i = 0; i < dynamic_syminfo_nent; ++i)
11963     {
11964       unsigned short int flags = dynamic_syminfo[i].si_flags;
11965
11966       printf ("%4d: ", i);
11967       if (i >= num_dynamic_syms)
11968         printf (_("<corrupt index>"));
11969       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11970         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11971       else
11972         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11973       putchar (' ');
11974
11975       switch (dynamic_syminfo[i].si_boundto)
11976         {
11977         case SYMINFO_BT_SELF:
11978           fputs ("SELF       ", stdout);
11979           break;
11980         case SYMINFO_BT_PARENT:
11981           fputs ("PARENT     ", stdout);
11982           break;
11983         default:
11984           if (dynamic_syminfo[i].si_boundto > 0
11985               && dynamic_syminfo[i].si_boundto < dynamic_nent
11986               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11987             {
11988               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11989               putchar (' ' );
11990             }
11991           else
11992             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11993           break;
11994         }
11995
11996       if (flags & SYMINFO_FLG_DIRECT)
11997         printf (" DIRECT");
11998       if (flags & SYMINFO_FLG_PASSTHRU)
11999         printf (" PASSTHRU");
12000       if (flags & SYMINFO_FLG_COPY)
12001         printf (" COPY");
12002       if (flags & SYMINFO_FLG_LAZYLOAD)
12003         printf (" LAZYLOAD");
12004
12005       puts ("");
12006     }
12007
12008   return TRUE;
12009 }
12010
12011 #define IN_RANGE(START,END,ADDR,OFF)            \
12012   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12013
12014 /* Check to see if the given reloc needs to be handled in a target specific
12015    manner.  If so then process the reloc and return TRUE otherwise return
12016    FALSE.
12017
12018    If called with reloc == NULL, then this is a signal that reloc processing
12019    for the current section has finished, and any saved state should be
12020    discarded.  */
12021
12022 static bfd_boolean
12023 target_specific_reloc_handling (Filedata *           filedata,
12024                                 Elf_Internal_Rela *  reloc,
12025                                 unsigned char *      start,
12026                                 unsigned char *      end,
12027                                 Elf_Internal_Sym *   symtab,
12028                                 unsigned long        num_syms)
12029 {
12030   unsigned int reloc_type = 0;
12031   unsigned long sym_index = 0;
12032
12033   if (reloc)
12034     {
12035       reloc_type = get_reloc_type (filedata, reloc->r_info);
12036       sym_index = get_reloc_symindex (reloc->r_info);
12037     }
12038
12039   switch (filedata->file_header.e_machine)
12040     {
12041     case EM_MSP430:
12042     case EM_MSP430_OLD:
12043       {
12044         static Elf_Internal_Sym * saved_sym = NULL;
12045
12046         if (reloc == NULL)
12047           {
12048             saved_sym = NULL;
12049             return TRUE;
12050           }
12051
12052         switch (reloc_type)
12053           {
12054           case 10: /* R_MSP430_SYM_DIFF */
12055             if (uses_msp430x_relocs (filedata))
12056               break;
12057             /* Fall through.  */
12058           case 21: /* R_MSP430X_SYM_DIFF */
12059             /* PR 21139.  */
12060             if (sym_index >= num_syms)
12061               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12062                      sym_index);
12063             else
12064               saved_sym = symtab + sym_index;
12065             return TRUE;
12066
12067           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12068           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12069             goto handle_sym_diff;
12070
12071           case 5: /* R_MSP430_16_BYTE */
12072           case 9: /* R_MSP430_8 */
12073             if (uses_msp430x_relocs (filedata))
12074               break;
12075             goto handle_sym_diff;
12076
12077           case 2: /* R_MSP430_ABS16 */
12078           case 15: /* R_MSP430X_ABS16 */
12079             if (! uses_msp430x_relocs (filedata))
12080               break;
12081             goto handle_sym_diff;
12082
12083           handle_sym_diff:
12084             if (saved_sym != NULL)
12085               {
12086                 int reloc_size = reloc_type == 1 ? 4 : 2;
12087                 bfd_vma value;
12088
12089                 if (sym_index >= num_syms)
12090                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12091                          sym_index);
12092                 else
12093                   {
12094                     value = reloc->r_addend + (symtab[sym_index].st_value
12095                                                - saved_sym->st_value);
12096
12097                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12098                       byte_put (start + reloc->r_offset, value, reloc_size);
12099                     else
12100                       /* PR 21137 */
12101                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12102                              (long) reloc->r_offset);
12103                   }
12104
12105                 saved_sym = NULL;
12106                 return TRUE;
12107               }
12108             break;
12109
12110           default:
12111             if (saved_sym != NULL)
12112               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12113             break;
12114           }
12115         break;
12116       }
12117
12118     case EM_MN10300:
12119     case EM_CYGNUS_MN10300:
12120       {
12121         static Elf_Internal_Sym * saved_sym = NULL;
12122
12123         if (reloc == NULL)
12124           {
12125             saved_sym = NULL;
12126             return TRUE;
12127           }
12128
12129         switch (reloc_type)
12130           {
12131           case 34: /* R_MN10300_ALIGN */
12132             return TRUE;
12133           case 33: /* R_MN10300_SYM_DIFF */
12134             if (sym_index >= num_syms)
12135               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12136                      sym_index);
12137             else
12138               saved_sym = symtab + sym_index;
12139             return TRUE;
12140
12141           case 1: /* R_MN10300_32 */
12142           case 2: /* R_MN10300_16 */
12143             if (saved_sym != NULL)
12144               {
12145                 int reloc_size = reloc_type == 1 ? 4 : 2;
12146                 bfd_vma value;
12147
12148                 if (sym_index >= num_syms)
12149                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12150                          sym_index);
12151                 else
12152                   {
12153                     value = reloc->r_addend + (symtab[sym_index].st_value
12154                                                - saved_sym->st_value);
12155
12156                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12157                       byte_put (start + reloc->r_offset, value, reloc_size);
12158                     else
12159                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12160                              (long) reloc->r_offset);
12161                   }
12162
12163                 saved_sym = NULL;
12164                 return TRUE;
12165               }
12166             break;
12167           default:
12168             if (saved_sym != NULL)
12169               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12170             break;
12171           }
12172         break;
12173       }
12174
12175     case EM_RL78:
12176       {
12177         static bfd_vma saved_sym1 = 0;
12178         static bfd_vma saved_sym2 = 0;
12179         static bfd_vma value;
12180
12181         if (reloc == NULL)
12182           {
12183             saved_sym1 = saved_sym2 = 0;
12184             return TRUE;
12185           }
12186
12187         switch (reloc_type)
12188           {
12189           case 0x80: /* R_RL78_SYM.  */
12190             saved_sym1 = saved_sym2;
12191             if (sym_index >= num_syms)
12192               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12193                      sym_index);
12194             else
12195               {
12196                 saved_sym2 = symtab[sym_index].st_value;
12197                 saved_sym2 += reloc->r_addend;
12198               }
12199             return TRUE;
12200
12201           case 0x83: /* R_RL78_OPsub.  */
12202             value = saved_sym1 - saved_sym2;
12203             saved_sym2 = saved_sym1 = 0;
12204             return TRUE;
12205             break;
12206
12207           case 0x41: /* R_RL78_ABS32.  */
12208             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12209               byte_put (start + reloc->r_offset, value, 4);
12210             else
12211               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12212                      (long) reloc->r_offset);
12213             value = 0;
12214             return TRUE;
12215
12216           case 0x43: /* R_RL78_ABS16.  */
12217             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12218               byte_put (start + reloc->r_offset, value, 2);
12219             else
12220               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12221                      (long) reloc->r_offset);
12222             value = 0;
12223             return TRUE;
12224
12225           default:
12226             break;
12227           }
12228         break;
12229       }
12230     }
12231
12232   return FALSE;
12233 }
12234
12235 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12236    DWARF debug sections.  This is a target specific test.  Note - we do not
12237    go through the whole including-target-headers-multiple-times route, (as
12238    we have already done with <elf/h8.h>) because this would become very
12239    messy and even then this function would have to contain target specific
12240    information (the names of the relocs instead of their numeric values).
12241    FIXME: This is not the correct way to solve this problem.  The proper way
12242    is to have target specific reloc sizing and typing functions created by
12243    the reloc-macros.h header, in the same way that it already creates the
12244    reloc naming functions.  */
12245
12246 static bfd_boolean
12247 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12248 {
12249   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12250   switch (filedata->file_header.e_machine)
12251     {
12252     case EM_386:
12253     case EM_IAMCU:
12254       return reloc_type == 1; /* R_386_32.  */
12255     case EM_68K:
12256       return reloc_type == 1; /* R_68K_32.  */
12257     case EM_860:
12258       return reloc_type == 1; /* R_860_32.  */
12259     case EM_960:
12260       return reloc_type == 2; /* R_960_32.  */
12261     case EM_AARCH64:
12262       return (reloc_type == 258
12263               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12264     case EM_ADAPTEVA_EPIPHANY:
12265       return reloc_type == 3;
12266     case EM_ALPHA:
12267       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12268     case EM_ARC:
12269       return reloc_type == 1; /* R_ARC_32.  */
12270     case EM_ARC_COMPACT:
12271     case EM_ARC_COMPACT2:
12272       return reloc_type == 4; /* R_ARC_32.  */
12273     case EM_ARM:
12274       return reloc_type == 2; /* R_ARM_ABS32 */
12275     case EM_AVR_OLD:
12276     case EM_AVR:
12277       return reloc_type == 1;
12278     case EM_BLACKFIN:
12279       return reloc_type == 0x12; /* R_byte4_data.  */
12280     case EM_CRIS:
12281       return reloc_type == 3; /* R_CRIS_32.  */
12282     case EM_CR16:
12283       return reloc_type == 3; /* R_CR16_NUM32.  */
12284     case EM_CRX:
12285       return reloc_type == 15; /* R_CRX_NUM32.  */
12286     case EM_CYGNUS_FRV:
12287       return reloc_type == 1;
12288     case EM_CYGNUS_D10V:
12289     case EM_D10V:
12290       return reloc_type == 6; /* R_D10V_32.  */
12291     case EM_CYGNUS_D30V:
12292     case EM_D30V:
12293       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12294     case EM_DLX:
12295       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12296     case EM_CYGNUS_FR30:
12297     case EM_FR30:
12298       return reloc_type == 3; /* R_FR30_32.  */
12299     case EM_FT32:
12300       return reloc_type == 1; /* R_FT32_32.  */
12301     case EM_H8S:
12302     case EM_H8_300:
12303     case EM_H8_300H:
12304       return reloc_type == 1; /* R_H8_DIR32.  */
12305     case EM_IA_64:
12306       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12307               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12308               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12309               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12310     case EM_IP2K_OLD:
12311     case EM_IP2K:
12312       return reloc_type == 2; /* R_IP2K_32.  */
12313     case EM_IQ2000:
12314       return reloc_type == 2; /* R_IQ2000_32.  */
12315     case EM_LATTICEMICO32:
12316       return reloc_type == 3; /* R_LM32_32.  */
12317     case EM_M32C_OLD:
12318     case EM_M32C:
12319       return reloc_type == 3; /* R_M32C_32.  */
12320     case EM_M32R:
12321       return reloc_type == 34; /* R_M32R_32_RELA.  */
12322     case EM_68HC11:
12323     case EM_68HC12:
12324       return reloc_type == 6; /* R_M68HC11_32.  */
12325     case EM_S12Z:
12326       return reloc_type == 6; /* R_S12Z_EXT32.  */
12327     case EM_MCORE:
12328       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12329     case EM_CYGNUS_MEP:
12330       return reloc_type == 4; /* R_MEP_32.  */
12331     case EM_METAG:
12332       return reloc_type == 2; /* R_METAG_ADDR32.  */
12333     case EM_MICROBLAZE:
12334       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12335     case EM_MIPS:
12336       return reloc_type == 2; /* R_MIPS_32.  */
12337     case EM_MMIX:
12338       return reloc_type == 4; /* R_MMIX_32.  */
12339     case EM_CYGNUS_MN10200:
12340     case EM_MN10200:
12341       return reloc_type == 1; /* R_MN10200_32.  */
12342     case EM_CYGNUS_MN10300:
12343     case EM_MN10300:
12344       return reloc_type == 1; /* R_MN10300_32.  */
12345     case EM_MOXIE:
12346       return reloc_type == 1; /* R_MOXIE_32.  */
12347     case EM_MSP430_OLD:
12348     case EM_MSP430:
12349       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12350     case EM_MT:
12351       return reloc_type == 2; /* R_MT_32.  */
12352     case EM_NDS32:
12353       return reloc_type == 20; /* R_NDS32_RELA.  */
12354     case EM_ALTERA_NIOS2:
12355       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12356     case EM_NIOS32:
12357       return reloc_type == 1; /* R_NIOS_32.  */
12358     case EM_OR1K:
12359       return reloc_type == 1; /* R_OR1K_32.  */
12360     case EM_PARISC:
12361       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12362               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12363               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12364     case EM_PJ:
12365     case EM_PJ_OLD:
12366       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12367     case EM_PPC64:
12368       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12369     case EM_PPC:
12370       return reloc_type == 1; /* R_PPC_ADDR32.  */
12371     case EM_TI_PRU:
12372       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12373     case EM_RISCV:
12374       return reloc_type == 1; /* R_RISCV_32.  */
12375     case EM_RL78:
12376       return reloc_type == 1; /* R_RL78_DIR32.  */
12377     case EM_RX:
12378       return reloc_type == 1; /* R_RX_DIR32.  */
12379     case EM_S370:
12380       return reloc_type == 1; /* R_I370_ADDR31.  */
12381     case EM_S390_OLD:
12382     case EM_S390:
12383       return reloc_type == 4; /* R_S390_32.  */
12384     case EM_SCORE:
12385       return reloc_type == 8; /* R_SCORE_ABS32.  */
12386     case EM_SH:
12387       return reloc_type == 1; /* R_SH_DIR32.  */
12388     case EM_SPARC32PLUS:
12389     case EM_SPARCV9:
12390     case EM_SPARC:
12391       return reloc_type == 3 /* R_SPARC_32.  */
12392         || reloc_type == 23; /* R_SPARC_UA32.  */
12393     case EM_SPU:
12394       return reloc_type == 6; /* R_SPU_ADDR32 */
12395     case EM_TI_C6000:
12396       return reloc_type == 1; /* R_C6000_ABS32.  */
12397     case EM_TILEGX:
12398       return reloc_type == 2; /* R_TILEGX_32.  */
12399     case EM_TILEPRO:
12400       return reloc_type == 1; /* R_TILEPRO_32.  */
12401     case EM_CYGNUS_V850:
12402     case EM_V850:
12403       return reloc_type == 6; /* R_V850_ABS32.  */
12404     case EM_V800:
12405       return reloc_type == 0x33; /* R_V810_WORD.  */
12406     case EM_VAX:
12407       return reloc_type == 1; /* R_VAX_32.  */
12408     case EM_VISIUM:
12409       return reloc_type == 3;  /* R_VISIUM_32. */
12410     case EM_WEBASSEMBLY:
12411       return reloc_type == 1;  /* R_WASM32_32.  */
12412     case EM_X86_64:
12413     case EM_L1OM:
12414     case EM_K1OM:
12415       return reloc_type == 10; /* R_X86_64_32.  */
12416     case EM_XC16X:
12417     case EM_C166:
12418       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12419     case EM_XGATE:
12420       return reloc_type == 4; /* R_XGATE_32.  */
12421     case EM_XSTORMY16:
12422       return reloc_type == 1; /* R_XSTROMY16_32.  */
12423     case EM_XTENSA_OLD:
12424     case EM_XTENSA:
12425       return reloc_type == 1; /* R_XTENSA_32.  */
12426     default:
12427       {
12428         static unsigned int prev_warn = 0;
12429
12430         /* Avoid repeating the same warning multiple times.  */
12431         if (prev_warn != filedata->file_header.e_machine)
12432           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12433                  filedata->file_header.e_machine);
12434         prev_warn = filedata->file_header.e_machine;
12435         return FALSE;
12436       }
12437     }
12438 }
12439
12440 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12441    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12442
12443 static bfd_boolean
12444 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12445 {
12446   switch (filedata->file_header.e_machine)
12447   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12448     {
12449     case EM_386:
12450     case EM_IAMCU:
12451       return reloc_type == 2;  /* R_386_PC32.  */
12452     case EM_68K:
12453       return reloc_type == 4;  /* R_68K_PC32.  */
12454     case EM_AARCH64:
12455       return reloc_type == 261; /* R_AARCH64_PREL32 */
12456     case EM_ADAPTEVA_EPIPHANY:
12457       return reloc_type == 6;
12458     case EM_ALPHA:
12459       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12460     case EM_ARC_COMPACT:
12461     case EM_ARC_COMPACT2:
12462       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12463     case EM_ARM:
12464       return reloc_type == 3;  /* R_ARM_REL32 */
12465     case EM_AVR_OLD:
12466     case EM_AVR:
12467       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12468     case EM_MICROBLAZE:
12469       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12470     case EM_OR1K:
12471       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12472     case EM_PARISC:
12473       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12474     case EM_PPC:
12475       return reloc_type == 26; /* R_PPC_REL32.  */
12476     case EM_PPC64:
12477       return reloc_type == 26; /* R_PPC64_REL32.  */
12478     case EM_S390_OLD:
12479     case EM_S390:
12480       return reloc_type == 5;  /* R_390_PC32.  */
12481     case EM_SH:
12482       return reloc_type == 2;  /* R_SH_REL32.  */
12483     case EM_SPARC32PLUS:
12484     case EM_SPARCV9:
12485     case EM_SPARC:
12486       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12487     case EM_SPU:
12488       return reloc_type == 13; /* R_SPU_REL32.  */
12489     case EM_TILEGX:
12490       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12491     case EM_TILEPRO:
12492       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12493     case EM_VISIUM:
12494       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12495     case EM_X86_64:
12496     case EM_L1OM:
12497     case EM_K1OM:
12498       return reloc_type == 2;  /* R_X86_64_PC32.  */
12499     case EM_XTENSA_OLD:
12500     case EM_XTENSA:
12501       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12502     default:
12503       /* Do not abort or issue an error message here.  Not all targets use
12504          pc-relative 32-bit relocs in their DWARF debug information and we
12505          have already tested for target coverage in is_32bit_abs_reloc.  A
12506          more helpful warning message will be generated by apply_relocations
12507          anyway, so just return.  */
12508       return FALSE;
12509     }
12510 }
12511
12512 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12513    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12514
12515 static bfd_boolean
12516 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12517 {
12518   switch (filedata->file_header.e_machine)
12519     {
12520     case EM_AARCH64:
12521       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12522     case EM_ALPHA:
12523       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12524     case EM_IA_64:
12525       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12526               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12527     case EM_PARISC:
12528       return reloc_type == 80; /* R_PARISC_DIR64.  */
12529     case EM_PPC64:
12530       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12531     case EM_RISCV:
12532       return reloc_type == 2; /* R_RISCV_64.  */
12533     case EM_SPARC32PLUS:
12534     case EM_SPARCV9:
12535     case EM_SPARC:
12536       return reloc_type == 32 /* R_SPARC_64.  */
12537         || reloc_type == 54; /* R_SPARC_UA64.  */
12538     case EM_X86_64:
12539     case EM_L1OM:
12540     case EM_K1OM:
12541       return reloc_type == 1; /* R_X86_64_64.  */
12542     case EM_S390_OLD:
12543     case EM_S390:
12544       return reloc_type == 22;  /* R_S390_64.  */
12545     case EM_TILEGX:
12546       return reloc_type == 1; /* R_TILEGX_64.  */
12547     case EM_MIPS:
12548       return reloc_type == 18;  /* R_MIPS_64.  */
12549     default:
12550       return FALSE;
12551     }
12552 }
12553
12554 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12555    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12556
12557 static bfd_boolean
12558 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12559 {
12560   switch (filedata->file_header.e_machine)
12561     {
12562     case EM_AARCH64:
12563       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12564     case EM_ALPHA:
12565       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12566     case EM_IA_64:
12567       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12568               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12569     case EM_PARISC:
12570       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12571     case EM_PPC64:
12572       return reloc_type == 44; /* R_PPC64_REL64.  */
12573     case EM_SPARC32PLUS:
12574     case EM_SPARCV9:
12575     case EM_SPARC:
12576       return reloc_type == 46; /* R_SPARC_DISP64.  */
12577     case EM_X86_64:
12578     case EM_L1OM:
12579     case EM_K1OM:
12580       return reloc_type == 24; /* R_X86_64_PC64.  */
12581     case EM_S390_OLD:
12582     case EM_S390:
12583       return reloc_type == 23;  /* R_S390_PC64.  */
12584     case EM_TILEGX:
12585       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12586     default:
12587       return FALSE;
12588     }
12589 }
12590
12591 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12592    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12593
12594 static bfd_boolean
12595 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12596 {
12597   switch (filedata->file_header.e_machine)
12598     {
12599     case EM_CYGNUS_MN10200:
12600     case EM_MN10200:
12601       return reloc_type == 4; /* R_MN10200_24.  */
12602     case EM_FT32:
12603       return reloc_type == 5; /* R_FT32_20.  */
12604     default:
12605       return FALSE;
12606     }
12607 }
12608
12609 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12610    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12611
12612 static bfd_boolean
12613 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12614 {
12615   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12616   switch (filedata->file_header.e_machine)
12617     {
12618     case EM_ARC:
12619     case EM_ARC_COMPACT:
12620     case EM_ARC_COMPACT2:
12621       return reloc_type == 2; /* R_ARC_16.  */
12622     case EM_ADAPTEVA_EPIPHANY:
12623       return reloc_type == 5;
12624     case EM_AVR_OLD:
12625     case EM_AVR:
12626       return reloc_type == 4; /* R_AVR_16.  */
12627     case EM_CYGNUS_D10V:
12628     case EM_D10V:
12629       return reloc_type == 3; /* R_D10V_16.  */
12630     case EM_FT32:
12631       return reloc_type == 2; /* R_FT32_16.  */
12632     case EM_H8S:
12633     case EM_H8_300:
12634     case EM_H8_300H:
12635       return reloc_type == R_H8_DIR16;
12636     case EM_IP2K_OLD:
12637     case EM_IP2K:
12638       return reloc_type == 1; /* R_IP2K_16.  */
12639     case EM_M32C_OLD:
12640     case EM_M32C:
12641       return reloc_type == 1; /* R_M32C_16 */
12642     case EM_CYGNUS_MN10200:
12643     case EM_MN10200:
12644       return reloc_type == 2; /* R_MN10200_16.  */
12645     case EM_CYGNUS_MN10300:
12646     case EM_MN10300:
12647       return reloc_type == 2; /* R_MN10300_16.  */
12648     case EM_MSP430:
12649       if (uses_msp430x_relocs (filedata))
12650         return reloc_type == 2; /* R_MSP430_ABS16.  */
12651       /* Fall through.  */
12652     case EM_MSP430_OLD:
12653       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12654     case EM_NDS32:
12655       return reloc_type == 19; /* R_NDS32_RELA.  */
12656     case EM_ALTERA_NIOS2:
12657       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12658     case EM_NIOS32:
12659       return reloc_type == 9; /* R_NIOS_16.  */
12660     case EM_OR1K:
12661       return reloc_type == 2; /* R_OR1K_16.  */
12662     case EM_RISCV:
12663       return reloc_type == 55; /* R_RISCV_SET16.  */
12664     case EM_TI_PRU:
12665       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12666     case EM_TI_C6000:
12667       return reloc_type == 2; /* R_C6000_ABS16.  */
12668     case EM_VISIUM:
12669       return reloc_type == 2; /* R_VISIUM_16. */
12670     case EM_XC16X:
12671     case EM_C166:
12672       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12673     case EM_XGATE:
12674       return reloc_type == 3; /* R_XGATE_16.  */
12675     default:
12676       return FALSE;
12677     }
12678 }
12679
12680 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12681    a 8-bit absolute RELA relocation used in DWARF debug sections.  */
12682
12683 static bfd_boolean
12684 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12685 {
12686   switch (filedata->file_header.e_machine)
12687     {
12688     case EM_RISCV:
12689       return reloc_type == 54; /* R_RISCV_SET8.  */
12690     default:
12691       return FALSE;
12692     }
12693 }
12694
12695 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12696    a 6-bit absolute RELA relocation used in DWARF debug sections.  */
12697
12698 static bfd_boolean
12699 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12700 {
12701   switch (filedata->file_header.e_machine)
12702     {
12703     case EM_RISCV:
12704       return reloc_type == 53; /* R_RISCV_SET6.  */
12705     default:
12706       return FALSE;
12707     }
12708 }
12709
12710 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12711    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12712
12713 static bfd_boolean
12714 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12715 {
12716   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12717   switch (filedata->file_header.e_machine)
12718     {
12719     case EM_RISCV:
12720       return reloc_type == 35; /* R_RISCV_ADD32.  */
12721     default:
12722       return FALSE;
12723     }
12724 }
12725
12726 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12727    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12728
12729 static bfd_boolean
12730 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12731 {
12732   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12733   switch (filedata->file_header.e_machine)
12734     {
12735     case EM_RISCV:
12736       return reloc_type == 39; /* R_RISCV_SUB32.  */
12737     default:
12738       return FALSE;
12739     }
12740 }
12741
12742 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12743    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12744
12745 static bfd_boolean
12746 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12747 {
12748   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12749   switch (filedata->file_header.e_machine)
12750     {
12751     case EM_RISCV:
12752       return reloc_type == 36; /* R_RISCV_ADD64.  */
12753     default:
12754       return FALSE;
12755     }
12756 }
12757
12758 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12759    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12760
12761 static bfd_boolean
12762 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12763 {
12764   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12765   switch (filedata->file_header.e_machine)
12766     {
12767     case EM_RISCV:
12768       return reloc_type == 40; /* R_RISCV_SUB64.  */
12769     default:
12770       return FALSE;
12771     }
12772 }
12773
12774 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12775    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12776
12777 static bfd_boolean
12778 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12779 {
12780   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12781   switch (filedata->file_header.e_machine)
12782     {
12783     case EM_RISCV:
12784       return reloc_type == 34; /* R_RISCV_ADD16.  */
12785     default:
12786       return FALSE;
12787     }
12788 }
12789
12790 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12791    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12792
12793 static bfd_boolean
12794 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12795 {
12796   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12797   switch (filedata->file_header.e_machine)
12798     {
12799     case EM_RISCV:
12800       return reloc_type == 38; /* R_RISCV_SUB16.  */
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 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12808
12809 static bfd_boolean
12810 is_8bit_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 == 33; /* R_RISCV_ADD8.  */
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 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12824
12825 static bfd_boolean
12826 is_8bit_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 == 37; /* R_RISCV_SUB8.  */
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 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
12840
12841 static bfd_boolean
12842 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12843 {
12844   switch (filedata->file_header.e_machine)
12845     {
12846     case EM_RISCV:
12847       return reloc_type == 52; /* R_RISCV_SUB6.  */
12848     default:
12849       return FALSE;
12850     }
12851 }
12852
12853 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12854    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12855
12856 static bfd_boolean
12857 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12858 {
12859   switch (filedata->file_header.e_machine)
12860     {
12861     case EM_386:     /* R_386_NONE.  */
12862     case EM_68K:     /* R_68K_NONE.  */
12863     case EM_ADAPTEVA_EPIPHANY:
12864     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12865     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12866     case EM_ARC:     /* R_ARC_NONE.  */
12867     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12868     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12869     case EM_ARM:     /* R_ARM_NONE.  */
12870     case EM_C166:    /* R_XC16X_NONE.  */
12871     case EM_CRIS:    /* R_CRIS_NONE.  */
12872     case EM_FT32:    /* R_FT32_NONE.  */
12873     case EM_IA_64:   /* R_IA64_NONE.  */
12874     case EM_K1OM:    /* R_X86_64_NONE.  */
12875     case EM_L1OM:    /* R_X86_64_NONE.  */
12876     case EM_M32R:    /* R_M32R_NONE.  */
12877     case EM_MIPS:    /* R_MIPS_NONE.  */
12878     case EM_MN10300: /* R_MN10300_NONE.  */
12879     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12880     case EM_NIOS32:  /* R_NIOS_NONE.  */
12881     case EM_OR1K:    /* R_OR1K_NONE. */
12882     case EM_PARISC:  /* R_PARISC_NONE.  */
12883     case EM_PPC64:   /* R_PPC64_NONE.  */
12884     case EM_PPC:     /* R_PPC_NONE.  */
12885     case EM_RISCV:   /* R_RISCV_NONE.  */
12886     case EM_S390:    /* R_390_NONE.  */
12887     case EM_S390_OLD:
12888     case EM_SH:      /* R_SH_NONE.  */
12889     case EM_SPARC32PLUS:
12890     case EM_SPARC:   /* R_SPARC_NONE.  */
12891     case EM_SPARCV9:
12892     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12893     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12894     case EM_TI_C6000:/* R_C6000_NONE.  */
12895     case EM_X86_64:  /* R_X86_64_NONE.  */
12896     case EM_XC16X:
12897     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12898       return reloc_type == 0;
12899
12900     case EM_AARCH64:
12901       return reloc_type == 0 || reloc_type == 256;
12902     case EM_AVR_OLD:
12903     case EM_AVR:
12904       return (reloc_type == 0 /* R_AVR_NONE.  */
12905               || reloc_type == 30 /* R_AVR_DIFF8.  */
12906               || reloc_type == 31 /* R_AVR_DIFF16.  */
12907               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12908     case EM_METAG:
12909       return reloc_type == 3; /* R_METAG_NONE.  */
12910     case EM_NDS32:
12911       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12912               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12913               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12914               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12915               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12916     case EM_TI_PRU:
12917       return (reloc_type == 0       /* R_PRU_NONE.  */
12918               || reloc_type == 65   /* R_PRU_DIFF8.  */
12919               || reloc_type == 66   /* R_PRU_DIFF16.  */
12920               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12921     case EM_XTENSA_OLD:
12922     case EM_XTENSA:
12923       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12924               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12925               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12926               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12927     }
12928   return FALSE;
12929 }
12930
12931 /* Returns TRUE if there is a relocation against
12932    section NAME at OFFSET bytes.  */
12933
12934 bfd_boolean
12935 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12936 {
12937   Elf_Internal_Rela * relocs;
12938   Elf_Internal_Rela * rp;
12939
12940   if (dsec == NULL || dsec->reloc_info == NULL)
12941     return FALSE;
12942
12943   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12944
12945   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12946     if (rp->r_offset == offset)
12947       return TRUE;
12948
12949    return FALSE;
12950 }
12951
12952 /* Apply relocations to a section.
12953    Returns TRUE upon success, FALSE otherwise.
12954    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12955    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12956    will be set to the number of relocs loaded.
12957
12958    Note: So far support has been added only for those relocations
12959    which can be found in debug sections. FIXME: Add support for
12960    more relocations ?  */
12961
12962 static bfd_boolean
12963 apply_relocations (Filedata *                 filedata,
12964                    const Elf_Internal_Shdr *  section,
12965                    unsigned char *            start,
12966                    bfd_size_type              size,
12967                    void **                    relocs_return,
12968                    unsigned long *            num_relocs_return)
12969 {
12970   Elf_Internal_Shdr * relsec;
12971   unsigned char * end = start + size;
12972   bfd_boolean res = TRUE;
12973
12974   if (relocs_return != NULL)
12975     {
12976       * (Elf_Internal_Rela **) relocs_return = NULL;
12977       * num_relocs_return = 0;
12978     }
12979
12980   if (filedata->file_header.e_type != ET_REL)
12981     /* No relocs to apply.  */
12982     return TRUE;
12983
12984   /* Find the reloc section associated with the section.  */
12985   for (relsec = filedata->section_headers;
12986        relsec < filedata->section_headers + filedata->file_header.e_shnum;
12987        ++relsec)
12988     {
12989       bfd_boolean is_rela;
12990       unsigned long num_relocs;
12991       Elf_Internal_Rela * relocs;
12992       Elf_Internal_Rela * rp;
12993       Elf_Internal_Shdr * symsec;
12994       Elf_Internal_Sym * symtab;
12995       unsigned long num_syms;
12996       Elf_Internal_Sym * sym;
12997
12998       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12999           || relsec->sh_info >= filedata->file_header.e_shnum
13000           || filedata->section_headers + relsec->sh_info != section
13001           || relsec->sh_size == 0
13002           || relsec->sh_link >= filedata->file_header.e_shnum)
13003         continue;
13004
13005       is_rela = relsec->sh_type == SHT_RELA;
13006
13007       if (is_rela)
13008         {
13009           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13010                                   relsec->sh_size, & relocs, & num_relocs))
13011             return FALSE;
13012         }
13013       else
13014         {
13015           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13016                                  relsec->sh_size, & relocs, & num_relocs))
13017             return FALSE;
13018         }
13019
13020       /* SH uses RELA but uses in place value instead of the addend field.  */
13021       if (filedata->file_header.e_machine == EM_SH)
13022         is_rela = FALSE;
13023
13024       symsec = filedata->section_headers + relsec->sh_link;
13025       if (symsec->sh_type != SHT_SYMTAB
13026           && symsec->sh_type != SHT_DYNSYM)
13027         return FALSE;
13028       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13029
13030       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13031         {
13032           bfd_vma         addend;
13033           unsigned int    reloc_type;
13034           unsigned int    reloc_size;
13035           bfd_boolean     reloc_inplace = FALSE;
13036           bfd_boolean     reloc_subtract = FALSE;
13037           unsigned char * rloc;
13038           unsigned long   sym_index;
13039
13040           reloc_type = get_reloc_type (filedata, rp->r_info);
13041
13042           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13043             continue;
13044           else if (is_none_reloc (filedata, reloc_type))
13045             continue;
13046           else if (is_32bit_abs_reloc (filedata, reloc_type)
13047                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13048             reloc_size = 4;
13049           else if (is_64bit_abs_reloc (filedata, reloc_type)
13050                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13051             reloc_size = 8;
13052           else if (is_24bit_abs_reloc (filedata, reloc_type))
13053             reloc_size = 3;
13054           else if (is_16bit_abs_reloc (filedata, reloc_type))
13055             reloc_size = 2;
13056           else if (is_8bit_abs_reloc (filedata, reloc_type)
13057                    || is_6bit_abs_reloc (filedata, reloc_type))
13058             reloc_size = 1;
13059           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13060                                                                  reloc_type))
13061                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13062             {
13063               reloc_size = 4;
13064               reloc_inplace = TRUE;
13065             }
13066           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13067                                                                  reloc_type))
13068                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13069             {
13070               reloc_size = 8;
13071               reloc_inplace = TRUE;
13072             }
13073           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13074                                                                  reloc_type))
13075                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13076             {
13077               reloc_size = 2;
13078               reloc_inplace = TRUE;
13079             }
13080           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13081                                                                 reloc_type))
13082                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13083             {
13084               reloc_size = 1;
13085               reloc_inplace = TRUE;
13086             }
13087           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13088                                                                 reloc_type)))
13089             {
13090               reloc_size = 1;
13091               reloc_inplace = TRUE;
13092             }
13093           else
13094             {
13095               static unsigned int prev_reloc = 0;
13096
13097               if (reloc_type != prev_reloc)
13098                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13099                       reloc_type, printable_section_name (filedata, section));
13100               prev_reloc = reloc_type;
13101               res = FALSE;
13102               continue;
13103             }
13104
13105           rloc = start + rp->r_offset;
13106           if ((rloc + reloc_size) > end || (rloc < start))
13107             {
13108               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13109                     (unsigned long) rp->r_offset,
13110                     printable_section_name (filedata, section));
13111               res = FALSE;
13112               continue;
13113             }
13114
13115           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13116           if (sym_index >= num_syms)
13117             {
13118               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13119                     sym_index, printable_section_name (filedata, section));
13120               res = FALSE;
13121               continue;
13122             }
13123           sym = symtab + sym_index;
13124
13125           /* If the reloc has a symbol associated with it,
13126              make sure that it is of an appropriate type.
13127
13128              Relocations against symbols without type can happen.
13129              Gcc -feliminate-dwarf2-dups may generate symbols
13130              without type for debug info.
13131
13132              Icc generates relocations against function symbols
13133              instead of local labels.
13134
13135              Relocations against object symbols can happen, eg when
13136              referencing a global array.  For an example of this see
13137              the _clz.o binary in libgcc.a.  */
13138           if (sym != symtab
13139               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13140               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13141             {
13142               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13143                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13144                     printable_section_name (filedata, relsec),
13145                     (long int)(rp - relocs));
13146               res = FALSE;
13147               continue;
13148             }
13149
13150           addend = 0;
13151           if (is_rela)
13152             addend += rp->r_addend;
13153           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13154              partial_inplace.  */
13155           if (!is_rela
13156               || (filedata->file_header.e_machine == EM_XTENSA
13157                   && reloc_type == 1)
13158               || ((filedata->file_header.e_machine == EM_PJ
13159                    || filedata->file_header.e_machine == EM_PJ_OLD)
13160                   && reloc_type == 1)
13161               || ((filedata->file_header.e_machine == EM_D30V
13162                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13163                   && reloc_type == 12)
13164               || reloc_inplace)
13165             {
13166               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13167                 addend += byte_get (rloc, reloc_size) & 0x3f;
13168               else
13169                 addend += byte_get (rloc, reloc_size);
13170             }
13171
13172           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13173               || is_64bit_pcrel_reloc (filedata, reloc_type))
13174             {
13175               /* On HPPA, all pc-relative relocations are biased by 8.  */
13176               if (filedata->file_header.e_machine == EM_PARISC)
13177                 addend -= 8;
13178               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13179                         reloc_size);
13180             }
13181           else if (is_6bit_abs_reloc (filedata, reloc_type)
13182                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13183             {
13184               if (reloc_subtract)
13185                 addend -= sym->st_value;
13186               else
13187                 addend += sym->st_value;
13188               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13189               byte_put (rloc, addend, reloc_size);
13190             }
13191           else if (reloc_subtract)
13192             byte_put (rloc, addend - sym->st_value, reloc_size);
13193           else
13194             byte_put (rloc, addend + sym->st_value, reloc_size);
13195         }
13196
13197       free (symtab);
13198       /* Let the target specific reloc processing code know that
13199          we have finished with these relocs.  */
13200       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13201
13202       if (relocs_return)
13203         {
13204           * (Elf_Internal_Rela **) relocs_return = relocs;
13205           * num_relocs_return = num_relocs;
13206         }
13207       else
13208         free (relocs);
13209
13210       break;
13211     }
13212
13213   return res;
13214 }
13215
13216 #ifdef SUPPORT_DISASSEMBLY
13217 static bfd_boolean
13218 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13219 {
13220   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13221
13222   /* FIXME: XXX -- to be done --- XXX */
13223
13224   return TRUE;
13225 }
13226 #endif
13227
13228 /* Reads in the contents of SECTION from FILE, returning a pointer
13229    to a malloc'ed buffer or NULL if something went wrong.  */
13230
13231 static char *
13232 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13233 {
13234   bfd_size_type num_bytes = section->sh_size;
13235
13236   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13237     {
13238       printf (_("Section '%s' has no data to dump.\n"),
13239               printable_section_name (filedata, section));
13240       return NULL;
13241     }
13242
13243   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13244                              _("section contents"));
13245 }
13246
13247 /* Uncompresses a section that was compressed using zlib, in place.  */
13248
13249 static bfd_boolean
13250 uncompress_section_contents (unsigned char **   buffer,
13251                              dwarf_size_type    uncompressed_size,
13252                              dwarf_size_type *  size)
13253 {
13254   dwarf_size_type compressed_size = *size;
13255   unsigned char * compressed_buffer = *buffer;
13256   unsigned char * uncompressed_buffer;
13257   z_stream strm;
13258   int rc;
13259
13260   /* It is possible the section consists of several compressed
13261      buffers concatenated together, so we uncompress in a loop.  */
13262   /* PR 18313: The state field in the z_stream structure is supposed
13263      to be invisible to the user (ie us), but some compilers will
13264      still complain about it being used without initialisation.  So
13265      we first zero the entire z_stream structure and then set the fields
13266      that we need.  */
13267   memset (& strm, 0, sizeof strm);
13268   strm.avail_in = compressed_size;
13269   strm.next_in = (Bytef *) compressed_buffer;
13270   strm.avail_out = uncompressed_size;
13271   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13272
13273   rc = inflateInit (& strm);
13274   while (strm.avail_in > 0)
13275     {
13276       if (rc != Z_OK)
13277         goto fail;
13278       strm.next_out = ((Bytef *) uncompressed_buffer
13279                        + (uncompressed_size - strm.avail_out));
13280       rc = inflate (&strm, Z_FINISH);
13281       if (rc != Z_STREAM_END)
13282         goto fail;
13283       rc = inflateReset (& strm);
13284     }
13285   rc = inflateEnd (& strm);
13286   if (rc != Z_OK
13287       || strm.avail_out != 0)
13288     goto fail;
13289
13290   *buffer = uncompressed_buffer;
13291   *size = uncompressed_size;
13292   return TRUE;
13293
13294  fail:
13295   free (uncompressed_buffer);
13296   /* Indicate decompression failure.  */
13297   *buffer = NULL;
13298   return FALSE;
13299 }
13300
13301 static bfd_boolean
13302 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13303 {
13304   Elf_Internal_Shdr *  relsec;
13305   bfd_size_type        num_bytes;
13306   unsigned char *      data;
13307   unsigned char *      end;
13308   unsigned char *      real_start;
13309   unsigned char *      start;
13310   bfd_boolean          some_strings_shown;
13311
13312   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13313   if (start == NULL)
13314     /* PR 21820: Do not fail if the section was empty.  */
13315     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13316
13317   num_bytes = section->sh_size;
13318
13319   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13320
13321   if (decompress_dumps)
13322     {
13323       dwarf_size_type new_size = num_bytes;
13324       dwarf_size_type uncompressed_size = 0;
13325
13326       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13327         {
13328           Elf_Internal_Chdr chdr;
13329           unsigned int compression_header_size
13330             = get_compression_header (& chdr, (unsigned char *) start,
13331                                       num_bytes);
13332
13333           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13334             {
13335               warn (_("section '%s' has unsupported compress type: %d\n"),
13336                     printable_section_name (filedata, section), chdr.ch_type);
13337               return FALSE;
13338             }
13339           else if (chdr.ch_addralign != section->sh_addralign)
13340             {
13341               warn (_("compressed section '%s' is corrupted\n"),
13342                     printable_section_name (filedata, section));
13343               return FALSE;
13344             }
13345           uncompressed_size = chdr.ch_size;
13346           start += compression_header_size;
13347           new_size -= compression_header_size;
13348         }
13349       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13350         {
13351           /* Read the zlib header.  In this case, it should be "ZLIB"
13352              followed by the uncompressed section size, 8 bytes in
13353              big-endian order.  */
13354           uncompressed_size = start[4]; uncompressed_size <<= 8;
13355           uncompressed_size += start[5]; uncompressed_size <<= 8;
13356           uncompressed_size += start[6]; uncompressed_size <<= 8;
13357           uncompressed_size += start[7]; uncompressed_size <<= 8;
13358           uncompressed_size += start[8]; uncompressed_size <<= 8;
13359           uncompressed_size += start[9]; uncompressed_size <<= 8;
13360           uncompressed_size += start[10]; uncompressed_size <<= 8;
13361           uncompressed_size += start[11];
13362           start += 12;
13363           new_size -= 12;
13364         }
13365
13366       if (uncompressed_size)
13367         {
13368           if (uncompress_section_contents (& start,
13369                                            uncompressed_size, & new_size))
13370             num_bytes = new_size;
13371           else
13372             {
13373               error (_("Unable to decompress section %s\n"),
13374                      printable_section_name (filedata, section));
13375               return FALSE;
13376             }
13377         }
13378       else
13379         start = real_start;
13380     }
13381
13382   /* If the section being dumped has relocations against it the user might
13383      be expecting these relocations to have been applied.  Check for this
13384      case and issue a warning message in order to avoid confusion.
13385      FIXME: Maybe we ought to have an option that dumps a section with
13386      relocs applied ?  */
13387   for (relsec = filedata->section_headers;
13388        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13389        ++relsec)
13390     {
13391       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13392           || relsec->sh_info >= filedata->file_header.e_shnum
13393           || filedata->section_headers + relsec->sh_info != section
13394           || relsec->sh_size == 0
13395           || relsec->sh_link >= filedata->file_header.e_shnum)
13396         continue;
13397
13398       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13399       break;
13400     }
13401
13402   data = start;
13403   end  = start + num_bytes;
13404   some_strings_shown = FALSE;
13405
13406   while (data < end)
13407     {
13408       while (!ISPRINT (* data))
13409         if (++ data >= end)
13410           break;
13411
13412       if (data < end)
13413         {
13414           size_t maxlen = end - data;
13415
13416 #ifndef __MSVCRT__
13417           /* PR 11128: Use two separate invocations in order to work
13418              around bugs in the Solaris 8 implementation of printf.  */
13419           printf ("  [%6tx]  ", data - start);
13420 #else
13421           printf ("  [%6Ix]  ", (size_t) (data - start));
13422 #endif
13423           if (maxlen > 0)
13424             {
13425               print_symbol ((int) maxlen, (const char *) data);
13426               putchar ('\n');
13427               data += strnlen ((const char *) data, maxlen);
13428             }
13429           else
13430             {
13431               printf (_("<corrupt>\n"));
13432               data = end;
13433             }
13434           some_strings_shown = TRUE;
13435         }
13436     }
13437
13438   if (! some_strings_shown)
13439     printf (_("  No strings found in this section."));
13440
13441   free (real_start);
13442
13443   putchar ('\n');
13444   return TRUE;
13445 }
13446
13447 static bfd_boolean
13448 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13449                        Filedata *           filedata,
13450                        bfd_boolean          relocate)
13451 {
13452   Elf_Internal_Shdr * relsec;
13453   bfd_size_type       bytes;
13454   bfd_size_type       section_size;
13455   bfd_vma             addr;
13456   unsigned char *     data;
13457   unsigned char *     real_start;
13458   unsigned char *     start;
13459
13460   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13461   if (start == NULL)
13462     /* PR 21820: Do not fail if the section was empty.  */
13463     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13464
13465   section_size = section->sh_size;
13466
13467   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13468
13469   if (decompress_dumps)
13470     {
13471       dwarf_size_type new_size = section_size;
13472       dwarf_size_type uncompressed_size = 0;
13473
13474       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13475         {
13476           Elf_Internal_Chdr chdr;
13477           unsigned int compression_header_size
13478             = get_compression_header (& chdr, start, section_size);
13479
13480           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13481             {
13482               warn (_("section '%s' has unsupported compress type: %d\n"),
13483                     printable_section_name (filedata, section), chdr.ch_type);
13484               return FALSE;
13485             }
13486           else if (chdr.ch_addralign != section->sh_addralign)
13487             {
13488               warn (_("compressed section '%s' is corrupted\n"),
13489                     printable_section_name (filedata, section));
13490               return FALSE;
13491             }
13492           uncompressed_size = chdr.ch_size;
13493           start += compression_header_size;
13494           new_size -= compression_header_size;
13495         }
13496       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13497         {
13498           /* Read the zlib header.  In this case, it should be "ZLIB"
13499              followed by the uncompressed section size, 8 bytes in
13500              big-endian order.  */
13501           uncompressed_size = start[4]; uncompressed_size <<= 8;
13502           uncompressed_size += start[5]; uncompressed_size <<= 8;
13503           uncompressed_size += start[6]; uncompressed_size <<= 8;
13504           uncompressed_size += start[7]; uncompressed_size <<= 8;
13505           uncompressed_size += start[8]; uncompressed_size <<= 8;
13506           uncompressed_size += start[9]; uncompressed_size <<= 8;
13507           uncompressed_size += start[10]; uncompressed_size <<= 8;
13508           uncompressed_size += start[11];
13509           start += 12;
13510           new_size -= 12;
13511         }
13512
13513       if (uncompressed_size)
13514         {
13515           if (uncompress_section_contents (& start, uncompressed_size,
13516                                            & new_size))
13517             {
13518               section_size = new_size;
13519             }
13520           else
13521             {
13522               error (_("Unable to decompress section %s\n"),
13523                      printable_section_name (filedata, section));
13524               /* FIXME: Print the section anyway ?  */
13525               return FALSE;
13526             }
13527         }
13528       else
13529         start = real_start;
13530     }
13531
13532   if (relocate)
13533     {
13534       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13535         return FALSE;
13536     }
13537   else
13538     {
13539       /* If the section being dumped has relocations against it the user might
13540          be expecting these relocations to have been applied.  Check for this
13541          case and issue a warning message in order to avoid confusion.
13542          FIXME: Maybe we ought to have an option that dumps a section with
13543          relocs applied ?  */
13544       for (relsec = filedata->section_headers;
13545            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13546            ++relsec)
13547         {
13548           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13549               || relsec->sh_info >= filedata->file_header.e_shnum
13550               || filedata->section_headers + relsec->sh_info != section
13551               || relsec->sh_size == 0
13552               || relsec->sh_link >= filedata->file_header.e_shnum)
13553             continue;
13554
13555           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13556           break;
13557         }
13558     }
13559
13560   addr = section->sh_addr;
13561   bytes = section_size;
13562   data = start;
13563
13564   while (bytes)
13565     {
13566       int j;
13567       int k;
13568       int lbytes;
13569
13570       lbytes = (bytes > 16 ? 16 : bytes);
13571
13572       printf ("  0x%8.8lx ", (unsigned long) addr);
13573
13574       for (j = 0; j < 16; j++)
13575         {
13576           if (j < lbytes)
13577             printf ("%2.2x", data[j]);
13578           else
13579             printf ("  ");
13580
13581           if ((j & 3) == 3)
13582             printf (" ");
13583         }
13584
13585       for (j = 0; j < lbytes; j++)
13586         {
13587           k = data[j];
13588           if (k >= ' ' && k < 0x7f)
13589             printf ("%c", k);
13590           else
13591             printf (".");
13592         }
13593
13594       putchar ('\n');
13595
13596       data  += lbytes;
13597       addr  += lbytes;
13598       bytes -= lbytes;
13599     }
13600
13601   free (real_start);
13602
13603   putchar ('\n');
13604   return TRUE;
13605 }
13606
13607 static bfd_boolean
13608 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13609                              const Elf_Internal_Shdr *        sec,
13610                              void *                           data)
13611 {
13612   struct dwarf_section * section = &debug_displays [debug].section;
13613   char buf [64];
13614   Filedata * filedata = (Filedata *) data;
13615
13616   if (section->start != NULL)
13617     {
13618       /* If it is already loaded, do nothing.  */
13619       if (streq (section->filename, filedata->file_name))
13620         return TRUE;
13621       free (section->start);
13622     }
13623
13624   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13625   section->address = sec->sh_addr;
13626   section->user_data = NULL;
13627   section->filename = filedata->file_name;
13628   section->start = (unsigned char *) get_data (NULL, filedata,
13629                                                sec->sh_offset, 1,
13630                                                sec->sh_size, buf);
13631   if (section->start == NULL)
13632     section->size = 0;
13633   else
13634     {
13635       unsigned char *start = section->start;
13636       dwarf_size_type size = sec->sh_size;
13637       dwarf_size_type uncompressed_size = 0;
13638
13639       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13640         {
13641           Elf_Internal_Chdr chdr;
13642           unsigned int compression_header_size;
13643
13644           if (size < (is_32bit_elf
13645                       ? sizeof (Elf32_External_Chdr)
13646                       : sizeof (Elf64_External_Chdr)))
13647             {
13648               warn (_("compressed section %s is too small to contain a compression header"),
13649                     section->name);
13650               return FALSE;
13651             }
13652
13653           compression_header_size = get_compression_header (&chdr, start, size);
13654
13655           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13656             {
13657               warn (_("section '%s' has unsupported compress type: %d\n"),
13658                     section->name, chdr.ch_type);
13659               return FALSE;
13660             }
13661           else if (chdr.ch_addralign != sec->sh_addralign)
13662             {
13663               warn (_("compressed section '%s' is corrupted\n"),
13664                     section->name);
13665               return FALSE;
13666             }
13667           uncompressed_size = chdr.ch_size;
13668           start += compression_header_size;
13669           size -= compression_header_size;
13670         }
13671       else if (size > 12 && streq ((char *) start, "ZLIB"))
13672         {
13673           /* Read the zlib header.  In this case, it should be "ZLIB"
13674              followed by the uncompressed section size, 8 bytes in
13675              big-endian order.  */
13676           uncompressed_size = start[4]; uncompressed_size <<= 8;
13677           uncompressed_size += start[5]; uncompressed_size <<= 8;
13678           uncompressed_size += start[6]; uncompressed_size <<= 8;
13679           uncompressed_size += start[7]; uncompressed_size <<= 8;
13680           uncompressed_size += start[8]; uncompressed_size <<= 8;
13681           uncompressed_size += start[9]; uncompressed_size <<= 8;
13682           uncompressed_size += start[10]; uncompressed_size <<= 8;
13683           uncompressed_size += start[11];
13684           start += 12;
13685           size -= 12;
13686         }
13687
13688       if (uncompressed_size)
13689         {
13690           if (uncompress_section_contents (&start, uncompressed_size,
13691                                            &size))
13692             {
13693               /* Free the compressed buffer, update the section buffer
13694                  and the section size if uncompress is successful.  */
13695               free (section->start);
13696               section->start = start;
13697             }
13698           else
13699             {
13700               error (_("Unable to decompress section %s\n"),
13701                      printable_section_name (filedata, sec));
13702               return FALSE;
13703             }
13704         }
13705
13706       section->size = size;
13707     }
13708
13709   if (section->start == NULL)
13710     return FALSE;
13711
13712   if (debug_displays [debug].relocate)
13713     {
13714       if (! apply_relocations (filedata, sec, section->start, section->size,
13715                                & section->reloc_info, & section->num_relocs))
13716         return FALSE;
13717     }
13718   else
13719     {
13720       section->reloc_info = NULL;
13721       section->num_relocs = 0;
13722     }
13723
13724   return TRUE;
13725 }
13726
13727 /* If this is not NULL, load_debug_section will only look for sections
13728    within the list of sections given here.  */
13729 static unsigned int * section_subset = NULL;
13730
13731 bfd_boolean
13732 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13733 {
13734   struct dwarf_section * section = &debug_displays [debug].section;
13735   Elf_Internal_Shdr * sec;
13736   Filedata * filedata = (Filedata *) data;
13737
13738   /* Without section headers we cannot find any sections.  */
13739   if (filedata->section_headers == NULL)
13740     return FALSE;
13741
13742   if (filedata->string_table == NULL
13743       && filedata->file_header.e_shstrndx != SHN_UNDEF
13744       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13745     {
13746       Elf_Internal_Shdr * strs;
13747
13748       /* Read in the string table, so that we have section names to scan.  */
13749       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13750
13751       if (strs != NULL && strs->sh_size != 0)
13752         {
13753           filedata->string_table
13754             = (char *) get_data (NULL, filedata, strs->sh_offset,
13755                                  1, strs->sh_size, _("string table"));
13756
13757           filedata->string_table_length
13758             = filedata->string_table != NULL ? strs->sh_size : 0;
13759         }
13760     }
13761
13762   /* Locate the debug section.  */
13763   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13764   if (sec != NULL)
13765     section->name = section->uncompressed_name;
13766   else
13767     {
13768       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13769       if (sec != NULL)
13770         section->name = section->compressed_name;
13771     }
13772   if (sec == NULL)
13773     return FALSE;
13774
13775   /* If we're loading from a subset of sections, and we've loaded
13776      a section matching this name before, it's likely that it's a
13777      different one.  */
13778   if (section_subset != NULL)
13779     free_debug_section (debug);
13780
13781   return load_specific_debug_section (debug, sec, data);
13782 }
13783
13784 void
13785 free_debug_section (enum dwarf_section_display_enum debug)
13786 {
13787   struct dwarf_section * section = &debug_displays [debug].section;
13788
13789   if (section->start == NULL)
13790     return;
13791
13792   free ((char *) section->start);
13793   section->start = NULL;
13794   section->address = 0;
13795   section->size = 0;
13796 }
13797
13798 static bfd_boolean
13799 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13800 {
13801   char * name = SECTION_NAME (section);
13802   const char * print_name = printable_section_name (filedata, section);
13803   bfd_size_type length;
13804   bfd_boolean result = TRUE;
13805   int i;
13806
13807   length = section->sh_size;
13808   if (length == 0)
13809     {
13810       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13811       return TRUE;
13812     }
13813   if (section->sh_type == SHT_NOBITS)
13814     {
13815       /* There is no point in dumping the contents of a debugging section
13816          which has the NOBITS type - the bits in the file will be random.
13817          This can happen when a file containing a .eh_frame section is
13818          stripped with the --only-keep-debug command line option.  */
13819       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13820               print_name);
13821       return FALSE;
13822     }
13823
13824   if (const_strneq (name, ".gnu.linkonce.wi."))
13825     name = ".debug_info";
13826
13827   /* See if we know how to display the contents of this section.  */
13828   for (i = 0; i < max; i++)
13829     {
13830       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13831       struct dwarf_section_display *   display = debug_displays + i;
13832       struct dwarf_section *           sec = & display->section;
13833
13834       if (streq (sec->uncompressed_name, name)
13835           || (id == line && const_strneq (name, ".debug_line."))
13836           || streq (sec->compressed_name, name))
13837         {
13838           bfd_boolean secondary = (section != find_section (filedata, name));
13839
13840           if (secondary)
13841             free_debug_section (id);
13842
13843           if (i == line && const_strneq (name, ".debug_line."))
13844             sec->name = name;
13845           else if (streq (sec->uncompressed_name, name))
13846             sec->name = sec->uncompressed_name;
13847           else
13848             sec->name = sec->compressed_name;
13849
13850           if (load_specific_debug_section (id, section, filedata))
13851             {
13852               /* If this debug section is part of a CU/TU set in a .dwp file,
13853                  restrict load_debug_section to the sections in that set.  */
13854               section_subset = find_cu_tu_set (filedata, shndx);
13855
13856               result &= display->display (sec, filedata);
13857
13858               section_subset = NULL;
13859
13860               if (secondary || (id != info && id != abbrev))
13861                 free_debug_section (id);
13862             }
13863           break;
13864         }
13865     }
13866
13867   if (i == max)
13868     {
13869       printf (_("Unrecognized debug section: %s\n"), print_name);
13870       result = FALSE;
13871     }
13872
13873   return result;
13874 }
13875
13876 /* Set DUMP_SECTS for all sections where dumps were requested
13877    based on section name.  */
13878
13879 static void
13880 initialise_dumps_byname (Filedata * filedata)
13881 {
13882   struct dump_list_entry * cur;
13883
13884   for (cur = dump_sects_byname; cur; cur = cur->next)
13885     {
13886       unsigned int i;
13887       bfd_boolean any = FALSE;
13888
13889       for (i = 0; i < filedata->file_header.e_shnum; i++)
13890         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13891           {
13892             request_dump_bynumber (filedata, i, cur->type);
13893             any = TRUE;
13894           }
13895
13896       if (!any)
13897         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13898               cur->name);
13899     }
13900 }
13901
13902 static bfd_boolean
13903 process_section_contents (Filedata * filedata)
13904 {
13905   Elf_Internal_Shdr * section;
13906   unsigned int i;
13907   bfd_boolean res = TRUE;
13908
13909   if (! do_dump)
13910     return TRUE;
13911
13912   initialise_dumps_byname (filedata);
13913
13914   for (i = 0, section = filedata->section_headers;
13915        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13916        i++, section++)
13917     {
13918       dump_type dump = filedata->dump_sects[i];
13919
13920 #ifdef SUPPORT_DISASSEMBLY
13921       if (dump & DISASS_DUMP)
13922         {
13923           if (! disassemble_section (section, filedata))
13924             res = FALSE;
13925         }
13926 #endif
13927       if (dump & HEX_DUMP)
13928         {
13929           if (! dump_section_as_bytes (section, filedata, FALSE))
13930             res = FALSE;
13931         }
13932
13933       if (dump & RELOC_DUMP)
13934         {
13935           if (! dump_section_as_bytes (section, filedata, TRUE))
13936             res = FALSE;
13937         }
13938
13939       if (dump & STRING_DUMP)
13940         {
13941           if (! dump_section_as_strings (section, filedata))
13942             res = FALSE;
13943         }
13944
13945       if (dump & DEBUG_DUMP)
13946         {
13947           if (! display_debug_section (i, section, filedata))
13948             res = FALSE;
13949         }
13950     }
13951
13952   /* Check to see if the user requested a
13953      dump of a section that does not exist.  */
13954   while (i < filedata->num_dump_sects)
13955     {
13956       if (filedata->dump_sects[i])
13957         {
13958           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13959           res = FALSE;
13960         }
13961       i++;
13962     }
13963
13964   return res;
13965 }
13966
13967 static void
13968 process_mips_fpe_exception (int mask)
13969 {
13970   if (mask)
13971     {
13972       bfd_boolean first = TRUE;
13973
13974       if (mask & OEX_FPU_INEX)
13975         fputs ("INEX", stdout), first = FALSE;
13976       if (mask & OEX_FPU_UFLO)
13977         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13978       if (mask & OEX_FPU_OFLO)
13979         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13980       if (mask & OEX_FPU_DIV0)
13981         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13982       if (mask & OEX_FPU_INVAL)
13983         printf ("%sINVAL", first ? "" : "|");
13984     }
13985   else
13986     fputs ("0", stdout);
13987 }
13988
13989 /* Display's the value of TAG at location P.  If TAG is
13990    greater than 0 it is assumed to be an unknown tag, and
13991    a message is printed to this effect.  Otherwise it is
13992    assumed that a message has already been printed.
13993
13994    If the bottom bit of TAG is set it assumed to have a
13995    string value, otherwise it is assumed to have an integer
13996    value.
13997
13998    Returns an updated P pointing to the first unread byte
13999    beyond the end of TAG's value.
14000
14001    Reads at or beyond END will not be made.  */
14002
14003 static unsigned char *
14004 display_tag_value (signed int tag,
14005                    unsigned char * p,
14006                    const unsigned char * const end)
14007 {
14008   unsigned long val;
14009
14010   if (tag > 0)
14011     printf ("  Tag_unknown_%d: ", tag);
14012
14013   if (p >= end)
14014     {
14015       warn (_("<corrupt tag>\n"));
14016     }
14017   else if (tag & 1)
14018     {
14019       /* PR 17531 file: 027-19978-0.004.  */
14020       size_t maxlen = (end - p) - 1;
14021
14022       putchar ('"');
14023       if (maxlen > 0)
14024         {
14025           print_symbol ((int) maxlen, (const char *) p);
14026           p += strnlen ((char *) p, maxlen) + 1;
14027         }
14028       else
14029         {
14030           printf (_("<corrupt string tag>"));
14031           p = (unsigned char *) end;
14032         }
14033       printf ("\"\n");
14034     }
14035   else
14036     {
14037       unsigned int len;
14038
14039       val = read_uleb128 (p, &len, end);
14040       p += len;
14041       printf ("%ld (0x%lx)\n", val, val);
14042     }
14043
14044   assert (p <= end);
14045   return p;
14046 }
14047
14048 /* ARC ABI attributes section.  */
14049
14050 static unsigned char *
14051 display_arc_attribute (unsigned char * p,
14052                        const unsigned char * const end)
14053 {
14054   unsigned int tag;
14055   unsigned int len;
14056   unsigned int val;
14057
14058   tag = read_uleb128 (p, &len, end);
14059   p += len;
14060
14061   switch (tag)
14062     {
14063     case Tag_ARC_PCS_config:
14064       val = read_uleb128 (p, &len, end);
14065       p += len;
14066       printf ("  Tag_ARC_PCS_config: ");
14067       switch (val)
14068         {
14069         case 0:
14070           printf (_("Absent/Non standard\n"));
14071           break;
14072         case 1:
14073           printf (_("Bare metal/mwdt\n"));
14074           break;
14075         case 2:
14076           printf (_("Bare metal/newlib\n"));
14077           break;
14078         case 3:
14079           printf (_("Linux/uclibc\n"));
14080           break;
14081         case 4:
14082           printf (_("Linux/glibc\n"));
14083           break;
14084         default:
14085           printf (_("Unknown\n"));
14086           break;
14087         }
14088       break;
14089
14090     case Tag_ARC_CPU_base:
14091       val = read_uleb128 (p, &len, end);
14092       p += len;
14093       printf ("  Tag_ARC_CPU_base: ");
14094       switch (val)
14095         {
14096         default:
14097         case TAG_CPU_NONE:
14098           printf (_("Absent\n"));
14099           break;
14100         case TAG_CPU_ARC6xx:
14101           printf ("ARC6xx\n");
14102           break;
14103         case TAG_CPU_ARC7xx:
14104           printf ("ARC7xx\n");
14105           break;
14106         case TAG_CPU_ARCEM:
14107           printf ("ARCEM\n");
14108           break;
14109         case TAG_CPU_ARCHS:
14110           printf ("ARCHS\n");
14111           break;
14112         }
14113       break;
14114
14115     case Tag_ARC_CPU_variation:
14116       val = read_uleb128 (p, &len, end);
14117       p += len;
14118       printf ("  Tag_ARC_CPU_variation: ");
14119       switch (val)
14120         {
14121         default:
14122           if (val > 0 && val < 16)
14123               printf ("Core%d\n", val);
14124           else
14125               printf ("Unknown\n");
14126           break;
14127
14128         case 0:
14129           printf (_("Absent\n"));
14130           break;
14131         }
14132       break;
14133
14134     case Tag_ARC_CPU_name:
14135       printf ("  Tag_ARC_CPU_name: ");
14136       p = display_tag_value (-1, p, end);
14137       break;
14138
14139     case Tag_ARC_ABI_rf16:
14140       val = read_uleb128 (p, &len, end);
14141       p += len;
14142       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14143       break;
14144
14145     case Tag_ARC_ABI_osver:
14146       val = read_uleb128 (p, &len, end);
14147       p += len;
14148       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14149       break;
14150
14151     case Tag_ARC_ABI_pic:
14152     case Tag_ARC_ABI_sda:
14153       val = read_uleb128 (p, &len, end);
14154       p += len;
14155       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14156               : "  Tag_ARC_ABI_pic: ");
14157       switch (val)
14158         {
14159         case 0:
14160           printf (_("Absent\n"));
14161           break;
14162         case 1:
14163           printf ("MWDT\n");
14164           break;
14165         case 2:
14166           printf ("GNU\n");
14167           break;
14168         default:
14169           printf (_("Unknown\n"));
14170           break;
14171         }
14172       break;
14173
14174     case Tag_ARC_ABI_tls:
14175       val = read_uleb128 (p, &len, end);
14176       p += len;
14177       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14178       break;
14179
14180     case Tag_ARC_ABI_enumsize:
14181       val = read_uleb128 (p, &len, end);
14182       p += len;
14183       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14184               _("smallest"));
14185       break;
14186
14187     case Tag_ARC_ABI_exceptions:
14188       val = read_uleb128 (p, &len, end);
14189       p += len;
14190       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14191               : _("default"));
14192       break;
14193
14194     case Tag_ARC_ABI_double_size:
14195       val = read_uleb128 (p, &len, end);
14196       p += len;
14197       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14198       break;
14199
14200     case Tag_ARC_ISA_config:
14201       printf ("  Tag_ARC_ISA_config: ");
14202       p = display_tag_value (-1, p, end);
14203       break;
14204
14205     case Tag_ARC_ISA_apex:
14206       printf ("  Tag_ARC_ISA_apex: ");
14207       p = display_tag_value (-1, p, end);
14208       break;
14209
14210     case Tag_ARC_ISA_mpy_option:
14211       val = read_uleb128 (p, &len, end);
14212       p += len;
14213       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14214       break;
14215
14216     default:
14217       return display_tag_value (tag & 1, p, end);
14218     }
14219
14220   return p;
14221 }
14222
14223 /* ARM EABI attributes section.  */
14224 typedef struct
14225 {
14226   unsigned int tag;
14227   const char * name;
14228   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14229   unsigned int type;
14230   const char ** table;
14231 } arm_attr_public_tag;
14232
14233 static const char * arm_attr_tag_CPU_arch[] =
14234   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14235    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14236    "v8-M.mainline"};
14237 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14238 static const char * arm_attr_tag_THUMB_ISA_use[] =
14239   {"No", "Thumb-1", "Thumb-2", "Yes"};
14240 static const char * arm_attr_tag_FP_arch[] =
14241   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14242    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14243 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14244 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14245   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14246    "NEON for ARMv8.1"};
14247 static const char * arm_attr_tag_PCS_config[] =
14248   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14249    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14250 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14251   {"V6", "SB", "TLS", "Unused"};
14252 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14253   {"Absolute", "PC-relative", "SB-relative", "None"};
14254 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14255   {"Absolute", "PC-relative", "None"};
14256 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14257   {"None", "direct", "GOT-indirect"};
14258 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14259   {"None", "??? 1", "2", "??? 3", "4"};
14260 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14261 static const char * arm_attr_tag_ABI_FP_denormal[] =
14262   {"Unused", "Needed", "Sign only"};
14263 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14264 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14265 static const char * arm_attr_tag_ABI_FP_number_model[] =
14266   {"Unused", "Finite", "RTABI", "IEEE 754"};
14267 static const char * arm_attr_tag_ABI_enum_size[] =
14268   {"Unused", "small", "int", "forced to int"};
14269 static const char * arm_attr_tag_ABI_HardFP_use[] =
14270   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14271 static const char * arm_attr_tag_ABI_VFP_args[] =
14272   {"AAPCS", "VFP registers", "custom", "compatible"};
14273 static const char * arm_attr_tag_ABI_WMMX_args[] =
14274   {"AAPCS", "WMMX registers", "custom"};
14275 static const char * arm_attr_tag_ABI_optimization_goals[] =
14276   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14277     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14278 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14279   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14280     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14281 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14282 static const char * arm_attr_tag_FP_HP_extension[] =
14283   {"Not Allowed", "Allowed"};
14284 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14285   {"None", "IEEE 754", "Alternative Format"};
14286 static const char * arm_attr_tag_DSP_extension[] =
14287   {"Follow architecture", "Allowed"};
14288 static const char * arm_attr_tag_MPextension_use[] =
14289   {"Not Allowed", "Allowed"};
14290 static const char * arm_attr_tag_DIV_use[] =
14291   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14292     "Allowed in v7-A with integer division extension"};
14293 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14294 static const char * arm_attr_tag_Virtualization_use[] =
14295   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14296     "TrustZone and Virtualization Extensions"};
14297 static const char * arm_attr_tag_MPextension_use_legacy[] =
14298   {"Not Allowed", "Allowed"};
14299
14300 #define LOOKUP(id, name) \
14301   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14302 static arm_attr_public_tag arm_attr_public_tags[] =
14303 {
14304   {4, "CPU_raw_name", 1, NULL},
14305   {5, "CPU_name", 1, NULL},
14306   LOOKUP(6, CPU_arch),
14307   {7, "CPU_arch_profile", 0, NULL},
14308   LOOKUP(8, ARM_ISA_use),
14309   LOOKUP(9, THUMB_ISA_use),
14310   LOOKUP(10, FP_arch),
14311   LOOKUP(11, WMMX_arch),
14312   LOOKUP(12, Advanced_SIMD_arch),
14313   LOOKUP(13, PCS_config),
14314   LOOKUP(14, ABI_PCS_R9_use),
14315   LOOKUP(15, ABI_PCS_RW_data),
14316   LOOKUP(16, ABI_PCS_RO_data),
14317   LOOKUP(17, ABI_PCS_GOT_use),
14318   LOOKUP(18, ABI_PCS_wchar_t),
14319   LOOKUP(19, ABI_FP_rounding),
14320   LOOKUP(20, ABI_FP_denormal),
14321   LOOKUP(21, ABI_FP_exceptions),
14322   LOOKUP(22, ABI_FP_user_exceptions),
14323   LOOKUP(23, ABI_FP_number_model),
14324   {24, "ABI_align_needed", 0, NULL},
14325   {25, "ABI_align_preserved", 0, NULL},
14326   LOOKUP(26, ABI_enum_size),
14327   LOOKUP(27, ABI_HardFP_use),
14328   LOOKUP(28, ABI_VFP_args),
14329   LOOKUP(29, ABI_WMMX_args),
14330   LOOKUP(30, ABI_optimization_goals),
14331   LOOKUP(31, ABI_FP_optimization_goals),
14332   {32, "compatibility", 0, NULL},
14333   LOOKUP(34, CPU_unaligned_access),
14334   LOOKUP(36, FP_HP_extension),
14335   LOOKUP(38, ABI_FP_16bit_format),
14336   LOOKUP(42, MPextension_use),
14337   LOOKUP(44, DIV_use),
14338   LOOKUP(46, DSP_extension),
14339   {64, "nodefaults", 0, NULL},
14340   {65, "also_compatible_with", 0, NULL},
14341   LOOKUP(66, T2EE_use),
14342   {67, "conformance", 1, NULL},
14343   LOOKUP(68, Virtualization_use),
14344   LOOKUP(70, MPextension_use_legacy)
14345 };
14346 #undef LOOKUP
14347
14348 static unsigned char *
14349 display_arm_attribute (unsigned char * p,
14350                        const unsigned char * const end)
14351 {
14352   unsigned int tag;
14353   unsigned int len;
14354   unsigned int val;
14355   arm_attr_public_tag * attr;
14356   unsigned i;
14357   unsigned int type;
14358
14359   tag = read_uleb128 (p, &len, end);
14360   p += len;
14361   attr = NULL;
14362   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14363     {
14364       if (arm_attr_public_tags[i].tag == tag)
14365         {
14366           attr = &arm_attr_public_tags[i];
14367           break;
14368         }
14369     }
14370
14371   if (attr)
14372     {
14373       printf ("  Tag_%s: ", attr->name);
14374       switch (attr->type)
14375         {
14376         case 0:
14377           switch (tag)
14378             {
14379             case 7: /* Tag_CPU_arch_profile.  */
14380               val = read_uleb128 (p, &len, end);
14381               p += len;
14382               switch (val)
14383                 {
14384                 case 0: printf (_("None\n")); break;
14385                 case 'A': printf (_("Application\n")); break;
14386                 case 'R': printf (_("Realtime\n")); break;
14387                 case 'M': printf (_("Microcontroller\n")); break;
14388                 case 'S': printf (_("Application or Realtime\n")); break;
14389                 default: printf ("??? (%d)\n", val); break;
14390                 }
14391               break;
14392
14393             case 24: /* Tag_align_needed.  */
14394               val = read_uleb128 (p, &len, end);
14395               p += len;
14396               switch (val)
14397                 {
14398                 case 0: printf (_("None\n")); break;
14399                 case 1: printf (_("8-byte\n")); break;
14400                 case 2: printf (_("4-byte\n")); break;
14401                 case 3: printf ("??? 3\n"); break;
14402                 default:
14403                   if (val <= 12)
14404                     printf (_("8-byte and up to %d-byte extended\n"),
14405                             1 << val);
14406                   else
14407                     printf ("??? (%d)\n", val);
14408                   break;
14409                 }
14410               break;
14411
14412             case 25: /* Tag_align_preserved.  */
14413               val = read_uleb128 (p, &len, end);
14414               p += len;
14415               switch (val)
14416                 {
14417                 case 0: printf (_("None\n")); break;
14418                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14419                 case 2: printf (_("8-byte\n")); break;
14420                 case 3: printf ("??? 3\n"); break;
14421                 default:
14422                   if (val <= 12)
14423                     printf (_("8-byte and up to %d-byte extended\n"),
14424                             1 << val);
14425                   else
14426                     printf ("??? (%d)\n", val);
14427                   break;
14428                 }
14429               break;
14430
14431             case 32: /* Tag_compatibility.  */
14432               {
14433                 val = read_uleb128 (p, &len, end);
14434                 p += len;
14435                 printf (_("flag = %d, vendor = "), val);
14436                 if (p < end - 1)
14437                   {
14438                     size_t maxlen = (end - p) - 1;
14439
14440                     print_symbol ((int) maxlen, (const char *) p);
14441                     p += strnlen ((char *) p, maxlen) + 1;
14442                   }
14443                 else
14444                   {
14445                     printf (_("<corrupt>"));
14446                     p = (unsigned char *) end;
14447                   }
14448                 putchar ('\n');
14449               }
14450               break;
14451
14452             case 64: /* Tag_nodefaults.  */
14453               /* PR 17531: file: 001-505008-0.01.  */
14454               if (p < end)
14455                 p++;
14456               printf (_("True\n"));
14457               break;
14458
14459             case 65: /* Tag_also_compatible_with.  */
14460               val = read_uleb128 (p, &len, end);
14461               p += len;
14462               if (val == 6 /* Tag_CPU_arch.  */)
14463                 {
14464                   val = read_uleb128 (p, &len, end);
14465                   p += len;
14466                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14467                     printf ("??? (%d)\n", val);
14468                   else
14469                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14470                 }
14471               else
14472                 printf ("???\n");
14473               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14474                 ;
14475               break;
14476
14477             default:
14478               printf (_("<unknown: %d>\n"), tag);
14479               break;
14480             }
14481           return p;
14482
14483         case 1:
14484           return display_tag_value (-1, p, end);
14485         case 2:
14486           return display_tag_value (0, p, end);
14487
14488         default:
14489           assert (attr->type & 0x80);
14490           val = read_uleb128 (p, &len, end);
14491           p += len;
14492           type = attr->type & 0x7f;
14493           if (val >= type)
14494             printf ("??? (%d)\n", val);
14495           else
14496             printf ("%s\n", attr->table[val]);
14497           return p;
14498         }
14499     }
14500
14501   return display_tag_value (tag, p, end);
14502 }
14503
14504 static unsigned char *
14505 display_gnu_attribute (unsigned char * p,
14506                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14507                        const unsigned char * const end)
14508 {
14509   int tag;
14510   unsigned int len;
14511   unsigned int val;
14512
14513   tag = read_uleb128 (p, &len, end);
14514   p += len;
14515
14516   /* Tag_compatibility is the only generic GNU attribute defined at
14517      present.  */
14518   if (tag == 32)
14519     {
14520       val = read_uleb128 (p, &len, end);
14521       p += len;
14522
14523       printf (_("flag = %d, vendor = "), val);
14524       if (p == end)
14525         {
14526           printf (_("<corrupt>\n"));
14527           warn (_("corrupt vendor attribute\n"));
14528         }
14529       else
14530         {
14531           if (p < end - 1)
14532             {
14533               size_t maxlen = (end - p) - 1;
14534
14535               print_symbol ((int) maxlen, (const char *) p);
14536               p += strnlen ((char *) p, maxlen) + 1;
14537             }
14538           else
14539             {
14540               printf (_("<corrupt>"));
14541               p = (unsigned char *) end;
14542             }
14543           putchar ('\n');
14544         }
14545       return p;
14546     }
14547
14548   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14549     return display_proc_gnu_attribute (p, tag, end);
14550
14551   return display_tag_value (tag, p, end);
14552 }
14553
14554 static unsigned char *
14555 display_power_gnu_attribute (unsigned char * p,
14556                              unsigned int tag,
14557                              const unsigned char * const end)
14558 {
14559   unsigned int len;
14560   unsigned int val;
14561
14562   if (tag == Tag_GNU_Power_ABI_FP)
14563     {
14564       val = read_uleb128 (p, &len, end);
14565       p += len;
14566       printf ("  Tag_GNU_Power_ABI_FP: ");
14567       if (len == 0)
14568         {
14569           printf (_("<corrupt>\n"));
14570           return p;
14571         }
14572
14573       if (val > 15)
14574         printf ("(%#x), ", val);
14575
14576       switch (val & 3)
14577         {
14578         case 0:
14579           printf (_("unspecified hard/soft float, "));
14580           break;
14581         case 1:
14582           printf (_("hard float, "));
14583           break;
14584         case 2:
14585           printf (_("soft float, "));
14586           break;
14587         case 3:
14588           printf (_("single-precision hard float, "));
14589           break;
14590         }
14591
14592       switch (val & 0xC)
14593         {
14594         case 0:
14595           printf (_("unspecified long double\n"));
14596           break;
14597         case 4:
14598           printf (_("128-bit IBM long double\n"));
14599           break;
14600         case 8:
14601           printf (_("64-bit long double\n"));
14602           break;
14603         case 12:
14604           printf (_("128-bit IEEE long double\n"));
14605           break;
14606         }
14607       return p;
14608     }
14609
14610   if (tag == Tag_GNU_Power_ABI_Vector)
14611     {
14612       val = read_uleb128 (p, &len, end);
14613       p += len;
14614       printf ("  Tag_GNU_Power_ABI_Vector: ");
14615       if (len == 0)
14616         {
14617           printf (_("<corrupt>\n"));
14618           return p;
14619         }
14620
14621       if (val > 3)
14622         printf ("(%#x), ", val);
14623
14624       switch (val & 3)
14625         {
14626         case 0:
14627           printf (_("unspecified\n"));
14628           break;
14629         case 1:
14630           printf (_("generic\n"));
14631           break;
14632         case 2:
14633           printf ("AltiVec\n");
14634           break;
14635         case 3:
14636           printf ("SPE\n");
14637           break;
14638         }
14639       return p;
14640     }
14641
14642   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14643     {
14644       val = read_uleb128 (p, &len, end);
14645       p += len;
14646       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14647       if (len == 0)
14648         {
14649           printf (_("<corrupt>\n"));
14650           return p;
14651         }
14652
14653       if (val > 2)
14654         printf ("(%#x), ", val);
14655
14656       switch (val & 3)
14657         {
14658         case 0:
14659           printf (_("unspecified\n"));
14660           break;
14661         case 1:
14662           printf ("r3/r4\n");
14663           break;
14664         case 2:
14665           printf (_("memory\n"));
14666           break;
14667         case 3:
14668           printf ("???\n");
14669           break;
14670         }
14671       return p;
14672     }
14673
14674   return display_tag_value (tag & 1, p, end);
14675 }
14676
14677 static unsigned char *
14678 display_s390_gnu_attribute (unsigned char * p,
14679                             unsigned int tag,
14680                             const unsigned char * const end)
14681 {
14682   unsigned int len;
14683   int val;
14684
14685   if (tag == Tag_GNU_S390_ABI_Vector)
14686     {
14687       val = read_uleb128 (p, &len, end);
14688       p += len;
14689       printf ("  Tag_GNU_S390_ABI_Vector: ");
14690
14691       switch (val)
14692         {
14693         case 0:
14694           printf (_("any\n"));
14695           break;
14696         case 1:
14697           printf (_("software\n"));
14698           break;
14699         case 2:
14700           printf (_("hardware\n"));
14701           break;
14702         default:
14703           printf ("??? (%d)\n", val);
14704           break;
14705         }
14706       return p;
14707    }
14708
14709   return display_tag_value (tag & 1, p, end);
14710 }
14711
14712 static void
14713 display_sparc_hwcaps (unsigned int mask)
14714 {
14715   if (mask)
14716     {
14717       bfd_boolean first = TRUE;
14718
14719       if (mask & ELF_SPARC_HWCAP_MUL32)
14720         fputs ("mul32", stdout), first = FALSE;
14721       if (mask & ELF_SPARC_HWCAP_DIV32)
14722         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14723       if (mask & ELF_SPARC_HWCAP_FSMULD)
14724         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14725       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14726         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14727       if (mask & ELF_SPARC_HWCAP_POPC)
14728         printf ("%spopc", first ? "" : "|"), first = FALSE;
14729       if (mask & ELF_SPARC_HWCAP_VIS)
14730         printf ("%svis", first ? "" : "|"), first = FALSE;
14731       if (mask & ELF_SPARC_HWCAP_VIS2)
14732         printf ("%svis2", first ? "" : "|"), first = FALSE;
14733       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14734         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14735       if (mask & ELF_SPARC_HWCAP_FMAF)
14736         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14737       if (mask & ELF_SPARC_HWCAP_VIS3)
14738         printf ("%svis3", first ? "" : "|"), first = FALSE;
14739       if (mask & ELF_SPARC_HWCAP_HPC)
14740         printf ("%shpc", first ? "" : "|"), first = FALSE;
14741       if (mask & ELF_SPARC_HWCAP_RANDOM)
14742         printf ("%srandom", first ? "" : "|"), first = FALSE;
14743       if (mask & ELF_SPARC_HWCAP_TRANS)
14744         printf ("%strans", first ? "" : "|"), first = FALSE;
14745       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14746         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14747       if (mask & ELF_SPARC_HWCAP_IMA)
14748         printf ("%sima", first ? "" : "|"), first = FALSE;
14749       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14750         printf ("%scspare", first ? "" : "|"), first = FALSE;
14751     }
14752   else
14753     fputc ('0', stdout);
14754   fputc ('\n', stdout);
14755 }
14756
14757 static void
14758 display_sparc_hwcaps2 (unsigned int mask)
14759 {
14760   if (mask)
14761     {
14762       bfd_boolean first = TRUE;
14763
14764       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14765         fputs ("fjathplus", stdout), first = FALSE;
14766       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14767         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14768       if (mask & ELF_SPARC_HWCAP2_ADP)
14769         printf ("%sadp", first ? "" : "|"), first = FALSE;
14770       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14771         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14772       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14773         printf ("%smwait", first ? "" : "|"), first = FALSE;
14774       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14775         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14776       if (mask & ELF_SPARC_HWCAP2_XMONT)
14777         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14778       if (mask & ELF_SPARC_HWCAP2_NSEC)
14779         printf ("%snsec", first ? "" : "|"), first = FALSE;
14780       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14781         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14782       if (mask & ELF_SPARC_HWCAP2_FJDES)
14783         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14784       if (mask & ELF_SPARC_HWCAP2_FJAES)
14785         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14786     }
14787   else
14788     fputc ('0', stdout);
14789   fputc ('\n', stdout);
14790 }
14791
14792 static unsigned char *
14793 display_sparc_gnu_attribute (unsigned char * p,
14794                              unsigned int tag,
14795                              const unsigned char * const end)
14796 {
14797   unsigned int len;
14798   int val;
14799
14800   if (tag == Tag_GNU_Sparc_HWCAPS)
14801     {
14802       val = read_uleb128 (p, &len, end);
14803       p += len;
14804       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14805       display_sparc_hwcaps (val);
14806       return p;
14807     }
14808   if (tag == Tag_GNU_Sparc_HWCAPS2)
14809     {
14810       val = read_uleb128 (p, &len, end);
14811       p += len;
14812       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14813       display_sparc_hwcaps2 (val);
14814       return p;
14815     }
14816
14817   return display_tag_value (tag, p, end);
14818 }
14819
14820 static void
14821 print_mips_fp_abi_value (unsigned int val)
14822 {
14823   switch (val)
14824     {
14825     case Val_GNU_MIPS_ABI_FP_ANY:
14826       printf (_("Hard or soft float\n"));
14827       break;
14828     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14829       printf (_("Hard float (double precision)\n"));
14830       break;
14831     case Val_GNU_MIPS_ABI_FP_SINGLE:
14832       printf (_("Hard float (single precision)\n"));
14833       break;
14834     case Val_GNU_MIPS_ABI_FP_SOFT:
14835       printf (_("Soft float\n"));
14836       break;
14837     case Val_GNU_MIPS_ABI_FP_OLD_64:
14838       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14839       break;
14840     case Val_GNU_MIPS_ABI_FP_XX:
14841       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14842       break;
14843     case Val_GNU_MIPS_ABI_FP_64:
14844       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14845       break;
14846     case Val_GNU_MIPS_ABI_FP_64A:
14847       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14848       break;
14849     case Val_GNU_MIPS_ABI_FP_NAN2008:
14850       printf (_("NaN 2008 compatibility\n"));
14851       break;
14852     default:
14853       printf ("??? (%d)\n", val);
14854       break;
14855     }
14856 }
14857
14858 static unsigned char *
14859 display_mips_gnu_attribute (unsigned char * p,
14860                             unsigned int tag,
14861                             const unsigned char * const end)
14862 {
14863   if (tag == Tag_GNU_MIPS_ABI_FP)
14864     {
14865       unsigned int len;
14866       unsigned int val;
14867
14868       val = read_uleb128 (p, &len, end);
14869       p += len;
14870       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14871
14872       print_mips_fp_abi_value (val);
14873
14874       return p;
14875    }
14876
14877   if (tag == Tag_GNU_MIPS_ABI_MSA)
14878     {
14879       unsigned int len;
14880       unsigned int val;
14881
14882       val = read_uleb128 (p, &len, end);
14883       p += len;
14884       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14885
14886       switch (val)
14887         {
14888         case Val_GNU_MIPS_ABI_MSA_ANY:
14889           printf (_("Any MSA or not\n"));
14890           break;
14891         case Val_GNU_MIPS_ABI_MSA_128:
14892           printf (_("128-bit MSA\n"));
14893           break;
14894         default:
14895           printf ("??? (%d)\n", val);
14896           break;
14897         }
14898       return p;
14899     }
14900
14901   return display_tag_value (tag & 1, p, end);
14902 }
14903
14904 static unsigned char *
14905 display_tic6x_attribute (unsigned char * p,
14906                          const unsigned char * const end)
14907 {
14908   unsigned int tag;
14909   unsigned int len;
14910   int val;
14911
14912   tag = read_uleb128 (p, &len, end);
14913   p += len;
14914
14915   switch (tag)
14916     {
14917     case Tag_ISA:
14918       val = read_uleb128 (p, &len, end);
14919       p += len;
14920       printf ("  Tag_ISA: ");
14921
14922       switch (val)
14923         {
14924         case C6XABI_Tag_ISA_none:
14925           printf (_("None\n"));
14926           break;
14927         case C6XABI_Tag_ISA_C62X:
14928           printf ("C62x\n");
14929           break;
14930         case C6XABI_Tag_ISA_C67X:
14931           printf ("C67x\n");
14932           break;
14933         case C6XABI_Tag_ISA_C67XP:
14934           printf ("C67x+\n");
14935           break;
14936         case C6XABI_Tag_ISA_C64X:
14937           printf ("C64x\n");
14938           break;
14939         case C6XABI_Tag_ISA_C64XP:
14940           printf ("C64x+\n");
14941           break;
14942         case C6XABI_Tag_ISA_C674X:
14943           printf ("C674x\n");
14944           break;
14945         default:
14946           printf ("??? (%d)\n", val);
14947           break;
14948         }
14949       return p;
14950
14951     case Tag_ABI_wchar_t:
14952       val = read_uleb128 (p, &len, end);
14953       p += len;
14954       printf ("  Tag_ABI_wchar_t: ");
14955       switch (val)
14956         {
14957         case 0:
14958           printf (_("Not used\n"));
14959           break;
14960         case 1:
14961           printf (_("2 bytes\n"));
14962           break;
14963         case 2:
14964           printf (_("4 bytes\n"));
14965           break;
14966         default:
14967           printf ("??? (%d)\n", val);
14968           break;
14969         }
14970       return p;
14971
14972     case Tag_ABI_stack_align_needed:
14973       val = read_uleb128 (p, &len, end);
14974       p += len;
14975       printf ("  Tag_ABI_stack_align_needed: ");
14976       switch (val)
14977         {
14978         case 0:
14979           printf (_("8-byte\n"));
14980           break;
14981         case 1:
14982           printf (_("16-byte\n"));
14983           break;
14984         default:
14985           printf ("??? (%d)\n", val);
14986           break;
14987         }
14988       return p;
14989
14990     case Tag_ABI_stack_align_preserved:
14991       val = read_uleb128 (p, &len, end);
14992       p += len;
14993       printf ("  Tag_ABI_stack_align_preserved: ");
14994       switch (val)
14995         {
14996         case 0:
14997           printf (_("8-byte\n"));
14998           break;
14999         case 1:
15000           printf (_("16-byte\n"));
15001           break;
15002         default:
15003           printf ("??? (%d)\n", val);
15004           break;
15005         }
15006       return p;
15007
15008     case Tag_ABI_DSBT:
15009       val = read_uleb128 (p, &len, end);
15010       p += len;
15011       printf ("  Tag_ABI_DSBT: ");
15012       switch (val)
15013         {
15014         case 0:
15015           printf (_("DSBT addressing not used\n"));
15016           break;
15017         case 1:
15018           printf (_("DSBT addressing used\n"));
15019           break;
15020         default:
15021           printf ("??? (%d)\n", val);
15022           break;
15023         }
15024       return p;
15025
15026     case Tag_ABI_PID:
15027       val = read_uleb128 (p, &len, end);
15028       p += len;
15029       printf ("  Tag_ABI_PID: ");
15030       switch (val)
15031         {
15032         case 0:
15033           printf (_("Data addressing position-dependent\n"));
15034           break;
15035         case 1:
15036           printf (_("Data addressing position-independent, GOT near DP\n"));
15037           break;
15038         case 2:
15039           printf (_("Data addressing position-independent, GOT far from DP\n"));
15040           break;
15041         default:
15042           printf ("??? (%d)\n", val);
15043           break;
15044         }
15045       return p;
15046
15047     case Tag_ABI_PIC:
15048       val = read_uleb128 (p, &len, end);
15049       p += len;
15050       printf ("  Tag_ABI_PIC: ");
15051       switch (val)
15052         {
15053         case 0:
15054           printf (_("Code addressing position-dependent\n"));
15055           break;
15056         case 1:
15057           printf (_("Code addressing position-independent\n"));
15058           break;
15059         default:
15060           printf ("??? (%d)\n", val);
15061           break;
15062         }
15063       return p;
15064
15065     case Tag_ABI_array_object_alignment:
15066       val = read_uleb128 (p, &len, end);
15067       p += len;
15068       printf ("  Tag_ABI_array_object_alignment: ");
15069       switch (val)
15070         {
15071         case 0:
15072           printf (_("8-byte\n"));
15073           break;
15074         case 1:
15075           printf (_("4-byte\n"));
15076           break;
15077         case 2:
15078           printf (_("16-byte\n"));
15079           break;
15080         default:
15081           printf ("??? (%d)\n", val);
15082           break;
15083         }
15084       return p;
15085
15086     case Tag_ABI_array_object_align_expected:
15087       val = read_uleb128 (p, &len, end);
15088       p += len;
15089       printf ("  Tag_ABI_array_object_align_expected: ");
15090       switch (val)
15091         {
15092         case 0:
15093           printf (_("8-byte\n"));
15094           break;
15095         case 1:
15096           printf (_("4-byte\n"));
15097           break;
15098         case 2:
15099           printf (_("16-byte\n"));
15100           break;
15101         default:
15102           printf ("??? (%d)\n", val);
15103           break;
15104         }
15105       return p;
15106
15107     case Tag_ABI_compatibility:
15108       {
15109         val = read_uleb128 (p, &len, end);
15110         p += len;
15111         printf ("  Tag_ABI_compatibility: ");
15112         printf (_("flag = %d, vendor = "), val);
15113         if (p < end - 1)
15114           {
15115             size_t maxlen = (end - p) - 1;
15116
15117             print_symbol ((int) maxlen, (const char *) p);
15118             p += strnlen ((char *) p, maxlen) + 1;
15119           }
15120         else
15121           {
15122             printf (_("<corrupt>"));
15123             p = (unsigned char *) end;
15124           }
15125         putchar ('\n');
15126         return p;
15127       }
15128
15129     case Tag_ABI_conformance:
15130       {
15131         printf ("  Tag_ABI_conformance: \"");
15132         if (p < end - 1)
15133           {
15134             size_t maxlen = (end - p) - 1;
15135
15136             print_symbol ((int) maxlen, (const char *) p);
15137             p += strnlen ((char *) p, maxlen) + 1;
15138           }
15139         else
15140           {
15141             printf (_("<corrupt>"));
15142             p = (unsigned char *) end;
15143           }
15144         printf ("\"\n");
15145         return p;
15146       }
15147     }
15148
15149   return display_tag_value (tag, p, end);
15150 }
15151
15152 static void
15153 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15154 {
15155   unsigned long addr = 0;
15156   size_t bytes = end - p;
15157
15158   assert (end > p);
15159   while (bytes)
15160     {
15161       int j;
15162       int k;
15163       int lbytes = (bytes > 16 ? 16 : bytes);
15164
15165       printf ("  0x%8.8lx ", addr);
15166
15167       for (j = 0; j < 16; j++)
15168         {
15169           if (j < lbytes)
15170             printf ("%2.2x", p[j]);
15171           else
15172             printf ("  ");
15173
15174           if ((j & 3) == 3)
15175             printf (" ");
15176         }
15177
15178       for (j = 0; j < lbytes; j++)
15179         {
15180           k = p[j];
15181           if (k >= ' ' && k < 0x7f)
15182             printf ("%c", k);
15183           else
15184             printf (".");
15185         }
15186
15187       putchar ('\n');
15188
15189       p  += lbytes;
15190       bytes -= lbytes;
15191       addr += lbytes;
15192     }
15193
15194   putchar ('\n');
15195 }
15196
15197 static unsigned char *
15198 display_msp430x_attribute (unsigned char * p,
15199                            const unsigned char * const end)
15200 {
15201   unsigned int len;
15202   unsigned int val;
15203   unsigned int tag;
15204
15205   tag = read_uleb128 (p, & len, end);
15206   p += len;
15207
15208   switch (tag)
15209     {
15210     case OFBA_MSPABI_Tag_ISA:
15211       val = read_uleb128 (p, &len, end);
15212       p += len;
15213       printf ("  Tag_ISA: ");
15214       switch (val)
15215         {
15216         case 0: printf (_("None\n")); break;
15217         case 1: printf (_("MSP430\n")); break;
15218         case 2: printf (_("MSP430X\n")); break;
15219         default: printf ("??? (%d)\n", val); break;
15220         }
15221       break;
15222
15223     case OFBA_MSPABI_Tag_Code_Model:
15224       val = read_uleb128 (p, &len, end);
15225       p += len;
15226       printf ("  Tag_Code_Model: ");
15227       switch (val)
15228         {
15229         case 0: printf (_("None\n")); break;
15230         case 1: printf (_("Small\n")); break;
15231         case 2: printf (_("Large\n")); break;
15232         default: printf ("??? (%d)\n", val); break;
15233         }
15234       break;
15235
15236     case OFBA_MSPABI_Tag_Data_Model:
15237       val = read_uleb128 (p, &len, end);
15238       p += len;
15239       printf ("  Tag_Data_Model: ");
15240       switch (val)
15241         {
15242         case 0: printf (_("None\n")); break;
15243         case 1: printf (_("Small\n")); break;
15244         case 2: printf (_("Large\n")); break;
15245         case 3: printf (_("Restricted Large\n")); break;
15246         default: printf ("??? (%d)\n", val); break;
15247         }
15248       break;
15249
15250     default:
15251       printf (_("  <unknown tag %d>: "), tag);
15252
15253       if (tag & 1)
15254         {
15255           putchar ('"');
15256           if (p < end - 1)
15257             {
15258               size_t maxlen = (end - p) - 1;
15259
15260               print_symbol ((int) maxlen, (const char *) p);
15261               p += strnlen ((char *) p, maxlen) + 1;
15262             }
15263           else
15264             {
15265               printf (_("<corrupt>"));
15266               p = (unsigned char *) end;
15267             }
15268           printf ("\"\n");
15269         }
15270       else
15271         {
15272           val = read_uleb128 (p, &len, end);
15273           p += len;
15274           printf ("%d (0x%x)\n", val, val);
15275         }
15276       break;
15277    }
15278
15279   assert (p <= end);
15280   return p;
15281 }
15282
15283 static bfd_boolean
15284 process_attributes (Filedata * filedata,
15285                     const char * public_name,
15286                     unsigned int proc_type,
15287                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15288                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15289 {
15290   Elf_Internal_Shdr * sect;
15291   unsigned i;
15292   bfd_boolean res = TRUE;
15293
15294   /* Find the section header so that we get the size.  */
15295   for (i = 0, sect = filedata->section_headers;
15296        i < filedata->file_header.e_shnum;
15297        i++, sect++)
15298     {
15299       unsigned char * contents;
15300       unsigned char * p;
15301
15302       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15303         continue;
15304
15305       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15306                                              sect->sh_size, _("attributes"));
15307       if (contents == NULL)
15308         {
15309           res = FALSE;
15310           continue;
15311         }
15312
15313       p = contents;
15314       /* The first character is the version of the attributes.
15315          Currently only version 1, (aka 'A') is recognised here.  */
15316       if (*p != 'A')
15317         {
15318           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15319           res = FALSE;
15320         }
15321       else
15322         {
15323           bfd_vma section_len;
15324
15325           section_len = sect->sh_size - 1;
15326           p++;
15327
15328           while (section_len > 0)
15329             {
15330               bfd_vma attr_len;
15331               unsigned int namelen;
15332               bfd_boolean public_section;
15333               bfd_boolean gnu_section;
15334
15335               if (section_len <= 4)
15336                 {
15337                   error (_("Tag section ends prematurely\n"));
15338                   res = FALSE;
15339                   break;
15340                 }
15341               attr_len = byte_get (p, 4);
15342               p += 4;
15343
15344               if (attr_len > section_len)
15345                 {
15346                   error (_("Bad attribute length (%u > %u)\n"),
15347                           (unsigned) attr_len, (unsigned) section_len);
15348                   attr_len = section_len;
15349                   res = FALSE;
15350                 }
15351               /* PR 17531: file: 001-101425-0.004  */
15352               else if (attr_len < 5)
15353                 {
15354                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15355                   res = FALSE;
15356                   break;
15357                 }
15358
15359               section_len -= attr_len;
15360               attr_len -= 4;
15361
15362               namelen = strnlen ((char *) p, attr_len) + 1;
15363               if (namelen == 0 || namelen >= attr_len)
15364                 {
15365                   error (_("Corrupt attribute section name\n"));
15366                   res = FALSE;
15367                   break;
15368                 }
15369
15370               printf (_("Attribute Section: "));
15371               print_symbol (INT_MAX, (const char *) p);
15372               putchar ('\n');
15373
15374               if (public_name && streq ((char *) p, public_name))
15375                 public_section = TRUE;
15376               else
15377                 public_section = FALSE;
15378
15379               if (streq ((char *) p, "gnu"))
15380                 gnu_section = TRUE;
15381               else
15382                 gnu_section = FALSE;
15383
15384               p += namelen;
15385               attr_len -= namelen;
15386
15387               while (attr_len > 0 && p < contents + sect->sh_size)
15388                 {
15389                   int tag;
15390                   int val;
15391                   bfd_vma size;
15392                   unsigned char * end;
15393
15394                   /* PR binutils/17531: Safe handling of corrupt files.  */
15395                   if (attr_len < 6)
15396                     {
15397                       error (_("Unused bytes at end of section\n"));
15398                       res = FALSE;
15399                       section_len = 0;
15400                       break;
15401                     }
15402
15403                   tag = *(p++);
15404                   size = byte_get (p, 4);
15405                   if (size > attr_len)
15406                     {
15407                       error (_("Bad subsection length (%u > %u)\n"),
15408                               (unsigned) size, (unsigned) attr_len);
15409                       res = FALSE;
15410                       size = attr_len;
15411                     }
15412                   /* PR binutils/17531: Safe handling of corrupt files.  */
15413                   if (size < 6)
15414                     {
15415                       error (_("Bad subsection length (%u < 6)\n"),
15416                               (unsigned) size);
15417                       res = FALSE;
15418                       section_len = 0;
15419                       break;
15420                     }
15421
15422                   attr_len -= size;
15423                   end = p + size - 1;
15424                   assert (end <= contents + sect->sh_size);
15425                   p += 4;
15426
15427                   switch (tag)
15428                     {
15429                     case 1:
15430                       printf (_("File Attributes\n"));
15431                       break;
15432                     case 2:
15433                       printf (_("Section Attributes:"));
15434                       goto do_numlist;
15435                     case 3:
15436                       printf (_("Symbol Attributes:"));
15437                       /* Fall through.  */
15438                     do_numlist:
15439                       for (;;)
15440                         {
15441                           unsigned int j;
15442
15443                           val = read_uleb128 (p, &j, end);
15444                           p += j;
15445                           if (val == 0)
15446                             break;
15447                           printf (" %d", val);
15448                         }
15449                       printf ("\n");
15450                       break;
15451                     default:
15452                       printf (_("Unknown tag: %d\n"), tag);
15453                       public_section = FALSE;
15454                       break;
15455                     }
15456
15457                   if (public_section && display_pub_attribute != NULL)
15458                     {
15459                       while (p < end)
15460                         p = display_pub_attribute (p, end);
15461                       assert (p == end);
15462                     }
15463                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15464                     {
15465                       while (p < end)
15466                         p = display_gnu_attribute (p,
15467                                                    display_proc_gnu_attribute,
15468                                                    end);
15469                       assert (p == end);
15470                     }
15471                   else if (p < end)
15472                     {
15473                       printf (_("  Unknown attribute:\n"));
15474                       display_raw_attribute (p, end);
15475                       p = end;
15476                     }
15477                   else
15478                     attr_len = 0;
15479                 }
15480             }
15481         }
15482
15483       free (contents);
15484     }
15485
15486   return res;
15487 }
15488
15489 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15490    Print the Address, Access and Initial fields of an entry at VMA ADDR
15491    and return the VMA of the next entry, or -1 if there was a problem.
15492    Does not read from DATA_END or beyond.  */
15493
15494 static bfd_vma
15495 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15496                       unsigned char * data_end)
15497 {
15498   printf ("  ");
15499   print_vma (addr, LONG_HEX);
15500   printf (" ");
15501   if (addr < pltgot + 0xfff0)
15502     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15503   else
15504     printf ("%10s", "");
15505   printf (" ");
15506   if (data == NULL)
15507     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15508   else
15509     {
15510       bfd_vma entry;
15511       unsigned char * from = data + addr - pltgot;
15512
15513       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15514         {
15515           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15516           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15517           return (bfd_vma) -1;
15518         }
15519       else
15520         {
15521           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15522           print_vma (entry, LONG_HEX);
15523         }
15524     }
15525   return addr + (is_32bit_elf ? 4 : 8);
15526 }
15527
15528 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15529    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15530    ADDR and return the VMA of the next entry.  */
15531
15532 static bfd_vma
15533 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15534 {
15535   printf ("  ");
15536   print_vma (addr, LONG_HEX);
15537   printf (" ");
15538   if (data == NULL)
15539     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15540   else
15541     {
15542       bfd_vma entry;
15543
15544       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15545       print_vma (entry, LONG_HEX);
15546     }
15547   return addr + (is_32bit_elf ? 4 : 8);
15548 }
15549
15550 static void
15551 print_mips_ases (unsigned int mask)
15552 {
15553   if (mask & AFL_ASE_DSP)
15554     fputs ("\n\tDSP ASE", stdout);
15555   if (mask & AFL_ASE_DSPR2)
15556     fputs ("\n\tDSP R2 ASE", stdout);
15557   if (mask & AFL_ASE_DSPR3)
15558     fputs ("\n\tDSP R3 ASE", stdout);
15559   if (mask & AFL_ASE_EVA)
15560     fputs ("\n\tEnhanced VA Scheme", stdout);
15561   if (mask & AFL_ASE_MCU)
15562     fputs ("\n\tMCU (MicroController) ASE", stdout);
15563   if (mask & AFL_ASE_MDMX)
15564     fputs ("\n\tMDMX ASE", stdout);
15565   if (mask & AFL_ASE_MIPS3D)
15566     fputs ("\n\tMIPS-3D ASE", stdout);
15567   if (mask & AFL_ASE_MT)
15568     fputs ("\n\tMT ASE", stdout);
15569   if (mask & AFL_ASE_SMARTMIPS)
15570     fputs ("\n\tSmartMIPS ASE", stdout);
15571   if (mask & AFL_ASE_VIRT)
15572     fputs ("\n\tVZ ASE", stdout);
15573   if (mask & AFL_ASE_MSA)
15574     fputs ("\n\tMSA ASE", stdout);
15575   if (mask & AFL_ASE_MIPS16)
15576     fputs ("\n\tMIPS16 ASE", stdout);
15577   if (mask & AFL_ASE_MICROMIPS)
15578     fputs ("\n\tMICROMIPS ASE", stdout);
15579   if (mask & AFL_ASE_XPA)
15580     fputs ("\n\tXPA ASE", stdout);
15581   if (mask & AFL_ASE_MIPS16E2)
15582     fputs ("\n\tMIPS16e2 ASE", stdout);
15583   if (mask & AFL_ASE_CRC)
15584     fputs ("\n\tCRC ASE", stdout);
15585   if (mask & AFL_ASE_GINV)
15586     fputs ("\n\tGINV ASE", stdout);
15587   if (mask == 0)
15588     fprintf (stdout, "\n\t%s", _("None"));
15589   else if ((mask & ~AFL_ASE_MASK) != 0)
15590     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15591 }
15592
15593 static void
15594 print_mips_isa_ext (unsigned int isa_ext)
15595 {
15596   switch (isa_ext)
15597     {
15598     case 0:
15599       fputs (_("None"), stdout);
15600       break;
15601     case AFL_EXT_XLR:
15602       fputs ("RMI XLR", stdout);
15603       break;
15604     case AFL_EXT_OCTEON3:
15605       fputs ("Cavium Networks Octeon3", stdout);
15606       break;
15607     case AFL_EXT_OCTEON2:
15608       fputs ("Cavium Networks Octeon2", stdout);
15609       break;
15610     case AFL_EXT_OCTEONP:
15611       fputs ("Cavium Networks OcteonP", stdout);
15612       break;
15613     case AFL_EXT_LOONGSON_3A:
15614       fputs ("Loongson 3A", stdout);
15615       break;
15616     case AFL_EXT_OCTEON:
15617       fputs ("Cavium Networks Octeon", stdout);
15618       break;
15619     case AFL_EXT_5900:
15620       fputs ("Toshiba R5900", stdout);
15621       break;
15622     case AFL_EXT_4650:
15623       fputs ("MIPS R4650", stdout);
15624       break;
15625     case AFL_EXT_4010:
15626       fputs ("LSI R4010", stdout);
15627       break;
15628     case AFL_EXT_4100:
15629       fputs ("NEC VR4100", stdout);
15630       break;
15631     case AFL_EXT_3900:
15632       fputs ("Toshiba R3900", stdout);
15633       break;
15634     case AFL_EXT_10000:
15635       fputs ("MIPS R10000", stdout);
15636       break;
15637     case AFL_EXT_SB1:
15638       fputs ("Broadcom SB-1", stdout);
15639       break;
15640     case AFL_EXT_4111:
15641       fputs ("NEC VR4111/VR4181", stdout);
15642       break;
15643     case AFL_EXT_4120:
15644       fputs ("NEC VR4120", stdout);
15645       break;
15646     case AFL_EXT_5400:
15647       fputs ("NEC VR5400", stdout);
15648       break;
15649     case AFL_EXT_5500:
15650       fputs ("NEC VR5500", stdout);
15651       break;
15652     case AFL_EXT_LOONGSON_2E:
15653       fputs ("ST Microelectronics Loongson 2E", stdout);
15654       break;
15655     case AFL_EXT_LOONGSON_2F:
15656       fputs ("ST Microelectronics Loongson 2F", stdout);
15657       break;
15658     case AFL_EXT_INTERAPTIV_MR2:
15659       fputs ("Imagination interAptiv MR2", stdout);
15660       break;
15661     default:
15662       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15663     }
15664 }
15665
15666 static signed int
15667 get_mips_reg_size (int reg_size)
15668 {
15669   return (reg_size == AFL_REG_NONE) ? 0
15670          : (reg_size == AFL_REG_32) ? 32
15671          : (reg_size == AFL_REG_64) ? 64
15672          : (reg_size == AFL_REG_128) ? 128
15673          : -1;
15674 }
15675
15676 static bfd_boolean
15677 process_mips_specific (Filedata * filedata)
15678 {
15679   Elf_Internal_Dyn * entry;
15680   Elf_Internal_Shdr *sect = NULL;
15681   size_t liblist_offset = 0;
15682   size_t liblistno = 0;
15683   size_t conflictsno = 0;
15684   size_t options_offset = 0;
15685   size_t conflicts_offset = 0;
15686   size_t pltrelsz = 0;
15687   size_t pltrel = 0;
15688   bfd_vma pltgot = 0;
15689   bfd_vma mips_pltgot = 0;
15690   bfd_vma jmprel = 0;
15691   bfd_vma local_gotno = 0;
15692   bfd_vma gotsym = 0;
15693   bfd_vma symtabno = 0;
15694   bfd_boolean res = TRUE;
15695
15696   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15697                             display_mips_gnu_attribute))
15698     res = FALSE;
15699
15700   sect = find_section (filedata, ".MIPS.abiflags");
15701
15702   if (sect != NULL)
15703     {
15704       Elf_External_ABIFlags_v0 *abiflags_ext;
15705       Elf_Internal_ABIFlags_v0 abiflags_in;
15706
15707       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15708         {
15709           error (_("Corrupt MIPS ABI Flags section.\n"));
15710           res = FALSE;
15711         }
15712       else
15713         {
15714           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15715                                    sect->sh_size, _("MIPS ABI Flags section"));
15716           if (abiflags_ext)
15717             {
15718               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15719               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15720               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15721               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15722               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15723               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15724               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15725               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15726               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15727               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15728               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15729
15730               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15731               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15732               if (abiflags_in.isa_rev > 1)
15733                 printf ("r%d", abiflags_in.isa_rev);
15734               printf ("\nGPR size: %d",
15735                       get_mips_reg_size (abiflags_in.gpr_size));
15736               printf ("\nCPR1 size: %d",
15737                       get_mips_reg_size (abiflags_in.cpr1_size));
15738               printf ("\nCPR2 size: %d",
15739                       get_mips_reg_size (abiflags_in.cpr2_size));
15740               fputs ("\nFP ABI: ", stdout);
15741               print_mips_fp_abi_value (abiflags_in.fp_abi);
15742               fputs ("ISA Extension: ", stdout);
15743               print_mips_isa_ext (abiflags_in.isa_ext);
15744               fputs ("\nASEs:", stdout);
15745               print_mips_ases (abiflags_in.ases);
15746               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15747               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15748               fputc ('\n', stdout);
15749               free (abiflags_ext);
15750             }
15751         }
15752     }
15753
15754   /* We have a lot of special sections.  Thanks SGI!  */
15755   if (dynamic_section == NULL)
15756     {
15757       /* No dynamic information available.  See if there is static GOT.  */
15758       sect = find_section (filedata, ".got");
15759       if (sect != NULL)
15760         {
15761           unsigned char *data_end;
15762           unsigned char *data;
15763           bfd_vma ent, end;
15764           int addr_size;
15765
15766           pltgot = sect->sh_addr;
15767
15768           ent = pltgot;
15769           addr_size = (is_32bit_elf ? 4 : 8);
15770           end = pltgot + sect->sh_size;
15771
15772           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15773                                              end - pltgot, 1,
15774                                              _("Global Offset Table data"));
15775           /* PR 12855: Null data is handled gracefully throughout.  */
15776           data_end = data + (end - pltgot);
15777
15778           printf (_("\nStatic GOT:\n"));
15779           printf (_(" Canonical gp value: "));
15780           print_vma (ent + 0x7ff0, LONG_HEX);
15781           printf ("\n\n");
15782
15783           /* In a dynamic binary GOT[0] is reserved for the dynamic
15784              loader to store the lazy resolver pointer, however in
15785              a static binary it may well have been omitted and GOT
15786              reduced to a table of addresses.
15787              PR 21344: Check for the entry being fully available
15788              before fetching it.  */
15789           if (data
15790               && data + ent - pltgot + addr_size <= data_end
15791               && byte_get (data + ent - pltgot, addr_size) == 0)
15792             {
15793               printf (_(" Reserved entries:\n"));
15794               printf (_("  %*s %10s %*s\n"),
15795                       addr_size * 2, _("Address"), _("Access"),
15796                       addr_size * 2, _("Value"));
15797               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15798               printf ("\n");
15799               if (ent == (bfd_vma) -1)
15800                 goto sgot_print_fail;
15801
15802               /* Check for the MSB of GOT[1] being set, identifying a
15803                  GNU object.  This entry will be used by some runtime
15804                  loaders, to store the module pointer.  Otherwise this
15805                  is an ordinary local entry.
15806                  PR 21344: Check for the entry being fully available
15807                  before fetching it.  */
15808               if (data
15809                   && data + ent - pltgot + addr_size <= data_end
15810                   && (byte_get (data + ent - pltgot, addr_size)
15811                       >> (addr_size * 8 - 1)) != 0)
15812                 {
15813                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15814                   printf ("\n");
15815                   if (ent == (bfd_vma) -1)
15816                     goto sgot_print_fail;
15817                 }
15818               printf ("\n");
15819             }
15820
15821           if (data != NULL && ent < end)
15822             {
15823               printf (_(" Local entries:\n"));
15824               printf ("  %*s %10s %*s\n",
15825                       addr_size * 2, _("Address"), _("Access"),
15826                       addr_size * 2, _("Value"));
15827               while (ent < end)
15828                 {
15829                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15830                   printf ("\n");
15831                   if (ent == (bfd_vma) -1)
15832                     goto sgot_print_fail;
15833                 }
15834               printf ("\n");
15835             }
15836
15837         sgot_print_fail:
15838           if (data)
15839             free (data);
15840         }
15841       return res;
15842     }
15843
15844   for (entry = dynamic_section;
15845        /* PR 17531 file: 012-50589-0.004.  */
15846        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15847        ++entry)
15848     switch (entry->d_tag)
15849       {
15850       case DT_MIPS_LIBLIST:
15851         liblist_offset
15852           = offset_from_vma (filedata, entry->d_un.d_val,
15853                              liblistno * sizeof (Elf32_External_Lib));
15854         break;
15855       case DT_MIPS_LIBLISTNO:
15856         liblistno = entry->d_un.d_val;
15857         break;
15858       case DT_MIPS_OPTIONS:
15859         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15860         break;
15861       case DT_MIPS_CONFLICT:
15862         conflicts_offset
15863           = offset_from_vma (filedata, entry->d_un.d_val,
15864                              conflictsno * sizeof (Elf32_External_Conflict));
15865         break;
15866       case DT_MIPS_CONFLICTNO:
15867         conflictsno = entry->d_un.d_val;
15868         break;
15869       case DT_PLTGOT:
15870         pltgot = entry->d_un.d_ptr;
15871         break;
15872       case DT_MIPS_LOCAL_GOTNO:
15873         local_gotno = entry->d_un.d_val;
15874         break;
15875       case DT_MIPS_GOTSYM:
15876         gotsym = entry->d_un.d_val;
15877         break;
15878       case DT_MIPS_SYMTABNO:
15879         symtabno = entry->d_un.d_val;
15880         break;
15881       case DT_MIPS_PLTGOT:
15882         mips_pltgot = entry->d_un.d_ptr;
15883         break;
15884       case DT_PLTREL:
15885         pltrel = entry->d_un.d_val;
15886         break;
15887       case DT_PLTRELSZ:
15888         pltrelsz = entry->d_un.d_val;
15889         break;
15890       case DT_JMPREL:
15891         jmprel = entry->d_un.d_ptr;
15892         break;
15893       default:
15894         break;
15895       }
15896
15897   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15898     {
15899       Elf32_External_Lib * elib;
15900       size_t cnt;
15901
15902       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15903                                               liblistno,
15904                                               sizeof (Elf32_External_Lib),
15905                                               _("liblist section data"));
15906       if (elib)
15907         {
15908           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15909                             "\nSection '.liblist' contains %lu entries:\n",
15910                             (unsigned long) liblistno),
15911                   (unsigned long) liblistno);
15912           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15913                  stdout);
15914
15915           for (cnt = 0; cnt < liblistno; ++cnt)
15916             {
15917               Elf32_Lib liblist;
15918               time_t atime;
15919               char timebuf[128];
15920               struct tm * tmp;
15921
15922               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15923               atime = BYTE_GET (elib[cnt].l_time_stamp);
15924               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15925               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15926               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15927
15928               tmp = gmtime (&atime);
15929               snprintf (timebuf, sizeof (timebuf),
15930                         "%04u-%02u-%02uT%02u:%02u:%02u",
15931                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15932                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15933
15934               printf ("%3lu: ", (unsigned long) cnt);
15935               if (VALID_DYNAMIC_NAME (liblist.l_name))
15936                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15937               else
15938                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15939               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15940                       liblist.l_version);
15941
15942               if (liblist.l_flags == 0)
15943                 puts (_(" NONE"));
15944               else
15945                 {
15946                   static const struct
15947                   {
15948                     const char * name;
15949                     int bit;
15950                   }
15951                   l_flags_vals[] =
15952                   {
15953                     { " EXACT_MATCH", LL_EXACT_MATCH },
15954                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15955                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15956                     { " EXPORTS", LL_EXPORTS },
15957                     { " DELAY_LOAD", LL_DELAY_LOAD },
15958                     { " DELTA", LL_DELTA }
15959                   };
15960                   int flags = liblist.l_flags;
15961                   size_t fcnt;
15962
15963                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15964                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15965                       {
15966                         fputs (l_flags_vals[fcnt].name, stdout);
15967                         flags ^= l_flags_vals[fcnt].bit;
15968                       }
15969                   if (flags != 0)
15970                     printf (" %#x", (unsigned int) flags);
15971
15972                   puts ("");
15973                 }
15974             }
15975
15976           free (elib);
15977         }
15978       else
15979         res = FALSE;
15980     }
15981
15982   if (options_offset != 0)
15983     {
15984       Elf_External_Options * eopt;
15985       Elf_Internal_Options * iopt;
15986       Elf_Internal_Options * option;
15987       size_t offset;
15988       int cnt;
15989       sect = filedata->section_headers;
15990
15991       /* Find the section header so that we get the size.  */
15992       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
15993       /* PR 17533 file: 012-277276-0.004.  */
15994       if (sect == NULL)
15995         {
15996           error (_("No MIPS_OPTIONS header found\n"));
15997           return FALSE;
15998         }
15999
16000       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16001                                                 sect->sh_size, _("options"));
16002       if (eopt)
16003         {
16004           iopt = (Elf_Internal_Options *)
16005               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16006           if (iopt == NULL)
16007             {
16008               error (_("Out of memory allocating space for MIPS options\n"));
16009               return FALSE;
16010             }
16011
16012           offset = cnt = 0;
16013           option = iopt;
16014
16015           while (offset <= sect->sh_size - sizeof (* eopt))
16016             {
16017               Elf_External_Options * eoption;
16018
16019               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16020
16021               option->kind = BYTE_GET (eoption->kind);
16022               option->size = BYTE_GET (eoption->size);
16023               option->section = BYTE_GET (eoption->section);
16024               option->info = BYTE_GET (eoption->info);
16025
16026               /* PR 17531: file: ffa0fa3b.  */
16027               if (option->size < sizeof (* eopt)
16028                   || offset + option->size > sect->sh_size)
16029                 {
16030                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
16031                   return FALSE;
16032                 }
16033               offset += option->size;
16034
16035               ++option;
16036               ++cnt;
16037             }
16038
16039           printf (ngettext ("\nSection '%s' contains %d entry:\n",
16040                             "\nSection '%s' contains %d entries:\n",
16041                             cnt),
16042                   printable_section_name (filedata, sect), cnt);
16043
16044           option = iopt;
16045           offset = 0;
16046
16047           while (cnt-- > 0)
16048             {
16049               size_t len;
16050
16051               switch (option->kind)
16052                 {
16053                 case ODK_NULL:
16054                   /* This shouldn't happen.  */
16055                   printf (" NULL       %d %lx", option->section, option->info);
16056                   break;
16057                 case ODK_REGINFO:
16058                   printf (" REGINFO    ");
16059                   if (filedata->file_header.e_machine == EM_MIPS)
16060                     {
16061                       /* 32bit form.  */
16062                       Elf32_External_RegInfo * ereg;
16063                       Elf32_RegInfo reginfo;
16064
16065                       ereg = (Elf32_External_RegInfo *) (option + 1);
16066                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16067                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16068                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16069                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16070                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16071                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16072
16073                       printf ("GPR %08lx  GP 0x%lx\n",
16074                               reginfo.ri_gprmask,
16075                               (unsigned long) reginfo.ri_gp_value);
16076                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16077                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16078                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16079                     }
16080                   else
16081                     {
16082                       /* 64 bit form.  */
16083                       Elf64_External_RegInfo * ereg;
16084                       Elf64_Internal_RegInfo reginfo;
16085
16086                       ereg = (Elf64_External_RegInfo *) (option + 1);
16087                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
16088                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16089                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16090                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16091                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16092                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16093
16094                       printf ("GPR %08lx  GP 0x",
16095                               reginfo.ri_gprmask);
16096                       printf_vma (reginfo.ri_gp_value);
16097                       printf ("\n");
16098
16099                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16100                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16101                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16102                     }
16103                   ++option;
16104                   continue;
16105                 case ODK_EXCEPTIONS:
16106                   fputs (" EXCEPTIONS fpe_min(", stdout);
16107                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16108                   fputs (") fpe_max(", stdout);
16109                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16110                   fputs (")", stdout);
16111
16112                   if (option->info & OEX_PAGE0)
16113                     fputs (" PAGE0", stdout);
16114                   if (option->info & OEX_SMM)
16115                     fputs (" SMM", stdout);
16116                   if (option->info & OEX_FPDBUG)
16117                     fputs (" FPDBUG", stdout);
16118                   if (option->info & OEX_DISMISS)
16119                     fputs (" DISMISS", stdout);
16120                   break;
16121                 case ODK_PAD:
16122                   fputs (" PAD       ", stdout);
16123                   if (option->info & OPAD_PREFIX)
16124                     fputs (" PREFIX", stdout);
16125                   if (option->info & OPAD_POSTFIX)
16126                     fputs (" POSTFIX", stdout);
16127                   if (option->info & OPAD_SYMBOL)
16128                     fputs (" SYMBOL", stdout);
16129                   break;
16130                 case ODK_HWPATCH:
16131                   fputs (" HWPATCH   ", stdout);
16132                   if (option->info & OHW_R4KEOP)
16133                     fputs (" R4KEOP", stdout);
16134                   if (option->info & OHW_R8KPFETCH)
16135                     fputs (" R8KPFETCH", stdout);
16136                   if (option->info & OHW_R5KEOP)
16137                     fputs (" R5KEOP", stdout);
16138                   if (option->info & OHW_R5KCVTL)
16139                     fputs (" R5KCVTL", stdout);
16140                   break;
16141                 case ODK_FILL:
16142                   fputs (" FILL       ", stdout);
16143                   /* XXX Print content of info word?  */
16144                   break;
16145                 case ODK_TAGS:
16146                   fputs (" TAGS       ", stdout);
16147                   /* XXX Print content of info word?  */
16148                   break;
16149                 case ODK_HWAND:
16150                   fputs (" HWAND     ", stdout);
16151                   if (option->info & OHWA0_R4KEOP_CHECKED)
16152                     fputs (" R4KEOP_CHECKED", stdout);
16153                   if (option->info & OHWA0_R4KEOP_CLEAN)
16154                     fputs (" R4KEOP_CLEAN", stdout);
16155                   break;
16156                 case ODK_HWOR:
16157                   fputs (" HWOR      ", stdout);
16158                   if (option->info & OHWA0_R4KEOP_CHECKED)
16159                     fputs (" R4KEOP_CHECKED", stdout);
16160                   if (option->info & OHWA0_R4KEOP_CLEAN)
16161                     fputs (" R4KEOP_CLEAN", stdout);
16162                   break;
16163                 case ODK_GP_GROUP:
16164                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16165                           option->info & OGP_GROUP,
16166                           (option->info & OGP_SELF) >> 16);
16167                   break;
16168                 case ODK_IDENT:
16169                   printf (" IDENT     %#06lx  self-contained %#06lx",
16170                           option->info & OGP_GROUP,
16171                           (option->info & OGP_SELF) >> 16);
16172                   break;
16173                 default:
16174                   /* This shouldn't happen.  */
16175                   printf (" %3d ???     %d %lx",
16176                           option->kind, option->section, option->info);
16177                   break;
16178                 }
16179
16180               len = sizeof (* eopt);
16181               while (len < option->size)
16182                 {
16183                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16184
16185                   if (ISPRINT (datum))
16186                     printf ("%c", datum);
16187                   else
16188                     printf ("\\%03o", datum);
16189                   len ++;
16190                 }
16191               fputs ("\n", stdout);
16192
16193               offset += option->size;
16194               ++option;
16195             }
16196
16197           free (eopt);
16198         }
16199       else
16200         res = FALSE;
16201     }
16202
16203   if (conflicts_offset != 0 && conflictsno != 0)
16204     {
16205       Elf32_Conflict * iconf;
16206       size_t cnt;
16207
16208       if (dynamic_symbols == NULL)
16209         {
16210           error (_("conflict list found without a dynamic symbol table\n"));
16211           return FALSE;
16212         }
16213
16214       /* PR 21345 - print a slightly more helpful error message
16215          if we are sure that the cmalloc will fail.  */
16216       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16217         {
16218           error (_("Overlarge number of conflicts detected: %lx\n"),
16219                  (long) conflictsno);
16220           return FALSE;
16221         }
16222
16223       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16224       if (iconf == NULL)
16225         {
16226           error (_("Out of memory allocating space for dynamic conflicts\n"));
16227           return FALSE;
16228         }
16229
16230       if (is_32bit_elf)
16231         {
16232           Elf32_External_Conflict * econf32;
16233
16234           econf32 = (Elf32_External_Conflict *)
16235               get_data (NULL, filedata, conflicts_offset, conflictsno,
16236                         sizeof (* econf32), _("conflict"));
16237           if (!econf32)
16238             return FALSE;
16239
16240           for (cnt = 0; cnt < conflictsno; ++cnt)
16241             iconf[cnt] = BYTE_GET (econf32[cnt]);
16242
16243           free (econf32);
16244         }
16245       else
16246         {
16247           Elf64_External_Conflict * econf64;
16248
16249           econf64 = (Elf64_External_Conflict *)
16250               get_data (NULL, filedata, conflicts_offset, conflictsno,
16251                         sizeof (* econf64), _("conflict"));
16252           if (!econf64)
16253             return FALSE;
16254
16255           for (cnt = 0; cnt < conflictsno; ++cnt)
16256             iconf[cnt] = BYTE_GET (econf64[cnt]);
16257
16258           free (econf64);
16259         }
16260
16261       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16262                         "\nSection '.conflict' contains %lu entries:\n",
16263                         (unsigned long) conflictsno),
16264               (unsigned long) conflictsno);
16265       puts (_("  Num:    Index       Value  Name"));
16266
16267       for (cnt = 0; cnt < conflictsno; ++cnt)
16268         {
16269           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16270
16271           if (iconf[cnt] >= num_dynamic_syms)
16272             printf (_("<corrupt symbol index>"));
16273           else
16274             {
16275               Elf_Internal_Sym * psym;
16276
16277               psym = & dynamic_symbols[iconf[cnt]];
16278               print_vma (psym->st_value, FULL_HEX);
16279               putchar (' ');
16280               if (VALID_DYNAMIC_NAME (psym->st_name))
16281                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16282               else
16283                 printf (_("<corrupt: %14ld>"), psym->st_name);
16284             }
16285           putchar ('\n');
16286         }
16287
16288       free (iconf);
16289     }
16290
16291   if (pltgot != 0 && local_gotno != 0)
16292     {
16293       bfd_vma ent, local_end, global_end;
16294       size_t i, offset;
16295       unsigned char * data;
16296       unsigned char * data_end;
16297       int addr_size;
16298
16299       ent = pltgot;
16300       addr_size = (is_32bit_elf ? 4 : 8);
16301       local_end = pltgot + local_gotno * addr_size;
16302
16303       /* PR binutils/17533 file: 012-111227-0.004  */
16304       if (symtabno < gotsym)
16305         {
16306           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16307                  (unsigned long) gotsym, (unsigned long) symtabno);
16308           return FALSE;
16309         }
16310
16311       global_end = local_end + (symtabno - gotsym) * addr_size;
16312       /* PR 17531: file: 54c91a34.  */
16313       if (global_end < local_end)
16314         {
16315           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16316           return FALSE;
16317         }
16318
16319       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16320       data = (unsigned char *) get_data (NULL, filedata, offset,
16321                                          global_end - pltgot, 1,
16322                                          _("Global Offset Table data"));
16323       /* PR 12855: Null data is handled gracefully throughout.  */
16324       data_end = data + (global_end - pltgot);
16325
16326       printf (_("\nPrimary GOT:\n"));
16327       printf (_(" Canonical gp value: "));
16328       print_vma (pltgot + 0x7ff0, LONG_HEX);
16329       printf ("\n\n");
16330
16331       printf (_(" Reserved entries:\n"));
16332       printf (_("  %*s %10s %*s Purpose\n"),
16333               addr_size * 2, _("Address"), _("Access"),
16334               addr_size * 2, _("Initial"));
16335       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16336       printf (_(" Lazy resolver\n"));
16337       if (ent == (bfd_vma) -1)
16338         goto got_print_fail;
16339
16340       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16341          This entry will be used by some runtime loaders, to store the
16342          module pointer.  Otherwise this is an ordinary local entry.
16343          PR 21344: Check for the entry being fully available before
16344          fetching it.  */
16345       if (data
16346           && data + ent - pltgot + addr_size <= data_end
16347           && (byte_get (data + ent - pltgot, addr_size)
16348               >> (addr_size * 8 - 1)) != 0)
16349         {
16350           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16351           printf (_(" Module pointer (GNU extension)\n"));
16352           if (ent == (bfd_vma) -1)
16353             goto got_print_fail;
16354         }
16355       printf ("\n");
16356
16357       if (data != NULL && ent < local_end)
16358         {
16359           printf (_(" Local entries:\n"));
16360           printf ("  %*s %10s %*s\n",
16361                   addr_size * 2, _("Address"), _("Access"),
16362                   addr_size * 2, _("Initial"));
16363           while (ent < local_end)
16364             {
16365               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16366               printf ("\n");
16367               if (ent == (bfd_vma) -1)
16368                 goto got_print_fail;
16369             }
16370           printf ("\n");
16371         }
16372
16373       if (data != NULL && gotsym < symtabno)
16374         {
16375           int sym_width;
16376
16377           printf (_(" Global entries:\n"));
16378           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16379                   addr_size * 2, _("Address"),
16380                   _("Access"),
16381                   addr_size * 2, _("Initial"),
16382                   addr_size * 2, _("Sym.Val."),
16383                   _("Type"),
16384                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16385                   _("Ndx"), _("Name"));
16386
16387           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16388
16389           for (i = gotsym; i < symtabno; i++)
16390             {
16391               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16392               printf (" ");
16393
16394               if (dynamic_symbols == NULL)
16395                 printf (_("<no dynamic symbols>"));
16396               else if (i < num_dynamic_syms)
16397                 {
16398                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16399
16400                   print_vma (psym->st_value, LONG_HEX);
16401                   printf (" %-7s %3s ",
16402                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16403                           get_symbol_index_type (filedata, psym->st_shndx));
16404
16405                   if (VALID_DYNAMIC_NAME (psym->st_name))
16406                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16407                   else
16408                     printf (_("<corrupt: %14ld>"), psym->st_name);
16409                 }
16410               else
16411                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16412                         (unsigned long) i);
16413
16414               printf ("\n");
16415               if (ent == (bfd_vma) -1)
16416                 break;
16417             }
16418           printf ("\n");
16419         }
16420
16421     got_print_fail:
16422       if (data)
16423         free (data);
16424     }
16425
16426   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16427     {
16428       bfd_vma ent, end;
16429       size_t offset, rel_offset;
16430       unsigned long count, i;
16431       unsigned char * data;
16432       int addr_size, sym_width;
16433       Elf_Internal_Rela * rels;
16434
16435       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16436       if (pltrel == DT_RELA)
16437         {
16438           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16439             return FALSE;
16440         }
16441       else
16442         {
16443           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16444             return FALSE;
16445         }
16446
16447       ent = mips_pltgot;
16448       addr_size = (is_32bit_elf ? 4 : 8);
16449       end = mips_pltgot + (2 + count) * addr_size;
16450
16451       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16452       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16453                                          1, _("Procedure Linkage Table data"));
16454       if (data == NULL)
16455         return FALSE;
16456
16457       printf ("\nPLT GOT:\n\n");
16458       printf (_(" Reserved entries:\n"));
16459       printf (_("  %*s %*s Purpose\n"),
16460               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16461       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16462       printf (_(" PLT lazy resolver\n"));
16463       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16464       printf (_(" Module pointer\n"));
16465       printf ("\n");
16466
16467       printf (_(" Entries:\n"));
16468       printf ("  %*s %*s %*s %-7s %3s %s\n",
16469               addr_size * 2, _("Address"),
16470               addr_size * 2, _("Initial"),
16471               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16472       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16473       for (i = 0; i < count; i++)
16474         {
16475           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16476
16477           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16478           printf (" ");
16479
16480           if (idx >= num_dynamic_syms)
16481             printf (_("<corrupt symbol index: %lu>"), idx);
16482           else
16483             {
16484               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16485
16486               print_vma (psym->st_value, LONG_HEX);
16487               printf (" %-7s %3s ",
16488                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16489                       get_symbol_index_type (filedata, psym->st_shndx));
16490               if (VALID_DYNAMIC_NAME (psym->st_name))
16491                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16492               else
16493                 printf (_("<corrupt: %14ld>"), psym->st_name);
16494             }
16495           printf ("\n");
16496         }
16497       printf ("\n");
16498
16499       if (data)
16500         free (data);
16501       free (rels);
16502     }
16503
16504   return res;
16505 }
16506
16507 static bfd_boolean
16508 process_nds32_specific (Filedata * filedata)
16509 {
16510   Elf_Internal_Shdr *sect = NULL;
16511
16512   sect = find_section (filedata, ".nds32_e_flags");
16513   if (sect != NULL)
16514     {
16515       unsigned int *flag;
16516
16517       printf ("\nNDS32 elf flags section:\n");
16518       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16519                        sect->sh_size, _("NDS32 elf flags section"));
16520
16521       if (! flag)
16522         return FALSE;
16523
16524       switch ((*flag) & 0x3)
16525         {
16526         case 0:
16527           printf ("(VEC_SIZE):\tNo entry.\n");
16528           break;
16529         case 1:
16530           printf ("(VEC_SIZE):\t4 bytes\n");
16531           break;
16532         case 2:
16533           printf ("(VEC_SIZE):\t16 bytes\n");
16534           break;
16535         case 3:
16536           printf ("(VEC_SIZE):\treserved\n");
16537           break;
16538         }
16539     }
16540
16541   return TRUE;
16542 }
16543
16544 static bfd_boolean
16545 process_gnu_liblist (Filedata * filedata)
16546 {
16547   Elf_Internal_Shdr * section;
16548   Elf_Internal_Shdr * string_sec;
16549   Elf32_External_Lib * elib;
16550   char * strtab;
16551   size_t strtab_size;
16552   size_t cnt;
16553   unsigned long num_liblist;
16554   unsigned i;
16555   bfd_boolean res = TRUE;
16556
16557   if (! do_arch)
16558     return TRUE;
16559
16560   for (i = 0, section = filedata->section_headers;
16561        i < filedata->file_header.e_shnum;
16562        i++, section++)
16563     {
16564       switch (section->sh_type)
16565         {
16566         case SHT_GNU_LIBLIST:
16567           if (section->sh_link >= filedata->file_header.e_shnum)
16568             break;
16569
16570           elib = (Elf32_External_Lib *)
16571               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16572                         _("liblist section data"));
16573
16574           if (elib == NULL)
16575             {
16576               res = FALSE;
16577               break;
16578             }
16579
16580           string_sec = filedata->section_headers + section->sh_link;
16581           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16582                                       string_sec->sh_size,
16583                                       _("liblist string table"));
16584           if (strtab == NULL
16585               || section->sh_entsize != sizeof (Elf32_External_Lib))
16586             {
16587               free (elib);
16588               free (strtab);
16589               res = FALSE;
16590               break;
16591             }
16592           strtab_size = string_sec->sh_size;
16593
16594           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16595           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16596                             "\nLibrary list section '%s' contains %lu entries:\n",
16597                             num_liblist),
16598                   printable_section_name (filedata, section),
16599                   num_liblist);
16600
16601           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16602
16603           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16604                ++cnt)
16605             {
16606               Elf32_Lib liblist;
16607               time_t atime;
16608               char timebuf[128];
16609               struct tm * tmp;
16610
16611               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16612               atime = BYTE_GET (elib[cnt].l_time_stamp);
16613               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16614               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16615               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16616
16617               tmp = gmtime (&atime);
16618               snprintf (timebuf, sizeof (timebuf),
16619                         "%04u-%02u-%02uT%02u:%02u:%02u",
16620                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16621                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16622
16623               printf ("%3lu: ", (unsigned long) cnt);
16624               if (do_wide)
16625                 printf ("%-20s", liblist.l_name < strtab_size
16626                         ? strtab + liblist.l_name : _("<corrupt>"));
16627               else
16628                 printf ("%-20.20s", liblist.l_name < strtab_size
16629                         ? strtab + liblist.l_name : _("<corrupt>"));
16630               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16631                       liblist.l_version, liblist.l_flags);
16632             }
16633
16634           free (elib);
16635           free (strtab);
16636         }
16637     }
16638
16639   return res;
16640 }
16641
16642 static const char *
16643 get_note_type (Filedata * filedata, unsigned e_type)
16644 {
16645   static char buff[64];
16646
16647   if (filedata->file_header.e_type == ET_CORE)
16648     switch (e_type)
16649       {
16650       case NT_AUXV:
16651         return _("NT_AUXV (auxiliary vector)");
16652       case NT_PRSTATUS:
16653         return _("NT_PRSTATUS (prstatus structure)");
16654       case NT_FPREGSET:
16655         return _("NT_FPREGSET (floating point registers)");
16656       case NT_PRPSINFO:
16657         return _("NT_PRPSINFO (prpsinfo structure)");
16658       case NT_TASKSTRUCT:
16659         return _("NT_TASKSTRUCT (task structure)");
16660       case NT_PRXFPREG:
16661         return _("NT_PRXFPREG (user_xfpregs structure)");
16662       case NT_PPC_VMX:
16663         return _("NT_PPC_VMX (ppc Altivec registers)");
16664       case NT_PPC_VSX:
16665         return _("NT_PPC_VSX (ppc VSX registers)");
16666       case NT_PPC_TAR:
16667         return _("NT_PPC_TAR (ppc TAR register)");
16668       case NT_PPC_PPR:
16669         return _("NT_PPC_PPR (ppc PPR register)");
16670       case NT_PPC_DSCR:
16671         return _("NT_PPC_DSCR (ppc DSCR register)");
16672       case NT_PPC_EBB:
16673         return _("NT_PPC_EBB (ppc EBB registers)");
16674       case NT_PPC_PMU:
16675         return _("NT_PPC_PMU (ppc PMU registers)");
16676       case NT_PPC_TM_CGPR:
16677         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16678       case NT_PPC_TM_CFPR:
16679         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16680       case NT_PPC_TM_CVMX:
16681         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16682       case NT_PPC_TM_CVSX:
16683         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16684       case NT_PPC_TM_SPR:
16685         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16686       case NT_PPC_TM_CTAR:
16687         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16688       case NT_PPC_TM_CPPR:
16689         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16690       case NT_PPC_TM_CDSCR:
16691         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16692       case NT_386_TLS:
16693         return _("NT_386_TLS (x86 TLS information)");
16694       case NT_386_IOPERM:
16695         return _("NT_386_IOPERM (x86 I/O permissions)");
16696       case NT_X86_XSTATE:
16697         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16698       case NT_S390_HIGH_GPRS:
16699         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16700       case NT_S390_TIMER:
16701         return _("NT_S390_TIMER (s390 timer register)");
16702       case NT_S390_TODCMP:
16703         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16704       case NT_S390_TODPREG:
16705         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16706       case NT_S390_CTRS:
16707         return _("NT_S390_CTRS (s390 control registers)");
16708       case NT_S390_PREFIX:
16709         return _("NT_S390_PREFIX (s390 prefix register)");
16710       case NT_S390_LAST_BREAK:
16711         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16712       case NT_S390_SYSTEM_CALL:
16713         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16714       case NT_S390_TDB:
16715         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16716       case NT_S390_VXRS_LOW:
16717         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16718       case NT_S390_VXRS_HIGH:
16719         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16720       case NT_S390_GS_CB:
16721         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16722       case NT_S390_GS_BC:
16723         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16724       case NT_ARM_VFP:
16725         return _("NT_ARM_VFP (arm VFP registers)");
16726       case NT_ARM_TLS:
16727         return _("NT_ARM_TLS (AArch TLS registers)");
16728       case NT_ARM_HW_BREAK:
16729         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16730       case NT_ARM_HW_WATCH:
16731         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16732       case NT_PSTATUS:
16733         return _("NT_PSTATUS (pstatus structure)");
16734       case NT_FPREGS:
16735         return _("NT_FPREGS (floating point registers)");
16736       case NT_PSINFO:
16737         return _("NT_PSINFO (psinfo structure)");
16738       case NT_LWPSTATUS:
16739         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16740       case NT_LWPSINFO:
16741         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16742       case NT_WIN32PSTATUS:
16743         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16744       case NT_SIGINFO:
16745         return _("NT_SIGINFO (siginfo_t data)");
16746       case NT_FILE:
16747         return _("NT_FILE (mapped files)");
16748       default:
16749         break;
16750       }
16751   else
16752     switch (e_type)
16753       {
16754       case NT_VERSION:
16755         return _("NT_VERSION (version)");
16756       case NT_ARCH:
16757         return _("NT_ARCH (architecture)");
16758       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16759         return _("OPEN");
16760       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16761         return _("func");
16762       default:
16763         break;
16764       }
16765
16766   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16767   return buff;
16768 }
16769
16770 static bfd_boolean
16771 print_core_note (Elf_Internal_Note *pnote)
16772 {
16773   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16774   bfd_vma count, page_size;
16775   unsigned char *descdata, *filenames, *descend;
16776
16777   if (pnote->type != NT_FILE)
16778     {
16779       if (do_wide)
16780         printf ("\n");
16781       return TRUE;
16782     }
16783
16784 #ifndef BFD64
16785   if (!is_32bit_elf)
16786     {
16787       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16788       /* Still "successful".  */
16789       return TRUE;
16790     }
16791 #endif
16792
16793   if (pnote->descsz < 2 * addr_size)
16794     {
16795       error (_("    Malformed note - too short for header\n"));
16796       return FALSE;
16797     }
16798
16799   descdata = (unsigned char *) pnote->descdata;
16800   descend = descdata + pnote->descsz;
16801
16802   if (descdata[pnote->descsz - 1] != '\0')
16803     {
16804       error (_("    Malformed note - does not end with \\0\n"));
16805       return FALSE;
16806     }
16807
16808   count = byte_get (descdata, addr_size);
16809   descdata += addr_size;
16810
16811   page_size = byte_get (descdata, addr_size);
16812   descdata += addr_size;
16813
16814   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16815       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16816     {
16817       error (_("    Malformed note - too short for supplied file count\n"));
16818       return FALSE;
16819     }
16820
16821   printf (_("    Page size: "));
16822   print_vma (page_size, DEC);
16823   printf ("\n");
16824
16825   printf (_("    %*s%*s%*s\n"),
16826           (int) (2 + 2 * addr_size), _("Start"),
16827           (int) (4 + 2 * addr_size), _("End"),
16828           (int) (4 + 2 * addr_size), _("Page Offset"));
16829   filenames = descdata + count * 3 * addr_size;
16830   while (count-- > 0)
16831     {
16832       bfd_vma start, end, file_ofs;
16833
16834       if (filenames == descend)
16835         {
16836           error (_("    Malformed note - filenames end too early\n"));
16837           return FALSE;
16838         }
16839
16840       start = byte_get (descdata, addr_size);
16841       descdata += addr_size;
16842       end = byte_get (descdata, addr_size);
16843       descdata += addr_size;
16844       file_ofs = byte_get (descdata, addr_size);
16845       descdata += addr_size;
16846
16847       printf ("    ");
16848       print_vma (start, FULL_HEX);
16849       printf ("  ");
16850       print_vma (end, FULL_HEX);
16851       printf ("  ");
16852       print_vma (file_ofs, FULL_HEX);
16853       printf ("\n        %s\n", filenames);
16854
16855       filenames += 1 + strlen ((char *) filenames);
16856     }
16857
16858   return TRUE;
16859 }
16860
16861 static const char *
16862 get_gnu_elf_note_type (unsigned e_type)
16863 {
16864   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16865   switch (e_type)
16866     {
16867     case NT_GNU_ABI_TAG:
16868       return _("NT_GNU_ABI_TAG (ABI version tag)");
16869     case NT_GNU_HWCAP:
16870       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16871     case NT_GNU_BUILD_ID:
16872       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16873     case NT_GNU_GOLD_VERSION:
16874       return _("NT_GNU_GOLD_VERSION (gold version)");
16875     case NT_GNU_PROPERTY_TYPE_0:
16876       return _("NT_GNU_PROPERTY_TYPE_0");
16877     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16878       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16879     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16880       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16881     default:
16882       {
16883         static char buff[64];
16884
16885         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16886         return buff;
16887       }
16888     }
16889 }
16890
16891 static void
16892 decode_x86_isa (unsigned int bitmask)
16893 {
16894   while (bitmask)
16895     {
16896       unsigned int bit = bitmask & (- bitmask);
16897
16898       bitmask &= ~ bit;
16899       switch (bit)
16900         {
16901         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16902         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16903         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16904         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16905         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16906         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16907         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16908         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16909         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16910         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16911         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16912         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16913         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16914         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16915         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16916         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16917         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16918         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16919         default: printf (_("<unknown: %x>"), bit); break;
16920         }
16921       if (bitmask)
16922         printf (", ");
16923     }
16924 }
16925
16926 static void
16927 decode_x86_feature (unsigned int type, unsigned int bitmask)
16928 {
16929   while (bitmask)
16930     {
16931       unsigned int bit = bitmask & (- bitmask);
16932
16933       bitmask &= ~ bit;
16934       switch (bit)
16935         {
16936         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16937           switch (type)
16938             {
16939             case GNU_PROPERTY_X86_FEATURE_1_AND:
16940               printf ("IBT");
16941               break;
16942             default:
16943               /* This should never happen.  */
16944               abort ();
16945             }
16946           break;
16947         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16948           switch (type)
16949             {
16950             case GNU_PROPERTY_X86_FEATURE_1_AND:
16951               printf ("SHSTK");
16952               break;
16953             default:
16954               /* This should never happen.  */
16955               abort ();
16956             }
16957           break;
16958         default:
16959           printf (_("<unknown: %x>"), bit);
16960           break;
16961         }
16962       if (bitmask)
16963         printf (", ");
16964     }
16965 }
16966
16967 static void
16968 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
16969 {
16970   unsigned char * ptr = (unsigned char *) pnote->descdata;
16971   unsigned char * ptr_end = ptr + pnote->descsz;
16972   unsigned int    size = is_32bit_elf ? 4 : 8;
16973
16974   printf (_("      Properties: "));
16975
16976   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16977     {
16978       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16979       return;
16980     }
16981
16982   while (ptr < ptr_end)
16983     {
16984       unsigned int j;
16985       unsigned int type;
16986       unsigned int datasz;
16987
16988       if ((size_t) (ptr_end - ptr) < 8)
16989         {
16990           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16991           break;
16992         }
16993
16994       type = byte_get (ptr, 4);
16995       datasz = byte_get (ptr + 4, 4);
16996
16997       ptr += 8;
16998
16999       if (datasz > (size_t) (ptr_end - ptr))
17000         {
17001           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17002                   type, datasz);
17003           break;
17004         }
17005
17006       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17007         {
17008           if (filedata->file_header.e_machine == EM_X86_64
17009               || filedata->file_header.e_machine == EM_IAMCU
17010               || filedata->file_header.e_machine == EM_386)
17011             {
17012               switch (type)
17013                 {
17014                 case GNU_PROPERTY_X86_ISA_1_USED:
17015                   printf ("x86 ISA used: ");
17016                   if (datasz != 4)
17017                     printf (_("<corrupt length: %#x> "), datasz);
17018                   else
17019                     decode_x86_isa (byte_get (ptr, 4));
17020                   goto next;
17021
17022                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17023                   printf ("x86 ISA needed: ");
17024                   if (datasz != 4)
17025                     printf (_("<corrupt length: %#x> "), datasz);
17026                   else
17027                     decode_x86_isa (byte_get (ptr, 4));
17028                   goto next;
17029
17030                 case GNU_PROPERTY_X86_FEATURE_1_AND:
17031                   printf ("x86 feature: ");
17032                   if (datasz != 4)
17033                     printf (_("<corrupt length: %#x> "), datasz);
17034                   else
17035                     decode_x86_feature (type, byte_get (ptr, 4));
17036                   goto next;
17037
17038                 default:
17039                   break;
17040                 }
17041             }
17042         }
17043       else
17044         {
17045           switch (type)
17046             {
17047             case GNU_PROPERTY_STACK_SIZE:
17048               printf (_("stack size: "));
17049               if (datasz != size)
17050                 printf (_("<corrupt length: %#x> "), datasz);
17051               else
17052                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17053               goto next;
17054
17055             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17056               printf ("no copy on protected ");
17057               if (datasz)
17058                 printf (_("<corrupt length: %#x> "), datasz);
17059               goto next;
17060
17061             default:
17062               break;
17063             }
17064         }
17065
17066       if (type < GNU_PROPERTY_LOPROC)
17067         printf (_("<unknown type %#x data: "), type);
17068       else if (type < GNU_PROPERTY_LOUSER)
17069         printf (_("<procesor-specific type %#x data: "), type);
17070       else
17071         printf (_("<application-specific type %#x data: "), type);
17072       for (j = 0; j < datasz; ++j)
17073         printf ("%02x ", ptr[j] & 0xff);
17074       printf (">");
17075
17076 next:
17077       ptr += ((datasz + (size - 1)) & ~ (size - 1));
17078       if (ptr == ptr_end)
17079         break;
17080
17081       if (do_wide)
17082         printf (", ");
17083       else
17084         printf ("\n\t");
17085     }
17086
17087   printf ("\n");
17088 }
17089
17090 static bfd_boolean
17091 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17092 {
17093   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17094   switch (pnote->type)
17095     {
17096     case NT_GNU_BUILD_ID:
17097       {
17098         unsigned long i;
17099
17100         printf (_("    Build ID: "));
17101         for (i = 0; i < pnote->descsz; ++i)
17102           printf ("%02x", pnote->descdata[i] & 0xff);
17103         printf ("\n");
17104       }
17105       break;
17106
17107     case NT_GNU_ABI_TAG:
17108       {
17109         unsigned long os, major, minor, subminor;
17110         const char *osname;
17111
17112         /* PR 17531: file: 030-599401-0.004.  */
17113         if (pnote->descsz < 16)
17114           {
17115             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17116             break;
17117           }
17118
17119         os = byte_get ((unsigned char *) pnote->descdata, 4);
17120         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17121         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17122         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17123
17124         switch (os)
17125           {
17126           case GNU_ABI_TAG_LINUX:
17127             osname = "Linux";
17128             break;
17129           case GNU_ABI_TAG_HURD:
17130             osname = "Hurd";
17131             break;
17132           case GNU_ABI_TAG_SOLARIS:
17133             osname = "Solaris";
17134             break;
17135           case GNU_ABI_TAG_FREEBSD:
17136             osname = "FreeBSD";
17137             break;
17138           case GNU_ABI_TAG_NETBSD:
17139             osname = "NetBSD";
17140             break;
17141           case GNU_ABI_TAG_SYLLABLE:
17142             osname = "Syllable";
17143             break;
17144           case GNU_ABI_TAG_NACL:
17145             osname = "NaCl";
17146             break;
17147           default:
17148             osname = "Unknown";
17149             break;
17150           }
17151
17152         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17153                 major, minor, subminor);
17154       }
17155       break;
17156
17157     case NT_GNU_GOLD_VERSION:
17158       {
17159         unsigned long i;
17160
17161         printf (_("    Version: "));
17162         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17163           printf ("%c", pnote->descdata[i]);
17164         printf ("\n");
17165       }
17166       break;
17167
17168     case NT_GNU_HWCAP:
17169       {
17170         unsigned long num_entries, mask;
17171
17172         /* Hardware capabilities information.  Word 0 is the number of entries.
17173            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17174            is a series of entries, where each entry is a single byte followed
17175            by a nul terminated string.  The byte gives the bit number to test
17176            if enabled in the bitmask.  */
17177         printf (_("      Hardware Capabilities: "));
17178         if (pnote->descsz < 8)
17179           {
17180             error (_("<corrupt GNU_HWCAP>\n"));
17181             return FALSE;
17182           }
17183         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17184         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17185         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17186         /* FIXME: Add code to display the entries... */
17187       }
17188       break;
17189
17190     case NT_GNU_PROPERTY_TYPE_0:
17191       print_gnu_property_note (filedata, pnote);
17192       break;
17193
17194     default:
17195       /* Handle unrecognised types.  An error message should have already been
17196          created by get_gnu_elf_note_type(), so all that we need to do is to
17197          display the data.  */
17198       {
17199         unsigned long i;
17200
17201         printf (_("    Description data: "));
17202         for (i = 0; i < pnote->descsz; ++i)
17203           printf ("%02x ", pnote->descdata[i] & 0xff);
17204         printf ("\n");
17205       }
17206       break;
17207     }
17208
17209   return TRUE;
17210 }
17211
17212 static const char *
17213 get_v850_elf_note_type (enum v850_notes n_type)
17214 {
17215   static char buff[64];
17216
17217   switch (n_type)
17218     {
17219     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17220     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17221     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17222     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17223     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17224     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17225     default:
17226       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17227       return buff;
17228     }
17229 }
17230
17231 static bfd_boolean
17232 print_v850_note (Elf_Internal_Note * pnote)
17233 {
17234   unsigned int val;
17235
17236   if (pnote->descsz != 4)
17237     return FALSE;
17238
17239   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17240
17241   if (val == 0)
17242     {
17243       printf (_("not set\n"));
17244       return TRUE;
17245     }
17246
17247   switch (pnote->type)
17248     {
17249     case V850_NOTE_ALIGNMENT:
17250       switch (val)
17251         {
17252         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17253         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17254         }
17255       break;
17256
17257     case V850_NOTE_DATA_SIZE:
17258       switch (val)
17259         {
17260         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17261         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17262         }
17263       break;
17264
17265     case V850_NOTE_FPU_INFO:
17266       switch (val)
17267         {
17268         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17269         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17270         }
17271       break;
17272
17273     case V850_NOTE_MMU_INFO:
17274     case V850_NOTE_CACHE_INFO:
17275     case V850_NOTE_SIMD_INFO:
17276       if (val == EF_RH850_SIMD)
17277         {
17278           printf (_("yes\n"));
17279           return TRUE;
17280         }
17281       break;
17282
17283     default:
17284       /* An 'unknown note type' message will already have been displayed.  */
17285       break;
17286     }
17287
17288   printf (_("unknown value: %x\n"), val);
17289   return FALSE;
17290 }
17291
17292 static bfd_boolean
17293 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17294 {
17295   unsigned int version;
17296
17297   switch (pnote->type)
17298     {
17299     case NT_NETBSD_IDENT:
17300       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17301       if ((version / 10000) % 100)
17302         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17303                 version, version / 100000000, (version / 1000000) % 100,
17304                 (version / 10000) % 100 > 26 ? "Z" : "",
17305                 'A' + (version / 10000) % 26);
17306       else
17307         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17308                 version, version / 100000000, (version / 1000000) % 100,
17309                 (version / 100) % 100);
17310       return TRUE;
17311
17312     case NT_NETBSD_MARCH:
17313       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17314               pnote->descdata);
17315       return TRUE;
17316
17317     default:
17318       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17319               pnote->type);
17320       return FALSE;
17321     }
17322 }
17323
17324 static const char *
17325 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17326 {
17327   switch (e_type)
17328     {
17329     case NT_FREEBSD_THRMISC:
17330       return _("NT_THRMISC (thrmisc structure)");
17331     case NT_FREEBSD_PROCSTAT_PROC:
17332       return _("NT_PROCSTAT_PROC (proc data)");
17333     case NT_FREEBSD_PROCSTAT_FILES:
17334       return _("NT_PROCSTAT_FILES (files data)");
17335     case NT_FREEBSD_PROCSTAT_VMMAP:
17336       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17337     case NT_FREEBSD_PROCSTAT_GROUPS:
17338       return _("NT_PROCSTAT_GROUPS (groups data)");
17339     case NT_FREEBSD_PROCSTAT_UMASK:
17340       return _("NT_PROCSTAT_UMASK (umask data)");
17341     case NT_FREEBSD_PROCSTAT_RLIMIT:
17342       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17343     case NT_FREEBSD_PROCSTAT_OSREL:
17344       return _("NT_PROCSTAT_OSREL (osreldate data)");
17345     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17346       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17347     case NT_FREEBSD_PROCSTAT_AUXV:
17348       return _("NT_PROCSTAT_AUXV (auxv data)");
17349     case NT_FREEBSD_PTLWPINFO:
17350       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17351     }
17352   return get_note_type (filedata, e_type);
17353 }
17354
17355 static const char *
17356 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17357 {
17358   static char buff[64];
17359
17360   if (e_type == NT_NETBSDCORE_PROCINFO)
17361     return _("NetBSD procinfo structure");
17362
17363   /* As of Jan 2002 there are no other machine-independent notes
17364      defined for NetBSD core files.  If the note type is less
17365      than the start of the machine-dependent note types, we don't
17366      understand it.  */
17367
17368   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17369     {
17370       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17371       return buff;
17372     }
17373
17374   switch (filedata->file_header.e_machine)
17375     {
17376     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17377        and PT_GETFPREGS == mach+2.  */
17378
17379     case EM_OLD_ALPHA:
17380     case EM_ALPHA:
17381     case EM_SPARC:
17382     case EM_SPARC32PLUS:
17383     case EM_SPARCV9:
17384       switch (e_type)
17385         {
17386         case NT_NETBSDCORE_FIRSTMACH + 0:
17387           return _("PT_GETREGS (reg structure)");
17388         case NT_NETBSDCORE_FIRSTMACH + 2:
17389           return _("PT_GETFPREGS (fpreg structure)");
17390         default:
17391           break;
17392         }
17393       break;
17394
17395     /* On all other arch's, PT_GETREGS == mach+1 and
17396        PT_GETFPREGS == mach+3.  */
17397     default:
17398       switch (e_type)
17399         {
17400         case NT_NETBSDCORE_FIRSTMACH + 1:
17401           return _("PT_GETREGS (reg structure)");
17402         case NT_NETBSDCORE_FIRSTMACH + 3:
17403           return _("PT_GETFPREGS (fpreg structure)");
17404         default:
17405           break;
17406         }
17407     }
17408
17409   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17410             e_type - NT_NETBSDCORE_FIRSTMACH);
17411   return buff;
17412 }
17413
17414 static const char *
17415 get_stapsdt_note_type (unsigned e_type)
17416 {
17417   static char buff[64];
17418
17419   switch (e_type)
17420     {
17421     case NT_STAPSDT:
17422       return _("NT_STAPSDT (SystemTap probe descriptors)");
17423
17424     default:
17425       break;
17426     }
17427
17428   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17429   return buff;
17430 }
17431
17432 static bfd_boolean
17433 print_stapsdt_note (Elf_Internal_Note *pnote)
17434 {
17435   int addr_size = is_32bit_elf ? 4 : 8;
17436   char *data = pnote->descdata;
17437   char *data_end = pnote->descdata + pnote->descsz;
17438   bfd_vma pc, base_addr, semaphore;
17439   char *provider, *probe, *arg_fmt;
17440
17441   pc = byte_get ((unsigned char *) data, addr_size);
17442   data += addr_size;
17443   base_addr = byte_get ((unsigned char *) data, addr_size);
17444   data += addr_size;
17445   semaphore = byte_get ((unsigned char *) data, addr_size);
17446   data += addr_size;
17447
17448   provider = data;
17449   data += strlen (data) + 1;
17450   probe = data;
17451   data += strlen (data) + 1;
17452   arg_fmt = data;
17453   data += strlen (data) + 1;
17454
17455   printf (_("    Provider: %s\n"), provider);
17456   printf (_("    Name: %s\n"), probe);
17457   printf (_("    Location: "));
17458   print_vma (pc, FULL_HEX);
17459   printf (_(", Base: "));
17460   print_vma (base_addr, FULL_HEX);
17461   printf (_(", Semaphore: "));
17462   print_vma (semaphore, FULL_HEX);
17463   printf ("\n");
17464   printf (_("    Arguments: %s\n"), arg_fmt);
17465
17466   return data == data_end;
17467 }
17468
17469 static const char *
17470 get_ia64_vms_note_type (unsigned e_type)
17471 {
17472   static char buff[64];
17473
17474   switch (e_type)
17475     {
17476     case NT_VMS_MHD:
17477       return _("NT_VMS_MHD (module header)");
17478     case NT_VMS_LNM:
17479       return _("NT_VMS_LNM (language name)");
17480     case NT_VMS_SRC:
17481       return _("NT_VMS_SRC (source files)");
17482     case NT_VMS_TITLE:
17483       return "NT_VMS_TITLE";
17484     case NT_VMS_EIDC:
17485       return _("NT_VMS_EIDC (consistency check)");
17486     case NT_VMS_FPMODE:
17487       return _("NT_VMS_FPMODE (FP mode)");
17488     case NT_VMS_LINKTIME:
17489       return "NT_VMS_LINKTIME";
17490     case NT_VMS_IMGNAM:
17491       return _("NT_VMS_IMGNAM (image name)");
17492     case NT_VMS_IMGID:
17493       return _("NT_VMS_IMGID (image id)");
17494     case NT_VMS_LINKID:
17495       return _("NT_VMS_LINKID (link id)");
17496     case NT_VMS_IMGBID:
17497       return _("NT_VMS_IMGBID (build id)");
17498     case NT_VMS_GSTNAM:
17499       return _("NT_VMS_GSTNAM (sym table name)");
17500     case NT_VMS_ORIG_DYN:
17501       return "NT_VMS_ORIG_DYN";
17502     case NT_VMS_PATCHTIME:
17503       return "NT_VMS_PATCHTIME";
17504     default:
17505       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17506       return buff;
17507     }
17508 }
17509
17510 static bfd_boolean
17511 print_ia64_vms_note (Elf_Internal_Note * pnote)
17512 {
17513   switch (pnote->type)
17514     {
17515     case NT_VMS_MHD:
17516       if (pnote->descsz > 36)
17517         {
17518           size_t l = strlen (pnote->descdata + 34);
17519           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17520           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17521           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17522           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17523         }
17524       else
17525         printf (_("    Invalid size\n"));
17526       break;
17527     case NT_VMS_LNM:
17528       printf (_("   Language: %s\n"), pnote->descdata);
17529       break;
17530 #ifdef BFD64
17531     case NT_VMS_FPMODE:
17532       printf (_("   Floating Point mode: "));
17533       printf ("0x%016" BFD_VMA_FMT "x\n",
17534               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17535       break;
17536     case NT_VMS_LINKTIME:
17537       printf (_("   Link time: "));
17538       print_vms_time
17539         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17540       printf ("\n");
17541       break;
17542     case NT_VMS_PATCHTIME:
17543       printf (_("   Patch time: "));
17544       print_vms_time
17545         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17546       printf ("\n");
17547       break;
17548     case NT_VMS_ORIG_DYN:
17549       printf (_("   Major id: %u,  minor id: %u\n"),
17550               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17551               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17552       printf (_("   Last modified  : "));
17553       print_vms_time
17554         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17555       printf (_("\n   Link flags  : "));
17556       printf ("0x%016" BFD_VMA_FMT "x\n",
17557               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17558       printf (_("   Header flags: 0x%08x\n"),
17559               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17560       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17561       break;
17562 #endif
17563     case NT_VMS_IMGNAM:
17564       printf (_("    Image name: %s\n"), pnote->descdata);
17565       break;
17566     case NT_VMS_GSTNAM:
17567       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17568       break;
17569     case NT_VMS_IMGID:
17570       printf (_("    Image id: %s\n"), pnote->descdata);
17571       break;
17572     case NT_VMS_LINKID:
17573       printf (_("    Linker id: %s\n"), pnote->descdata);
17574       break;
17575     default:
17576       return FALSE;
17577     }
17578   return TRUE;
17579 }
17580
17581 /* Find the symbol associated with a build attribute that is attached
17582    to address OFFSET.  If PNAME is non-NULL then store the name of
17583    the symbol (if found) in the provided pointer,  Returns NULL if a
17584    symbol could not be found.  */
17585
17586 static Elf_Internal_Sym *
17587 get_symbol_for_build_attribute (Filedata *       filedata,
17588                                 unsigned long    offset,
17589                                 bfd_boolean      is_open_attr,
17590                                 const char **    pname)
17591 {
17592   static Filedata *         saved_filedata = NULL;
17593   static char *             strtab;
17594   static unsigned long      strtablen;
17595   static Elf_Internal_Sym * symtab;
17596   static unsigned long      nsyms;
17597   Elf_Internal_Sym *        saved_sym = NULL;
17598   Elf_Internal_Sym *        sym;
17599
17600   if (filedata->section_headers != NULL
17601       && (saved_filedata == NULL || filedata != saved_filedata))
17602     {
17603       Elf_Internal_Shdr * symsec;
17604
17605       /* Load the symbol and string sections.  */
17606       for (symsec = filedata->section_headers;
17607            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17608            symsec ++)
17609         {
17610           if (symsec->sh_type == SHT_SYMTAB)
17611             {
17612               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17613
17614               if (symsec->sh_link < filedata->file_header.e_shnum)
17615                 {
17616                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17617
17618                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17619                                               1, strtab_sec->sh_size,
17620                                               _("string table"));
17621                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17622                 }
17623             }
17624         }
17625       saved_filedata = filedata;
17626     }
17627
17628   if (symtab == NULL || strtab == NULL)
17629     return NULL;
17630
17631   /* Find a symbol whose value matches offset.  */
17632   for (sym = symtab; sym < symtab + nsyms; sym ++)
17633     if (sym->st_value == offset)
17634       {
17635         if (sym->st_name >= strtablen)
17636           /* Huh ?  This should not happen.  */
17637           continue;
17638
17639         if (strtab[sym->st_name] == 0)
17640           continue;
17641
17642         /* The AArch64 and ARM architectures define mapping symbols
17643            (eg $d, $x, $t) which we want to ignore.  */
17644         if (strtab[sym->st_name] == '$'
17645             && strtab[sym->st_name + 1] != 0
17646             && strtab[sym->st_name + 2] == 0)
17647           continue;
17648
17649         if (is_open_attr)
17650           {
17651             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17652                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17653                FUNC symbols entirely.  */
17654             switch (ELF_ST_TYPE (sym->st_info))
17655               {
17656               case STT_OBJECT:
17657               case STT_FILE:
17658                 saved_sym = sym;
17659                 if (sym->st_size)
17660                   {
17661                     /* If the symbol has a size associated
17662                        with it then we can stop searching.  */
17663                     sym = symtab + nsyms;
17664                   }
17665                 continue;
17666
17667               case STT_FUNC:
17668                 /* Ignore function symbols.  */
17669                 continue;
17670
17671               default:
17672                 break;
17673               }
17674
17675             switch (ELF_ST_BIND (sym->st_info))
17676               {
17677               case STB_GLOBAL:
17678                 if (saved_sym == NULL
17679                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17680                   saved_sym = sym;
17681                 break;
17682
17683               case STB_LOCAL:
17684                 if (saved_sym == NULL)
17685                   saved_sym = sym;
17686                 break;
17687
17688               default:
17689                 break;
17690               }
17691           }
17692         else
17693           {
17694             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17695               continue;
17696
17697             saved_sym = sym;
17698             break;
17699           }
17700       }
17701
17702   if (saved_sym && pname)
17703     * pname = strtab + saved_sym->st_name;
17704
17705   return saved_sym;
17706 }
17707
17708 /* Returns true iff addr1 and addr2 are in the same section.  */
17709
17710 static bfd_boolean
17711 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
17712 {
17713   Elf_Internal_Shdr * a1;
17714   Elf_Internal_Shdr * a2;
17715
17716   a1 = find_section_by_address (filedata, addr1);
17717   a2 = find_section_by_address (filedata, addr2);
17718
17719   return a1 == a2 && a1 != NULL;
17720 }
17721
17722 static bfd_boolean
17723 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
17724                                        Filedata *           filedata)
17725 {
17726   static unsigned long  global_offset = 0;
17727   static unsigned long  global_end = 0;
17728   static unsigned long  func_offset = 0;
17729   static unsigned long  func_end = 0;
17730
17731   Elf_Internal_Sym *    sym;
17732   const char *          name;
17733   unsigned long         start;
17734   unsigned long         end;
17735   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17736
17737   switch (pnote->descsz)
17738     {
17739     case 0:
17740       /* A zero-length description means that the range of
17741          the previous note of the same type should be used.  */
17742       if (is_open_attr)
17743         {
17744           if (global_end > global_offset)
17745             printf (_("    Applies to region from %#lx to %#lx\n"),
17746                     global_offset, global_end);
17747           else
17748             printf (_("    Applies to region from %#lx\n"), global_offset);
17749         }
17750       else
17751         {
17752           if (func_end > func_offset)
17753             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
17754           else
17755             printf (_("    Applies to region from %#lx\n"), func_offset);
17756         }
17757       return TRUE;
17758
17759     case 4:
17760       start = byte_get ((unsigned char *) pnote->descdata, 4);
17761       end = 0;
17762       break;
17763
17764     case 8:
17765       if (is_32bit_elf)
17766         {
17767           /* FIXME: We should check that version 3+ notes are being used here...  */
17768           start = byte_get ((unsigned char *) pnote->descdata, 4);
17769           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17770         }
17771       else
17772         {
17773           start = byte_get ((unsigned char *) pnote->descdata, 8);
17774           end = 0;
17775         }
17776       break;
17777
17778     case 16:
17779       start = byte_get ((unsigned char *) pnote->descdata, 8);
17780       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
17781       break;
17782
17783     default:
17784       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17785       printf (_("    <invalid descsz>"));
17786       return FALSE;
17787     }
17788
17789   name = NULL;
17790   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
17791   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17792      in order to avoid them being confused with the start address of the
17793      first function in the file...  */
17794   if (sym == NULL && is_open_attr)
17795     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
17796                                           & name);
17797
17798   if (end == 0 && sym != NULL && sym->st_size > 0)
17799     end = start + sym->st_size;
17800
17801   if (is_open_attr)
17802     {
17803       /* FIXME: Need to properly allow for section alignment.
17804          16 is just the alignment used on x86_64.  */
17805       if (global_end > 0
17806           && start > BFD_ALIGN (global_end, 16)
17807           /* Build notes are not guaranteed to be organised in order of
17808              increasing address, but we should find the all of the notes
17809              for one section in the same place.  */
17810           && same_section (filedata, start, global_end))
17811         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17812               global_end + 1, start - 1);
17813
17814       printf (_("    Applies to region from %#lx"), start);
17815       global_offset = start;
17816
17817       if (end)
17818         {
17819           printf (_(" to %#lx"), end);
17820           global_end = end;
17821         }
17822     }
17823   else
17824     {
17825       printf (_("    Applies to region from %#lx"), start);
17826       func_offset = start;
17827
17828       if (end)
17829         {
17830           printf (_(" to %#lx"), end);
17831           func_end = end;
17832         }
17833     }
17834
17835   if (sym && name)
17836     printf (_(" (%s)"), name);
17837
17838   printf ("\n");
17839   return TRUE;
17840 }
17841
17842 static bfd_boolean
17843 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17844 {
17845   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17846   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17847   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17848   char         name_type;
17849   char         name_attribute;
17850   const char * expected_types;
17851   const char * name = pnote->namedata;
17852   const char * text;
17853   signed int   left;
17854
17855   if (name == NULL || pnote->namesz < 2)
17856     {
17857       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17858       print_symbol (-20, _("  <corrupt name>"));
17859       return FALSE;
17860     }
17861
17862   if (do_wide)
17863     left = 28;
17864   else
17865     left = 20;
17866
17867   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17868   if (name[0] == 'G' && name[1] == 'A')
17869     {
17870       if (pnote->namesz < 4)
17871         {
17872           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17873           print_symbol (-20, _("  <corrupt name>"));
17874           return FALSE;
17875         }
17876
17877       printf ("GA");
17878       name += 2;
17879       left -= 2;
17880     }
17881
17882   switch ((name_type = * name))
17883     {
17884     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17885     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17886     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17887     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17888       printf ("%c", * name);
17889       left --;
17890       break;
17891     default:
17892       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17893       print_symbol (-20, _("<unknown name type>"));
17894       return FALSE;
17895     }
17896
17897   ++ name;
17898   text = NULL;
17899
17900   switch ((name_attribute = * name))
17901     {
17902     case GNU_BUILD_ATTRIBUTE_VERSION:
17903       text = _("<version>");
17904       expected_types = string_expected;
17905       ++ name;
17906       break;
17907     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17908       text = _("<stack prot>");
17909       expected_types = "!+*";
17910       ++ name;
17911       break;
17912     case GNU_BUILD_ATTRIBUTE_RELRO:
17913       text = _("<relro>");
17914       expected_types = bool_expected;
17915       ++ name;
17916       break;
17917     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17918       text = _("<stack size>");
17919       expected_types = number_expected;
17920       ++ name;
17921       break;
17922     case GNU_BUILD_ATTRIBUTE_TOOL:
17923       text = _("<tool>");
17924       expected_types = string_expected;
17925       ++ name;
17926       break;
17927     case GNU_BUILD_ATTRIBUTE_ABI:
17928       text = _("<ABI>");
17929       expected_types = "$*";
17930       ++ name;
17931       break;
17932     case GNU_BUILD_ATTRIBUTE_PIC:
17933       text = _("<PIC>");
17934       expected_types = number_expected;
17935       ++ name;
17936       break;
17937     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17938       text = _("<short enum>");
17939       expected_types = bool_expected;
17940       ++ name;
17941       break;
17942     default:
17943       if (ISPRINT (* name))
17944         {
17945           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17946
17947           if (len > left && ! do_wide)
17948             len = left;
17949           printf ("%.*s:", len, name);
17950           left -= len;
17951           name += len;
17952         }
17953       else
17954         {
17955           static char tmpbuf [128];
17956
17957           error (_("unrecognised byte in name field: %d\n"), * name);
17958           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17959           text = tmpbuf;
17960           name ++;
17961         }
17962       expected_types = "*$!+";
17963       break;
17964     }
17965
17966   if (text)
17967     left -= printf ("%s", text);
17968
17969   if (strchr (expected_types, name_type) == NULL)
17970     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17971
17972   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17973     {
17974       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17975              (unsigned long) pnote->namesz,
17976              (long) (name - pnote->namedata));
17977       return FALSE;
17978     }
17979
17980   if (left < 1 && ! do_wide)
17981     return TRUE;
17982
17983   switch (name_type)
17984     {
17985     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17986       {
17987         unsigned int        bytes;
17988         unsigned long long  val = 0;
17989         unsigned int        shift = 0;
17990         char *              decoded = NULL;
17991
17992         bytes = pnote->namesz - (name - pnote->namedata);
17993         if (bytes > 0)
17994           /* The -1 is because the name field is always 0 terminated, and we
17995              want to be able to ensure that the shift in the while loop below
17996              will not overflow.  */
17997           -- bytes;
17998
17999         if (bytes > sizeof (val))
18000           {
18001             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18002                    bytes);
18003             bytes = sizeof (val);
18004           }
18005         /* We do not bother to warn if bytes == 0 as this can
18006            happen with some early versions of the gcc plugin.  */
18007
18008         while (bytes --)
18009           {
18010             unsigned long byte = (* name ++) & 0xff;
18011
18012             val |= byte << shift;
18013             shift += 8;
18014           }
18015
18016         switch (name_attribute)
18017           {
18018           case GNU_BUILD_ATTRIBUTE_PIC:
18019             switch (val)
18020               {
18021               case 0: decoded = "static"; break;
18022               case 1: decoded = "pic"; break;
18023               case 2: decoded = "PIC"; break;
18024               case 3: decoded = "pie"; break;
18025               case 4: decoded = "PIE"; break;
18026               default: break;
18027               }
18028             break;
18029           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18030             switch (val)
18031               {
18032                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
18033               case 0: decoded = "off"; break;
18034               case 1: decoded = "on"; break;
18035               case 2: decoded = "all"; break;
18036               case 3: decoded = "strong"; break;
18037               case 4: decoded = "explicit"; break;
18038               default: break;
18039               }
18040             break;
18041           default:
18042             break;
18043           }
18044
18045         if (decoded != NULL)
18046           {
18047             print_symbol (-left, decoded);
18048             left = 0;
18049           }
18050         else if (val == 0)
18051           {
18052             printf ("0x0");
18053             left -= 3;
18054           }
18055         else
18056           {
18057             if (do_wide)
18058               left -= printf ("0x%llx", val);
18059             else
18060               left -= printf ("0x%-.*llx", left, val);
18061           }
18062       }
18063       break;
18064     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18065       left -= print_symbol (- left, name);
18066       break;
18067     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18068       left -= print_symbol (- left, "true");
18069       break;
18070     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18071       left -= print_symbol (- left, "false");
18072       break;
18073     }
18074
18075   if (do_wide && left > 0)
18076     printf ("%-*s", left, " ");
18077
18078   return TRUE;
18079 }
18080
18081 /* Note that by the ELF standard, the name field is already null byte
18082    terminated, and namesz includes the terminating null byte.
18083    I.E. the value of namesz for the name "FSF" is 4.
18084
18085    If the value of namesz is zero, there is no name present.  */
18086
18087 static bfd_boolean
18088 process_note (Elf_Internal_Note *  pnote,
18089               Filedata *           filedata)
18090 {
18091   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18092   const char * nt;
18093
18094   if (pnote->namesz == 0)
18095     /* If there is no note name, then use the default set of
18096        note type strings.  */
18097     nt = get_note_type (filedata, pnote->type);
18098
18099   else if (const_strneq (pnote->namedata, "GNU"))
18100     /* GNU-specific object file notes.  */
18101     nt = get_gnu_elf_note_type (pnote->type);
18102
18103   else if (const_strneq (pnote->namedata, "FreeBSD"))
18104     /* FreeBSD-specific core file notes.  */
18105     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18106
18107   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18108     /* NetBSD-specific core file notes.  */
18109     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18110
18111   else if (const_strneq (pnote->namedata, "NetBSD"))
18112     /* NetBSD-specific core file notes.  */
18113     return process_netbsd_elf_note (pnote);
18114
18115   else if (strneq (pnote->namedata, "SPU/", 4))
18116     {
18117       /* SPU-specific core file notes.  */
18118       nt = pnote->namedata + 4;
18119       name = "SPU";
18120     }
18121
18122   else if (const_strneq (pnote->namedata, "IPF/VMS"))
18123     /* VMS/ia64-specific file notes.  */
18124     nt = get_ia64_vms_note_type (pnote->type);
18125
18126   else if (const_strneq (pnote->namedata, "stapsdt"))
18127     nt = get_stapsdt_note_type (pnote->type);
18128
18129   else
18130     /* Don't recognize this note name; just use the default set of
18131        note type strings.  */
18132     nt = get_note_type (filedata, pnote->type);
18133
18134   printf ("  ");
18135
18136   if (((const_strneq (pnote->namedata, "GA")
18137         && strchr ("*$!+", pnote->namedata[2]) != NULL)
18138        || strchr ("*$!+", pnote->namedata[0]) != NULL)
18139       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18140           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18141     print_gnu_build_attribute_name (pnote);
18142   else
18143     print_symbol (-20, name);
18144
18145   if (do_wide)
18146     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18147   else
18148     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18149
18150   if (const_strneq (pnote->namedata, "IPF/VMS"))
18151     return print_ia64_vms_note (pnote);
18152   else if (const_strneq (pnote->namedata, "GNU"))
18153     return print_gnu_note (filedata, pnote);
18154   else if (const_strneq (pnote->namedata, "stapsdt"))
18155     return print_stapsdt_note (pnote);
18156   else if (const_strneq (pnote->namedata, "CORE"))
18157     return print_core_note (pnote);
18158   else if (((const_strneq (pnote->namedata, "GA")
18159              && strchr ("*$!+", pnote->namedata[2]) != NULL)
18160             || strchr ("*$!+", pnote->namedata[0]) != NULL)
18161            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18162                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18163     return print_gnu_build_attribute_description (pnote, filedata);
18164
18165   if (pnote->descsz)
18166     {
18167       unsigned long i;
18168
18169       printf (_("   description data: "));
18170       for (i = 0; i < pnote->descsz; i++)
18171         printf ("%02x ", pnote->descdata[i]);
18172       if (!do_wide)
18173         printf ("\n");
18174     }
18175
18176   if (do_wide)
18177     printf ("\n");
18178
18179   return TRUE;
18180 }
18181
18182 static bfd_boolean
18183 process_notes_at (Filedata *           filedata,
18184                   Elf_Internal_Shdr *  section,
18185                   bfd_vma              offset,
18186                   bfd_vma              length,
18187                   bfd_vma              align)
18188 {
18189   Elf_External_Note * pnotes;
18190   Elf_External_Note * external;
18191   char *              end;
18192   bfd_boolean         res = TRUE;
18193
18194   if (length <= 0)
18195     return FALSE;
18196
18197   if (section)
18198     {
18199       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18200       if (pnotes)
18201         {
18202           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18203             return FALSE;
18204         }
18205     }
18206   else
18207     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18208                                              _("notes"));
18209
18210   if (pnotes == NULL)
18211     return FALSE;
18212
18213   external = pnotes;
18214
18215   if (section)
18216     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18217   else
18218     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18219             (unsigned long) offset, (unsigned long) length);
18220
18221   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18222      specifies that notes should be aligned to 4 bytes in 32-bit
18223      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18224      we also support 4 byte alignment in 64-bit objects.  If section
18225      alignment is less than 4, we treate alignment as 4 bytes.   */
18226   if (align < 4)
18227     align = 4;
18228   else if (align != 4 && align != 8)
18229     {
18230       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18231             (long) align);
18232       return FALSE;
18233     }
18234
18235   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18236
18237   end = (char *) pnotes + length;
18238   while ((char *) external < end)
18239     {
18240       Elf_Internal_Note inote;
18241       size_t min_notesz;
18242       char * next;
18243       char * temp = NULL;
18244       size_t data_remaining = end - (char *) external;
18245
18246       if (!is_ia64_vms (filedata))
18247         {
18248           /* PR binutils/15191
18249              Make sure that there is enough data to read.  */
18250           min_notesz = offsetof (Elf_External_Note, name);
18251           if (data_remaining < min_notesz)
18252             {
18253               warn (ngettext ("Corrupt note: only %ld byte remains, "
18254                               "not enough for a full note\n",
18255                               "Corrupt note: only %ld bytes remain, "
18256                               "not enough for a full note\n",
18257                               data_remaining),
18258                     (long) data_remaining);
18259               break;
18260             }
18261           data_remaining -= min_notesz;
18262
18263           inote.type     = BYTE_GET (external->type);
18264           inote.namesz   = BYTE_GET (external->namesz);
18265           inote.namedata = external->name;
18266           inote.descsz   = BYTE_GET (external->descsz);
18267           inote.descdata = ((char *) external
18268                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18269           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18270           next = ((char *) external
18271                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18272         }
18273       else
18274         {
18275           Elf64_External_VMS_Note *vms_external;
18276
18277           /* PR binutils/15191
18278              Make sure that there is enough data to read.  */
18279           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18280           if (data_remaining < min_notesz)
18281             {
18282               warn (ngettext ("Corrupt note: only %ld byte remains, "
18283                               "not enough for a full note\n",
18284                               "Corrupt note: only %ld bytes remain, "
18285                               "not enough for a full note\n",
18286                               data_remaining),
18287                     (long) data_remaining);
18288               break;
18289             }
18290           data_remaining -= min_notesz;
18291
18292           vms_external = (Elf64_External_VMS_Note *) external;
18293           inote.type     = BYTE_GET (vms_external->type);
18294           inote.namesz   = BYTE_GET (vms_external->namesz);
18295           inote.namedata = vms_external->name;
18296           inote.descsz   = BYTE_GET (vms_external->descsz);
18297           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18298           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18299           next = inote.descdata + align_power (inote.descsz, 3);
18300         }
18301
18302       /* PR 17531: file: 3443835e.  */
18303       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18304       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18305           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18306           || (size_t) (next - inote.descdata) < inote.descsz
18307           || ((size_t) (next - inote.descdata)
18308               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18309         {
18310           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18311                 (unsigned long) ((char *) external - (char *) pnotes));
18312           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18313                 inote.type, inote.namesz, inote.descsz, (int) align);
18314           break;
18315         }
18316
18317       external = (Elf_External_Note *) next;
18318
18319       /* Verify that name is null terminated.  It appears that at least
18320          one version of Linux (RedHat 6.0) generates corefiles that don't
18321          comply with the ELF spec by failing to include the null byte in
18322          namesz.  */
18323       if (inote.namedata[inote.namesz - 1] != '\0')
18324         {
18325           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18326             {
18327               temp = (char *) malloc (inote.namesz + 1);
18328               if (temp == NULL)
18329                 {
18330                   error (_("Out of memory allocating space for inote name\n"));
18331                   res = FALSE;
18332                   break;
18333                 }
18334
18335               memcpy (temp, inote.namedata, inote.namesz);
18336               inote.namedata = temp;
18337             }
18338           inote.namedata[inote.namesz] = 0;
18339         }
18340
18341       if (! process_note (& inote, filedata))
18342         res = FALSE;
18343
18344       if (temp != NULL)
18345         {
18346           free (temp);
18347           temp = NULL;
18348         }
18349     }
18350
18351   free (pnotes);
18352
18353   return res;
18354 }
18355
18356 static bfd_boolean
18357 process_corefile_note_segments (Filedata * filedata)
18358 {
18359   Elf_Internal_Phdr * segment;
18360   unsigned int i;
18361   bfd_boolean res = TRUE;
18362
18363   if (! get_program_headers (filedata))
18364     return TRUE;
18365
18366   for (i = 0, segment = filedata->program_headers;
18367        i < filedata->file_header.e_phnum;
18368        i++, segment++)
18369     {
18370       if (segment->p_type == PT_NOTE)
18371         if (! process_notes_at (filedata, NULL,
18372                                 (bfd_vma) segment->p_offset,
18373                                 (bfd_vma) segment->p_filesz,
18374                                 (bfd_vma) segment->p_align))
18375           res = FALSE;
18376     }
18377
18378   return res;
18379 }
18380
18381 static bfd_boolean
18382 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18383 {
18384   Elf_External_Note * pnotes;
18385   Elf_External_Note * external;
18386   char * end;
18387   bfd_boolean res = TRUE;
18388
18389   if (length <= 0)
18390     return FALSE;
18391
18392   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18393                                            _("v850 notes"));
18394   if (pnotes == NULL)
18395     return FALSE;
18396
18397   external = pnotes;
18398   end = (char*) pnotes + length;
18399
18400   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18401           (unsigned long) offset, (unsigned long) length);
18402
18403   while ((char *) external + sizeof (Elf_External_Note) < end)
18404     {
18405       Elf_External_Note * next;
18406       Elf_Internal_Note inote;
18407
18408       inote.type     = BYTE_GET (external->type);
18409       inote.namesz   = BYTE_GET (external->namesz);
18410       inote.namedata = external->name;
18411       inote.descsz   = BYTE_GET (external->descsz);
18412       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18413       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18414
18415       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18416         {
18417           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18418           inote.descdata = inote.namedata;
18419           inote.namesz   = 0;
18420         }
18421
18422       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18423
18424       if (   ((char *) next > end)
18425           || ((char *) next <  (char *) pnotes))
18426         {
18427           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18428                 (unsigned long) ((char *) external - (char *) pnotes));
18429           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18430                 inote.type, inote.namesz, inote.descsz);
18431           break;
18432         }
18433
18434       external = next;
18435
18436       /* Prevent out-of-bounds indexing.  */
18437       if (   inote.namedata + inote.namesz > end
18438           || inote.namedata + inote.namesz < inote.namedata)
18439         {
18440           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18441                 (unsigned long) ((char *) external - (char *) pnotes));
18442           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18443                 inote.type, inote.namesz, inote.descsz);
18444           break;
18445         }
18446
18447       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18448
18449       if (! print_v850_note (& inote))
18450         {
18451           res = FALSE;
18452           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18453                   inote.namesz, inote.descsz);
18454         }
18455     }
18456
18457   free (pnotes);
18458
18459   return res;
18460 }
18461
18462 static bfd_boolean
18463 process_note_sections (Filedata * filedata)
18464 {
18465   Elf_Internal_Shdr * section;
18466   unsigned long i;
18467   unsigned int n = 0;
18468   bfd_boolean res = TRUE;
18469
18470   for (i = 0, section = filedata->section_headers;
18471        i < filedata->file_header.e_shnum && section != NULL;
18472        i++, section++)
18473     {
18474       if (section->sh_type == SHT_NOTE)
18475         {
18476           if (! process_notes_at (filedata, section,
18477                                   (bfd_vma) section->sh_offset,
18478                                   (bfd_vma) section->sh_size,
18479                                   (bfd_vma) section->sh_addralign))
18480             res = FALSE;
18481           n++;
18482         }
18483
18484       if ((   filedata->file_header.e_machine == EM_V800
18485            || filedata->file_header.e_machine == EM_V850
18486            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18487           && section->sh_type == SHT_RENESAS_INFO)
18488         {
18489           if (! process_v850_notes (filedata,
18490                                     (bfd_vma) section->sh_offset,
18491                                     (bfd_vma) section->sh_size))
18492             res = FALSE;
18493           n++;
18494         }
18495     }
18496
18497   if (n == 0)
18498     /* Try processing NOTE segments instead.  */
18499     return process_corefile_note_segments (filedata);
18500
18501   return res;
18502 }
18503
18504 static bfd_boolean
18505 process_notes (Filedata * filedata)
18506 {
18507   /* If we have not been asked to display the notes then do nothing.  */
18508   if (! do_notes)
18509     return TRUE;
18510
18511   if (filedata->file_header.e_type != ET_CORE)
18512     return process_note_sections (filedata);
18513
18514   /* No program headers means no NOTE segment.  */
18515   if (filedata->file_header.e_phnum > 0)
18516     return process_corefile_note_segments (filedata);
18517
18518   printf (_("No note segments present in the core file.\n"));
18519   return TRUE;
18520 }
18521
18522 static unsigned char *
18523 display_public_gnu_attributes (unsigned char * start,
18524                                const unsigned char * const end)
18525 {
18526   printf (_("  Unknown GNU attribute: %s\n"), start);
18527
18528   start += strnlen ((char *) start, end - start);
18529   display_raw_attribute (start, end);
18530
18531   return (unsigned char *) end;
18532 }
18533
18534 static unsigned char *
18535 display_generic_attribute (unsigned char * start,
18536                            unsigned int tag,
18537                            const unsigned char * const end)
18538 {
18539   if (tag == 0)
18540     return (unsigned char *) end;
18541
18542   return display_tag_value (tag, start, end);
18543 }
18544
18545 static bfd_boolean
18546 process_arch_specific (Filedata * filedata)
18547 {
18548   if (! do_arch)
18549     return TRUE;
18550
18551   switch (filedata->file_header.e_machine)
18552     {
18553     case EM_ARC:
18554     case EM_ARC_COMPACT:
18555     case EM_ARC_COMPACT2:
18556       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18557                                  display_arc_attribute,
18558                                  display_generic_attribute);
18559     case EM_ARM:
18560       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18561                                  display_arm_attribute,
18562                                  display_generic_attribute);
18563
18564     case EM_MIPS:
18565     case EM_MIPS_RS3_LE:
18566       return process_mips_specific (filedata);
18567
18568     case EM_MSP430:
18569      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18570                                 display_msp430x_attribute,
18571                                 display_generic_attribute);
18572
18573     case EM_NDS32:
18574       return process_nds32_specific (filedata);
18575
18576     case EM_PPC:
18577     case EM_PPC64:
18578       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18579                                  display_power_gnu_attribute);
18580
18581     case EM_S390:
18582     case EM_S390_OLD:
18583       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18584                                  display_s390_gnu_attribute);
18585
18586     case EM_SPARC:
18587     case EM_SPARC32PLUS:
18588     case EM_SPARCV9:
18589       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18590                                  display_sparc_gnu_attribute);
18591
18592     case EM_TI_C6000:
18593       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18594                                  display_tic6x_attribute,
18595                                  display_generic_attribute);
18596
18597     default:
18598       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18599                                  display_public_gnu_attributes,
18600                                  display_generic_attribute);
18601     }
18602 }
18603
18604 static bfd_boolean
18605 get_file_header (Filedata * filedata)
18606 {
18607   /* Read in the identity array.  */
18608   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18609     return FALSE;
18610
18611   /* Determine how to read the rest of the header.  */
18612   switch (filedata->file_header.e_ident[EI_DATA])
18613     {
18614     default:
18615     case ELFDATANONE:
18616     case ELFDATA2LSB:
18617       byte_get = byte_get_little_endian;
18618       byte_put = byte_put_little_endian;
18619       break;
18620     case ELFDATA2MSB:
18621       byte_get = byte_get_big_endian;
18622       byte_put = byte_put_big_endian;
18623       break;
18624     }
18625
18626   /* For now we only support 32 bit and 64 bit ELF files.  */
18627   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18628
18629   /* Read in the rest of the header.  */
18630   if (is_32bit_elf)
18631     {
18632       Elf32_External_Ehdr ehdr32;
18633
18634       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18635         return FALSE;
18636
18637       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18638       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18639       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18640       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18641       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18642       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18643       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18644       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18645       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18646       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18647       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18648       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18649       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18650     }
18651   else
18652     {
18653       Elf64_External_Ehdr ehdr64;
18654
18655       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18656          we will not be able to cope with the 64bit data found in
18657          64 ELF files.  Detect this now and abort before we start
18658          overwriting things.  */
18659       if (sizeof (bfd_vma) < 8)
18660         {
18661           error (_("This instance of readelf has been built without support for a\n\
18662 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18663           return FALSE;
18664         }
18665
18666       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18667         return FALSE;
18668
18669       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18670       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18671       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18672       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18673       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18674       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18675       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18676       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18677       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18678       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18679       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18680       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18681       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18682     }
18683
18684   if (filedata->file_header.e_shoff)
18685     {
18686       /* There may be some extensions in the first section header.  Don't
18687          bomb if we can't read it.  */
18688       if (is_32bit_elf)
18689         get_32bit_section_headers (filedata, TRUE);
18690       else
18691         get_64bit_section_headers (filedata, TRUE);
18692     }
18693
18694   return TRUE;
18695 }
18696
18697 static void
18698 close_file (Filedata * filedata)
18699 {
18700   if (filedata)
18701     {
18702       if (filedata->handle)
18703         fclose (filedata->handle);
18704       free (filedata);
18705     }
18706 }
18707
18708 void
18709 close_debug_file (void * data)
18710 {
18711   close_file ((Filedata *) data);
18712 }
18713
18714 static Filedata *
18715 open_file (const char * pathname)
18716 {
18717   struct stat  statbuf;
18718   Filedata *   filedata = NULL;
18719
18720   if (stat (pathname, & statbuf) < 0
18721       || ! S_ISREG (statbuf.st_mode))
18722     goto fail;
18723
18724   filedata = calloc (1, sizeof * filedata);
18725   if (filedata == NULL)
18726     goto fail;
18727
18728   filedata->handle = fopen (pathname, "rb");
18729   if (filedata->handle == NULL)
18730     goto fail;
18731
18732   filedata->file_size = (bfd_size_type) statbuf.st_size;
18733   filedata->file_name = pathname;
18734
18735   if (! get_file_header (filedata))
18736     goto fail;
18737
18738   if (filedata->file_header.e_shoff)
18739     {
18740       bfd_boolean res;
18741
18742       /* Read the section headers again, this time for real.  */
18743       if (is_32bit_elf)
18744         res = get_32bit_section_headers (filedata, FALSE);
18745       else
18746         res = get_64bit_section_headers (filedata, FALSE);
18747
18748       if (!res)
18749         goto fail;
18750     }
18751
18752   return filedata;
18753
18754  fail:
18755   if (filedata)
18756     {
18757       if (filedata->handle)
18758         fclose (filedata->handle);
18759       free (filedata);
18760     }
18761   return NULL;
18762 }
18763
18764 void *
18765 open_debug_file (const char * pathname)
18766 {
18767   return open_file (pathname);
18768 }
18769
18770 /* Process one ELF object file according to the command line options.
18771    This file may actually be stored in an archive.  The file is
18772    positioned at the start of the ELF object.  Returns TRUE if no
18773    problems were encountered, FALSE otherwise.  */
18774
18775 static bfd_boolean
18776 process_object (Filedata * filedata)
18777 {
18778   Filedata * separates;
18779   unsigned int i;
18780   bfd_boolean res = TRUE;
18781
18782   if (! get_file_header (filedata))
18783     {
18784       error (_("%s: Failed to read file header\n"), filedata->file_name);
18785       return FALSE;
18786     }
18787
18788   /* Initialise per file variables.  */
18789   for (i = ARRAY_SIZE (version_info); i--;)
18790     version_info[i] = 0;
18791
18792   for (i = ARRAY_SIZE (dynamic_info); i--;)
18793     dynamic_info[i] = 0;
18794   dynamic_info_DT_GNU_HASH = 0;
18795
18796   /* Process the file.  */
18797   if (show_name)
18798     printf (_("\nFile: %s\n"), filedata->file_name);
18799
18800   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18801      Note we do this even if cmdline_dump_sects is empty because we
18802      must make sure that the dump_sets array is zeroed out before each
18803      object file is processed.  */
18804   if (filedata->num_dump_sects > cmdline.num_dump_sects)
18805     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
18806
18807   if (cmdline.num_dump_sects > 0)
18808     {
18809       if (filedata->num_dump_sects == 0)
18810         /* A sneaky way of allocating the dump_sects array.  */
18811         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
18812
18813       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
18814       memcpy (filedata->dump_sects, cmdline.dump_sects,
18815               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
18816     }
18817
18818   if (! process_file_header (filedata))
18819     return FALSE;
18820
18821   if (! process_section_headers (filedata))
18822     {
18823       /* Without loaded section headers we cannot process lots of things.  */
18824       do_unwind = do_version = do_dump = do_arch = FALSE;
18825
18826       if (! do_using_dynamic)
18827         do_syms = do_dyn_syms = do_reloc = FALSE;
18828     }
18829
18830   if (! process_section_groups (filedata))
18831     /* Without loaded section groups we cannot process unwind.  */
18832     do_unwind = FALSE;
18833
18834   if (process_program_headers (filedata))
18835     process_dynamic_section (filedata);
18836   else
18837     res = FALSE;
18838
18839   if (! process_relocs (filedata))
18840     res = FALSE;
18841
18842   if (! process_unwind (filedata))
18843     res = FALSE;
18844
18845   if (! process_symbol_table (filedata))
18846     res = FALSE;
18847
18848   if (! process_syminfo (filedata))
18849     res = FALSE;
18850
18851   if (! process_version_sections (filedata))
18852     res = FALSE;
18853
18854   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
18855     separates = load_separate_debug_file (filedata, filedata->file_name);
18856   else
18857     separates = NULL;
18858
18859   if (! process_section_contents (filedata))
18860     res = FALSE;
18861
18862   if (separates)
18863     {
18864       if (! process_section_headers (separates))
18865         res = FALSE;
18866       else if (! process_section_contents (separates))
18867         res = FALSE;
18868     }
18869
18870   if (! process_notes (filedata))
18871     res = FALSE;
18872
18873   if (! process_gnu_liblist (filedata))
18874     res = FALSE;
18875
18876   if (! process_arch_specific (filedata))
18877     res = FALSE;
18878
18879   free (filedata->program_headers);
18880   filedata->program_headers = NULL;
18881
18882   free (filedata->section_headers);
18883   filedata->section_headers = NULL;
18884
18885   free (filedata->string_table);
18886   filedata->string_table = NULL;
18887   filedata->string_table_length = 0;
18888
18889   if (dynamic_strings)
18890     {
18891       free (dynamic_strings);
18892       dynamic_strings = NULL;
18893       dynamic_strings_length = 0;
18894     }
18895
18896   if (dynamic_symbols)
18897     {
18898       free (dynamic_symbols);
18899       dynamic_symbols = NULL;
18900       num_dynamic_syms = 0;
18901     }
18902
18903   if (dynamic_syminfo)
18904     {
18905       free (dynamic_syminfo);
18906       dynamic_syminfo = NULL;
18907     }
18908
18909   if (dynamic_section)
18910     {
18911       free (dynamic_section);
18912       dynamic_section = NULL;
18913     }
18914
18915   if (section_headers_groups)
18916     {
18917       free (section_headers_groups);
18918       section_headers_groups = NULL;
18919     }
18920
18921   if (section_groups)
18922     {
18923       struct group_list * g;
18924       struct group_list * next;
18925
18926       for (i = 0; i < group_count; i++)
18927         {
18928           for (g = section_groups [i].root; g != NULL; g = next)
18929             {
18930               next = g->next;
18931               free (g);
18932             }
18933         }
18934
18935       free (section_groups);
18936       section_groups = NULL;
18937     }
18938
18939   free_debug_memory ();
18940
18941   return res;
18942 }
18943
18944 /* Process an ELF archive.
18945    On entry the file is positioned just after the ARMAG string.
18946    Returns TRUE upon success, FALSE otherwise.  */
18947
18948 static bfd_boolean
18949 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
18950 {
18951   struct archive_info arch;
18952   struct archive_info nested_arch;
18953   size_t got;
18954   bfd_boolean ret = TRUE;
18955
18956   show_name = TRUE;
18957
18958   /* The ARCH structure is used to hold information about this archive.  */
18959   arch.file_name = NULL;
18960   arch.file = NULL;
18961   arch.index_array = NULL;
18962   arch.sym_table = NULL;
18963   arch.longnames = NULL;
18964
18965   /* The NESTED_ARCH structure is used as a single-item cache of information
18966      about a nested archive (when members of a thin archive reside within
18967      another regular archive file).  */
18968   nested_arch.file_name = NULL;
18969   nested_arch.file = NULL;
18970   nested_arch.index_array = NULL;
18971   nested_arch.sym_table = NULL;
18972   nested_arch.longnames = NULL;
18973
18974   if (setup_archive (&arch, filedata->file_name, filedata->handle,
18975                      is_thin_archive, do_archive_index) != 0)
18976     {
18977       ret = FALSE;
18978       goto out;
18979     }
18980
18981   if (do_archive_index)
18982     {
18983       if (arch.sym_table == NULL)
18984         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
18985       else
18986         {
18987           unsigned long i, l;
18988           unsigned long current_pos;
18989
18990           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18991                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
18992
18993           current_pos = ftell (filedata->handle);
18994
18995           for (i = l = 0; i < arch.index_num; i++)
18996             {
18997               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18998                 {
18999                   char * member_name;
19000
19001                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19002
19003                   if (member_name != NULL)
19004                     {
19005                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19006
19007                       if (qualified_name != NULL)
19008                         {
19009                           printf (_("Contents of binary %s at offset "), qualified_name);
19010                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
19011                           putchar ('\n');
19012                           free (qualified_name);
19013                         }
19014                     }
19015                 }
19016
19017               if (l >= arch.sym_size)
19018                 {
19019                   error (_("%s: end of the symbol table reached before the end of the index\n"),
19020                          filedata->file_name);
19021                   ret = FALSE;
19022                   break;
19023                 }
19024               /* PR 17531: file: 0b6630b2.  */
19025               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19026               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19027             }
19028
19029           if (arch.uses_64bit_indicies)
19030             l = (l + 7) & ~ 7;
19031           else
19032             l += l & 1;
19033
19034           if (l < arch.sym_size)
19035             {
19036               error (ngettext ("%s: %ld byte remains in the symbol table, "
19037                                "but without corresponding entries in "
19038                                "the index table\n",
19039                                "%s: %ld bytes remain in the symbol table, "
19040                                "but without corresponding entries in "
19041                                "the index table\n",
19042                                arch.sym_size - l),
19043                      filedata->file_name, arch.sym_size - l);
19044               ret = FALSE;
19045             }
19046
19047           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19048             {
19049               error (_("%s: failed to seek back to start of object files in the archive\n"),
19050                      filedata->file_name);
19051               ret = FALSE;
19052               goto out;
19053             }
19054         }
19055
19056       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19057           && !do_segments && !do_header && !do_dump && !do_version
19058           && !do_histogram && !do_debugging && !do_arch && !do_notes
19059           && !do_section_groups && !do_dyn_syms)
19060         {
19061           ret = TRUE; /* Archive index only.  */
19062           goto out;
19063         }
19064     }
19065
19066   while (1)
19067     {
19068       char * name;
19069       size_t namelen;
19070       char * qualified_name;
19071
19072       /* Read the next archive header.  */
19073       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19074         {
19075           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
19076           return FALSE;
19077         }
19078       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19079       if (got != sizeof arch.arhdr)
19080         {
19081           if (got == 0)
19082             break;
19083           error (_("%s: failed to read archive header\n"), filedata->file_name);
19084           ret = FALSE;
19085           break;
19086         }
19087       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19088         {
19089           error (_("%s: did not find a valid archive header\n"), arch.file_name);
19090           ret = FALSE;
19091           break;
19092         }
19093
19094       arch.next_arhdr_offset += sizeof arch.arhdr;
19095
19096       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19097       if (archive_file_size & 01)
19098         ++archive_file_size;
19099
19100       name = get_archive_member_name (&arch, &nested_arch);
19101       if (name == NULL)
19102         {
19103           error (_("%s: bad archive file name\n"), filedata->file_name);
19104           ret = FALSE;
19105           break;
19106         }
19107       namelen = strlen (name);
19108
19109       qualified_name = make_qualified_name (&arch, &nested_arch, name);
19110       if (qualified_name == NULL)
19111         {
19112           error (_("%s: bad archive file name\n"), filedata->file_name);
19113           ret = FALSE;
19114           break;
19115         }
19116
19117       if (is_thin_archive && arch.nested_member_origin == 0)
19118         {
19119           /* This is a proxy for an external member of a thin archive.  */
19120           Filedata * member_filedata;
19121           char * member_file_name = adjust_relative_path
19122             (filedata->file_name, name, namelen);
19123
19124           if (member_file_name == NULL)
19125             {
19126               ret = FALSE;
19127               break;
19128             }
19129
19130           member_filedata = open_file (member_file_name);
19131           if (member_filedata == NULL)
19132             {
19133               error (_("Input file '%s' is not readable.\n"), member_file_name);
19134               free (member_file_name);
19135               ret = FALSE;
19136               break;
19137             }
19138
19139           archive_file_offset = arch.nested_member_origin;
19140           member_filedata->file_name = qualified_name;
19141
19142           if (! process_object (member_filedata))
19143             ret = FALSE;
19144
19145           close_file (member_filedata);
19146           free (member_file_name);
19147         }
19148       else if (is_thin_archive)
19149         {
19150           Filedata thin_filedata;
19151
19152           memset (&thin_filedata, 0, sizeof (thin_filedata));
19153
19154           /* PR 15140: Allow for corrupt thin archives.  */
19155           if (nested_arch.file == NULL)
19156             {
19157               error (_("%s: contains corrupt thin archive: %s\n"),
19158                      filedata->file_name, name);
19159               ret = FALSE;
19160               break;
19161             }
19162
19163           /* This is a proxy for a member of a nested archive.  */
19164           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19165
19166           /* The nested archive file will have been opened and setup by
19167              get_archive_member_name.  */
19168           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19169             {
19170               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19171               ret = FALSE;
19172               break;
19173             }
19174
19175           thin_filedata.handle = nested_arch.file;
19176           thin_filedata.file_name = qualified_name;
19177
19178           if (! process_object (& thin_filedata))
19179             ret = FALSE;
19180         }
19181       else
19182         {
19183           archive_file_offset = arch.next_arhdr_offset;
19184           arch.next_arhdr_offset += archive_file_size;
19185
19186           filedata->file_name = qualified_name;
19187           if (! process_object (filedata))
19188             ret = FALSE;
19189         }
19190
19191       if (filedata->dump_sects != NULL)
19192         {
19193           free (filedata->dump_sects);
19194           filedata->dump_sects = NULL;
19195           filedata->num_dump_sects = 0;
19196         }
19197
19198       free (qualified_name);
19199     }
19200
19201  out:
19202   if (nested_arch.file != NULL)
19203     fclose (nested_arch.file);
19204   release_archive (&nested_arch);
19205   release_archive (&arch);
19206
19207   return ret;
19208 }
19209
19210 static bfd_boolean
19211 process_file (char * file_name)
19212 {
19213   Filedata * filedata = NULL;
19214   struct stat statbuf;
19215   char armag[SARMAG];
19216   bfd_boolean ret = TRUE;
19217
19218   if (stat (file_name, &statbuf) < 0)
19219     {
19220       if (errno == ENOENT)
19221         error (_("'%s': No such file\n"), file_name);
19222       else
19223         error (_("Could not locate '%s'.  System error message: %s\n"),
19224                file_name, strerror (errno));
19225       return FALSE;
19226     }
19227
19228   if (! S_ISREG (statbuf.st_mode))
19229     {
19230       error (_("'%s' is not an ordinary file\n"), file_name);
19231       return FALSE;
19232     }
19233
19234   filedata = calloc (1, sizeof * filedata);
19235   if (filedata == NULL)
19236     {
19237       error (_("Out of memory allocating file data structure\n"));
19238       return FALSE;
19239     }
19240
19241   filedata->file_name = file_name;
19242   filedata->handle = fopen (file_name, "rb");
19243   if (filedata->handle == NULL)
19244     {
19245       error (_("Input file '%s' is not readable.\n"), file_name);
19246       free (filedata);
19247       return FALSE;
19248     }
19249
19250   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19251     {
19252       error (_("%s: Failed to read file's magic number\n"), file_name);
19253       fclose (filedata->handle);
19254       free (filedata);
19255       return FALSE;
19256     }
19257
19258   filedata->file_size = (bfd_size_type) statbuf.st_size;
19259
19260   if (memcmp (armag, ARMAG, SARMAG) == 0)
19261     {
19262       if (! process_archive (filedata, FALSE))
19263         ret = FALSE;
19264     }
19265   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19266     {
19267       if ( ! process_archive (filedata, TRUE))
19268         ret = FALSE;
19269     }
19270   else
19271     {
19272       if (do_archive_index)
19273         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19274                file_name);
19275
19276       rewind (filedata->handle);
19277       archive_file_size = archive_file_offset = 0;
19278
19279       if (! process_object (filedata))
19280         ret = FALSE;
19281     }
19282
19283   fclose (filedata->handle);
19284   free (filedata);
19285
19286   return ret;
19287 }
19288
19289 #ifdef SUPPORT_DISASSEMBLY
19290 /* Needed by the i386 disassembler.  For extra credit, someone could
19291    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19292    symbols.  */
19293
19294 void
19295 print_address (unsigned int addr, FILE * outfile)
19296 {
19297   fprintf (outfile,"0x%8.8x", addr);
19298 }
19299
19300 /* Needed by the i386 disassembler.  */
19301
19302 void
19303 db_task_printsym (unsigned int addr)
19304 {
19305   print_address (addr, stderr);
19306 }
19307 #endif
19308
19309 int
19310 main (int argc, char ** argv)
19311 {
19312   int err;
19313
19314 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19315   setlocale (LC_MESSAGES, "");
19316 #endif
19317 #if defined (HAVE_SETLOCALE)
19318   setlocale (LC_CTYPE, "");
19319 #endif
19320   bindtextdomain (PACKAGE, LOCALEDIR);
19321   textdomain (PACKAGE);
19322
19323   expandargv (&argc, &argv);
19324
19325   cmdline.file_name = "<cmdline>";
19326   parse_args (& cmdline, argc, argv);
19327
19328   if (optind < (argc - 1))
19329     show_name = TRUE;
19330   else if (optind >= argc)
19331     {
19332       warn (_("Nothing to do.\n"));
19333       usage (stderr);
19334     }
19335
19336   err = FALSE;
19337   while (optind < argc)
19338     if (! process_file (argv[optind++]))
19339       err = TRUE;
19340
19341   if (cmdline.dump_sects != NULL)
19342     free (cmdline.dump_sects);
19343
19344   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19345 }