binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2018 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #include <zlib.h>
  47 #ifdef HAVE_WCHAR_H
  48 #include <wchar.h>
  49 #endif
  50
  51 #if __GNUC__ >= 2
  52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  53    as this will allow us to read in and parse 64bit and 32bit ELF files.
  54    Only do this if we believe that the compiler can support a 64 bit
  55    data type.  For now we only rely on GCC being able to do this.  */
  56 #define BFD64
  57 #endif
  58
  59 #include "bfd.h"
  60 #include "bucomm.h"
  61 #include "elfcomm.h"
  62 #include "dwarf.h"
  63
  64 #include "elf/common.h"
  65 #include "elf/external.h"
  66 #include "elf/internal.h"
  67
  68
  69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  70    we can obtain the H8 reloc numbers.  We need these for the
  71    get_reloc_size() function.  We include h8.h again after defining
  72    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  73
  74 #include "elf/h8.h"
  75 #undef _ELF_H8_H
  76
  77 /* Undo the effects of #including reloc-macros.h.  */
  78
  79 #undef START_RELOC_NUMBERS
  80 #undef RELOC_NUMBER
  81 #undef FAKE_RELOC
  82 #undef EMPTY_RELOC
  83 #undef END_RELOC_NUMBERS
  84 #undef _RELOC_MACROS_H
  85
  86 /* The following headers use the elf/reloc-macros.h file to
  87    automatically generate relocation recognition functions
  88    such as elf_mips_reloc_type()  */
  89
  90 #define RELOC_MACROS_GEN_FUNC
  91
  92 #include "elf/aarch64.h"
  93 #include "elf/alpha.h"
  94 #include "elf/arc.h"
  95 #include "elf/arm.h"
  96 #include "elf/avr.h"
  97 #include "elf/bfin.h"
  98 #include "elf/cr16.h"
  99 #include "elf/cris.h"
 100 #include "elf/crx.h"
 101 #include "elf/d10v.h"
 102 #include "elf/d30v.h"
 103 #include "elf/dlx.h"
 104 #include "elf/epiphany.h"
 105 #include "elf/fr30.h"
 106 #include "elf/frv.h"
 107 #include "elf/ft32.h"
 108 #include "elf/h8.h"
 109 #include "elf/hppa.h"
 110 #include "elf/i386.h"
 111 #include "elf/i370.h"
 112 #include "elf/i860.h"
 113 #include "elf/i960.h"
 114 #include "elf/ia64.h"
 115 #include "elf/ip2k.h"
 116 #include "elf/lm32.h"
 117 #include "elf/iq2000.h"
 118 #include "elf/m32c.h"
 119 #include "elf/m32r.h"
 120 #include "elf/m68k.h"
 121 #include "elf/m68hc11.h"
 122 #include "elf/mcore.h"
 123 #include "elf/mep.h"
 124 #include "elf/metag.h"
 125 #include "elf/microblaze.h"
 126 #include "elf/mips.h"
 127 #include "elf/mmix.h"
 128 #include "elf/mn10200.h"
 129 #include "elf/mn10300.h"
 130 #include "elf/moxie.h"
 131 #include "elf/mt.h"
 132 #include "elf/msp430.h"
 133 #include "elf/nds32.h"
 134 #include "elf/nfp.h"
 135 #include "elf/nios2.h"
 136 #include "elf/or1k.h"
 137 #include "elf/pj.h"
 138 #include "elf/ppc.h"
 139 #include "elf/ppc64.h"
 140 #include "elf/pru.h"
 141 #include "elf/riscv.h"
 142 #include "elf/rl78.h"
 143 #include "elf/rx.h"
 144 #include "elf/s390.h"
 145 #include "elf/score.h"
 146 #include "elf/sh.h"
 147 #include "elf/sparc.h"
 148 #include "elf/spu.h"
 149 #include "elf/tic6x.h"
 150 #include "elf/tilegx.h"
 151 #include "elf/tilepro.h"
 152 #include "elf/v850.h"
 153 #include "elf/vax.h"
 154 #include "elf/visium.h"
 155 #include "elf/wasm32.h"
 156 #include "elf/x86-64.h"
 157 #include "elf/xc16x.h"
 158 #include "elf/xgate.h"
 159 #include "elf/xstormy16.h"
 160 #include "elf/xtensa.h"
 161
 162 #include "getopt.h"
 163 #include "libiberty.h"
 164 #include "safe-ctype.h"
 165 #include "filenames.h"
 166
 167 #ifndef offsetof
 168 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 169 #endif
 170
 171 typedef struct elf_section_list
 172 {
 173   Elf_Internal_Shdr *        hdr;
 174   struct elf_section_list *  next;
 175 } elf_section_list;
 176
 177 /* Flag bits indicating particular types of dump.  */
 178 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 179 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 180 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 181 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 182 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 183
 184 typedef unsigned char dump_type;
 185
 186 /* A linked list of the section names for which dumps were requested.  */
 187 struct dump_list_entry
 188 {
 189   char *                    name;
 190   dump_type                 type;
 191   struct dump_list_entry *  next;
 192 };
 193
 194 typedef struct filedata
 195 {
 196   const char *         file_name;
 197   FILE *               handle;
 198   bfd_size_type        file_size;
 199   Elf_Internal_Ehdr    file_header;
 200   Elf_Internal_Shdr *  section_headers;
 201   Elf_Internal_Phdr *  program_headers;
 202   char *               string_table;
 203   unsigned long        string_table_length;
 204   /* A dynamic array of flags indicating for which sections a dump of
 205      some kind has been requested.  It is reset on a per-object file
 206      basis and then initialised from the cmdline_dump_sects array,
 207      the results of interpreting the -w switch, and the
 208      dump_sects_byname list.  */
 209   dump_type *          dump_sects;
 210   unsigned int         num_dump_sects;
 211 } Filedata;
 212
 213 char * program_name = "readelf";
 214
 215 static unsigned long archive_file_offset;
 216 static unsigned long archive_file_size;
 217 static unsigned long dynamic_addr;
 218 static bfd_size_type dynamic_size;
 219 static size_t dynamic_nent;
 220 static char * dynamic_strings;
 221 static unsigned long dynamic_strings_length;
 222 static unsigned long num_dynamic_syms;
 223 static Elf_Internal_Sym * dynamic_symbols;
 224 static Elf_Internal_Syminfo * dynamic_syminfo;
 225 static unsigned long dynamic_syminfo_offset;
 226 static unsigned int dynamic_syminfo_nent;
 227 static char program_interpreter[PATH_MAX];
 228 static bfd_vma dynamic_info[DT_ENCODING];
 229 static bfd_vma dynamic_info_DT_GNU_HASH;
 230 static bfd_vma version_info[16];
 231 static Elf_Internal_Dyn *  dynamic_section;
 232 static elf_section_list * symtab_shndx_list;
 233 static bfd_boolean show_name = FALSE;
 234 static bfd_boolean do_dynamic = FALSE;
 235 static bfd_boolean do_syms = FALSE;
 236 static bfd_boolean do_dyn_syms = FALSE;
 237 static bfd_boolean do_reloc = FALSE;
 238 static bfd_boolean do_sections = FALSE;
 239 static bfd_boolean do_section_groups = FALSE;
 240 static bfd_boolean do_section_details = FALSE;
 241 static bfd_boolean do_segments = FALSE;
 242 static bfd_boolean do_unwind = FALSE;
 243 static bfd_boolean do_using_dynamic = FALSE;
 244 static bfd_boolean do_header = FALSE;
 245 static bfd_boolean do_dump = FALSE;
 246 static bfd_boolean do_version = FALSE;
 247 static bfd_boolean do_histogram = FALSE;
 248 static bfd_boolean do_debugging = FALSE;
 249 static bfd_boolean do_arch = FALSE;
 250 static bfd_boolean do_notes = FALSE;
 251 static bfd_boolean do_archive_index = FALSE;
 252 static bfd_boolean is_32bit_elf = FALSE;
 253 static bfd_boolean decompress_dumps = FALSE;
 254
 255 struct group_list
 256 {
 257   struct group_list *  next;
 258   unsigned int         section_index;
 259 };
 260
 261 struct group
 262 {
 263   struct group_list *  root;
 264   unsigned int         group_index;
 265 };
 266
 267 static size_t           group_count;
 268 static struct group *   section_groups;
 269 static struct group **  section_headers_groups;
 270
 271 /* A dynamic array of flags indicating for which sections a dump
 272    has been requested via command line switches.  */
 273 static Filedata         cmdline;
 274
 275 static struct dump_list_entry * dump_sects_byname;
 276
 277 /* How to print a vma value.  */
 278 typedef enum print_mode
 279 {
 280   HEX,
 281   DEC,
 282   DEC_5,
 283   UNSIGNED,
 284   PREFIX_HEX,
 285   FULL_HEX,
 286   LONG_HEX
 287 }
 288 print_mode;
 289
 290 /* Versioned symbol info.  */
 291 enum versioned_symbol_info
 292 {
 293   symbol_undefined,
 294   symbol_hidden,
 295   symbol_public
 296 };
 297
 298 static const char * get_symbol_version_string
 299   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 300    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 301
 302 #define UNKNOWN -1
 303
 304 #define SECTION_NAME(X)                                         \
 305   ((X) == NULL ? _("<none>")                                    \
 306    : filedata->string_table == NULL ? _("<no-strings>")         \
 307    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 308   : filedata->string_table + (X)->sh_name))
 309
 310 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 311
 312 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 313   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 314    : get_64bit_elf_symbols (file, section, sym_count))
 315
 316 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 317 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 318    already been called and verified that the string exists.  */
 319 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 320
 321 #define REMOVE_ARCH_BITS(ADDR)                  \
 322   do                                            \
 323     {                                           \
 324       if (filedata->file_header.e_machine == EM_ARM)    \
 325         (ADDR) &= ~1;                           \
 326     }                                           \
 327   while (0)
 328 \f
 329 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 330    BFD_FMA_FMT can't be used in translated strings.  */
 331
 332 static const char *
 333 bfd_vmatoa (char *fmtch, bfd_vma value)
 334 {
 335   /* bfd_vmatoa is used more then once in a printf call for output.
 336      Cycle through an array of buffers.  */
 337   static int buf_pos = 0;
 338   static struct bfd_vmatoa_buf
 339   {
 340     char place[64];
 341   } buf[4];
 342   char *ret;
 343   char fmt[32];
 344
 345   ret = buf[buf_pos++].place;
 346   buf_pos %= ARRAY_SIZE (buf);
 347
 348   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 349   snprintf (ret, sizeof (buf[0].place), fmt, value);
 350   return ret;
 351 }
 352
 353 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 354    OFFSET + the offset of the current archive member, if we are examining an
 355    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 356    allocate a buffer using malloc and fill that.  In either case return the
 357    pointer to the start of the retrieved data or NULL if something went wrong.
 358    If something does go wrong and REASON is not NULL then emit an error
 359    message using REASON as part of the context.  */
 360
 361 static void *
 362 get_data (void *         var,
 363           Filedata *     filedata,
 364           unsigned long  offset,
 365           bfd_size_type  size,
 366           bfd_size_type  nmemb,
 367           const char *   reason)
 368 {
 369   void * mvar;
 370   bfd_size_type amt = size * nmemb;
 371
 372   if (size == 0 || nmemb == 0)
 373     return NULL;
 374
 375   /* If the size_t type is smaller than the bfd_size_type, eg because
 376      you are building a 32-bit tool on a 64-bit host, then make sure
 377      that when the sizes are cast to (size_t) no information is lost.  */
 378   if (sizeof (size_t) < sizeof (bfd_size_type)
 379       && (   (bfd_size_type) ((size_t) size) != size
 380           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 381     {
 382       if (reason)
 383         error (_("Size truncation prevents reading %s"
 384                  " elements of size %s for %s\n"),
 385                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 386       return NULL;
 387     }
 388
 389   /* Check for size overflow.  */
 390   if (amt < nmemb)
 391     {
 392       if (reason)
 393         error (_("Size overflow prevents reading %s"
 394                  " elements of size %s for %s\n"),
 395                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 396       return NULL;
 397     }
 398
 399   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 400      attempting to allocate memory when the read is bound to fail.  */
 401   if (amt > filedata->file_size
 402       || offset + archive_file_offset + amt > filedata->file_size)
 403     {
 404       if (reason)
 405         error (_("Reading %s bytes extends past end of file for %s\n"),
 406                bfd_vmatoa ("u", amt), reason);
 407       return NULL;
 408     }
 409
 410   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 411     {
 412       if (reason)
 413         error (_("Unable to seek to 0x%lx for %s\n"),
 414                archive_file_offset + offset, reason);
 415       return NULL;
 416     }
 417
 418   mvar = var;
 419   if (mvar == NULL)
 420     {
 421       /* Check for overflow.  */
 422       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 423         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 424         mvar = malloc ((size_t) amt + 1);
 425
 426       if (mvar == NULL)
 427         {
 428           if (reason)
 429             error (_("Out of memory allocating %s bytes for %s\n"),
 430                    bfd_vmatoa ("u", amt), reason);
 431           return NULL;
 432         }
 433
 434       ((char *) mvar)[amt] = '\0';
 435     }
 436
 437   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 438     {
 439       if (reason)
 440         error (_("Unable to read in %s bytes of %s\n"),
 441                bfd_vmatoa ("u", amt), reason);
 442       if (mvar != var)
 443         free (mvar);
 444       return NULL;
 445     }
 446
 447   return mvar;
 448 }
 449
 450 /* Print a VMA value in the MODE specified.
 451    Returns the number of characters displayed.  */
 452
 453 static unsigned int
 454 print_vma (bfd_vma vma, print_mode mode)
 455 {
 456   unsigned int nc = 0;
 457
 458   switch (mode)
 459     {
 460     case FULL_HEX:
 461       nc = printf ("0x");
 462       /* Fall through.  */
 463     case LONG_HEX:
 464 #ifdef BFD64
 465       if (is_32bit_elf)
 466         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 467 #endif
 468       printf_vma (vma);
 469       return nc + 16;
 470
 471     case DEC_5:
 472       if (vma <= 99999)
 473         return printf ("%5" BFD_VMA_FMT "d", vma);
 474       /* Fall through.  */
 475     case PREFIX_HEX:
 476       nc = printf ("0x");
 477       /* Fall through.  */
 478     case HEX:
 479       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 480
 481     case DEC:
 482       return printf ("%" BFD_VMA_FMT "d", vma);
 483
 484     case UNSIGNED:
 485       return printf ("%" BFD_VMA_FMT "u", vma);
 486
 487     default:
 488       /* FIXME: Report unrecognised mode ?  */
 489       return 0;
 490     }
 491 }
 492
 493 /* Display a symbol on stdout.  Handles the display of control characters and
 494    multibye characters (assuming the host environment supports them).
 495
 496    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 497
 498    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 499    padding as necessary.
 500
 501    Returns the number of emitted characters.  */
 502
 503 static unsigned int
 504 print_symbol (signed int width, const char *symbol)
 505 {
 506   bfd_boolean extra_padding = FALSE;
 507   signed int num_printed = 0;
 508 #ifdef HAVE_MBSTATE_T
 509   mbstate_t state;
 510 #endif
 511   unsigned int width_remaining;
 512
 513   if (width < 0)
 514     {
 515       /* Keep the width positive.  This helps the code below.  */
 516       width = - width;
 517       extra_padding = TRUE;
 518     }
 519   else if (width == 0)
 520     return 0;
 521
 522   if (do_wide)
 523     /* Set the remaining width to a very large value.
 524        This simplifies the code below.  */
 525     width_remaining = INT_MAX;
 526   else
 527     width_remaining = width;
 528
 529 #ifdef HAVE_MBSTATE_T
 530   /* Initialise the multibyte conversion state.  */
 531   memset (& state, 0, sizeof (state));
 532 #endif
 533
 534   while (width_remaining)
 535     {
 536       size_t  n;
 537       const char c = *symbol++;
 538
 539       if (c == 0)
 540         break;
 541
 542       /* Do not print control characters directly as they can affect terminal
 543          settings.  Such characters usually appear in the names generated
 544          by the assembler for local labels.  */
 545       if (ISCNTRL (c))
 546         {
 547           if (width_remaining < 2)
 548             break;
 549
 550           printf ("^%c", c + 0x40);
 551           width_remaining -= 2;
 552           num_printed += 2;
 553         }
 554       else if (ISPRINT (c))
 555         {
 556           putchar (c);
 557           width_remaining --;
 558           num_printed ++;
 559         }
 560       else
 561         {
 562 #ifdef HAVE_MBSTATE_T
 563           wchar_t w;
 564 #endif
 565           /* Let printf do the hard work of displaying multibyte characters.  */
 566           printf ("%.1s", symbol - 1);
 567           width_remaining --;
 568           num_printed ++;
 569
 570 #ifdef HAVE_MBSTATE_T
 571           /* Try to find out how many bytes made up the character that was
 572              just printed.  Advance the symbol pointer past the bytes that
 573              were displayed.  */
 574           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 575 #else
 576           n = 1;
 577 #endif
 578           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 579             symbol += (n - 1);
 580         }
 581     }
 582
 583   if (extra_padding && num_printed < width)
 584     {
 585       /* Fill in the remaining spaces.  */
 586       printf ("%-*s", width - num_printed, " ");
 587       num_printed = width;
 588     }
 589
 590   return num_printed;
 591 }
 592
 593 /* Returns a pointer to a static buffer containing a printable version of
 594    the given section's name.  Like print_symbol, except that it does not try
 595    to print multibyte characters, it just interprets them as hex values.  */
 596
 597 static const char *
 598 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 599 {
 600 #define MAX_PRINT_SEC_NAME_LEN 128
 601   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 602   const char * name = SECTION_NAME (sec);
 603   char *       buf = sec_name_buf;
 604   char         c;
 605   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 606
 607   while ((c = * name ++) != 0)
 608     {
 609       if (ISCNTRL (c))
 610         {
 611           if (remaining < 2)
 612             break;
 613
 614           * buf ++ = '^';
 615           * buf ++ = c + 0x40;
 616           remaining -= 2;
 617         }
 618       else if (ISPRINT (c))
 619         {
 620           * buf ++ = c;
 621           remaining -= 1;
 622         }
 623       else
 624         {
 625           static char hex[17] = "0123456789ABCDEF";
 626
 627           if (remaining < 4)
 628             break;
 629           * buf ++ = '<';
 630           * buf ++ = hex[(c & 0xf0) >> 4];
 631           * buf ++ = hex[c & 0x0f];
 632           * buf ++ = '>';
 633           remaining -= 4;
 634         }
 635
 636       if (remaining == 0)
 637         break;
 638     }
 639
 640   * buf = 0;
 641   return sec_name_buf;
 642 }
 643
 644 static const char *
 645 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 646 {
 647   if (ndx >= filedata->file_header.e_shnum)
 648     return _("<corrupt>");
 649
 650   return printable_section_name (filedata, filedata->section_headers + ndx);
 651 }
 652
 653 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 654
 655 static Elf_Internal_Shdr *
 656 find_section (Filedata * filedata, const char * name)
 657 {
 658   unsigned int i;
 659
 660   if (filedata->section_headers == NULL)
 661     return NULL;
 662
 663   for (i = 0; i < filedata->file_header.e_shnum; i++)
 664     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 665       return filedata->section_headers + i;
 666
 667   return NULL;
 668 }
 669
 670 /* Return a pointer to a section containing ADDR, or NULL if no such
 671    section exists.  */
 672
 673 static Elf_Internal_Shdr *
 674 find_section_by_address (Filedata * filedata, bfd_vma addr)
 675 {
 676   unsigned int i;
 677
 678   if (filedata->section_headers == NULL)
 679     return NULL;
 680
 681   for (i = 0; i < filedata->file_header.e_shnum; i++)
 682     {
 683       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 684
 685       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 686         return sec;
 687     }
 688
 689   return NULL;
 690 }
 691
 692 static Elf_Internal_Shdr *
 693 find_section_by_type (Filedata * filedata, unsigned int type)
 694 {
 695   unsigned int i;
 696
 697   if (filedata->section_headers == NULL)
 698     return NULL;
 699
 700   for (i = 0; i < filedata->file_header.e_shnum; i++)
 701     {
 702       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 703
 704       if (sec->sh_type == type)
 705         return sec;
 706     }
 707
 708   return NULL;
 709 }
 710
 711 /* Return a pointer to section NAME, or NULL if no such section exists,
 712    restricted to the list of sections given in SET.  */
 713
 714 static Elf_Internal_Shdr *
 715 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 716 {
 717   unsigned int i;
 718
 719   if (filedata->section_headers == NULL)
 720     return NULL;
 721
 722   if (set != NULL)
 723     {
 724       while ((i = *set++) > 0)
 725         {
 726           /* See PR 21156 for a reproducer.  */
 727           if (i >= filedata->file_header.e_shnum)
 728             continue; /* FIXME: Should we issue an error message ?  */
 729
 730           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 731             return filedata->section_headers + i;
 732         }
 733     }
 734
 735   return find_section (filedata, name);
 736 }
 737
 738 /* Read an unsigned LEB128 encoded value from DATA.
 739    Set *LENGTH_RETURN to the number of bytes read.  */
 740
 741 static inline unsigned long
 742 read_uleb128 (unsigned char * data,
 743               unsigned int * length_return,
 744               const unsigned char * const end)
 745 {
 746   return read_leb128 (data, length_return, FALSE, end);
 747 }
 748
 749 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 750    This OS has so many departures from the ELF standard that we test it at
 751    many places.  */
 752
 753 static inline bfd_boolean
 754 is_ia64_vms (Filedata * filedata)
 755 {
 756   return filedata->file_header.e_machine == EM_IA_64
 757     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 758 }
 759
 760 /* Guess the relocation size commonly used by the specific machines.  */
 761
 762 static bfd_boolean
 763 guess_is_rela (unsigned int e_machine)
 764 {
 765   switch (e_machine)
 766     {
 767       /* Targets that use REL relocations.  */
 768     case EM_386:
 769     case EM_IAMCU:
 770     case EM_960:
 771     case EM_ARM:
 772     case EM_D10V:
 773     case EM_CYGNUS_D10V:
 774     case EM_DLX:
 775     case EM_MIPS:
 776     case EM_MIPS_RS3_LE:
 777     case EM_CYGNUS_M32R:
 778     case EM_SCORE:
 779     case EM_XGATE:
 780     case EM_NFP:
 781       return FALSE;
 782
 783       /* Targets that use RELA relocations.  */
 784     case EM_68K:
 785     case EM_860:
 786     case EM_AARCH64:
 787     case EM_ADAPTEVA_EPIPHANY:
 788     case EM_ALPHA:
 789     case EM_ALTERA_NIOS2:
 790     case EM_ARC:
 791     case EM_ARC_COMPACT:
 792     case EM_ARC_COMPACT2:
 793     case EM_AVR:
 794     case EM_AVR_OLD:
 795     case EM_BLACKFIN:
 796     case EM_CR16:
 797     case EM_CRIS:
 798     case EM_CRX:
 799     case EM_D30V:
 800     case EM_CYGNUS_D30V:
 801     case EM_FR30:
 802     case EM_FT32:
 803     case EM_CYGNUS_FR30:
 804     case EM_CYGNUS_FRV:
 805     case EM_H8S:
 806     case EM_H8_300:
 807     case EM_H8_300H:
 808     case EM_IA_64:
 809     case EM_IP2K:
 810     case EM_IP2K_OLD:
 811     case EM_IQ2000:
 812     case EM_LATTICEMICO32:
 813     case EM_M32C_OLD:
 814     case EM_M32C:
 815     case EM_M32R:
 816     case EM_MCORE:
 817     case EM_CYGNUS_MEP:
 818     case EM_METAG:
 819     case EM_MMIX:
 820     case EM_MN10200:
 821     case EM_CYGNUS_MN10200:
 822     case EM_MN10300:
 823     case EM_CYGNUS_MN10300:
 824     case EM_MOXIE:
 825     case EM_MSP430:
 826     case EM_MSP430_OLD:
 827     case EM_MT:
 828     case EM_NDS32:
 829     case EM_NIOS32:
 830     case EM_OR1K:
 831     case EM_PPC64:
 832     case EM_PPC:
 833     case EM_TI_PRU:
 834     case EM_RISCV:
 835     case EM_RL78:
 836     case EM_RX:
 837     case EM_S390:
 838     case EM_S390_OLD:
 839     case EM_SH:
 840     case EM_SPARC:
 841     case EM_SPARC32PLUS:
 842     case EM_SPARCV9:
 843     case EM_SPU:
 844     case EM_TI_C6000:
 845     case EM_TILEGX:
 846     case EM_TILEPRO:
 847     case EM_V800:
 848     case EM_V850:
 849     case EM_CYGNUS_V850:
 850     case EM_VAX:
 851     case EM_VISIUM:
 852     case EM_X86_64:
 853     case EM_L1OM:
 854     case EM_K1OM:
 855     case EM_XSTORMY16:
 856     case EM_XTENSA:
 857     case EM_XTENSA_OLD:
 858     case EM_MICROBLAZE:
 859     case EM_MICROBLAZE_OLD:
 860     case EM_WEBASSEMBLY:
 861       return TRUE;
 862
 863     case EM_68HC05:
 864     case EM_68HC08:
 865     case EM_68HC11:
 866     case EM_68HC16:
 867     case EM_FX66:
 868     case EM_ME16:
 869     case EM_MMA:
 870     case EM_NCPU:
 871     case EM_NDR1:
 872     case EM_PCP:
 873     case EM_ST100:
 874     case EM_ST19:
 875     case EM_ST7:
 876     case EM_ST9PLUS:
 877     case EM_STARCORE:
 878     case EM_SVX:
 879     case EM_TINYJ:
 880     default:
 881       warn (_("Don't know about relocations on this machine architecture\n"));
 882       return FALSE;
 883     }
 884 }
 885
 886 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 887    Returns TRUE upon success, FALSE otherwise.  If successful then a
 888    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 889    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 890    responsibility to free the allocated buffer.  */
 891
 892 static bfd_boolean
 893 slurp_rela_relocs (Filedata *            filedata,
 894                    unsigned long         rel_offset,
 895                    unsigned long         rel_size,
 896                    Elf_Internal_Rela **  relasp,
 897                    unsigned long *       nrelasp)
 898 {
 899   Elf_Internal_Rela * relas;
 900   size_t nrelas;
 901   unsigned int i;
 902
 903   if (is_32bit_elf)
 904     {
 905       Elf32_External_Rela * erelas;
 906
 907       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 908                                                  rel_size, _("32-bit relocation data"));
 909       if (!erelas)
 910         return FALSE;
 911
 912       nrelas = rel_size / sizeof (Elf32_External_Rela);
 913
 914       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 915                                              sizeof (Elf_Internal_Rela));
 916
 917       if (relas == NULL)
 918         {
 919           free (erelas);
 920           error (_("out of memory parsing relocs\n"));
 921           return FALSE;
 922         }
 923
 924       for (i = 0; i < nrelas; i++)
 925         {
 926           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 927           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 928           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 929         }
 930
 931       free (erelas);
 932     }
 933   else
 934     {
 935       Elf64_External_Rela * erelas;
 936
 937       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 938                                                  rel_size, _("64-bit relocation data"));
 939       if (!erelas)
 940         return FALSE;
 941
 942       nrelas = rel_size / sizeof (Elf64_External_Rela);
 943
 944       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 945                                              sizeof (Elf_Internal_Rela));
 946
 947       if (relas == NULL)
 948         {
 949           free (erelas);
 950           error (_("out of memory parsing relocs\n"));
 951           return FALSE;
 952         }
 953
 954       for (i = 0; i < nrelas; i++)
 955         {
 956           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 957           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 958           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 959
 960           /* The #ifdef BFD64 below is to prevent a compile time
 961              warning.  We know that if we do not have a 64 bit data
 962              type that we will never execute this code anyway.  */
 963 #ifdef BFD64
 964           if (filedata->file_header.e_machine == EM_MIPS
 965               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 966             {
 967               /* In little-endian objects, r_info isn't really a
 968                  64-bit little-endian value: it has a 32-bit
 969                  little-endian symbol index followed by four
 970                  individual byte fields.  Reorder INFO
 971                  accordingly.  */
 972               bfd_vma inf = relas[i].r_info;
 973               inf = (((inf & 0xffffffff) << 32)
 974                       | ((inf >> 56) & 0xff)
 975                       | ((inf >> 40) & 0xff00)
 976                       | ((inf >> 24) & 0xff0000)
 977                       | ((inf >> 8) & 0xff000000));
 978               relas[i].r_info = inf;
 979             }
 980 #endif /* BFD64 */
 981         }
 982
 983       free (erelas);
 984     }
 985
 986   *relasp = relas;
 987   *nrelasp = nrelas;
 988   return TRUE;
 989 }
 990
 991 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 992    Returns TRUE upon success, FALSE otherwise.  If successful then a
 993    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 994    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 995    responsibility to free the allocated buffer.  */
 996
 997 static bfd_boolean
 998 slurp_rel_relocs (Filedata *            filedata,
 999                   unsigned long         rel_offset,
1000                   unsigned long         rel_size,
1001                   Elf_Internal_Rela **  relsp,
1002                   unsigned long *       nrelsp)
1003 {
1004   Elf_Internal_Rela * rels;
1005   size_t nrels;
1006   unsigned int i;
1007
1008   if (is_32bit_elf)
1009     {
1010       Elf32_External_Rel * erels;
1011
1012       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1013                                                rel_size, _("32-bit relocation data"));
1014       if (!erels)
1015         return FALSE;
1016
1017       nrels = rel_size / sizeof (Elf32_External_Rel);
1018
1019       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1020
1021       if (rels == NULL)
1022         {
1023           free (erels);
1024           error (_("out of memory parsing relocs\n"));
1025           return FALSE;
1026         }
1027
1028       for (i = 0; i < nrels; i++)
1029         {
1030           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1031           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1032           rels[i].r_addend = 0;
1033         }
1034
1035       free (erels);
1036     }
1037   else
1038     {
1039       Elf64_External_Rel * erels;
1040
1041       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1042                                                rel_size, _("64-bit relocation data"));
1043       if (!erels)
1044         return FALSE;
1045
1046       nrels = rel_size / sizeof (Elf64_External_Rel);
1047
1048       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1049
1050       if (rels == NULL)
1051         {
1052           free (erels);
1053           error (_("out of memory parsing relocs\n"));
1054           return FALSE;
1055         }
1056
1057       for (i = 0; i < nrels; i++)
1058         {
1059           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1060           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1061           rels[i].r_addend = 0;
1062
1063           /* The #ifdef BFD64 below is to prevent a compile time
1064              warning.  We know that if we do not have a 64 bit data
1065              type that we will never execute this code anyway.  */
1066 #ifdef BFD64
1067           if (filedata->file_header.e_machine == EM_MIPS
1068               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1069             {
1070               /* In little-endian objects, r_info isn't really a
1071                  64-bit little-endian value: it has a 32-bit
1072                  little-endian symbol index followed by four
1073                  individual byte fields.  Reorder INFO
1074                  accordingly.  */
1075               bfd_vma inf = rels[i].r_info;
1076               inf = (((inf & 0xffffffff) << 32)
1077                      | ((inf >> 56) & 0xff)
1078                      | ((inf >> 40) & 0xff00)
1079                      | ((inf >> 24) & 0xff0000)
1080                      | ((inf >> 8) & 0xff000000));
1081               rels[i].r_info = inf;
1082             }
1083 #endif /* BFD64 */
1084         }
1085
1086       free (erels);
1087     }
1088
1089   *relsp = rels;
1090   *nrelsp = nrels;
1091   return TRUE;
1092 }
1093
1094 /* Returns the reloc type extracted from the reloc info field.  */
1095
1096 static unsigned int
1097 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1098 {
1099   if (is_32bit_elf)
1100     return ELF32_R_TYPE (reloc_info);
1101
1102   switch (filedata->file_header.e_machine)
1103     {
1104     case EM_MIPS:
1105       /* Note: We assume that reloc_info has already been adjusted for us.  */
1106       return ELF64_MIPS_R_TYPE (reloc_info);
1107
1108     case EM_SPARCV9:
1109       return ELF64_R_TYPE_ID (reloc_info);
1110
1111     default:
1112       return ELF64_R_TYPE (reloc_info);
1113     }
1114 }
1115
1116 /* Return the symbol index extracted from the reloc info field.  */
1117
1118 static bfd_vma
1119 get_reloc_symindex (bfd_vma reloc_info)
1120 {
1121   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1122 }
1123
1124 static inline bfd_boolean
1125 uses_msp430x_relocs (Filedata * filedata)
1126 {
1127   return
1128     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1129     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1130     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1131         /* TI compiler uses ELFOSABI_NONE.  */
1132         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1133 }
1134
1135 /* Display the contents of the relocation data found at the specified
1136    offset.  */
1137
1138 static bfd_boolean
1139 dump_relocations (Filedata *          filedata,
1140                   unsigned long       rel_offset,
1141                   unsigned long       rel_size,
1142                   Elf_Internal_Sym *  symtab,
1143                   unsigned long       nsyms,
1144                   char *              strtab,
1145                   unsigned long       strtablen,
1146                   int                 is_rela,
1147                   bfd_boolean         is_dynsym)
1148 {
1149   unsigned long i;
1150   Elf_Internal_Rela * rels;
1151   bfd_boolean res = TRUE;
1152
1153   if (is_rela == UNKNOWN)
1154     is_rela = guess_is_rela (filedata->file_header.e_machine);
1155
1156   if (is_rela)
1157     {
1158       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1159         return FALSE;
1160     }
1161   else
1162     {
1163       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1164         return FALSE;
1165     }
1166
1167   if (is_32bit_elf)
1168     {
1169       if (is_rela)
1170         {
1171           if (do_wide)
1172             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1173           else
1174             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1175         }
1176       else
1177         {
1178           if (do_wide)
1179             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1180           else
1181             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1182         }
1183     }
1184   else
1185     {
1186       if (is_rela)
1187         {
1188           if (do_wide)
1189             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1190           else
1191             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1192         }
1193       else
1194         {
1195           if (do_wide)
1196             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1197           else
1198             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1199         }
1200     }
1201
1202   for (i = 0; i < rel_size; i++)
1203     {
1204       const char * rtype;
1205       bfd_vma offset;
1206       bfd_vma inf;
1207       bfd_vma symtab_index;
1208       bfd_vma type;
1209
1210       offset = rels[i].r_offset;
1211       inf    = rels[i].r_info;
1212
1213       type = get_reloc_type (filedata, inf);
1214       symtab_index = get_reloc_symindex  (inf);
1215
1216       if (is_32bit_elf)
1217         {
1218           printf ("%8.8lx  %8.8lx ",
1219                   (unsigned long) offset & 0xffffffff,
1220                   (unsigned long) inf & 0xffffffff);
1221         }
1222       else
1223         {
1224 #if BFD_HOST_64BIT_LONG
1225           printf (do_wide
1226                   ? "%16.16lx  %16.16lx "
1227                   : "%12.12lx  %12.12lx ",
1228                   offset, inf);
1229 #elif BFD_HOST_64BIT_LONG_LONG
1230 #ifndef __MSVCRT__
1231           printf (do_wide
1232                   ? "%16.16llx  %16.16llx "
1233                   : "%12.12llx  %12.12llx ",
1234                   offset, inf);
1235 #else
1236           printf (do_wide
1237                   ? "%16.16I64x  %16.16I64x "
1238                   : "%12.12I64x  %12.12I64x ",
1239                   offset, inf);
1240 #endif
1241 #else
1242           printf (do_wide
1243                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1244                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1245                   _bfd_int64_high (offset),
1246                   _bfd_int64_low (offset),
1247                   _bfd_int64_high (inf),
1248                   _bfd_int64_low (inf));
1249 #endif
1250         }
1251
1252       switch (filedata->file_header.e_machine)
1253         {
1254         default:
1255           rtype = NULL;
1256           break;
1257
1258         case EM_AARCH64:
1259           rtype = elf_aarch64_reloc_type (type);
1260           break;
1261
1262         case EM_M32R:
1263         case EM_CYGNUS_M32R:
1264           rtype = elf_m32r_reloc_type (type);
1265           break;
1266
1267         case EM_386:
1268         case EM_IAMCU:
1269           rtype = elf_i386_reloc_type (type);
1270           break;
1271
1272         case EM_68HC11:
1273         case EM_68HC12:
1274           rtype = elf_m68hc11_reloc_type (type);
1275           break;
1276
1277         case EM_68K:
1278           rtype = elf_m68k_reloc_type (type);
1279           break;
1280
1281         case EM_960:
1282           rtype = elf_i960_reloc_type (type);
1283           break;
1284
1285         case EM_AVR:
1286         case EM_AVR_OLD:
1287           rtype = elf_avr_reloc_type (type);
1288           break;
1289
1290         case EM_OLD_SPARCV9:
1291         case EM_SPARC32PLUS:
1292         case EM_SPARCV9:
1293         case EM_SPARC:
1294           rtype = elf_sparc_reloc_type (type);
1295           break;
1296
1297         case EM_SPU:
1298           rtype = elf_spu_reloc_type (type);
1299           break;
1300
1301         case EM_V800:
1302           rtype = v800_reloc_type (type);
1303           break;
1304         case EM_V850:
1305         case EM_CYGNUS_V850:
1306           rtype = v850_reloc_type (type);
1307           break;
1308
1309         case EM_D10V:
1310         case EM_CYGNUS_D10V:
1311           rtype = elf_d10v_reloc_type (type);
1312           break;
1313
1314         case EM_D30V:
1315         case EM_CYGNUS_D30V:
1316           rtype = elf_d30v_reloc_type (type);
1317           break;
1318
1319         case EM_DLX:
1320           rtype = elf_dlx_reloc_type (type);
1321           break;
1322
1323         case EM_SH:
1324           rtype = elf_sh_reloc_type (type);
1325           break;
1326
1327         case EM_MN10300:
1328         case EM_CYGNUS_MN10300:
1329           rtype = elf_mn10300_reloc_type (type);
1330           break;
1331
1332         case EM_MN10200:
1333         case EM_CYGNUS_MN10200:
1334           rtype = elf_mn10200_reloc_type (type);
1335           break;
1336
1337         case EM_FR30:
1338         case EM_CYGNUS_FR30:
1339           rtype = elf_fr30_reloc_type (type);
1340           break;
1341
1342         case EM_CYGNUS_FRV:
1343           rtype = elf_frv_reloc_type (type);
1344           break;
1345
1346         case EM_FT32:
1347           rtype = elf_ft32_reloc_type (type);
1348           break;
1349
1350         case EM_MCORE:
1351           rtype = elf_mcore_reloc_type (type);
1352           break;
1353
1354         case EM_MMIX:
1355           rtype = elf_mmix_reloc_type (type);
1356           break;
1357
1358         case EM_MOXIE:
1359           rtype = elf_moxie_reloc_type (type);
1360           break;
1361
1362         case EM_MSP430:
1363           if (uses_msp430x_relocs (filedata))
1364             {
1365               rtype = elf_msp430x_reloc_type (type);
1366               break;
1367             }
1368           /* Fall through.  */
1369         case EM_MSP430_OLD:
1370           rtype = elf_msp430_reloc_type (type);
1371           break;
1372
1373         case EM_NDS32:
1374           rtype = elf_nds32_reloc_type (type);
1375           break;
1376
1377         case EM_PPC:
1378           rtype = elf_ppc_reloc_type (type);
1379           break;
1380
1381         case EM_PPC64:
1382           rtype = elf_ppc64_reloc_type (type);
1383           break;
1384
1385         case EM_MIPS:
1386         case EM_MIPS_RS3_LE:
1387           rtype = elf_mips_reloc_type (type);
1388           break;
1389
1390         case EM_RISCV:
1391           rtype = elf_riscv_reloc_type (type);
1392           break;
1393
1394         case EM_ALPHA:
1395           rtype = elf_alpha_reloc_type (type);
1396           break;
1397
1398         case EM_ARM:
1399           rtype = elf_arm_reloc_type (type);
1400           break;
1401
1402         case EM_ARC:
1403         case EM_ARC_COMPACT:
1404         case EM_ARC_COMPACT2:
1405           rtype = elf_arc_reloc_type (type);
1406           break;
1407
1408         case EM_PARISC:
1409           rtype = elf_hppa_reloc_type (type);
1410           break;
1411
1412         case EM_H8_300:
1413         case EM_H8_300H:
1414         case EM_H8S:
1415           rtype = elf_h8_reloc_type (type);
1416           break;
1417
1418         case EM_OR1K:
1419           rtype = elf_or1k_reloc_type (type);
1420           break;
1421
1422         case EM_PJ:
1423         case EM_PJ_OLD:
1424           rtype = elf_pj_reloc_type (type);
1425           break;
1426         case EM_IA_64:
1427           rtype = elf_ia64_reloc_type (type);
1428           break;
1429
1430         case EM_CRIS:
1431           rtype = elf_cris_reloc_type (type);
1432           break;
1433
1434         case EM_860:
1435           rtype = elf_i860_reloc_type (type);
1436           break;
1437
1438         case EM_X86_64:
1439         case EM_L1OM:
1440         case EM_K1OM:
1441           rtype = elf_x86_64_reloc_type (type);
1442           break;
1443
1444         case EM_S370:
1445           rtype = i370_reloc_type (type);
1446           break;
1447
1448         case EM_S390_OLD:
1449         case EM_S390:
1450           rtype = elf_s390_reloc_type (type);
1451           break;
1452
1453         case EM_SCORE:
1454           rtype = elf_score_reloc_type (type);
1455           break;
1456
1457         case EM_XSTORMY16:
1458           rtype = elf_xstormy16_reloc_type (type);
1459           break;
1460
1461         case EM_CRX:
1462           rtype = elf_crx_reloc_type (type);
1463           break;
1464
1465         case EM_VAX:
1466           rtype = elf_vax_reloc_type (type);
1467           break;
1468
1469         case EM_VISIUM:
1470           rtype = elf_visium_reloc_type (type);
1471           break;
1472
1473         case EM_ADAPTEVA_EPIPHANY:
1474           rtype = elf_epiphany_reloc_type (type);
1475           break;
1476
1477         case EM_IP2K:
1478         case EM_IP2K_OLD:
1479           rtype = elf_ip2k_reloc_type (type);
1480           break;
1481
1482         case EM_IQ2000:
1483           rtype = elf_iq2000_reloc_type (type);
1484           break;
1485
1486         case EM_XTENSA_OLD:
1487         case EM_XTENSA:
1488           rtype = elf_xtensa_reloc_type (type);
1489           break;
1490
1491         case EM_LATTICEMICO32:
1492           rtype = elf_lm32_reloc_type (type);
1493           break;
1494
1495         case EM_M32C_OLD:
1496         case EM_M32C:
1497           rtype = elf_m32c_reloc_type (type);
1498           break;
1499
1500         case EM_MT:
1501           rtype = elf_mt_reloc_type (type);
1502           break;
1503
1504         case EM_BLACKFIN:
1505           rtype = elf_bfin_reloc_type (type);
1506           break;
1507
1508         case EM_CYGNUS_MEP:
1509           rtype = elf_mep_reloc_type (type);
1510           break;
1511
1512         case EM_CR16:
1513           rtype = elf_cr16_reloc_type (type);
1514           break;
1515
1516         case EM_MICROBLAZE:
1517         case EM_MICROBLAZE_OLD:
1518           rtype = elf_microblaze_reloc_type (type);
1519           break;
1520
1521         case EM_RL78:
1522           rtype = elf_rl78_reloc_type (type);
1523           break;
1524
1525         case EM_RX:
1526           rtype = elf_rx_reloc_type (type);
1527           break;
1528
1529         case EM_METAG:
1530           rtype = elf_metag_reloc_type (type);
1531           break;
1532
1533         case EM_XC16X:
1534         case EM_C166:
1535           rtype = elf_xc16x_reloc_type (type);
1536           break;
1537
1538         case EM_TI_C6000:
1539           rtype = elf_tic6x_reloc_type (type);
1540           break;
1541
1542         case EM_TILEGX:
1543           rtype = elf_tilegx_reloc_type (type);
1544           break;
1545
1546         case EM_TILEPRO:
1547           rtype = elf_tilepro_reloc_type (type);
1548           break;
1549
1550         case EM_WEBASSEMBLY:
1551           rtype = elf_wasm32_reloc_type (type);
1552           break;
1553
1554         case EM_XGATE:
1555           rtype = elf_xgate_reloc_type (type);
1556           break;
1557
1558         case EM_ALTERA_NIOS2:
1559           rtype = elf_nios2_reloc_type (type);
1560           break;
1561
1562         case EM_TI_PRU:
1563           rtype = elf_pru_reloc_type (type);
1564           break;
1565
1566         case EM_NFP:
1567           if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1568             rtype = elf_nfp3200_reloc_type (type);
1569           else
1570             rtype = elf_nfp_reloc_type (type);
1571           break;
1572         }
1573
1574       if (rtype == NULL)
1575         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1576       else
1577         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1578
1579       if (filedata->file_header.e_machine == EM_ALPHA
1580           && rtype != NULL
1581           && streq (rtype, "R_ALPHA_LITUSE")
1582           && is_rela)
1583         {
1584           switch (rels[i].r_addend)
1585             {
1586             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1587             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1588             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1589             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1590             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1591             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1592             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1593             default: rtype = NULL;
1594             }
1595
1596           if (rtype)
1597             printf (" (%s)", rtype);
1598           else
1599             {
1600               putchar (' ');
1601               printf (_("<unknown addend: %lx>"),
1602                       (unsigned long) rels[i].r_addend);
1603               res = FALSE;
1604             }
1605         }
1606       else if (symtab_index)
1607         {
1608           if (symtab == NULL || symtab_index >= nsyms)
1609             {
1610               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1611               res = FALSE;
1612             }
1613           else
1614             {
1615               Elf_Internal_Sym * psym;
1616               const char * version_string;
1617               enum versioned_symbol_info sym_info;
1618               unsigned short vna_other;
1619
1620               psym = symtab + symtab_index;
1621
1622               version_string
1623                 = get_symbol_version_string (filedata, is_dynsym,
1624                                              strtab, strtablen,
1625                                              symtab_index,
1626                                              psym,
1627                                              &sym_info,
1628                                              &vna_other);
1629
1630               printf (" ");
1631
1632               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1633                 {
1634                   const char * name;
1635                   unsigned int len;
1636                   unsigned int width = is_32bit_elf ? 8 : 14;
1637
1638                   /* Relocations against GNU_IFUNC symbols do not use the value
1639                      of the symbol as the address to relocate against.  Instead
1640                      they invoke the function named by the symbol and use its
1641                      result as the address for relocation.
1642
1643                      To indicate this to the user, do not display the value of
1644                      the symbol in the "Symbols's Value" field.  Instead show
1645                      its name followed by () as a hint that the symbol is
1646                      invoked.  */
1647
1648                   if (strtab == NULL
1649                       || psym->st_name == 0
1650                       || psym->st_name >= strtablen)
1651                     name = "??";
1652                   else
1653                     name = strtab + psym->st_name;
1654
1655                   len = print_symbol (width, name);
1656                   if (version_string)
1657                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1658                             version_string);
1659                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1660                 }
1661               else
1662                 {
1663                   print_vma (psym->st_value, LONG_HEX);
1664
1665                   printf (is_32bit_elf ? "   " : " ");
1666                 }
1667
1668               if (psym->st_name == 0)
1669                 {
1670                   const char * sec_name = "<null>";
1671                   char name_buf[40];
1672
1673                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1674                     {
1675                       if (psym->st_shndx < filedata->file_header.e_shnum)
1676                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1677                       else if (psym->st_shndx == SHN_ABS)
1678                         sec_name = "ABS";
1679                       else if (psym->st_shndx == SHN_COMMON)
1680                         sec_name = "COMMON";
1681                       else if ((filedata->file_header.e_machine == EM_MIPS
1682                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1683                                || (filedata->file_header.e_machine == EM_TI_C6000
1684                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1685                         sec_name = "SCOMMON";
1686                       else if (filedata->file_header.e_machine == EM_MIPS
1687                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1688                         sec_name = "SUNDEF";
1689                       else if ((filedata->file_header.e_machine == EM_X86_64
1690                                 || filedata->file_header.e_machine == EM_L1OM
1691                                 || filedata->file_header.e_machine == EM_K1OM)
1692                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1693                         sec_name = "LARGE_COMMON";
1694                       else if (filedata->file_header.e_machine == EM_IA_64
1695                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1696                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1697                         sec_name = "ANSI_COM";
1698                       else if (is_ia64_vms (filedata)
1699                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1700                         sec_name = "VMS_SYMVEC";
1701                       else
1702                         {
1703                           sprintf (name_buf, "<section 0x%x>",
1704                                    (unsigned int) psym->st_shndx);
1705                           sec_name = name_buf;
1706                         }
1707                     }
1708                   print_symbol (22, sec_name);
1709                 }
1710               else if (strtab == NULL)
1711                 printf (_("<string table index: %3ld>"), psym->st_name);
1712               else if (psym->st_name >= strtablen)
1713                 {
1714                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1715                   res = FALSE;
1716                 }
1717               else
1718                 {
1719                   print_symbol (22, strtab + psym->st_name);
1720                   if (version_string)
1721                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1722                             version_string);
1723                 }
1724
1725               if (is_rela)
1726                 {
1727                   bfd_vma off = rels[i].r_addend;
1728
1729                   if ((bfd_signed_vma) off < 0)
1730                     printf (" - %" BFD_VMA_FMT "x", - off);
1731                   else
1732                     printf (" + %" BFD_VMA_FMT "x", off);
1733                 }
1734             }
1735         }
1736       else if (is_rela)
1737         {
1738           bfd_vma off = rels[i].r_addend;
1739
1740           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1741           if ((bfd_signed_vma) off < 0)
1742             printf ("-%" BFD_VMA_FMT "x", - off);
1743           else
1744             printf ("%" BFD_VMA_FMT "x", off);
1745         }
1746
1747       if (filedata->file_header.e_machine == EM_SPARCV9
1748           && rtype != NULL
1749           && streq (rtype, "R_SPARC_OLO10"))
1750         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1751
1752       putchar ('\n');
1753
1754 #ifdef BFD64
1755       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1756         {
1757           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1758           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1759           const char * rtype2 = elf_mips_reloc_type (type2);
1760           const char * rtype3 = elf_mips_reloc_type (type3);
1761
1762           printf ("                    Type2: ");
1763
1764           if (rtype2 == NULL)
1765             printf (_("unrecognized: %-7lx"),
1766                     (unsigned long) type2 & 0xffffffff);
1767           else
1768             printf ("%-17.17s", rtype2);
1769
1770           printf ("\n                    Type3: ");
1771
1772           if (rtype3 == NULL)
1773             printf (_("unrecognized: %-7lx"),
1774                     (unsigned long) type3 & 0xffffffff);
1775           else
1776             printf ("%-17.17s", rtype3);
1777
1778           putchar ('\n');
1779         }
1780 #endif /* BFD64 */
1781     }
1782
1783   free (rels);
1784
1785   return res;
1786 }
1787
1788 static const char *
1789 get_mips_dynamic_type (unsigned long type)
1790 {
1791   switch (type)
1792     {
1793     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1794     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1795     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1796     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1797     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1798     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1799     case DT_MIPS_MSYM: return "MIPS_MSYM";
1800     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1801     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1802     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1803     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1804     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1805     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1806     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1807     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1808     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1809     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1810     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1811     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1812     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1813     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1814     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1815     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1816     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1817     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1818     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1819     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1820     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1821     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1822     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1823     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1824     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1825     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1826     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1827     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1828     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1829     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1830     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1831     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1832     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1833     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1834     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1835     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1836     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1837     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1838     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1839     default:
1840       return NULL;
1841     }
1842 }
1843
1844 static const char *
1845 get_sparc64_dynamic_type (unsigned long type)
1846 {
1847   switch (type)
1848     {
1849     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1850     default:
1851       return NULL;
1852     }
1853 }
1854
1855 static const char *
1856 get_ppc_dynamic_type (unsigned long type)
1857 {
1858   switch (type)
1859     {
1860     case DT_PPC_GOT:    return "PPC_GOT";
1861     case DT_PPC_OPT:    return "PPC_OPT";
1862     default:
1863       return NULL;
1864     }
1865 }
1866
1867 static const char *
1868 get_ppc64_dynamic_type (unsigned long type)
1869 {
1870   switch (type)
1871     {
1872     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1873     case DT_PPC64_OPD:    return "PPC64_OPD";
1874     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1875     case DT_PPC64_OPT:    return "PPC64_OPT";
1876     default:
1877       return NULL;
1878     }
1879 }
1880
1881 static const char *
1882 get_parisc_dynamic_type (unsigned long type)
1883 {
1884   switch (type)
1885     {
1886     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1887     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1888     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1889     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1890     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1891     case DT_HP_PREINIT:         return "HP_PREINIT";
1892     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1893     case DT_HP_NEEDED:          return "HP_NEEDED";
1894     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1895     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1896     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1897     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1898     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1899     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1900     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1901     case DT_HP_FILTERED:        return "HP_FILTERED";
1902     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1903     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1904     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1905     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1906     case DT_PLT:                return "PLT";
1907     case DT_PLT_SIZE:           return "PLT_SIZE";
1908     case DT_DLT:                return "DLT";
1909     case DT_DLT_SIZE:           return "DLT_SIZE";
1910     default:
1911       return NULL;
1912     }
1913 }
1914
1915 static const char *
1916 get_ia64_dynamic_type (unsigned long type)
1917 {
1918   switch (type)
1919     {
1920     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1921     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1922     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1923     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1924     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1925     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1926     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1927     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1928     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1929     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1930     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1931     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1932     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1933     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1934     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1935     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1936     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1937     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1938     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1939     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1940     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1941     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1942     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1943     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1944     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1945     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1946     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1947     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1948     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1949     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1950     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1951     default:
1952       return NULL;
1953     }
1954 }
1955
1956 static const char *
1957 get_solaris_section_type (unsigned long type)
1958 {
1959   switch (type)
1960     {
1961     case 0x6fffffee: return "SUNW_ancillary";
1962     case 0x6fffffef: return "SUNW_capchain";
1963     case 0x6ffffff0: return "SUNW_capinfo";
1964     case 0x6ffffff1: return "SUNW_symsort";
1965     case 0x6ffffff2: return "SUNW_tlssort";
1966     case 0x6ffffff3: return "SUNW_LDYNSYM";
1967     case 0x6ffffff4: return "SUNW_dof";
1968     case 0x6ffffff5: return "SUNW_cap";
1969     case 0x6ffffff6: return "SUNW_SIGNATURE";
1970     case 0x6ffffff7: return "SUNW_ANNOTATE";
1971     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1972     case 0x6ffffff9: return "SUNW_DEBUG";
1973     case 0x6ffffffa: return "SUNW_move";
1974     case 0x6ffffffb: return "SUNW_COMDAT";
1975     case 0x6ffffffc: return "SUNW_syminfo";
1976     case 0x6ffffffd: return "SUNW_verdef";
1977     case 0x6ffffffe: return "SUNW_verneed";
1978     case 0x6fffffff: return "SUNW_versym";
1979     case 0x70000000: return "SPARC_GOTDATA";
1980     default: return NULL;
1981     }
1982 }
1983
1984 static const char *
1985 get_alpha_dynamic_type (unsigned long type)
1986 {
1987   switch (type)
1988     {
1989     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1990     default: return NULL;
1991     }
1992 }
1993
1994 static const char *
1995 get_score_dynamic_type (unsigned long type)
1996 {
1997   switch (type)
1998     {
1999     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2000     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
2001     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
2002     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
2003     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
2004     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
2005     default:                    return NULL;
2006     }
2007 }
2008
2009 static const char *
2010 get_tic6x_dynamic_type (unsigned long type)
2011 {
2012   switch (type)
2013     {
2014     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2015     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2016     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2017     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2018     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2019     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2020     default:                   return NULL;
2021     }
2022 }
2023
2024 static const char *
2025 get_nios2_dynamic_type (unsigned long type)
2026 {
2027   switch (type)
2028     {
2029     case DT_NIOS2_GP: return "NIOS2_GP";
2030     default:          return NULL;
2031     }
2032 }
2033
2034 static const char *
2035 get_solaris_dynamic_type (unsigned long type)
2036 {
2037   switch (type)
2038     {
2039     case 0x6000000d: return "SUNW_AUXILIARY";
2040     case 0x6000000e: return "SUNW_RTLDINF";
2041     case 0x6000000f: return "SUNW_FILTER";
2042     case 0x60000010: return "SUNW_CAP";
2043     case 0x60000011: return "SUNW_SYMTAB";
2044     case 0x60000012: return "SUNW_SYMSZ";
2045     case 0x60000013: return "SUNW_SORTENT";
2046     case 0x60000014: return "SUNW_SYMSORT";
2047     case 0x60000015: return "SUNW_SYMSORTSZ";
2048     case 0x60000016: return "SUNW_TLSSORT";
2049     case 0x60000017: return "SUNW_TLSSORTSZ";
2050     case 0x60000018: return "SUNW_CAPINFO";
2051     case 0x60000019: return "SUNW_STRPAD";
2052     case 0x6000001a: return "SUNW_CAPCHAIN";
2053     case 0x6000001b: return "SUNW_LDMACH";
2054     case 0x6000001d: return "SUNW_CAPCHAINENT";
2055     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2056     case 0x60000021: return "SUNW_PARENT";
2057     case 0x60000023: return "SUNW_ASLR";
2058     case 0x60000025: return "SUNW_RELAX";
2059     case 0x60000029: return "SUNW_NXHEAP";
2060     case 0x6000002b: return "SUNW_NXSTACK";
2061
2062     case 0x70000001: return "SPARC_REGISTER";
2063     case 0x7ffffffd: return "AUXILIARY";
2064     case 0x7ffffffe: return "USED";
2065     case 0x7fffffff: return "FILTER";
2066
2067     default: return NULL;
2068     }
2069 }
2070
2071 static const char *
2072 get_dynamic_type (Filedata * filedata, unsigned long type)
2073 {
2074   static char buff[64];
2075
2076   switch (type)
2077     {
2078     case DT_NULL:       return "NULL";
2079     case DT_NEEDED:     return "NEEDED";
2080     case DT_PLTRELSZ:   return "PLTRELSZ";
2081     case DT_PLTGOT:     return "PLTGOT";
2082     case DT_HASH:       return "HASH";
2083     case DT_STRTAB:     return "STRTAB";
2084     case DT_SYMTAB:     return "SYMTAB";
2085     case DT_RELA:       return "RELA";
2086     case DT_RELASZ:     return "RELASZ";
2087     case DT_RELAENT:    return "RELAENT";
2088     case DT_STRSZ:      return "STRSZ";
2089     case DT_SYMENT:     return "SYMENT";
2090     case DT_INIT:       return "INIT";
2091     case DT_FINI:       return "FINI";
2092     case DT_SONAME:     return "SONAME";
2093     case DT_RPATH:      return "RPATH";
2094     case DT_SYMBOLIC:   return "SYMBOLIC";
2095     case DT_REL:        return "REL";
2096     case DT_RELSZ:      return "RELSZ";
2097     case DT_RELENT:     return "RELENT";
2098     case DT_PLTREL:     return "PLTREL";
2099     case DT_DEBUG:      return "DEBUG";
2100     case DT_TEXTREL:    return "TEXTREL";
2101     case DT_JMPREL:     return "JMPREL";
2102     case DT_BIND_NOW:   return "BIND_NOW";
2103     case DT_INIT_ARRAY: return "INIT_ARRAY";
2104     case DT_FINI_ARRAY: return "FINI_ARRAY";
2105     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2106     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2107     case DT_RUNPATH:    return "RUNPATH";
2108     case DT_FLAGS:      return "FLAGS";
2109
2110     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2111     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2112     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2113
2114     case DT_CHECKSUM:   return "CHECKSUM";
2115     case DT_PLTPADSZ:   return "PLTPADSZ";
2116     case DT_MOVEENT:    return "MOVEENT";
2117     case DT_MOVESZ:     return "MOVESZ";
2118     case DT_FEATURE:    return "FEATURE";
2119     case DT_POSFLAG_1:  return "POSFLAG_1";
2120     case DT_SYMINSZ:    return "SYMINSZ";
2121     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2122
2123     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2124     case DT_CONFIG:     return "CONFIG";
2125     case DT_DEPAUDIT:   return "DEPAUDIT";
2126     case DT_AUDIT:      return "AUDIT";
2127     case DT_PLTPAD:     return "PLTPAD";
2128     case DT_MOVETAB:    return "MOVETAB";
2129     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2130
2131     case DT_VERSYM:     return "VERSYM";
2132
2133     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2134     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2135     case DT_RELACOUNT:  return "RELACOUNT";
2136     case DT_RELCOUNT:   return "RELCOUNT";
2137     case DT_FLAGS_1:    return "FLAGS_1";
2138     case DT_VERDEF:     return "VERDEF";
2139     case DT_VERDEFNUM:  return "VERDEFNUM";
2140     case DT_VERNEED:    return "VERNEED";
2141     case DT_VERNEEDNUM: return "VERNEEDNUM";
2142
2143     case DT_AUXILIARY:  return "AUXILIARY";
2144     case DT_USED:       return "USED";
2145     case DT_FILTER:     return "FILTER";
2146
2147     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2148     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2149     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2150     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2151     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2152     case DT_GNU_HASH:   return "GNU_HASH";
2153
2154     default:
2155       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2156         {
2157           const char * result;
2158
2159           switch (filedata->file_header.e_machine)
2160             {
2161             case EM_MIPS:
2162             case EM_MIPS_RS3_LE:
2163               result = get_mips_dynamic_type (type);
2164               break;
2165             case EM_SPARCV9:
2166               result = get_sparc64_dynamic_type (type);
2167               break;
2168             case EM_PPC:
2169               result = get_ppc_dynamic_type (type);
2170               break;
2171             case EM_PPC64:
2172               result = get_ppc64_dynamic_type (type);
2173               break;
2174             case EM_IA_64:
2175               result = get_ia64_dynamic_type (type);
2176               break;
2177             case EM_ALPHA:
2178               result = get_alpha_dynamic_type (type);
2179               break;
2180             case EM_SCORE:
2181               result = get_score_dynamic_type (type);
2182               break;
2183             case EM_TI_C6000:
2184               result = get_tic6x_dynamic_type (type);
2185               break;
2186             case EM_ALTERA_NIOS2:
2187               result = get_nios2_dynamic_type (type);
2188               break;
2189             default:
2190               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2191                 result = get_solaris_dynamic_type (type);
2192               else
2193                 result = NULL;
2194               break;
2195             }
2196
2197           if (result != NULL)
2198             return result;
2199
2200           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2201         }
2202       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2203                || (filedata->file_header.e_machine == EM_PARISC
2204                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2205         {
2206           const char * result;
2207
2208           switch (filedata->file_header.e_machine)
2209             {
2210             case EM_PARISC:
2211               result = get_parisc_dynamic_type (type);
2212               break;
2213             case EM_IA_64:
2214               result = get_ia64_dynamic_type (type);
2215               break;
2216             default:
2217               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2218                 result = get_solaris_dynamic_type (type);
2219               else
2220                 result = NULL;
2221               break;
2222             }
2223
2224           if (result != NULL)
2225             return result;
2226
2227           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2228                     type);
2229         }
2230       else
2231         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2232
2233       return buff;
2234     }
2235 }
2236
2237 static char *
2238 get_file_type (unsigned e_type)
2239 {
2240   static char buff[32];
2241
2242   switch (e_type)
2243     {
2244     case ET_NONE: return _("NONE (None)");
2245     case ET_REL:  return _("REL (Relocatable file)");
2246     case ET_EXEC: return _("EXEC (Executable file)");
2247     case ET_DYN:  return _("DYN (Shared object file)");
2248     case ET_CORE: return _("CORE (Core file)");
2249
2250     default:
2251       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2252         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2253       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2254         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2255       else
2256         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2257       return buff;
2258     }
2259 }
2260
2261 static char *
2262 get_machine_name (unsigned e_machine)
2263 {
2264   static char buff[64]; /* XXX */
2265
2266   switch (e_machine)
2267     {
2268       /* Please keep this switch table sorted by increasing EM_ value.  */
2269       /* 0 */
2270     case EM_NONE:               return _("None");
2271     case EM_M32:                return "WE32100";
2272     case EM_SPARC:              return "Sparc";
2273     case EM_386:                return "Intel 80386";
2274     case EM_68K:                return "MC68000";
2275     case EM_88K:                return "MC88000";
2276     case EM_IAMCU:              return "Intel MCU";
2277     case EM_860:                return "Intel 80860";
2278     case EM_MIPS:               return "MIPS R3000";
2279     case EM_S370:               return "IBM System/370";
2280       /* 10 */
2281     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2282     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2283     case EM_PARISC:             return "HPPA";
2284     case EM_VPP550:             return "Fujitsu VPP500";
2285     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2286     case EM_960:                return "Intel 80960";
2287     case EM_PPC:                return "PowerPC";
2288       /* 20 */
2289     case EM_PPC64:              return "PowerPC64";
2290     case EM_S390_OLD:
2291     case EM_S390:               return "IBM S/390";
2292     case EM_SPU:                return "SPU";
2293       /* 30 */
2294     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2295     case EM_FR20:               return "Fujitsu FR20";
2296     case EM_RH32:               return "TRW RH32";
2297     case EM_MCORE:              return "MCORE";
2298       /* 40 */
2299     case EM_ARM:                return "ARM";
2300     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2301     case EM_SH:                 return "Renesas / SuperH SH";
2302     case EM_SPARCV9:            return "Sparc v9";
2303     case EM_TRICORE:            return "Siemens Tricore";
2304     case EM_ARC:                return "ARC";
2305     case EM_H8_300:             return "Renesas H8/300";
2306     case EM_H8_300H:            return "Renesas H8/300H";
2307     case EM_H8S:                return "Renesas H8S";
2308     case EM_H8_500:             return "Renesas H8/500";
2309       /* 50 */
2310     case EM_IA_64:              return "Intel IA-64";
2311     case EM_MIPS_X:             return "Stanford MIPS-X";
2312     case EM_COLDFIRE:           return "Motorola Coldfire";
2313     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2314     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2315     case EM_PCP:                return "Siemens PCP";
2316     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2317     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2318     case EM_STARCORE:           return "Motorola Star*Core processor";
2319     case EM_ME16:               return "Toyota ME16 processor";
2320       /* 60 */
2321     case EM_ST100:              return "STMicroelectronics ST100 processor";
2322     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2323     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2324     case EM_PDSP:               return "Sony DSP processor";
2325     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2326     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2327     case EM_FX66:               return "Siemens FX66 microcontroller";
2328     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2329     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2330     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2331       /* 70 */
2332     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2333     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2334     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2335     case EM_SVX:                return "Silicon Graphics SVx";
2336     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2337     case EM_VAX:                return "Digital VAX";
2338     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2339     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2340     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2341     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2342       /* 80 */
2343     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2344     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2345     case EM_PRISM:              return "Vitesse Prism";
2346     case EM_AVR_OLD:
2347     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2348     case EM_CYGNUS_FR30:
2349     case EM_FR30:               return "Fujitsu FR30";
2350     case EM_CYGNUS_D10V:
2351     case EM_D10V:               return "d10v";
2352     case EM_CYGNUS_D30V:
2353     case EM_D30V:               return "d30v";
2354     case EM_CYGNUS_V850:
2355     case EM_V850:               return "Renesas V850";
2356     case EM_CYGNUS_M32R:
2357     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2358     case EM_CYGNUS_MN10300:
2359     case EM_MN10300:            return "mn10300";
2360       /* 90 */
2361     case EM_CYGNUS_MN10200:
2362     case EM_MN10200:            return "mn10200";
2363     case EM_PJ:                 return "picoJava";
2364     case EM_OR1K:               return "OpenRISC 1000";
2365     case EM_ARC_COMPACT:        return "ARCompact";
2366     case EM_XTENSA_OLD:
2367     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2368     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2369     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2370     case EM_NS32K:              return "National Semiconductor 32000 series";
2371     case EM_TPC:                return "Tenor Network TPC processor";
2372     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2373       /* 100 */
2374     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2375     case EM_IP2K_OLD:
2376     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2377     case EM_MAX:                return "MAX Processor";
2378     case EM_CR:                 return "National Semiconductor CompactRISC";
2379     case EM_F2MC16:             return "Fujitsu F2MC16";
2380     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2381     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2382     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2383     case EM_SEP:                return "Sharp embedded microprocessor";
2384     case EM_ARCA:               return "Arca RISC microprocessor";
2385       /* 110 */
2386     case EM_UNICORE:            return "Unicore";
2387     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2388     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2389     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2390     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2391     case EM_XGATE:              return "Motorola XGATE embedded processor";
2392     case EM_C166:
2393     case EM_XC16X:              return "Infineon Technologies xc16x";
2394     case EM_M16C:               return "Renesas M16C series microprocessors";
2395     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2396     case EM_CE:                 return "Freescale Communication Engine RISC core";
2397       /* 120 */
2398     case EM_M32C:               return "Renesas M32c";
2399       /* 130 */
2400     case EM_TSK3000:            return "Altium TSK3000 core";
2401     case EM_RS08:               return "Freescale RS08 embedded processor";
2402     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2403     case EM_SCORE:              return "SUNPLUS S+Core";
2404     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2405     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2406     case EM_LATTICEMICO32:      return "Lattice Mico32";
2407     case EM_SE_C17:             return "Seiko Epson C17 family";
2408       /* 140 */
2409     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2410     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2411     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2412     case EM_TI_PRU:             return "TI PRU I/O processor";
2413       /* 160 */
2414     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2415     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2416     case EM_R32C:               return "Renesas R32C series microprocessors";
2417     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2418     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2419     case EM_8051:               return "Intel 8051 and variants";
2420     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2421     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2422     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2423     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2424       /* 170 */
2425     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2426     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2427     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2428     case EM_RX:                 return "Renesas RX";
2429     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2430     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2431     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2432     case EM_CR16:
2433     case EM_MICROBLAZE:
2434     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2435     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2436     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2437       /* 180 */
2438     case EM_L1OM:               return "Intel L1OM";
2439     case EM_K1OM:               return "Intel K1OM";
2440     case EM_INTEL182:           return "Intel (reserved)";
2441     case EM_AARCH64:            return "AArch64";
2442     case EM_ARM184:             return "ARM (reserved)";
2443     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2444     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2445     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2446     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2447       /* 190 */
2448     case EM_CUDA:               return "NVIDIA CUDA architecture";
2449     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2450     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2451     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2452     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2453     case EM_ARC_COMPACT2:       return "ARCv2";
2454     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2455     case EM_RL78:               return "Renesas RL78";
2456     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2457     case EM_78K0R:              return "Renesas 78K0R";
2458       /* 200 */
2459     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2460     case EM_BA1:                return "Beyond BA1 CPU architecture";
2461     case EM_BA2:                return "Beyond BA2 CPU architecture";
2462     case EM_XCORE:              return "XMOS xCORE processor family";
2463     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2464       /* 210 */
2465     case EM_KM32:               return "KM211 KM32 32-bit processor";
2466     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2467     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2468     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2469     case EM_KVARC:              return "KM211 KVARC processor";
2470     case EM_CDP:                return "Paneve CDP architecture family";
2471     case EM_COGE:               return "Cognitive Smart Memory Processor";
2472     case EM_COOL:               return "Bluechip Systems CoolEngine";
2473     case EM_NORC:               return "Nanoradio Optimized RISC";
2474     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2475       /* 220 */
2476     case EM_Z80:                return "Zilog Z80";
2477     case EM_VISIUM:             return "CDS VISIUMcore processor";
2478     case EM_FT32:               return "FTDI Chip FT32";
2479     case EM_MOXIE:              return "Moxie";
2480     case EM_AMDGPU:             return "AMD GPU";
2481     case EM_RISCV:              return "RISC-V";
2482     case EM_LANAI:              return "Lanai 32-bit processor";
2483     case EM_BPF:                return "Linux BPF";
2484     case EM_NFP:                return "Netronome Flow Processor";
2485
2486       /* Large numbers...  */
2487     case EM_MT:                 return "Morpho Techologies MT processor";
2488     case EM_ALPHA:              return "Alpha";
2489     case EM_WEBASSEMBLY:        return "Web Assembly";
2490     case EM_DLX:                return "OpenDLX";
2491     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2492     case EM_IQ2000:             return "Vitesse IQ2000";
2493     case EM_M32C_OLD:
2494     case EM_NIOS32:             return "Altera Nios";
2495     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2496     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2497     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2498
2499     default:
2500       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2501       return buff;
2502     }
2503 }
2504
2505 static void
2506 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2507 {
2508   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2509      other compilers don't a specific architecture type in the e_flags, and
2510      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2511      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2512      architectures.
2513
2514      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2515      but also sets a specific architecture type in the e_flags field.
2516
2517      However, when decoding the flags we don't worry if we see an
2518      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2519      ARCEM architecture type.  */
2520
2521   switch (e_flags & EF_ARC_MACH_MSK)
2522     {
2523       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2524     case EF_ARC_CPU_ARCV2EM:
2525       strcat (buf, ", ARC EM");
2526       break;
2527     case EF_ARC_CPU_ARCV2HS:
2528       strcat (buf, ", ARC HS");
2529       break;
2530
2531       /* We only expect these to occur for EM_ARC_COMPACT.  */
2532     case E_ARC_MACH_ARC600:
2533       strcat (buf, ", ARC600");
2534       break;
2535     case E_ARC_MACH_ARC601:
2536       strcat (buf, ", ARC601");
2537       break;
2538     case E_ARC_MACH_ARC700:
2539       strcat (buf, ", ARC700");
2540       break;
2541
2542       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2543          new ELF with new architecture being read by an old version of
2544          readelf, or (c) An ELF built with non-GNU compiler that does not
2545          set the architecture in the e_flags.  */
2546     default:
2547       if (e_machine == EM_ARC_COMPACT)
2548         strcat (buf, ", Unknown ARCompact");
2549       else
2550         strcat (buf, ", Unknown ARC");
2551       break;
2552     }
2553
2554   switch (e_flags & EF_ARC_OSABI_MSK)
2555     {
2556     case E_ARC_OSABI_ORIG:
2557       strcat (buf, ", (ABI:legacy)");
2558       break;
2559     case E_ARC_OSABI_V2:
2560       strcat (buf, ", (ABI:v2)");
2561       break;
2562       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2563     case E_ARC_OSABI_V3:
2564       strcat (buf, ", v3 no-legacy-syscalls ABI");
2565       break;
2566     case E_ARC_OSABI_V4:
2567       strcat (buf, ", v4 ABI");
2568       break;
2569     default:
2570       strcat (buf, ", unrecognised ARC OSABI flag");
2571       break;
2572     }
2573 }
2574
2575 static void
2576 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2577 {
2578   unsigned eabi;
2579   bfd_boolean unknown = FALSE;
2580
2581   eabi = EF_ARM_EABI_VERSION (e_flags);
2582   e_flags &= ~ EF_ARM_EABIMASK;
2583
2584   /* Handle "generic" ARM flags.  */
2585   if (e_flags & EF_ARM_RELEXEC)
2586     {
2587       strcat (buf, ", relocatable executable");
2588       e_flags &= ~ EF_ARM_RELEXEC;
2589     }
2590
2591   if (e_flags & EF_ARM_PIC)
2592     {
2593       strcat (buf, ", position independent");
2594       e_flags &= ~ EF_ARM_PIC;
2595     }
2596
2597   /* Now handle EABI specific flags.  */
2598   switch (eabi)
2599     {
2600     default:
2601       strcat (buf, ", <unrecognized EABI>");
2602       if (e_flags)
2603         unknown = TRUE;
2604       break;
2605
2606     case EF_ARM_EABI_VER1:
2607       strcat (buf, ", Version1 EABI");
2608       while (e_flags)
2609         {
2610           unsigned flag;
2611
2612           /* Process flags one bit at a time.  */
2613           flag = e_flags & - e_flags;
2614           e_flags &= ~ flag;
2615
2616           switch (flag)
2617             {
2618             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2619               strcat (buf, ", sorted symbol tables");
2620               break;
2621
2622             default:
2623               unknown = TRUE;
2624               break;
2625             }
2626         }
2627       break;
2628
2629     case EF_ARM_EABI_VER2:
2630       strcat (buf, ", Version2 EABI");
2631       while (e_flags)
2632         {
2633           unsigned flag;
2634
2635           /* Process flags one bit at a time.  */
2636           flag = e_flags & - e_flags;
2637           e_flags &= ~ flag;
2638
2639           switch (flag)
2640             {
2641             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2642               strcat (buf, ", sorted symbol tables");
2643               break;
2644
2645             case EF_ARM_DYNSYMSUSESEGIDX:
2646               strcat (buf, ", dynamic symbols use segment index");
2647               break;
2648
2649             case EF_ARM_MAPSYMSFIRST:
2650               strcat (buf, ", mapping symbols precede others");
2651               break;
2652
2653             default:
2654               unknown = TRUE;
2655               break;
2656             }
2657         }
2658       break;
2659
2660     case EF_ARM_EABI_VER3:
2661       strcat (buf, ", Version3 EABI");
2662       break;
2663
2664     case EF_ARM_EABI_VER4:
2665       strcat (buf, ", Version4 EABI");
2666       while (e_flags)
2667         {
2668           unsigned flag;
2669
2670           /* Process flags one bit at a time.  */
2671           flag = e_flags & - e_flags;
2672           e_flags &= ~ flag;
2673
2674           switch (flag)
2675             {
2676             case EF_ARM_BE8:
2677               strcat (buf, ", BE8");
2678               break;
2679
2680             case EF_ARM_LE8:
2681               strcat (buf, ", LE8");
2682               break;
2683
2684             default:
2685               unknown = TRUE;
2686               break;
2687             }
2688         }
2689       break;
2690
2691     case EF_ARM_EABI_VER5:
2692       strcat (buf, ", Version5 EABI");
2693       while (e_flags)
2694         {
2695           unsigned flag;
2696
2697           /* Process flags one bit at a time.  */
2698           flag = e_flags & - e_flags;
2699           e_flags &= ~ flag;
2700
2701           switch (flag)
2702             {
2703             case EF_ARM_BE8:
2704               strcat (buf, ", BE8");
2705               break;
2706
2707             case EF_ARM_LE8:
2708               strcat (buf, ", LE8");
2709               break;
2710
2711             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2712               strcat (buf, ", soft-float ABI");
2713               break;
2714
2715             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2716               strcat (buf, ", hard-float ABI");
2717               break;
2718
2719             default:
2720               unknown = TRUE;
2721               break;
2722             }
2723         }
2724       break;
2725
2726     case EF_ARM_EABI_UNKNOWN:
2727       strcat (buf, ", GNU EABI");
2728       while (e_flags)
2729         {
2730           unsigned flag;
2731
2732           /* Process flags one bit at a time.  */
2733           flag = e_flags & - e_flags;
2734           e_flags &= ~ flag;
2735
2736           switch (flag)
2737             {
2738             case EF_ARM_INTERWORK:
2739               strcat (buf, ", interworking enabled");
2740               break;
2741
2742             case EF_ARM_APCS_26:
2743               strcat (buf, ", uses APCS/26");
2744               break;
2745
2746             case EF_ARM_APCS_FLOAT:
2747               strcat (buf, ", uses APCS/float");
2748               break;
2749
2750             case EF_ARM_PIC:
2751               strcat (buf, ", position independent");
2752               break;
2753
2754             case EF_ARM_ALIGN8:
2755               strcat (buf, ", 8 bit structure alignment");
2756               break;
2757
2758             case EF_ARM_NEW_ABI:
2759               strcat (buf, ", uses new ABI");
2760               break;
2761
2762             case EF_ARM_OLD_ABI:
2763               strcat (buf, ", uses old ABI");
2764               break;
2765
2766             case EF_ARM_SOFT_FLOAT:
2767               strcat (buf, ", software FP");
2768               break;
2769
2770             case EF_ARM_VFP_FLOAT:
2771               strcat (buf, ", VFP");
2772               break;
2773
2774             case EF_ARM_MAVERICK_FLOAT:
2775               strcat (buf, ", Maverick FP");
2776               break;
2777
2778             default:
2779               unknown = TRUE;
2780               break;
2781             }
2782         }
2783     }
2784
2785   if (unknown)
2786     strcat (buf,_(", <unknown>"));
2787 }
2788
2789 static void
2790 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2791 {
2792   --size; /* Leave space for null terminator.  */
2793
2794   switch (e_flags & EF_AVR_MACH)
2795     {
2796     case E_AVR_MACH_AVR1:
2797       strncat (buf, ", avr:1", size);
2798       break;
2799     case E_AVR_MACH_AVR2:
2800       strncat (buf, ", avr:2", size);
2801       break;
2802     case E_AVR_MACH_AVR25:
2803       strncat (buf, ", avr:25", size);
2804       break;
2805     case E_AVR_MACH_AVR3:
2806       strncat (buf, ", avr:3", size);
2807       break;
2808     case E_AVR_MACH_AVR31:
2809       strncat (buf, ", avr:31", size);
2810       break;
2811     case E_AVR_MACH_AVR35:
2812       strncat (buf, ", avr:35", size);
2813       break;
2814     case E_AVR_MACH_AVR4:
2815       strncat (buf, ", avr:4", size);
2816       break;
2817     case E_AVR_MACH_AVR5:
2818       strncat (buf, ", avr:5", size);
2819       break;
2820     case E_AVR_MACH_AVR51:
2821       strncat (buf, ", avr:51", size);
2822       break;
2823     case E_AVR_MACH_AVR6:
2824       strncat (buf, ", avr:6", size);
2825       break;
2826     case E_AVR_MACH_AVRTINY:
2827       strncat (buf, ", avr:100", size);
2828       break;
2829     case E_AVR_MACH_XMEGA1:
2830       strncat (buf, ", avr:101", size);
2831       break;
2832     case E_AVR_MACH_XMEGA2:
2833       strncat (buf, ", avr:102", size);
2834       break;
2835     case E_AVR_MACH_XMEGA3:
2836       strncat (buf, ", avr:103", size);
2837       break;
2838     case E_AVR_MACH_XMEGA4:
2839       strncat (buf, ", avr:104", size);
2840       break;
2841     case E_AVR_MACH_XMEGA5:
2842       strncat (buf, ", avr:105", size);
2843       break;
2844     case E_AVR_MACH_XMEGA6:
2845       strncat (buf, ", avr:106", size);
2846       break;
2847     case E_AVR_MACH_XMEGA7:
2848       strncat (buf, ", avr:107", size);
2849       break;
2850     default:
2851       strncat (buf, ", avr:<unknown>", size);
2852       break;
2853     }
2854
2855   size -= strlen (buf);
2856   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2857     strncat (buf, ", link-relax", size);
2858 }
2859
2860 static void
2861 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2862 {
2863   unsigned abi;
2864   unsigned arch;
2865   unsigned config;
2866   unsigned version;
2867   bfd_boolean has_fpu = FALSE;
2868   unsigned int r = 0;
2869
2870   static const char *ABI_STRINGS[] =
2871   {
2872     "ABI v0", /* use r5 as return register; only used in N1213HC */
2873     "ABI v1", /* use r0 as return register */
2874     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2875     "ABI v2fp", /* for FPU */
2876     "AABI",
2877     "ABI2 FP+"
2878   };
2879   static const char *VER_STRINGS[] =
2880   {
2881     "Andes ELF V1.3 or older",
2882     "Andes ELF V1.3.1",
2883     "Andes ELF V1.4"
2884   };
2885   static const char *ARCH_STRINGS[] =
2886   {
2887     "",
2888     "Andes Star v1.0",
2889     "Andes Star v2.0",
2890     "Andes Star v3.0",
2891     "Andes Star v3.0m"
2892   };
2893
2894   abi = EF_NDS_ABI & e_flags;
2895   arch = EF_NDS_ARCH & e_flags;
2896   config = EF_NDS_INST & e_flags;
2897   version = EF_NDS32_ELF_VERSION & e_flags;
2898
2899   memset (buf, 0, size);
2900
2901   switch (abi)
2902     {
2903     case E_NDS_ABI_V0:
2904     case E_NDS_ABI_V1:
2905     case E_NDS_ABI_V2:
2906     case E_NDS_ABI_V2FP:
2907     case E_NDS_ABI_AABI:
2908     case E_NDS_ABI_V2FP_PLUS:
2909       /* In case there are holes in the array.  */
2910       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2911       break;
2912
2913     default:
2914       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2915       break;
2916     }
2917
2918   switch (version)
2919     {
2920     case E_NDS32_ELF_VER_1_2:
2921     case E_NDS32_ELF_VER_1_3:
2922     case E_NDS32_ELF_VER_1_4:
2923       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2924       break;
2925
2926     default:
2927       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2928       break;
2929     }
2930
2931   if (E_NDS_ABI_V0 == abi)
2932     {
2933       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2934       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2935       if (arch == E_NDS_ARCH_STAR_V1_0)
2936         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2937       return;
2938     }
2939
2940   switch (arch)
2941     {
2942     case E_NDS_ARCH_STAR_V1_0:
2943     case E_NDS_ARCH_STAR_V2_0:
2944     case E_NDS_ARCH_STAR_V3_0:
2945     case E_NDS_ARCH_STAR_V3_M:
2946       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2947       break;
2948
2949     default:
2950       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2951       /* ARCH version determines how the e_flags are interpreted.
2952          If it is unknown, we cannot proceed.  */
2953       return;
2954     }
2955
2956   /* Newer ABI; Now handle architecture specific flags.  */
2957   if (arch == E_NDS_ARCH_STAR_V1_0)
2958     {
2959       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2960         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2961
2962       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2963         r += snprintf (buf + r, size -r, ", MAC");
2964
2965       if (config & E_NDS32_HAS_DIV_INST)
2966         r += snprintf (buf + r, size -r, ", DIV");
2967
2968       if (config & E_NDS32_HAS_16BIT_INST)
2969         r += snprintf (buf + r, size -r, ", 16b");
2970     }
2971   else
2972     {
2973       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2974         {
2975           if (version <= E_NDS32_ELF_VER_1_3)
2976             r += snprintf (buf + r, size -r, ", [B8]");
2977           else
2978             r += snprintf (buf + r, size -r, ", EX9");
2979         }
2980
2981       if (config & E_NDS32_HAS_MAC_DX_INST)
2982         r += snprintf (buf + r, size -r, ", MAC_DX");
2983
2984       if (config & E_NDS32_HAS_DIV_DX_INST)
2985         r += snprintf (buf + r, size -r, ", DIV_DX");
2986
2987       if (config & E_NDS32_HAS_16BIT_INST)
2988         {
2989           if (version <= E_NDS32_ELF_VER_1_3)
2990             r += snprintf (buf + r, size -r, ", 16b");
2991           else
2992             r += snprintf (buf + r, size -r, ", IFC");
2993         }
2994     }
2995
2996   if (config & E_NDS32_HAS_EXT_INST)
2997     r += snprintf (buf + r, size -r, ", PERF1");
2998
2999   if (config & E_NDS32_HAS_EXT2_INST)
3000     r += snprintf (buf + r, size -r, ", PERF2");
3001
3002   if (config & E_NDS32_HAS_FPU_INST)
3003     {
3004       has_fpu = TRUE;
3005       r += snprintf (buf + r, size -r, ", FPU_SP");
3006     }
3007
3008   if (config & E_NDS32_HAS_FPU_DP_INST)
3009     {
3010       has_fpu = TRUE;
3011       r += snprintf (buf + r, size -r, ", FPU_DP");
3012     }
3013
3014   if (config & E_NDS32_HAS_FPU_MAC_INST)
3015     {
3016       has_fpu = TRUE;
3017       r += snprintf (buf + r, size -r, ", FPU_MAC");
3018     }
3019
3020   if (has_fpu)
3021     {
3022       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3023         {
3024         case E_NDS32_FPU_REG_8SP_4DP:
3025           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3026           break;
3027         case E_NDS32_FPU_REG_16SP_8DP:
3028           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3029           break;
3030         case E_NDS32_FPU_REG_32SP_16DP:
3031           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3032           break;
3033         case E_NDS32_FPU_REG_32SP_32DP:
3034           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3035           break;
3036         }
3037     }
3038
3039   if (config & E_NDS32_HAS_AUDIO_INST)
3040     r += snprintf (buf + r, size -r, ", AUDIO");
3041
3042   if (config & E_NDS32_HAS_STRING_INST)
3043     r += snprintf (buf + r, size -r, ", STR");
3044
3045   if (config & E_NDS32_HAS_REDUCED_REGS)
3046     r += snprintf (buf + r, size -r, ", 16REG");
3047
3048   if (config & E_NDS32_HAS_VIDEO_INST)
3049     {
3050       if (version <= E_NDS32_ELF_VER_1_3)
3051         r += snprintf (buf + r, size -r, ", VIDEO");
3052       else
3053         r += snprintf (buf + r, size -r, ", SATURATION");
3054     }
3055
3056   if (config & E_NDS32_HAS_ENCRIPT_INST)
3057     r += snprintf (buf + r, size -r, ", ENCRP");
3058
3059   if (config & E_NDS32_HAS_L2C_INST)
3060     r += snprintf (buf + r, size -r, ", L2C");
3061 }
3062
3063 static char *
3064 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3065 {
3066   static char buf[1024];
3067
3068   buf[0] = '\0';
3069
3070   if (e_flags)
3071     {
3072       switch (e_machine)
3073         {
3074         default:
3075           break;
3076
3077         case EM_ARC_COMPACT2:
3078         case EM_ARC_COMPACT:
3079           decode_ARC_machine_flags (e_flags, e_machine, buf);
3080           break;
3081
3082         case EM_ARM:
3083           decode_ARM_machine_flags (e_flags, buf);
3084           break;
3085
3086         case EM_AVR:
3087           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3088           break;
3089
3090         case EM_BLACKFIN:
3091           if (e_flags & EF_BFIN_PIC)
3092             strcat (buf, ", PIC");
3093
3094           if (e_flags & EF_BFIN_FDPIC)
3095             strcat (buf, ", FDPIC");
3096
3097           if (e_flags & EF_BFIN_CODE_IN_L1)
3098             strcat (buf, ", code in L1");
3099
3100           if (e_flags & EF_BFIN_DATA_IN_L1)
3101             strcat (buf, ", data in L1");
3102
3103           break;
3104
3105         case EM_CYGNUS_FRV:
3106           switch (e_flags & EF_FRV_CPU_MASK)
3107             {
3108             case EF_FRV_CPU_GENERIC:
3109               break;
3110
3111             default:
3112               strcat (buf, ", fr???");
3113               break;
3114
3115             case EF_FRV_CPU_FR300:
3116               strcat (buf, ", fr300");
3117               break;
3118
3119             case EF_FRV_CPU_FR400:
3120               strcat (buf, ", fr400");
3121               break;
3122             case EF_FRV_CPU_FR405:
3123               strcat (buf, ", fr405");
3124               break;
3125
3126             case EF_FRV_CPU_FR450:
3127               strcat (buf, ", fr450");
3128               break;
3129
3130             case EF_FRV_CPU_FR500:
3131               strcat (buf, ", fr500");
3132               break;
3133             case EF_FRV_CPU_FR550:
3134               strcat (buf, ", fr550");
3135               break;
3136
3137             case EF_FRV_CPU_SIMPLE:
3138               strcat (buf, ", simple");
3139               break;
3140             case EF_FRV_CPU_TOMCAT:
3141               strcat (buf, ", tomcat");
3142               break;
3143             }
3144           break;
3145
3146         case EM_68K:
3147           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3148             strcat (buf, ", m68000");
3149           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3150             strcat (buf, ", cpu32");
3151           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3152             strcat (buf, ", fido_a");
3153           else
3154             {
3155               char const * isa = _("unknown");
3156               char const * mac = _("unknown mac");
3157               char const * additional = NULL;
3158
3159               switch (e_flags & EF_M68K_CF_ISA_MASK)
3160                 {
3161                 case EF_M68K_CF_ISA_A_NODIV:
3162                   isa = "A";
3163                   additional = ", nodiv";
3164                   break;
3165                 case EF_M68K_CF_ISA_A:
3166                   isa = "A";
3167                   break;
3168                 case EF_M68K_CF_ISA_A_PLUS:
3169                   isa = "A+";
3170                   break;
3171                 case EF_M68K_CF_ISA_B_NOUSP:
3172                   isa = "B";
3173                   additional = ", nousp";
3174                   break;
3175                 case EF_M68K_CF_ISA_B:
3176                   isa = "B";
3177                   break;
3178                 case EF_M68K_CF_ISA_C:
3179                   isa = "C";
3180                   break;
3181                 case EF_M68K_CF_ISA_C_NODIV:
3182                   isa = "C";
3183                   additional = ", nodiv";
3184                   break;
3185                 }
3186               strcat (buf, ", cf, isa ");
3187               strcat (buf, isa);
3188               if (additional)
3189                 strcat (buf, additional);
3190               if (e_flags & EF_M68K_CF_FLOAT)
3191                 strcat (buf, ", float");
3192               switch (e_flags & EF_M68K_CF_MAC_MASK)
3193                 {
3194                 case 0:
3195                   mac = NULL;
3196                   break;
3197                 case EF_M68K_CF_MAC:
3198                   mac = "mac";
3199                   break;
3200                 case EF_M68K_CF_EMAC:
3201                   mac = "emac";
3202                   break;
3203                 case EF_M68K_CF_EMAC_B:
3204                   mac = "emac_b";
3205                   break;
3206                 }
3207               if (mac)
3208                 {
3209                   strcat (buf, ", ");
3210                   strcat (buf, mac);
3211                 }
3212             }
3213           break;
3214
3215         case EM_CYGNUS_MEP:
3216           switch (e_flags & EF_MEP_CPU_MASK)
3217             {
3218             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3219             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3220             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3221             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3222             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3223             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3224             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3225             }
3226
3227           switch (e_flags & EF_MEP_COP_MASK)
3228             {
3229             case EF_MEP_COP_NONE: break;
3230             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3231             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3232             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3233             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3234             default: strcat (buf, _("<unknown MeP copro type>")); break;
3235             }
3236
3237           if (e_flags & EF_MEP_LIBRARY)
3238             strcat (buf, ", Built for Library");
3239
3240           if (e_flags & EF_MEP_INDEX_MASK)
3241             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3242                      e_flags & EF_MEP_INDEX_MASK);
3243
3244           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3245             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3246                      e_flags & ~ EF_MEP_ALL_FLAGS);
3247           break;
3248
3249         case EM_PPC:
3250           if (e_flags & EF_PPC_EMB)
3251             strcat (buf, ", emb");
3252
3253           if (e_flags & EF_PPC_RELOCATABLE)
3254             strcat (buf, _(", relocatable"));
3255
3256           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3257             strcat (buf, _(", relocatable-lib"));
3258           break;
3259
3260         case EM_PPC64:
3261           if (e_flags & EF_PPC64_ABI)
3262             {
3263               char abi[] = ", abiv0";
3264
3265               abi[6] += e_flags & EF_PPC64_ABI;
3266               strcat (buf, abi);
3267             }
3268           break;
3269
3270         case EM_V800:
3271           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3272             strcat (buf, ", RH850 ABI");
3273
3274           if (e_flags & EF_V800_850E3)
3275             strcat (buf, ", V3 architecture");
3276
3277           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3278             strcat (buf, ", FPU not used");
3279
3280           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3281             strcat (buf, ", regmode: COMMON");
3282
3283           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3284             strcat (buf, ", r4 not used");
3285
3286           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3287             strcat (buf, ", r30 not used");
3288
3289           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3290             strcat (buf, ", r5 not used");
3291
3292           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3293             strcat (buf, ", r2 not used");
3294
3295           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3296             {
3297               switch (e_flags & - e_flags)
3298                 {
3299                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3300                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3301                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3302                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3303                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3304                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3305                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3306                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3307                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3308                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3309                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3310                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3311                 default: break;
3312                 }
3313             }
3314           break;
3315
3316         case EM_V850:
3317         case EM_CYGNUS_V850:
3318           switch (e_flags & EF_V850_ARCH)
3319             {
3320             case E_V850E3V5_ARCH:
3321               strcat (buf, ", v850e3v5");
3322               break;
3323             case E_V850E2V3_ARCH:
3324               strcat (buf, ", v850e2v3");
3325               break;
3326             case E_V850E2_ARCH:
3327               strcat (buf, ", v850e2");
3328               break;
3329             case E_V850E1_ARCH:
3330               strcat (buf, ", v850e1");
3331               break;
3332             case E_V850E_ARCH:
3333               strcat (buf, ", v850e");
3334               break;
3335             case E_V850_ARCH:
3336               strcat (buf, ", v850");
3337               break;
3338             default:
3339               strcat (buf, _(", unknown v850 architecture variant"));
3340               break;
3341             }
3342           break;
3343
3344         case EM_M32R:
3345         case EM_CYGNUS_M32R:
3346           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3347             strcat (buf, ", m32r");
3348           break;
3349
3350         case EM_MIPS:
3351         case EM_MIPS_RS3_LE:
3352           if (e_flags & EF_MIPS_NOREORDER)
3353             strcat (buf, ", noreorder");
3354
3355           if (e_flags & EF_MIPS_PIC)
3356             strcat (buf, ", pic");
3357
3358           if (e_flags & EF_MIPS_CPIC)
3359             strcat (buf, ", cpic");
3360
3361           if (e_flags & EF_MIPS_UCODE)
3362             strcat (buf, ", ugen_reserved");
3363
3364           if (e_flags & EF_MIPS_ABI2)
3365             strcat (buf, ", abi2");
3366
3367           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3368             strcat (buf, ", odk first");
3369
3370           if (e_flags & EF_MIPS_32BITMODE)
3371             strcat (buf, ", 32bitmode");
3372
3373           if (e_flags & EF_MIPS_NAN2008)
3374             strcat (buf, ", nan2008");
3375
3376           if (e_flags & EF_MIPS_FP64)
3377             strcat (buf, ", fp64");
3378
3379           switch ((e_flags & EF_MIPS_MACH))
3380             {
3381             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3382             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3383             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3384             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3385             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3386             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3387             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3388             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3389             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3390             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3391             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3392             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3393             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3394             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3395             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3396             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3397             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3398             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3399             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3400             case 0:
3401             /* We simply ignore the field in this case to avoid confusion:
3402                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3403                extension.  */
3404               break;
3405             default: strcat (buf, _(", unknown CPU")); break;
3406             }
3407
3408           switch ((e_flags & EF_MIPS_ABI))
3409             {
3410             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3411             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3412             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3413             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3414             case 0:
3415             /* We simply ignore the field in this case to avoid confusion:
3416                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3417                This means it is likely to be an o32 file, but not for
3418                sure.  */
3419               break;
3420             default: strcat (buf, _(", unknown ABI")); break;
3421             }
3422
3423           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3424             strcat (buf, ", mdmx");
3425
3426           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3427             strcat (buf, ", mips16");
3428
3429           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3430             strcat (buf, ", micromips");
3431
3432           switch ((e_flags & EF_MIPS_ARCH))
3433             {
3434             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3435             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3436             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3437             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3438             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3439             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3440             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3441             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3442             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3443             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3444             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3445             default: strcat (buf, _(", unknown ISA")); break;
3446             }
3447           break;
3448
3449         case EM_NDS32:
3450           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3451           break;
3452
3453         case EM_NFP:
3454           switch (EF_NFP_MACH (e_flags))
3455             {
3456             case E_NFP_MACH_3200:
3457               strcat (buf, ", NFP-32xx");
3458               break;
3459             case E_NFP_MACH_6000:
3460               strcat (buf, ", NFP-6xxx");
3461               break;
3462             }
3463           break;
3464
3465         case EM_RISCV:
3466           if (e_flags & EF_RISCV_RVC)
3467             strcat (buf, ", RVC");
3468
3469           switch (e_flags & EF_RISCV_FLOAT_ABI)
3470             {
3471             case EF_RISCV_FLOAT_ABI_SOFT:
3472               strcat (buf, ", soft-float ABI");
3473               break;
3474
3475             case EF_RISCV_FLOAT_ABI_SINGLE:
3476               strcat (buf, ", single-float ABI");
3477               break;
3478
3479             case EF_RISCV_FLOAT_ABI_DOUBLE:
3480               strcat (buf, ", double-float ABI");
3481               break;
3482
3483             case EF_RISCV_FLOAT_ABI_QUAD:
3484               strcat (buf, ", quad-float ABI");
3485               break;
3486             }
3487           break;
3488
3489         case EM_SH:
3490           switch ((e_flags & EF_SH_MACH_MASK))
3491             {
3492             case EF_SH1: strcat (buf, ", sh1"); break;
3493             case EF_SH2: strcat (buf, ", sh2"); break;
3494             case EF_SH3: strcat (buf, ", sh3"); break;
3495             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3496             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3497             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3498             case EF_SH3E: strcat (buf, ", sh3e"); break;
3499             case EF_SH4: strcat (buf, ", sh4"); break;
3500             case EF_SH5: strcat (buf, ", sh5"); break;
3501             case EF_SH2E: strcat (buf, ", sh2e"); break;
3502             case EF_SH4A: strcat (buf, ", sh4a"); break;
3503             case EF_SH2A: strcat (buf, ", sh2a"); break;
3504             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3505             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3506             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3507             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3508             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3509             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3510             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3511             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3512             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3513             default: strcat (buf, _(", unknown ISA")); break;
3514             }
3515
3516           if (e_flags & EF_SH_PIC)
3517             strcat (buf, ", pic");
3518
3519           if (e_flags & EF_SH_FDPIC)
3520             strcat (buf, ", fdpic");
3521           break;
3522
3523         case EM_OR1K:
3524           if (e_flags & EF_OR1K_NODELAY)
3525             strcat (buf, ", no delay");
3526           break;
3527
3528         case EM_SPARCV9:
3529           if (e_flags & EF_SPARC_32PLUS)
3530             strcat (buf, ", v8+");
3531
3532           if (e_flags & EF_SPARC_SUN_US1)
3533             strcat (buf, ", ultrasparcI");
3534
3535           if (e_flags & EF_SPARC_SUN_US3)
3536             strcat (buf, ", ultrasparcIII");
3537
3538           if (e_flags & EF_SPARC_HAL_R1)
3539             strcat (buf, ", halr1");
3540
3541           if (e_flags & EF_SPARC_LEDATA)
3542             strcat (buf, ", ledata");
3543
3544           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3545             strcat (buf, ", tso");
3546
3547           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3548             strcat (buf, ", pso");
3549
3550           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3551             strcat (buf, ", rmo");
3552           break;
3553
3554         case EM_PARISC:
3555           switch (e_flags & EF_PARISC_ARCH)
3556             {
3557             case EFA_PARISC_1_0:
3558               strcpy (buf, ", PA-RISC 1.0");
3559               break;
3560             case EFA_PARISC_1_1:
3561               strcpy (buf, ", PA-RISC 1.1");
3562               break;
3563             case EFA_PARISC_2_0:
3564               strcpy (buf, ", PA-RISC 2.0");
3565               break;
3566             default:
3567               break;
3568             }
3569           if (e_flags & EF_PARISC_TRAPNIL)
3570             strcat (buf, ", trapnil");
3571           if (e_flags & EF_PARISC_EXT)
3572             strcat (buf, ", ext");
3573           if (e_flags & EF_PARISC_LSB)
3574             strcat (buf, ", lsb");
3575           if (e_flags & EF_PARISC_WIDE)
3576             strcat (buf, ", wide");
3577           if (e_flags & EF_PARISC_NO_KABP)
3578             strcat (buf, ", no kabp");
3579           if (e_flags & EF_PARISC_LAZYSWAP)
3580             strcat (buf, ", lazyswap");
3581           break;
3582
3583         case EM_PJ:
3584         case EM_PJ_OLD:
3585           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3586             strcat (buf, ", new calling convention");
3587
3588           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3589             strcat (buf, ", gnu calling convention");
3590           break;
3591
3592         case EM_IA_64:
3593           if ((e_flags & EF_IA_64_ABI64))
3594             strcat (buf, ", 64-bit");
3595           else
3596             strcat (buf, ", 32-bit");
3597           if ((e_flags & EF_IA_64_REDUCEDFP))
3598             strcat (buf, ", reduced fp model");
3599           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3600             strcat (buf, ", no function descriptors, constant gp");
3601           else if ((e_flags & EF_IA_64_CONS_GP))
3602             strcat (buf, ", constant gp");
3603           if ((e_flags & EF_IA_64_ABSOLUTE))
3604             strcat (buf, ", absolute");
3605           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3606             {
3607               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3608                 strcat (buf, ", vms_linkages");
3609               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3610                 {
3611                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3612                   break;
3613                 case EF_IA_64_VMS_COMCOD_WARNING:
3614                   strcat (buf, ", warning");
3615                   break;
3616                 case EF_IA_64_VMS_COMCOD_ERROR:
3617                   strcat (buf, ", error");
3618                   break;
3619                 case EF_IA_64_VMS_COMCOD_ABORT:
3620                   strcat (buf, ", abort");
3621                   break;
3622                 default:
3623                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3624                         e_flags & EF_IA_64_VMS_COMCOD);
3625                   strcat (buf, ", <unknown>");
3626                 }
3627             }
3628           break;
3629
3630         case EM_VAX:
3631           if ((e_flags & EF_VAX_NONPIC))
3632             strcat (buf, ", non-PIC");
3633           if ((e_flags & EF_VAX_DFLOAT))
3634             strcat (buf, ", D-Float");
3635           if ((e_flags & EF_VAX_GFLOAT))
3636             strcat (buf, ", G-Float");
3637           break;
3638
3639         case EM_VISIUM:
3640           if (e_flags & EF_VISIUM_ARCH_MCM)
3641             strcat (buf, ", mcm");
3642           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3643             strcat (buf, ", mcm24");
3644           if (e_flags & EF_VISIUM_ARCH_GR6)
3645             strcat (buf, ", gr6");
3646           break;
3647
3648         case EM_RL78:
3649           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3650             {
3651             case E_FLAG_RL78_ANY_CPU: break;
3652             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3653             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3654             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3655             }
3656           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3657             strcat (buf, ", 64-bit doubles");
3658           break;
3659
3660         case EM_RX:
3661           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3662             strcat (buf, ", 64-bit doubles");
3663           if (e_flags & E_FLAG_RX_DSP)
3664             strcat (buf, ", dsp");
3665           if (e_flags & E_FLAG_RX_PID)
3666             strcat (buf, ", pid");
3667           if (e_flags & E_FLAG_RX_ABI)
3668             strcat (buf, ", RX ABI");
3669           if (e_flags & E_FLAG_RX_SINSNS_SET)
3670             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3671                     ? ", uses String instructions" : ", bans String instructions");
3672           if (e_flags & E_FLAG_RX_V2)
3673             strcat (buf, ", V2");
3674           break;
3675
3676         case EM_S390:
3677           if (e_flags & EF_S390_HIGH_GPRS)
3678             strcat (buf, ", highgprs");
3679           break;
3680
3681         case EM_TI_C6000:
3682           if ((e_flags & EF_C6000_REL))
3683             strcat (buf, ", relocatable module");
3684           break;
3685
3686         case EM_MSP430:
3687           strcat (buf, _(": architecture variant: "));
3688           switch (e_flags & EF_MSP430_MACH)
3689             {
3690             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3691             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3692             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3693             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3694             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3695             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3696             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3697             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3698             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3699             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3700             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3701             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3702             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3703             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3704             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3705             default:
3706               strcat (buf, _(": unknown")); break;
3707             }
3708
3709           if (e_flags & ~ EF_MSP430_MACH)
3710             strcat (buf, _(": unknown extra flag bits also present"));
3711         }
3712     }
3713
3714   return buf;
3715 }
3716
3717 static const char *
3718 get_osabi_name (Filedata * filedata, unsigned int osabi)
3719 {
3720   static char buff[32];
3721
3722   switch (osabi)
3723     {
3724     case ELFOSABI_NONE:         return "UNIX - System V";
3725     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3726     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3727     case ELFOSABI_GNU:          return "UNIX - GNU";
3728     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3729     case ELFOSABI_AIX:          return "UNIX - AIX";
3730     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3731     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3732     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3733     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3734     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3735     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3736     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3737     case ELFOSABI_AROS:         return "AROS";
3738     case ELFOSABI_FENIXOS:      return "FenixOS";
3739     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3740     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3741     default:
3742       if (osabi >= 64)
3743         switch (filedata->file_header.e_machine)
3744           {
3745           case EM_ARM:
3746             switch (osabi)
3747               {
3748               case ELFOSABI_ARM:        return "ARM";
3749               case ELFOSABI_ARM_FDPIC:  return "ARM FDPIC";
3750               default:
3751                 break;
3752               }
3753             break;
3754
3755           case EM_MSP430:
3756           case EM_MSP430_OLD:
3757           case EM_VISIUM:
3758             switch (osabi)
3759               {
3760               case ELFOSABI_STANDALONE: return _("Standalone App");
3761               default:
3762                 break;
3763               }
3764             break;
3765
3766           case EM_TI_C6000:
3767             switch (osabi)
3768               {
3769               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3770               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3771               default:
3772                 break;
3773               }
3774             break;
3775
3776           default:
3777             break;
3778           }
3779       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3780       return buff;
3781     }
3782 }
3783
3784 static const char *
3785 get_aarch64_segment_type (unsigned long type)
3786 {
3787   switch (type)
3788     {
3789     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3790     default:                  return NULL;
3791     }
3792 }
3793
3794 static const char *
3795 get_arm_segment_type (unsigned long type)
3796 {
3797   switch (type)
3798     {
3799     case PT_ARM_EXIDX: return "EXIDX";
3800     default:           return NULL;
3801     }
3802 }
3803
3804 static const char *
3805 get_s390_segment_type (unsigned long type)
3806 {
3807   switch (type)
3808     {
3809     case PT_S390_PGSTE: return "S390_PGSTE";
3810     default:            return NULL;
3811     }
3812 }
3813
3814 static const char *
3815 get_mips_segment_type (unsigned long type)
3816 {
3817   switch (type)
3818     {
3819     case PT_MIPS_REGINFO:   return "REGINFO";
3820     case PT_MIPS_RTPROC:    return "RTPROC";
3821     case PT_MIPS_OPTIONS:   return "OPTIONS";
3822     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3823     default:                return NULL;
3824     }
3825 }
3826
3827 static const char *
3828 get_parisc_segment_type (unsigned long type)
3829 {
3830   switch (type)
3831     {
3832     case PT_HP_TLS:             return "HP_TLS";
3833     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3834     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3835     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3836     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3837     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3838     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3839     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3840     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3841     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3842     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3843     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3844     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3845     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3846     case PT_HP_STACK:           return "HP_STACK";
3847     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3848     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3849     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3850     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3851     default:                    return NULL;
3852     }
3853 }
3854
3855 static const char *
3856 get_ia64_segment_type (unsigned long type)
3857 {
3858   switch (type)
3859     {
3860     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3861     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3862     case PT_HP_TLS:             return "HP_TLS";
3863     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3864     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3865     case PT_IA_64_HP_STACK:     return "HP_STACK";
3866     default:                    return NULL;
3867     }
3868 }
3869
3870 static const char *
3871 get_tic6x_segment_type (unsigned long type)
3872 {
3873   switch (type)
3874     {
3875     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3876     default:               return NULL;
3877     }
3878 }
3879
3880 static const char *
3881 get_solaris_segment_type (unsigned long type)
3882 {
3883   switch (type)
3884     {
3885     case 0x6464e550: return "PT_SUNW_UNWIND";
3886     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3887     case 0x6ffffff7: return "PT_LOSUNW";
3888     case 0x6ffffffa: return "PT_SUNWBSS";
3889     case 0x6ffffffb: return "PT_SUNWSTACK";
3890     case 0x6ffffffc: return "PT_SUNWDTRACE";
3891     case 0x6ffffffd: return "PT_SUNWCAP";
3892     case 0x6fffffff: return "PT_HISUNW";
3893     default:         return NULL;
3894     }
3895 }
3896
3897 static const char *
3898 get_segment_type (Filedata * filedata, unsigned long p_type)
3899 {
3900   static char buff[32];
3901
3902   switch (p_type)
3903     {
3904     case PT_NULL:       return "NULL";
3905     case PT_LOAD:       return "LOAD";
3906     case PT_DYNAMIC:    return "DYNAMIC";
3907     case PT_INTERP:     return "INTERP";
3908     case PT_NOTE:       return "NOTE";
3909     case PT_SHLIB:      return "SHLIB";
3910     case PT_PHDR:       return "PHDR";
3911     case PT_TLS:        return "TLS";
3912     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3913     case PT_GNU_STACK:  return "GNU_STACK";
3914     case PT_GNU_RELRO:  return "GNU_RELRO";
3915
3916     default:
3917       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3918         {
3919           sprintf (buff, "GNU_MBIND+%#lx",
3920                    p_type - PT_GNU_MBIND_LO);
3921         }
3922       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3923         {
3924           const char * result;
3925
3926           switch (filedata->file_header.e_machine)
3927             {
3928             case EM_AARCH64:
3929               result = get_aarch64_segment_type (p_type);
3930               break;
3931             case EM_ARM:
3932               result = get_arm_segment_type (p_type);
3933               break;
3934             case EM_MIPS:
3935             case EM_MIPS_RS3_LE:
3936               result = get_mips_segment_type (p_type);
3937               break;
3938             case EM_PARISC:
3939               result = get_parisc_segment_type (p_type);
3940               break;
3941             case EM_IA_64:
3942               result = get_ia64_segment_type (p_type);
3943               break;
3944             case EM_TI_C6000:
3945               result = get_tic6x_segment_type (p_type);
3946               break;
3947             case EM_S390:
3948             case EM_S390_OLD:
3949               result = get_s390_segment_type (p_type);
3950               break;
3951             default:
3952               result = NULL;
3953               break;
3954             }
3955
3956           if (result != NULL)
3957             return result;
3958
3959           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3960         }
3961       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3962         {
3963           const char * result;
3964
3965           switch (filedata->file_header.e_machine)
3966             {
3967             case EM_PARISC:
3968               result = get_parisc_segment_type (p_type);
3969               break;
3970             case EM_IA_64:
3971               result = get_ia64_segment_type (p_type);
3972               break;
3973             default:
3974               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3975                 result = get_solaris_segment_type (p_type);
3976               else
3977                 result = NULL;
3978               break;
3979             }
3980
3981           if (result != NULL)
3982             return result;
3983
3984           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3985         }
3986       else
3987         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3988
3989       return buff;
3990     }
3991 }
3992
3993 static const char *
3994 get_arc_section_type_name (unsigned int sh_type)
3995 {
3996   switch (sh_type)
3997     {
3998     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
3999     default:
4000       break;
4001     }
4002   return NULL;
4003 }
4004
4005 static const char *
4006 get_mips_section_type_name (unsigned int sh_type)
4007 {
4008   switch (sh_type)
4009     {
4010     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
4011     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
4012     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
4013     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
4014     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
4015     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
4016     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
4017     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
4018     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
4019     case SHT_MIPS_RELD:          return "MIPS_RELD";
4020     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
4021     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
4022     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
4023     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
4024     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
4025     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
4026     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
4027     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
4028     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
4029     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4030     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4031     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4032     case SHT_MIPS_LINE:          return "MIPS_LINE";
4033     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4034     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4035     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4036     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4037     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4038     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4039     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4040     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4041     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4042     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4043     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4044     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4045     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4046     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4047     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4048     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4049     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4050     default:
4051       break;
4052     }
4053   return NULL;
4054 }
4055
4056 static const char *
4057 get_parisc_section_type_name (unsigned int sh_type)
4058 {
4059   switch (sh_type)
4060     {
4061     case SHT_PARISC_EXT:        return "PARISC_EXT";
4062     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4063     case SHT_PARISC_DOC:        return "PARISC_DOC";
4064     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4065     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4066     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4067     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4068     default:                    return NULL;
4069     }
4070 }
4071
4072 static const char *
4073 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4074 {
4075   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4076   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4077     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4078
4079   switch (sh_type)
4080     {
4081     case SHT_IA_64_EXT:                return "IA_64_EXT";
4082     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4083     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4084     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4085     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4086     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4087     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4088     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4089     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4090     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4091     default:
4092       break;
4093     }
4094   return NULL;
4095 }
4096
4097 static const char *
4098 get_x86_64_section_type_name (unsigned int sh_type)
4099 {
4100   switch (sh_type)
4101     {
4102     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4103     default:                    return NULL;
4104     }
4105 }
4106
4107 static const char *
4108 get_aarch64_section_type_name (unsigned int sh_type)
4109 {
4110   switch (sh_type)
4111     {
4112     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4113     default:                     return NULL;
4114     }
4115 }
4116
4117 static const char *
4118 get_arm_section_type_name (unsigned int sh_type)
4119 {
4120   switch (sh_type)
4121     {
4122     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4123     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4124     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4125     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4126     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4127     default:                      return NULL;
4128     }
4129 }
4130
4131 static const char *
4132 get_tic6x_section_type_name (unsigned int sh_type)
4133 {
4134   switch (sh_type)
4135     {
4136     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4137     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4138     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4139     case SHT_TI_ICODE:          return "TI_ICODE";
4140     case SHT_TI_XREF:           return "TI_XREF";
4141     case SHT_TI_HANDLER:        return "TI_HANDLER";
4142     case SHT_TI_INITINFO:       return "TI_INITINFO";
4143     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4144     default:                    return NULL;
4145     }
4146 }
4147
4148 static const char *
4149 get_msp430x_section_type_name (unsigned int sh_type)
4150 {
4151   switch (sh_type)
4152     {
4153     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4154     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4155     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4156     default:                      return NULL;
4157     }
4158 }
4159
4160 static const char *
4161 get_nfp_section_type_name (unsigned int sh_type)
4162 {
4163   switch (sh_type)
4164     {
4165     case SHT_NFP_MECONFIG:      return "NFP_MECONFIG";
4166     case SHT_NFP_INITREG:       return "NFP_INITREG";
4167     case SHT_NFP_UDEBUG:        return "NFP_UDEBUG";
4168     default:                    return NULL;
4169     }
4170 }
4171
4172 static const char *
4173 get_v850_section_type_name (unsigned int sh_type)
4174 {
4175   switch (sh_type)
4176     {
4177     case SHT_V850_SCOMMON:  return "V850 Small Common";
4178     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4179     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4180     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4181     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4182     default:                return NULL;
4183     }
4184 }
4185
4186 static const char *
4187 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4188 {
4189   static char buff[32];
4190   const char * result;
4191
4192   switch (sh_type)
4193     {
4194     case SHT_NULL:              return "NULL";
4195     case SHT_PROGBITS:          return "PROGBITS";
4196     case SHT_SYMTAB:            return "SYMTAB";
4197     case SHT_STRTAB:            return "STRTAB";
4198     case SHT_RELA:              return "RELA";
4199     case SHT_HASH:              return "HASH";
4200     case SHT_DYNAMIC:           return "DYNAMIC";
4201     case SHT_NOTE:              return "NOTE";
4202     case SHT_NOBITS:            return "NOBITS";
4203     case SHT_REL:               return "REL";
4204     case SHT_SHLIB:             return "SHLIB";
4205     case SHT_DYNSYM:            return "DYNSYM";
4206     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4207     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4208     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4209     case SHT_GNU_HASH:          return "GNU_HASH";
4210     case SHT_GROUP:             return "GROUP";
4211     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
4212     case SHT_GNU_verdef:        return "VERDEF";
4213     case SHT_GNU_verneed:       return "VERNEED";
4214     case SHT_GNU_versym:        return "VERSYM";
4215     case 0x6ffffff0:            return "VERSYM";
4216     case 0x6ffffffc:            return "VERDEF";
4217     case 0x7ffffffd:            return "AUXILIARY";
4218     case 0x7fffffff:            return "FILTER";
4219     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4220
4221     default:
4222       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4223         {
4224           switch (filedata->file_header.e_machine)
4225             {
4226             case EM_ARC:
4227             case EM_ARC_COMPACT:
4228             case EM_ARC_COMPACT2:
4229               result = get_arc_section_type_name (sh_type);
4230               break;
4231             case EM_MIPS:
4232             case EM_MIPS_RS3_LE:
4233               result = get_mips_section_type_name (sh_type);
4234               break;
4235             case EM_PARISC:
4236               result = get_parisc_section_type_name (sh_type);
4237               break;
4238             case EM_IA_64:
4239               result = get_ia64_section_type_name (filedata, sh_type);
4240               break;
4241             case EM_X86_64:
4242             case EM_L1OM:
4243             case EM_K1OM:
4244               result = get_x86_64_section_type_name (sh_type);
4245               break;
4246             case EM_AARCH64:
4247               result = get_aarch64_section_type_name (sh_type);
4248               break;
4249             case EM_ARM:
4250               result = get_arm_section_type_name (sh_type);
4251               break;
4252             case EM_TI_C6000:
4253               result = get_tic6x_section_type_name (sh_type);
4254               break;
4255             case EM_MSP430:
4256               result = get_msp430x_section_type_name (sh_type);
4257               break;
4258             case EM_NFP:
4259               result = get_nfp_section_type_name (sh_type);
4260               break;
4261             case EM_V800:
4262             case EM_V850:
4263             case EM_CYGNUS_V850:
4264               result = get_v850_section_type_name (sh_type);
4265               break;
4266             default:
4267               result = NULL;
4268               break;
4269             }
4270
4271           if (result != NULL)
4272             return result;
4273
4274           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4275         }
4276       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4277         {
4278           switch (filedata->file_header.e_machine)
4279             {
4280             case EM_IA_64:
4281               result = get_ia64_section_type_name (filedata, sh_type);
4282               break;
4283             default:
4284               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4285                 result = get_solaris_section_type (sh_type);
4286               else
4287                 {
4288                   switch (sh_type)
4289                     {
4290                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4291                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4292                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4293                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4294                     default:
4295                       result = NULL;
4296                       break;
4297                     }
4298                 }
4299               break;
4300             }
4301
4302           if (result != NULL)
4303             return result;
4304
4305           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4306         }
4307       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4308         {
4309           switch (filedata->file_header.e_machine)
4310             {
4311             case EM_V800:
4312             case EM_V850:
4313             case EM_CYGNUS_V850:
4314               result = get_v850_section_type_name (sh_type);
4315               break;
4316             default:
4317               result = NULL;
4318               break;
4319             }
4320
4321           if (result != NULL)
4322             return result;
4323
4324           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4325         }
4326       else
4327         /* This message is probably going to be displayed in a 15
4328            character wide field, so put the hex value first.  */
4329         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4330
4331       return buff;
4332     }
4333 }
4334
4335 #define OPTION_DEBUG_DUMP       512
4336 #define OPTION_DYN_SYMS         513
4337 #define OPTION_DWARF_DEPTH      514
4338 #define OPTION_DWARF_START      515
4339 #define OPTION_DWARF_CHECK      516
4340
4341 static struct option options[] =
4342 {
4343   {"all",              no_argument, 0, 'a'},
4344   {"file-header",      no_argument, 0, 'h'},
4345   {"program-headers",  no_argument, 0, 'l'},
4346   {"headers",          no_argument, 0, 'e'},
4347   {"histogram",        no_argument, 0, 'I'},
4348   {"segments",         no_argument, 0, 'l'},
4349   {"sections",         no_argument, 0, 'S'},
4350   {"section-headers",  no_argument, 0, 'S'},
4351   {"section-groups",   no_argument, 0, 'g'},
4352   {"section-details",  no_argument, 0, 't'},
4353   {"full-section-name",no_argument, 0, 'N'},
4354   {"symbols",          no_argument, 0, 's'},
4355   {"syms",             no_argument, 0, 's'},
4356   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4357   {"relocs",           no_argument, 0, 'r'},
4358   {"notes",            no_argument, 0, 'n'},
4359   {"dynamic",          no_argument, 0, 'd'},
4360   {"arch-specific",    no_argument, 0, 'A'},
4361   {"version-info",     no_argument, 0, 'V'},
4362   {"use-dynamic",      no_argument, 0, 'D'},
4363   {"unwind",           no_argument, 0, 'u'},
4364   {"archive-index",    no_argument, 0, 'c'},
4365   {"hex-dump",         required_argument, 0, 'x'},
4366   {"relocated-dump",   required_argument, 0, 'R'},
4367   {"string-dump",      required_argument, 0, 'p'},
4368   {"decompress",       no_argument, 0, 'z'},
4369 #ifdef SUPPORT_DISASSEMBLY
4370   {"instruction-dump", required_argument, 0, 'i'},
4371 #endif
4372   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4373
4374   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4375   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4376   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4377
4378   {"version",          no_argument, 0, 'v'},
4379   {"wide",             no_argument, 0, 'W'},
4380   {"help",             no_argument, 0, 'H'},
4381   {0,                  no_argument, 0, 0}
4382 };
4383
4384 static void
4385 usage (FILE * stream)
4386 {
4387   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4388   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4389   fprintf (stream, _(" Options are:\n\
4390   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4391   -h --file-header       Display the ELF file header\n\
4392   -l --program-headers   Display the program headers\n\
4393      --segments          An alias for --program-headers\n\
4394   -S --section-headers   Display the sections' header\n\
4395      --sections          An alias for --section-headers\n\
4396   -g --section-groups    Display the section groups\n\
4397   -t --section-details   Display the section details\n\
4398   -e --headers           Equivalent to: -h -l -S\n\
4399   -s --syms              Display the symbol table\n\
4400      --symbols           An alias for --syms\n\
4401   --dyn-syms             Display the dynamic symbol table\n\
4402   -n --notes             Display the core notes (if present)\n\
4403   -r --relocs            Display the relocations (if present)\n\
4404   -u --unwind            Display the unwind info (if present)\n\
4405   -d --dynamic           Display the dynamic section (if present)\n\
4406   -V --version-info      Display the version sections (if present)\n\
4407   -A --arch-specific     Display architecture specific information (if any)\n\
4408   -c --archive-index     Display the symbol/file index in an archive\n\
4409   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4410   -x --hex-dump=<number|name>\n\
4411                          Dump the contents of section <number|name> as bytes\n\
4412   -p --string-dump=<number|name>\n\
4413                          Dump the contents of section <number|name> as strings\n\
4414   -R --relocated-dump=<number|name>\n\
4415                          Dump the contents of section <number|name> as relocated bytes\n\
4416   -z --decompress        Decompress section before dumping it\n\
4417   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4418   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4419                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4420                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4421                =addr,=cu_index,=links,=follow-links]\n\
4422                          Display the contents of DWARF debug sections\n"));
4423   fprintf (stream, _("\
4424   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4425   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4426                          or deeper\n"));
4427 #ifdef SUPPORT_DISASSEMBLY
4428   fprintf (stream, _("\
4429   -i --instruction-dump=<number|name>\n\
4430                          Disassemble the contents of section <number|name>\n"));
4431 #endif
4432   fprintf (stream, _("\
4433   -I --histogram         Display histogram of bucket list lengths\n\
4434   -W --wide              Allow output width to exceed 80 characters\n\
4435   @<file>                Read options from <file>\n\
4436   -H --help              Display this information\n\
4437   -v --version           Display the version number of readelf\n"));
4438
4439   if (REPORT_BUGS_TO[0] && stream == stdout)
4440     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4441
4442   exit (stream == stdout ? 0 : 1);
4443 }
4444
4445 /* Record the fact that the user wants the contents of section number
4446    SECTION to be displayed using the method(s) encoded as flags bits
4447    in TYPE.  Note, TYPE can be zero if we are creating the array for
4448    the first time.  */
4449
4450 static void
4451 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4452 {
4453   if (section >= filedata->num_dump_sects)
4454     {
4455       dump_type * new_dump_sects;
4456
4457       new_dump_sects = (dump_type *) calloc (section + 1,
4458                                              sizeof (* new_dump_sects));
4459
4460       if (new_dump_sects == NULL)
4461         error (_("Out of memory allocating dump request table.\n"));
4462       else
4463         {
4464           if (filedata->dump_sects)
4465             {
4466               /* Copy current flag settings.  */
4467               memcpy (new_dump_sects, filedata->dump_sects,
4468                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4469
4470               free (filedata->dump_sects);
4471             }
4472
4473           filedata->dump_sects = new_dump_sects;
4474           filedata->num_dump_sects = section + 1;
4475         }
4476     }
4477
4478   if (filedata->dump_sects)
4479     filedata->dump_sects[section] |= type;
4480 }
4481
4482 /* Request a dump by section name.  */
4483
4484 static void
4485 request_dump_byname (const char * section, dump_type type)
4486 {
4487   struct dump_list_entry * new_request;
4488
4489   new_request = (struct dump_list_entry *)
4490       malloc (sizeof (struct dump_list_entry));
4491   if (!new_request)
4492     error (_("Out of memory allocating dump request table.\n"));
4493
4494   new_request->name = strdup (section);
4495   if (!new_request->name)
4496     error (_("Out of memory allocating dump request table.\n"));
4497
4498   new_request->type = type;
4499
4500   new_request->next = dump_sects_byname;
4501   dump_sects_byname = new_request;
4502 }
4503
4504 static inline void
4505 request_dump (Filedata * filedata, dump_type type)
4506 {
4507   int section;
4508   char * cp;
4509
4510   do_dump++;
4511   section = strtoul (optarg, & cp, 0);
4512
4513   if (! *cp && section >= 0)
4514     request_dump_bynumber (filedata, section, type);
4515   else
4516     request_dump_byname (optarg, type);
4517 }
4518
4519 static void
4520 parse_args (Filedata * filedata, int argc, char ** argv)
4521 {
4522   int c;
4523
4524   if (argc < 2)
4525     usage (stderr);
4526
4527   while ((c = getopt_long
4528           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4529     {
4530       switch (c)
4531         {
4532         case 0:
4533           /* Long options.  */
4534           break;
4535         case 'H':
4536           usage (stdout);
4537           break;
4538
4539         case 'a':
4540           do_syms = TRUE;
4541           do_reloc = TRUE;
4542           do_unwind = TRUE;
4543           do_dynamic = TRUE;
4544           do_header = TRUE;
4545           do_sections = TRUE;
4546           do_section_groups = TRUE;
4547           do_segments = TRUE;
4548           do_version = TRUE;
4549           do_histogram = TRUE;
4550           do_arch = TRUE;
4551           do_notes = TRUE;
4552           break;
4553         case 'g':
4554           do_section_groups = TRUE;
4555           break;
4556         case 't':
4557         case 'N':
4558           do_sections = TRUE;
4559           do_section_details = TRUE;
4560           break;
4561         case 'e':
4562           do_header = TRUE;
4563           do_sections = TRUE;
4564           do_segments = TRUE;
4565           break;
4566         case 'A':
4567           do_arch = TRUE;
4568           break;
4569         case 'D':
4570           do_using_dynamic = TRUE;
4571           break;
4572         case 'r':
4573           do_reloc = TRUE;
4574           break;
4575         case 'u':
4576           do_unwind = TRUE;
4577           break;
4578         case 'h':
4579           do_header = TRUE;
4580           break;
4581         case 'l':
4582           do_segments = TRUE;
4583           break;
4584         case 's':
4585           do_syms = TRUE;
4586           break;
4587         case 'S':
4588           do_sections = TRUE;
4589           break;
4590         case 'd':
4591           do_dynamic = TRUE;
4592           break;
4593         case 'I':
4594           do_histogram = TRUE;
4595           break;
4596         case 'n':
4597           do_notes = TRUE;
4598           break;
4599         case 'c':
4600           do_archive_index = TRUE;
4601           break;
4602         case 'x':
4603           request_dump (filedata, HEX_DUMP);
4604           break;
4605         case 'p':
4606           request_dump (filedata, STRING_DUMP);
4607           break;
4608         case 'R':
4609           request_dump (filedata, RELOC_DUMP);
4610           break;
4611         case 'z':
4612           decompress_dumps = TRUE;
4613           break;
4614         case 'w':
4615           do_dump = TRUE;
4616           if (optarg == 0)
4617             {
4618               do_debugging = TRUE;
4619               dwarf_select_sections_all ();
4620             }
4621           else
4622             {
4623               do_debugging = FALSE;
4624               dwarf_select_sections_by_letters (optarg);
4625             }
4626           break;
4627         case OPTION_DEBUG_DUMP:
4628           do_dump = TRUE;
4629           if (optarg == 0)
4630             do_debugging = TRUE;
4631           else
4632             {
4633               do_debugging = FALSE;
4634               dwarf_select_sections_by_names (optarg);
4635             }
4636           break;
4637         case OPTION_DWARF_DEPTH:
4638           {
4639             char *cp;
4640
4641             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4642           }
4643           break;
4644         case OPTION_DWARF_START:
4645           {
4646             char *cp;
4647
4648             dwarf_start_die = strtoul (optarg, & cp, 0);
4649           }
4650           break;
4651         case OPTION_DWARF_CHECK:
4652           dwarf_check = TRUE;
4653           break;
4654         case OPTION_DYN_SYMS:
4655           do_dyn_syms = TRUE;
4656           break;
4657 #ifdef SUPPORT_DISASSEMBLY
4658         case 'i':
4659           request_dump (filedata, DISASS_DUMP);
4660           break;
4661 #endif
4662         case 'v':
4663           print_version (program_name);
4664           break;
4665         case 'V':
4666           do_version = TRUE;
4667           break;
4668         case 'W':
4669           do_wide = TRUE;
4670           break;
4671         default:
4672           /* xgettext:c-format */
4673           error (_("Invalid option '-%c'\n"), c);
4674           /* Fall through.  */
4675         case '?':
4676           usage (stderr);
4677         }
4678     }
4679
4680   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4681       && !do_segments && !do_header && !do_dump && !do_version
4682       && !do_histogram && !do_debugging && !do_arch && !do_notes
4683       && !do_section_groups && !do_archive_index
4684       && !do_dyn_syms)
4685     usage (stderr);
4686 }
4687
4688 static const char *
4689 get_elf_class (unsigned int elf_class)
4690 {
4691   static char buff[32];
4692
4693   switch (elf_class)
4694     {
4695     case ELFCLASSNONE: return _("none");
4696     case ELFCLASS32:   return "ELF32";
4697     case ELFCLASS64:   return "ELF64";
4698     default:
4699       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4700       return buff;
4701     }
4702 }
4703
4704 static const char *
4705 get_data_encoding (unsigned int encoding)
4706 {
4707   static char buff[32];
4708
4709   switch (encoding)
4710     {
4711     case ELFDATANONE: return _("none");
4712     case ELFDATA2LSB: return _("2's complement, little endian");
4713     case ELFDATA2MSB: return _("2's complement, big endian");
4714     default:
4715       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4716       return buff;
4717     }
4718 }
4719
4720 /* Decode the data held in 'filedata->file_header'.  */
4721
4722 static bfd_boolean
4723 process_file_header (Filedata * filedata)
4724 {
4725   Elf_Internal_Ehdr * header = & filedata->file_header;
4726
4727   if (   header->e_ident[EI_MAG0] != ELFMAG0
4728       || header->e_ident[EI_MAG1] != ELFMAG1
4729       || header->e_ident[EI_MAG2] != ELFMAG2
4730       || header->e_ident[EI_MAG3] != ELFMAG3)
4731     {
4732       error
4733         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4734       return FALSE;
4735     }
4736
4737   init_dwarf_regnames (header->e_machine);
4738
4739   if (do_header)
4740     {
4741       unsigned i;
4742
4743       printf (_("ELF Header:\n"));
4744       printf (_("  Magic:   "));
4745       for (i = 0; i < EI_NIDENT; i++)
4746         printf ("%2.2x ", header->e_ident[i]);
4747       printf ("\n");
4748       printf (_("  Class:                             %s\n"),
4749               get_elf_class (header->e_ident[EI_CLASS]));
4750       printf (_("  Data:                              %s\n"),
4751               get_data_encoding (header->e_ident[EI_DATA]));
4752       printf (_("  Version:                           %d %s\n"),
4753               header->e_ident[EI_VERSION],
4754               (header->e_ident[EI_VERSION] == EV_CURRENT
4755                ? "(current)"
4756                : (header->e_ident[EI_VERSION] != EV_NONE
4757                   ? _("<unknown: %lx>")
4758                   : "")));
4759       printf (_("  OS/ABI:                            %s\n"),
4760               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4761       printf (_("  ABI Version:                       %d\n"),
4762               header->e_ident[EI_ABIVERSION]);
4763       printf (_("  Type:                              %s\n"),
4764               get_file_type (header->e_type));
4765       printf (_("  Machine:                           %s\n"),
4766               get_machine_name (header->e_machine));
4767       printf (_("  Version:                           0x%lx\n"),
4768               (unsigned long) header->e_version);
4769
4770       printf (_("  Entry point address:               "));
4771       print_vma ((bfd_vma) header->e_entry, PREFIX_HEX);
4772       printf (_("\n  Start of program headers:          "));
4773       print_vma ((bfd_vma) header->e_phoff, DEC);
4774       printf (_(" (bytes into file)\n  Start of section headers:          "));
4775       print_vma ((bfd_vma) header->e_shoff, DEC);
4776       printf (_(" (bytes into file)\n"));
4777
4778       printf (_("  Flags:                             0x%lx%s\n"),
4779               (unsigned long) header->e_flags,
4780               get_machine_flags (filedata, header->e_flags, header->e_machine));
4781       printf (_("  Size of this header:               %ld (bytes)\n"),
4782               (long) header->e_ehsize);
4783       printf (_("  Size of program headers:           %ld (bytes)\n"),
4784               (long) header->e_phentsize);
4785       printf (_("  Number of program headers:         %ld"),
4786               (long) header->e_phnum);
4787       if (filedata->section_headers != NULL
4788           && header->e_phnum == PN_XNUM
4789           && filedata->section_headers[0].sh_info != 0)
4790         printf (" (%ld)", (long) filedata->section_headers[0].sh_info);
4791       putc ('\n', stdout);
4792       printf (_("  Size of section headers:           %ld (bytes)\n"),
4793               (long) header->e_shentsize);
4794       printf (_("  Number of section headers:         %ld"),
4795               (long) header->e_shnum);
4796       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4797         printf (" (%ld)", (long) filedata->section_headers[0].sh_size);
4798       putc ('\n', stdout);
4799       printf (_("  Section header string table index: %ld"),
4800               (long) header->e_shstrndx);
4801       if (filedata->section_headers != NULL
4802           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4803         printf (" (%u)", filedata->section_headers[0].sh_link);
4804       else if (header->e_shstrndx != SHN_UNDEF
4805                && header->e_shstrndx >= header->e_shnum)
4806         printf (_(" <corrupt: out of range>"));
4807       putc ('\n', stdout);
4808     }
4809
4810   if (filedata->section_headers != NULL)
4811     {
4812       if (header->e_phnum == PN_XNUM
4813           && filedata->section_headers[0].sh_info != 0)
4814         header->e_phnum = filedata->section_headers[0].sh_info;
4815       if (header->e_shnum == SHN_UNDEF)
4816         header->e_shnum = filedata->section_headers[0].sh_size;
4817       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4818         header->e_shstrndx = filedata->section_headers[0].sh_link;
4819       if (header->e_shstrndx >= header->e_shnum)
4820         header->e_shstrndx = SHN_UNDEF;
4821       free (filedata->section_headers);
4822       filedata->section_headers = NULL;
4823     }
4824
4825   return TRUE;
4826 }
4827
4828 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4829    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4830
4831 static bfd_boolean
4832 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4833 {
4834   Elf32_External_Phdr * phdrs;
4835   Elf32_External_Phdr * external;
4836   Elf_Internal_Phdr *   internal;
4837   unsigned int i;
4838   unsigned int size = filedata->file_header.e_phentsize;
4839   unsigned int num  = filedata->file_header.e_phnum;
4840
4841   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4842   if (size == 0 || num == 0)
4843     return FALSE;
4844   if (size < sizeof * phdrs)
4845     {
4846       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4847       return FALSE;
4848     }
4849   if (size > sizeof * phdrs)
4850     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4851
4852   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4853                                             size, num, _("program headers"));
4854   if (phdrs == NULL)
4855     return FALSE;
4856
4857   for (i = 0, internal = pheaders, external = phdrs;
4858        i < filedata->file_header.e_phnum;
4859        i++, internal++, external++)
4860     {
4861       internal->p_type   = BYTE_GET (external->p_type);
4862       internal->p_offset = BYTE_GET (external->p_offset);
4863       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4864       internal->p_paddr  = BYTE_GET (external->p_paddr);
4865       internal->p_filesz = BYTE_GET (external->p_filesz);
4866       internal->p_memsz  = BYTE_GET (external->p_memsz);
4867       internal->p_flags  = BYTE_GET (external->p_flags);
4868       internal->p_align  = BYTE_GET (external->p_align);
4869     }
4870
4871   free (phdrs);
4872   return TRUE;
4873 }
4874
4875 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4876    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4877
4878 static bfd_boolean
4879 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4880 {
4881   Elf64_External_Phdr * phdrs;
4882   Elf64_External_Phdr * external;
4883   Elf_Internal_Phdr *   internal;
4884   unsigned int i;
4885   unsigned int size = filedata->file_header.e_phentsize;
4886   unsigned int num  = filedata->file_header.e_phnum;
4887
4888   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4889   if (size == 0 || num == 0)
4890     return FALSE;
4891   if (size < sizeof * phdrs)
4892     {
4893       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4894       return FALSE;
4895     }
4896   if (size > sizeof * phdrs)
4897     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4898
4899   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4900                                             size, num, _("program headers"));
4901   if (!phdrs)
4902     return FALSE;
4903
4904   for (i = 0, internal = pheaders, external = phdrs;
4905        i < filedata->file_header.e_phnum;
4906        i++, internal++, external++)
4907     {
4908       internal->p_type   = BYTE_GET (external->p_type);
4909       internal->p_flags  = BYTE_GET (external->p_flags);
4910       internal->p_offset = BYTE_GET (external->p_offset);
4911       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4912       internal->p_paddr  = BYTE_GET (external->p_paddr);
4913       internal->p_filesz = BYTE_GET (external->p_filesz);
4914       internal->p_memsz  = BYTE_GET (external->p_memsz);
4915       internal->p_align  = BYTE_GET (external->p_align);
4916     }
4917
4918   free (phdrs);
4919   return TRUE;
4920 }
4921
4922 /* Returns TRUE if the program headers were read into `program_headers'.  */
4923
4924 static bfd_boolean
4925 get_program_headers (Filedata * filedata)
4926 {
4927   Elf_Internal_Phdr * phdrs;
4928
4929   /* Check cache of prior read.  */
4930   if (filedata->program_headers != NULL)
4931     return TRUE;
4932
4933   /* Be kind to memory checkers by looking for
4934      e_phnum values which we know must be invalid.  */
4935   if (filedata->file_header.e_phnum
4936       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4937       >= filedata->file_size)
4938     {
4939       error (_("Too many program headers - %#x - the file is not that big\n"),
4940              filedata->file_header.e_phnum);
4941       return FALSE;
4942     }
4943
4944   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4945                                          sizeof (Elf_Internal_Phdr));
4946   if (phdrs == NULL)
4947     {
4948       error (_("Out of memory reading %u program headers\n"),
4949              filedata->file_header.e_phnum);
4950       return FALSE;
4951     }
4952
4953   if (is_32bit_elf
4954       ? get_32bit_program_headers (filedata, phdrs)
4955       : get_64bit_program_headers (filedata, phdrs))
4956     {
4957       filedata->program_headers = phdrs;
4958       return TRUE;
4959     }
4960
4961   free (phdrs);
4962   return FALSE;
4963 }
4964
4965 /* Returns TRUE if the program headers were loaded.  */
4966
4967 static bfd_boolean
4968 process_program_headers (Filedata * filedata)
4969 {
4970   Elf_Internal_Phdr * segment;
4971   unsigned int i;
4972   Elf_Internal_Phdr * previous_load = NULL;
4973
4974   if (filedata->file_header.e_phnum == 0)
4975     {
4976       /* PR binutils/12467.  */
4977       if (filedata->file_header.e_phoff != 0)
4978         {
4979           warn (_("possibly corrupt ELF header - it has a non-zero program"
4980                   " header offset, but no program headers\n"));
4981           return FALSE;
4982         }
4983       else if (do_segments)
4984         printf (_("\nThere are no program headers in this file.\n"));
4985       return TRUE;
4986     }
4987
4988   if (do_segments && !do_header)
4989     {
4990       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
4991       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
4992       printf (ngettext ("There is %d program header, starting at offset %s\n",
4993                         "There are %d program headers, starting at offset %s\n",
4994                         filedata->file_header.e_phnum),
4995               filedata->file_header.e_phnum,
4996               bfd_vmatoa ("u", filedata->file_header.e_phoff));
4997     }
4998
4999   if (! get_program_headers (filedata))
5000     return TRUE;
5001
5002   if (do_segments)
5003     {
5004       if (filedata->file_header.e_phnum > 1)
5005         printf (_("\nProgram Headers:\n"));
5006       else
5007         printf (_("\nProgram Headers:\n"));
5008
5009       if (is_32bit_elf)
5010         printf
5011           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
5012       else if (do_wide)
5013         printf
5014           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
5015       else
5016         {
5017           printf
5018             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
5019           printf
5020             (_("                 FileSiz            MemSiz              Flags  Align\n"));
5021         }
5022     }
5023
5024   dynamic_addr = 0;
5025   dynamic_size = 0;
5026
5027   for (i = 0, segment = filedata->program_headers;
5028        i < filedata->file_header.e_phnum;
5029        i++, segment++)
5030     {
5031       if (do_segments)
5032         {
5033           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
5034
5035           if (is_32bit_elf)
5036             {
5037               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5038               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5039               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5040               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5041               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5042               printf ("%c%c%c ",
5043                       (segment->p_flags & PF_R ? 'R' : ' '),
5044                       (segment->p_flags & PF_W ? 'W' : ' '),
5045                       (segment->p_flags & PF_X ? 'E' : ' '));
5046               printf ("%#lx", (unsigned long) segment->p_align);
5047             }
5048           else if (do_wide)
5049             {
5050               if ((unsigned long) segment->p_offset == segment->p_offset)
5051                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5052               else
5053                 {
5054                   print_vma (segment->p_offset, FULL_HEX);
5055                   putchar (' ');
5056                 }
5057
5058               print_vma (segment->p_vaddr, FULL_HEX);
5059               putchar (' ');
5060               print_vma (segment->p_paddr, FULL_HEX);
5061               putchar (' ');
5062
5063               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5064                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5065               else
5066                 {
5067                   print_vma (segment->p_filesz, FULL_HEX);
5068                   putchar (' ');
5069                 }
5070
5071               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5072                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5073               else
5074                 {
5075                   print_vma (segment->p_memsz, FULL_HEX);
5076                 }
5077
5078               printf (" %c%c%c ",
5079                       (segment->p_flags & PF_R ? 'R' : ' '),
5080                       (segment->p_flags & PF_W ? 'W' : ' '),
5081                       (segment->p_flags & PF_X ? 'E' : ' '));
5082
5083               if ((unsigned long) segment->p_align == segment->p_align)
5084                 printf ("%#lx", (unsigned long) segment->p_align);
5085               else
5086                 {
5087                   print_vma (segment->p_align, PREFIX_HEX);
5088                 }
5089             }
5090           else
5091             {
5092               print_vma (segment->p_offset, FULL_HEX);
5093               putchar (' ');
5094               print_vma (segment->p_vaddr, FULL_HEX);
5095               putchar (' ');
5096               print_vma (segment->p_paddr, FULL_HEX);
5097               printf ("\n                 ");
5098               print_vma (segment->p_filesz, FULL_HEX);
5099               putchar (' ');
5100               print_vma (segment->p_memsz, FULL_HEX);
5101               printf ("  %c%c%c    ",
5102                       (segment->p_flags & PF_R ? 'R' : ' '),
5103                       (segment->p_flags & PF_W ? 'W' : ' '),
5104                       (segment->p_flags & PF_X ? 'E' : ' '));
5105               print_vma (segment->p_align, PREFIX_HEX);
5106             }
5107
5108           putc ('\n', stdout);
5109         }
5110
5111       switch (segment->p_type)
5112         {
5113         case PT_LOAD:
5114 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5115          required by the ELF standard, several programs, including the Linux
5116          kernel, make use of non-ordered segments.  */
5117           if (previous_load
5118               && previous_load->p_vaddr > segment->p_vaddr)
5119             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5120 #endif
5121           if (segment->p_memsz < segment->p_filesz)
5122             error (_("the segment's file size is larger than its memory size\n"));
5123           previous_load = segment;
5124           break;
5125
5126         case PT_PHDR:
5127           /* PR 20815 - Verify that the program header is loaded into memory.  */
5128           if (i > 0 && previous_load != NULL)
5129             error (_("the PHDR segment must occur before any LOAD segment\n"));
5130           if (filedata->file_header.e_machine != EM_PARISC)
5131             {
5132               unsigned int j;
5133
5134               for (j = 1; j < filedata->file_header.e_phnum; j++)
5135                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5136                     && (filedata->program_headers[j].p_vaddr
5137                         + filedata->program_headers[j].p_memsz)
5138                     >= (segment->p_vaddr + segment->p_filesz))
5139                   break;
5140               if (j == filedata->file_header.e_phnum)
5141                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5142             }
5143           break;
5144
5145         case PT_DYNAMIC:
5146           if (dynamic_addr)
5147             error (_("more than one dynamic segment\n"));
5148
5149           /* By default, assume that the .dynamic section is the first
5150              section in the DYNAMIC segment.  */
5151           dynamic_addr = segment->p_offset;
5152           dynamic_size = segment->p_filesz;
5153
5154           /* Try to locate the .dynamic section. If there is
5155              a section header table, we can easily locate it.  */
5156           if (filedata->section_headers != NULL)
5157             {
5158               Elf_Internal_Shdr * sec;
5159
5160               sec = find_section (filedata, ".dynamic");
5161               if (sec == NULL || sec->sh_size == 0)
5162                 {
5163                   /* A corresponding .dynamic section is expected, but on
5164                      IA-64/OpenVMS it is OK for it to be missing.  */
5165                   if (!is_ia64_vms (filedata))
5166                     error (_("no .dynamic section in the dynamic segment\n"));
5167                   break;
5168                 }
5169
5170               if (sec->sh_type == SHT_NOBITS)
5171                 {
5172                   dynamic_size = 0;
5173                   break;
5174                 }
5175
5176               dynamic_addr = sec->sh_offset;
5177               dynamic_size = sec->sh_size;
5178
5179               if (dynamic_addr < segment->p_offset
5180                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5181                 warn (_("the .dynamic section is not contained"
5182                         " within the dynamic segment\n"));
5183               else if (dynamic_addr > segment->p_offset)
5184                 warn (_("the .dynamic section is not the first section"
5185                         " in the dynamic segment.\n"));
5186             }
5187
5188           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5189              segment.  Check this after matching against the section headers
5190              so we don't warn on debuginfo file (which have NOBITS .dynamic
5191              sections).  */
5192           if (dynamic_addr + dynamic_size >= filedata->file_size)
5193             {
5194               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5195               dynamic_addr = dynamic_size = 0;
5196             }
5197           break;
5198
5199         case PT_INTERP:
5200           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5201                      SEEK_SET))
5202             error (_("Unable to find program interpreter name\n"));
5203           else
5204             {
5205               char fmt [32];
5206               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5207
5208               if (ret >= (int) sizeof (fmt) || ret < 0)
5209                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5210
5211               program_interpreter[0] = 0;
5212               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5213                 error (_("Unable to read program interpreter name\n"));
5214
5215               if (do_segments)
5216                 printf (_("      [Requesting program interpreter: %s]\n"),
5217                     program_interpreter);
5218             }
5219           break;
5220         }
5221     }
5222
5223   if (do_segments
5224       && filedata->section_headers != NULL
5225       && filedata->string_table != NULL)
5226     {
5227       printf (_("\n Section to Segment mapping:\n"));
5228       printf (_("  Segment Sections...\n"));
5229
5230       for (i = 0; i < filedata->file_header.e_phnum; i++)
5231         {
5232           unsigned int j;
5233           Elf_Internal_Shdr * section;
5234
5235           segment = filedata->program_headers + i;
5236           section = filedata->section_headers + 1;
5237
5238           printf ("   %2.2d     ", i);
5239
5240           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5241             {
5242               if (!ELF_TBSS_SPECIAL (section, segment)
5243                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5244                 printf ("%s ", printable_section_name (filedata, section));
5245             }
5246
5247           putc ('\n',stdout);
5248         }
5249     }
5250
5251   return TRUE;
5252 }
5253
5254
5255 /* Find the file offset corresponding to VMA by using the program headers.  */
5256
5257 static long
5258 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5259 {
5260   Elf_Internal_Phdr * seg;
5261
5262   if (! get_program_headers (filedata))
5263     {
5264       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5265       return (long) vma;
5266     }
5267
5268   for (seg = filedata->program_headers;
5269        seg < filedata->program_headers + filedata->file_header.e_phnum;
5270        ++seg)
5271     {
5272       if (seg->p_type != PT_LOAD)
5273         continue;
5274
5275       if (vma >= (seg->p_vaddr & -seg->p_align)
5276           && vma + size <= seg->p_vaddr + seg->p_filesz)
5277         return vma - seg->p_vaddr + seg->p_offset;
5278     }
5279
5280   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5281         (unsigned long) vma);
5282   return (long) vma;
5283 }
5284
5285
5286 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5287    If PROBE is true, this is just a probe and we do not generate any error
5288    messages if the load fails.  */
5289
5290 static bfd_boolean
5291 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5292 {
5293   Elf32_External_Shdr * shdrs;
5294   Elf_Internal_Shdr *   internal;
5295   unsigned int          i;
5296   unsigned int          size = filedata->file_header.e_shentsize;
5297   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5298
5299   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5300   if (size == 0 || num == 0)
5301     return FALSE;
5302   if (size < sizeof * shdrs)
5303     {
5304       if (! probe)
5305         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5306       return FALSE;
5307     }
5308   if (!probe && size > sizeof * shdrs)
5309     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5310
5311   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5312                                             size, num,
5313                                             probe ? NULL : _("section headers"));
5314   if (shdrs == NULL)
5315     return FALSE;
5316
5317   free (filedata->section_headers);
5318   filedata->section_headers = (Elf_Internal_Shdr *)
5319     cmalloc (num, sizeof (Elf_Internal_Shdr));
5320   if (filedata->section_headers == NULL)
5321     {
5322       if (!probe)
5323         error (_("Out of memory reading %u section headers\n"), num);
5324       return FALSE;
5325     }
5326
5327   for (i = 0, internal = filedata->section_headers;
5328        i < num;
5329        i++, internal++)
5330     {
5331       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5332       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5333       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5334       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5335       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5336       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5337       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5338       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5339       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5340       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5341       if (!probe && internal->sh_link > num)
5342         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5343       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5344         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5345     }
5346
5347   free (shdrs);
5348   return TRUE;
5349 }
5350
5351 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5352
5353 static bfd_boolean
5354 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5355 {
5356   Elf64_External_Shdr *  shdrs;
5357   Elf_Internal_Shdr *    internal;
5358   unsigned int           i;
5359   unsigned int           size = filedata->file_header.e_shentsize;
5360   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5361
5362   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5363   if (size == 0 || num == 0)
5364     return FALSE;
5365
5366   if (size < sizeof * shdrs)
5367     {
5368       if (! probe)
5369         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5370       return FALSE;
5371     }
5372
5373   if (! probe && size > sizeof * shdrs)
5374     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5375
5376   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5377                                             filedata->file_header.e_shoff,
5378                                             size, num,
5379                                             probe ? NULL : _("section headers"));
5380   if (shdrs == NULL)
5381     return FALSE;
5382
5383   free (filedata->section_headers);
5384   filedata->section_headers = (Elf_Internal_Shdr *)
5385     cmalloc (num, sizeof (Elf_Internal_Shdr));
5386   if (filedata->section_headers == NULL)
5387     {
5388       if (! probe)
5389         error (_("Out of memory reading %u section headers\n"), num);
5390       return FALSE;
5391     }
5392
5393   for (i = 0, internal = filedata->section_headers;
5394        i < num;
5395        i++, internal++)
5396     {
5397       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5398       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5399       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5400       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5401       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5402       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5403       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5404       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5405       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5406       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5407       if (!probe && internal->sh_link > num)
5408         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5409       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5410         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5411     }
5412
5413   free (shdrs);
5414   return TRUE;
5415 }
5416
5417 static Elf_Internal_Sym *
5418 get_32bit_elf_symbols (Filedata *           filedata,
5419                        Elf_Internal_Shdr *  section,
5420                        unsigned long *      num_syms_return)
5421 {
5422   unsigned long number = 0;
5423   Elf32_External_Sym * esyms = NULL;
5424   Elf_External_Sym_Shndx * shndx = NULL;
5425   Elf_Internal_Sym * isyms = NULL;
5426   Elf_Internal_Sym * psym;
5427   unsigned int j;
5428
5429   if (section->sh_size == 0)
5430     {
5431       if (num_syms_return != NULL)
5432         * num_syms_return = 0;
5433       return NULL;
5434     }
5435
5436   /* Run some sanity checks first.  */
5437   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5438     {
5439       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5440              printable_section_name (filedata, section),
5441              (unsigned long) section->sh_entsize);
5442       goto exit_point;
5443     }
5444
5445   if (section->sh_size > filedata->file_size)
5446     {
5447       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5448              printable_section_name (filedata, section),
5449              (unsigned long) section->sh_size);
5450       goto exit_point;
5451     }
5452
5453   number = section->sh_size / section->sh_entsize;
5454
5455   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5456     {
5457       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5458              (unsigned long) section->sh_size,
5459              printable_section_name (filedata, section),
5460              (unsigned long) section->sh_entsize);
5461       goto exit_point;
5462     }
5463
5464   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5465                                            section->sh_size, _("symbols"));
5466   if (esyms == NULL)
5467     goto exit_point;
5468
5469   {
5470     elf_section_list * entry;
5471
5472     shndx = NULL;
5473     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5474       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5475         {
5476           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5477                                                        entry->hdr->sh_offset,
5478                                                        1, entry->hdr->sh_size,
5479                                                        _("symbol table section indicies"));
5480           if (shndx == NULL)
5481             goto exit_point;
5482           /* PR17531: file: heap-buffer-overflow */
5483           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5484             {
5485               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5486                      printable_section_name (filedata, entry->hdr),
5487                      (unsigned long) entry->hdr->sh_size,
5488                      (unsigned long) section->sh_size);
5489               goto exit_point;
5490             }
5491         }
5492   }
5493
5494   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5495
5496   if (isyms == NULL)
5497     {
5498       error (_("Out of memory reading %lu symbols\n"),
5499              (unsigned long) number);
5500       goto exit_point;
5501     }
5502
5503   for (j = 0, psym = isyms; j < number; j++, psym++)
5504     {
5505       psym->st_name  = BYTE_GET (esyms[j].st_name);
5506       psym->st_value = BYTE_GET (esyms[j].st_value);
5507       psym->st_size  = BYTE_GET (esyms[j].st_size);
5508       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5509       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5510         psym->st_shndx
5511           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5512       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5513         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5514       psym->st_info  = BYTE_GET (esyms[j].st_info);
5515       psym->st_other = BYTE_GET (esyms[j].st_other);
5516     }
5517
5518  exit_point:
5519   if (shndx != NULL)
5520     free (shndx);
5521   if (esyms != NULL)
5522     free (esyms);
5523
5524   if (num_syms_return != NULL)
5525     * num_syms_return = isyms == NULL ? 0 : number;
5526
5527   return isyms;
5528 }
5529
5530 static Elf_Internal_Sym *
5531 get_64bit_elf_symbols (Filedata *           filedata,
5532                        Elf_Internal_Shdr *  section,
5533                        unsigned long *      num_syms_return)
5534 {
5535   unsigned long number = 0;
5536   Elf64_External_Sym * esyms = NULL;
5537   Elf_External_Sym_Shndx * shndx = NULL;
5538   Elf_Internal_Sym * isyms = NULL;
5539   Elf_Internal_Sym * psym;
5540   unsigned int j;
5541
5542   if (section->sh_size == 0)
5543     {
5544       if (num_syms_return != NULL)
5545         * num_syms_return = 0;
5546       return NULL;
5547     }
5548
5549   /* Run some sanity checks first.  */
5550   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5551     {
5552       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5553              printable_section_name (filedata, section),
5554              (unsigned long) section->sh_entsize);
5555       goto exit_point;
5556     }
5557
5558   if (section->sh_size > filedata->file_size)
5559     {
5560       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5561              printable_section_name (filedata, section),
5562              (unsigned long) section->sh_size);
5563       goto exit_point;
5564     }
5565
5566   number = section->sh_size / section->sh_entsize;
5567
5568   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5569     {
5570       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5571              (unsigned long) section->sh_size,
5572              printable_section_name (filedata, section),
5573              (unsigned long) section->sh_entsize);
5574       goto exit_point;
5575     }
5576
5577   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5578                                            section->sh_size, _("symbols"));
5579   if (!esyms)
5580     goto exit_point;
5581
5582   {
5583     elf_section_list * entry;
5584
5585     shndx = NULL;
5586     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5587       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5588         {
5589           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5590                                                        entry->hdr->sh_offset,
5591                                                        1, entry->hdr->sh_size,
5592                                                        _("symbol table section indicies"));
5593           if (shndx == NULL)
5594             goto exit_point;
5595           /* PR17531: file: heap-buffer-overflow */
5596           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5597             {
5598               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5599                      printable_section_name (filedata, entry->hdr),
5600                      (unsigned long) entry->hdr->sh_size,
5601                      (unsigned long) section->sh_size);
5602               goto exit_point;
5603             }
5604         }
5605   }
5606
5607   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5608
5609   if (isyms == NULL)
5610     {
5611       error (_("Out of memory reading %lu symbols\n"),
5612              (unsigned long) number);
5613       goto exit_point;
5614     }
5615
5616   for (j = 0, psym = isyms; j < number; j++, psym++)
5617     {
5618       psym->st_name  = BYTE_GET (esyms[j].st_name);
5619       psym->st_info  = BYTE_GET (esyms[j].st_info);
5620       psym->st_other = BYTE_GET (esyms[j].st_other);
5621       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5622
5623       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5624         psym->st_shndx
5625           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5626       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5627         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5628
5629       psym->st_value = BYTE_GET (esyms[j].st_value);
5630       psym->st_size  = BYTE_GET (esyms[j].st_size);
5631     }
5632
5633  exit_point:
5634   if (shndx != NULL)
5635     free (shndx);
5636   if (esyms != NULL)
5637     free (esyms);
5638
5639   if (num_syms_return != NULL)
5640     * num_syms_return = isyms == NULL ? 0 : number;
5641
5642   return isyms;
5643 }
5644
5645 static const char *
5646 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5647 {
5648   static char buff[1024];
5649   char * p = buff;
5650   unsigned int field_size = is_32bit_elf ? 8 : 16;
5651   signed int sindex;
5652   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5653   bfd_vma os_flags = 0;
5654   bfd_vma proc_flags = 0;
5655   bfd_vma unknown_flags = 0;
5656   static const struct
5657     {
5658       const char * str;
5659       unsigned int len;
5660     }
5661   flags [] =
5662     {
5663       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5664       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5665       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5666       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5667       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5668       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5669       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5670       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5671       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5672       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5673       /* IA-64 specific.  */
5674       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5675       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5676       /* IA-64 OpenVMS specific.  */
5677       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5678       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5679       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5680       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5681       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5682       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5683       /* Generic.  */
5684       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5685       /* SPARC specific.  */
5686       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5687       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5688       /* ARM specific.  */
5689       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5690       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5691       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5692       /* GNU specific.  */
5693       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5694       /* VLE specific.  */
5695       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5696     };
5697
5698   if (do_section_details)
5699     {
5700       sprintf (buff, "[%*.*lx]: ",
5701                field_size, field_size, (unsigned long) sh_flags);
5702       p += field_size + 4;
5703     }
5704
5705   while (sh_flags)
5706     {
5707       bfd_vma flag;
5708
5709       flag = sh_flags & - sh_flags;
5710       sh_flags &= ~ flag;
5711
5712       if (do_section_details)
5713         {
5714           switch (flag)
5715             {
5716             case SHF_WRITE:             sindex = 0; break;
5717             case SHF_ALLOC:             sindex = 1; break;
5718             case SHF_EXECINSTR:         sindex = 2; break;
5719             case SHF_MERGE:             sindex = 3; break;
5720             case SHF_STRINGS:           sindex = 4; break;
5721             case SHF_INFO_LINK:         sindex = 5; break;
5722             case SHF_LINK_ORDER:        sindex = 6; break;
5723             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5724             case SHF_GROUP:             sindex = 8; break;
5725             case SHF_TLS:               sindex = 9; break;
5726             case SHF_EXCLUDE:           sindex = 18; break;
5727             case SHF_COMPRESSED:        sindex = 20; break;
5728             case SHF_GNU_MBIND:         sindex = 24; break;
5729
5730             default:
5731               sindex = -1;
5732               switch (filedata->file_header.e_machine)
5733                 {
5734                 case EM_IA_64:
5735                   if (flag == SHF_IA_64_SHORT)
5736                     sindex = 10;
5737                   else if (flag == SHF_IA_64_NORECOV)
5738                     sindex = 11;
5739 #ifdef BFD64
5740                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5741                     switch (flag)
5742                       {
5743                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5744                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5745                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5746                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5747                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5748                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5749                       default:                        break;
5750                       }
5751 #endif
5752                   break;
5753
5754                 case EM_386:
5755                 case EM_IAMCU:
5756                 case EM_X86_64:
5757                 case EM_L1OM:
5758                 case EM_K1OM:
5759                 case EM_OLD_SPARCV9:
5760                 case EM_SPARC32PLUS:
5761                 case EM_SPARCV9:
5762                 case EM_SPARC:
5763                   if (flag == SHF_ORDERED)
5764                     sindex = 19;
5765                   break;
5766
5767                 case EM_ARM:
5768                   switch (flag)
5769                     {
5770                     case SHF_ENTRYSECT: sindex = 21; break;
5771                     case SHF_ARM_PURECODE: sindex = 22; break;
5772                     case SHF_COMDEF: sindex = 23; break;
5773                     default: break;
5774                     }
5775                   break;
5776                 case EM_PPC:
5777                   if (flag == SHF_PPC_VLE)
5778                     sindex = 25;
5779                   break;
5780
5781                 default:
5782                   break;
5783                 }
5784             }
5785
5786           if (sindex != -1)
5787             {
5788               if (p != buff + field_size + 4)
5789                 {
5790                   if (size < (10 + 2))
5791                     {
5792                       warn (_("Internal error: not enough buffer room for section flag info"));
5793                       return _("<unknown>");
5794                     }
5795                   size -= 2;
5796                   *p++ = ',';
5797                   *p++ = ' ';
5798                 }
5799
5800               size -= flags [sindex].len;
5801               p = stpcpy (p, flags [sindex].str);
5802             }
5803           else if (flag & SHF_MASKOS)
5804             os_flags |= flag;
5805           else if (flag & SHF_MASKPROC)
5806             proc_flags |= flag;
5807           else
5808             unknown_flags |= flag;
5809         }
5810       else
5811         {
5812           switch (flag)
5813             {
5814             case SHF_WRITE:             *p = 'W'; break;
5815             case SHF_ALLOC:             *p = 'A'; break;
5816             case SHF_EXECINSTR:         *p = 'X'; break;
5817             case SHF_MERGE:             *p = 'M'; break;
5818             case SHF_STRINGS:           *p = 'S'; break;
5819             case SHF_INFO_LINK:         *p = 'I'; break;
5820             case SHF_LINK_ORDER:        *p = 'L'; break;
5821             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5822             case SHF_GROUP:             *p = 'G'; break;
5823             case SHF_TLS:               *p = 'T'; break;
5824             case SHF_EXCLUDE:           *p = 'E'; break;
5825             case SHF_COMPRESSED:        *p = 'C'; break;
5826             case SHF_GNU_MBIND:         *p = 'D'; break;
5827
5828             default:
5829               if ((filedata->file_header.e_machine == EM_X86_64
5830                    || filedata->file_header.e_machine == EM_L1OM
5831                    || filedata->file_header.e_machine == EM_K1OM)
5832                   && flag == SHF_X86_64_LARGE)
5833                 *p = 'l';
5834               else if (filedata->file_header.e_machine == EM_ARM
5835                        && flag == SHF_ARM_PURECODE)
5836                   *p = 'y';
5837               else if (filedata->file_header.e_machine == EM_PPC
5838                        && flag == SHF_PPC_VLE)
5839                   *p = 'v';
5840               else if (flag & SHF_MASKOS)
5841                 {
5842                   *p = 'o';
5843                   sh_flags &= ~ SHF_MASKOS;
5844                 }
5845               else if (flag & SHF_MASKPROC)
5846                 {
5847                   *p = 'p';
5848                   sh_flags &= ~ SHF_MASKPROC;
5849                 }
5850               else
5851                 *p = 'x';
5852               break;
5853             }
5854           p++;
5855         }
5856     }
5857
5858   if (do_section_details)
5859     {
5860       if (os_flags)
5861         {
5862           size -= 5 + field_size;
5863           if (p != buff + field_size + 4)
5864             {
5865               if (size < (2 + 1))
5866                 {
5867                   warn (_("Internal error: not enough buffer room for section flag info"));
5868                   return _("<unknown>");
5869                 }
5870               size -= 2;
5871               *p++ = ',';
5872               *p++ = ' ';
5873             }
5874           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5875                    (unsigned long) os_flags);
5876           p += 5 + field_size;
5877         }
5878       if (proc_flags)
5879         {
5880           size -= 7 + field_size;
5881           if (p != buff + field_size + 4)
5882             {
5883               if (size < (2 + 1))
5884                 {
5885                   warn (_("Internal error: not enough buffer room for section flag info"));
5886                   return _("<unknown>");
5887                 }
5888               size -= 2;
5889               *p++ = ',';
5890               *p++ = ' ';
5891             }
5892           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5893                    (unsigned long) proc_flags);
5894           p += 7 + field_size;
5895         }
5896       if (unknown_flags)
5897         {
5898           size -= 10 + field_size;
5899           if (p != buff + field_size + 4)
5900             {
5901               if (size < (2 + 1))
5902                 {
5903                   warn (_("Internal error: not enough buffer room for section flag info"));
5904                   return _("<unknown>");
5905                 }
5906               size -= 2;
5907               *p++ = ',';
5908               *p++ = ' ';
5909             }
5910           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5911                    (unsigned long) unknown_flags);
5912           p += 10 + field_size;
5913         }
5914     }
5915
5916   *p = '\0';
5917   return buff;
5918 }
5919
5920 static unsigned int
5921 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5922 {
5923   if (is_32bit_elf)
5924     {
5925       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5926
5927       if (size < sizeof (* echdr))
5928         {
5929           error (_("Compressed section is too small even for a compression header\n"));
5930           return 0;
5931         }
5932
5933       chdr->ch_type = BYTE_GET (echdr->ch_type);
5934       chdr->ch_size = BYTE_GET (echdr->ch_size);
5935       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5936       return sizeof (*echdr);
5937     }
5938   else
5939     {
5940       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5941
5942       if (size < sizeof (* echdr))
5943         {
5944           error (_("Compressed section is too small even for a compression header\n"));
5945           return 0;
5946         }
5947
5948       chdr->ch_type = BYTE_GET (echdr->ch_type);
5949       chdr->ch_size = BYTE_GET (echdr->ch_size);
5950       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5951       return sizeof (*echdr);
5952     }
5953 }
5954
5955 static bfd_boolean
5956 process_section_headers (Filedata * filedata)
5957 {
5958   Elf_Internal_Shdr * section;
5959   unsigned int i;
5960
5961   filedata->section_headers = NULL;
5962
5963   if (filedata->file_header.e_shnum == 0)
5964     {
5965       /* PR binutils/12467.  */
5966       if (filedata->file_header.e_shoff != 0)
5967         {
5968           warn (_("possibly corrupt ELF file header - it has a non-zero"
5969                   " section header offset, but no section headers\n"));
5970           return FALSE;
5971         }
5972       else if (do_sections)
5973         printf (_("\nThere are no sections in this file.\n"));
5974
5975       return TRUE;
5976     }
5977
5978   if (do_sections && !do_header)
5979     printf (ngettext ("There is %d section header, "
5980                       "starting at offset 0x%lx:\n",
5981                       "There are %d section headers, "
5982                       "starting at offset 0x%lx:\n",
5983                       filedata->file_header.e_shnum),
5984             filedata->file_header.e_shnum,
5985             (unsigned long) filedata->file_header.e_shoff);
5986
5987   if (is_32bit_elf)
5988     {
5989       if (! get_32bit_section_headers (filedata, FALSE))
5990         return FALSE;
5991     }
5992   else
5993     {
5994       if (! get_64bit_section_headers (filedata, FALSE))
5995         return FALSE;
5996     }
5997
5998   /* Read in the string table, so that we have names to display.  */
5999   if (filedata->file_header.e_shstrndx != SHN_UNDEF
6000        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6001     {
6002       section = filedata->section_headers + filedata->file_header.e_shstrndx;
6003
6004       if (section->sh_size != 0)
6005         {
6006           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6007                                                       1, section->sh_size,
6008                                                       _("string table"));
6009
6010           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6011         }
6012     }
6013
6014   /* Scan the sections for the dynamic symbol table
6015      and dynamic string table and debug sections.  */
6016   dynamic_symbols = NULL;
6017   dynamic_strings = NULL;
6018   dynamic_syminfo = NULL;
6019   symtab_shndx_list = NULL;
6020
6021   eh_addr_size = is_32bit_elf ? 4 : 8;
6022   switch (filedata->file_header.e_machine)
6023     {
6024     case EM_MIPS:
6025     case EM_MIPS_RS3_LE:
6026       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6027          FDE addresses.  However, the ABI also has a semi-official ILP32
6028          variant for which the normal FDE address size rules apply.
6029
6030          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6031          section, where XX is the size of longs in bits.  Unfortunately,
6032          earlier compilers provided no way of distinguishing ILP32 objects
6033          from LP64 objects, so if there's any doubt, we should assume that
6034          the official LP64 form is being used.  */
6035       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6036           && find_section (filedata, ".gcc_compiled_long32") == NULL)
6037         eh_addr_size = 8;
6038       break;
6039
6040     case EM_H8_300:
6041     case EM_H8_300H:
6042       switch (filedata->file_header.e_flags & EF_H8_MACH)
6043         {
6044         case E_H8_MACH_H8300:
6045         case E_H8_MACH_H8300HN:
6046         case E_H8_MACH_H8300SN:
6047         case E_H8_MACH_H8300SXN:
6048           eh_addr_size = 2;
6049           break;
6050         case E_H8_MACH_H8300H:
6051         case E_H8_MACH_H8300S:
6052         case E_H8_MACH_H8300SX:
6053           eh_addr_size = 4;
6054           break;
6055         }
6056       break;
6057
6058     case EM_M32C_OLD:
6059     case EM_M32C:
6060       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6061         {
6062         case EF_M32C_CPU_M16C:
6063           eh_addr_size = 2;
6064           break;
6065         }
6066       break;
6067     }
6068
6069 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6070   do                                                                    \
6071     {                                                                   \
6072       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6073       if (section->sh_entsize != expected_entsize)                      \
6074         {                                                               \
6075           char buf[40];                                                 \
6076           sprintf_vma (buf, section->sh_entsize);                       \
6077           /* Note: coded this way so that there is a single string for  \
6078              translation.  */ \
6079           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6080           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6081                    (unsigned) expected_entsize);                        \
6082           section->sh_entsize = expected_entsize;                       \
6083         }                                                               \
6084     }                                                                   \
6085   while (0)
6086
6087 #define CHECK_ENTSIZE(section, i, type)                                 \
6088   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6089                         sizeof (Elf64_External_##type))
6090
6091   for (i = 0, section = filedata->section_headers;
6092        i < filedata->file_header.e_shnum;
6093        i++, section++)
6094     {
6095       char * name = SECTION_NAME (section);
6096
6097       if (section->sh_type == SHT_DYNSYM)
6098         {
6099           if (dynamic_symbols != NULL)
6100             {
6101               error (_("File contains multiple dynamic symbol tables\n"));
6102               continue;
6103             }
6104
6105           CHECK_ENTSIZE (section, i, Sym);
6106           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6107         }
6108       else if (section->sh_type == SHT_STRTAB
6109                && streq (name, ".dynstr"))
6110         {
6111           if (dynamic_strings != NULL)
6112             {
6113               error (_("File contains multiple dynamic string tables\n"));
6114               continue;
6115             }
6116
6117           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6118                                                1, section->sh_size,
6119                                                _("dynamic strings"));
6120           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6121         }
6122       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6123         {
6124           elf_section_list * entry = xmalloc (sizeof * entry);
6125
6126           entry->hdr = section;
6127           entry->next = symtab_shndx_list;
6128           symtab_shndx_list = entry;
6129         }
6130       else if (section->sh_type == SHT_SYMTAB)
6131         CHECK_ENTSIZE (section, i, Sym);
6132       else if (section->sh_type == SHT_GROUP)
6133         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6134       else if (section->sh_type == SHT_REL)
6135         CHECK_ENTSIZE (section, i, Rel);
6136       else if (section->sh_type == SHT_RELA)
6137         CHECK_ENTSIZE (section, i, Rela);
6138       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6139                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6140                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6141                 || do_debug_str || do_debug_loc || do_debug_ranges
6142                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6143                && (const_strneq (name, ".debug_")
6144                    || const_strneq (name, ".zdebug_")))
6145         {
6146           if (name[1] == 'z')
6147             name += sizeof (".zdebug_") - 1;
6148           else
6149             name += sizeof (".debug_") - 1;
6150
6151           if (do_debugging
6152               || (do_debug_info     && const_strneq (name, "info"))
6153               || (do_debug_info     && const_strneq (name, "types"))
6154               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6155               || (do_debug_lines    && strcmp (name, "line") == 0)
6156               || (do_debug_lines    && const_strneq (name, "line."))
6157               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6158               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6159               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6160               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6161               || (do_debug_aranges  && const_strneq (name, "aranges"))
6162               || (do_debug_ranges   && const_strneq (name, "ranges"))
6163               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6164               || (do_debug_frames   && const_strneq (name, "frame"))
6165               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6166               || (do_debug_macinfo  && const_strneq (name, "macro"))
6167               || (do_debug_str      && const_strneq (name, "str"))
6168               || (do_debug_loc      && const_strneq (name, "loc"))
6169               || (do_debug_loc      && const_strneq (name, "loclists"))
6170               || (do_debug_addr     && const_strneq (name, "addr"))
6171               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6172               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6173               )
6174             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6175         }
6176       /* Linkonce section to be combined with .debug_info at link time.  */
6177       else if ((do_debugging || do_debug_info)
6178                && const_strneq (name, ".gnu.linkonce.wi."))
6179         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6180       else if (do_debug_frames && streq (name, ".eh_frame"))
6181         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6182       else if (do_gdb_index && (streq (name, ".gdb_index")
6183                                 || streq (name, ".debug_names")))
6184         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6185       /* Trace sections for Itanium VMS.  */
6186       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6187                 || do_trace_aranges)
6188                && const_strneq (name, ".trace_"))
6189         {
6190           name += sizeof (".trace_") - 1;
6191
6192           if (do_debugging
6193               || (do_trace_info     && streq (name, "info"))
6194               || (do_trace_abbrevs  && streq (name, "abbrev"))
6195               || (do_trace_aranges  && streq (name, "aranges"))
6196               )
6197             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6198         }
6199       else if ((do_debugging || do_debug_links)
6200                && (const_strneq (name, ".gnu_debuglink")
6201                    || const_strneq (name, ".gnu_debugaltlink")))
6202         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6203     }
6204
6205   if (! do_sections)
6206     return TRUE;
6207
6208   if (filedata->file_header.e_shnum > 1)
6209     printf (_("\nSection Headers:\n"));
6210   else
6211     printf (_("\nSection Header:\n"));
6212
6213   if (is_32bit_elf)
6214     {
6215       if (do_section_details)
6216         {
6217           printf (_("  [Nr] Name\n"));
6218           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6219         }
6220       else
6221         printf
6222           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6223     }
6224   else if (do_wide)
6225     {
6226       if (do_section_details)
6227         {
6228           printf (_("  [Nr] Name\n"));
6229           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6230         }
6231       else
6232         printf
6233           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6234     }
6235   else
6236     {
6237       if (do_section_details)
6238         {
6239           printf (_("  [Nr] Name\n"));
6240           printf (_("       Type              Address          Offset            Link\n"));
6241           printf (_("       Size              EntSize          Info              Align\n"));
6242         }
6243       else
6244         {
6245           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6246           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6247         }
6248     }
6249
6250   if (do_section_details)
6251     printf (_("       Flags\n"));
6252
6253   for (i = 0, section = filedata->section_headers;
6254        i < filedata->file_header.e_shnum;
6255        i++, section++)
6256     {
6257       /* Run some sanity checks on the section header.  */
6258
6259       /* Check the sh_link field.  */
6260       switch (section->sh_type)
6261         {
6262         case SHT_SYMTAB_SHNDX:
6263         case SHT_GROUP:
6264         case SHT_HASH:
6265         case SHT_GNU_HASH:
6266         case SHT_GNU_versym:
6267         case SHT_REL:
6268         case SHT_RELA:
6269           if (section->sh_link < 1
6270               || section->sh_link >= filedata->file_header.e_shnum
6271               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6272                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6273             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6274                   i, section->sh_link);
6275           break;
6276
6277         case SHT_DYNAMIC:
6278         case SHT_SYMTAB:
6279         case SHT_DYNSYM:
6280         case SHT_GNU_verneed:
6281         case SHT_GNU_verdef:
6282         case SHT_GNU_LIBLIST:
6283           if (section->sh_link < 1
6284               || section->sh_link >= filedata->file_header.e_shnum
6285               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6286             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6287                   i, section->sh_link);
6288           break;
6289
6290         case SHT_INIT_ARRAY:
6291         case SHT_FINI_ARRAY:
6292         case SHT_PREINIT_ARRAY:
6293           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6294             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6295                   i, section->sh_link);
6296           break;
6297
6298         default:
6299           /* FIXME: Add support for target specific section types.  */
6300 #if 0     /* Currently we do not check other section types as there are too
6301              many special cases.  Stab sections for example have a type
6302              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6303              section.  */
6304           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6305             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6306                   i, section->sh_link);
6307 #endif
6308           break;
6309         }
6310
6311       /* Check the sh_info field.  */
6312       switch (section->sh_type)
6313         {
6314         case SHT_REL:
6315         case SHT_RELA:
6316           if (section->sh_info < 1
6317               || section->sh_info >= filedata->file_header.e_shnum
6318               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6319                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6320                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6321                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6322                   /* FIXME: Are other section types valid ?  */
6323                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6324             {
6325               if (section->sh_info == 0
6326                   && (filedata->file_header.e_type == ET_EXEC
6327                       || filedata->file_header.e_type == ET_DYN
6328                       /* These next two tests may be redundant, but
6329                          they have been left in for paranoia's sake.  */
6330                       || streq (SECTION_NAME (section), ".rel.dyn")
6331                       || streq (SECTION_NAME (section), ".rela.dyn")))
6332                 /* Dynamic relocations apply to segments, not sections, so
6333                    they do not need an sh_info value.  */
6334                 ;
6335               else
6336                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6337                       i, section->sh_info);
6338             }
6339           break;
6340
6341         case SHT_DYNAMIC:
6342         case SHT_HASH:
6343         case SHT_SYMTAB_SHNDX:
6344         case SHT_INIT_ARRAY:
6345         case SHT_FINI_ARRAY:
6346         case SHT_PREINIT_ARRAY:
6347           if (section->sh_info != 0)
6348             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6349                   i, section->sh_info);
6350           break;
6351
6352         case SHT_GROUP:
6353         case SHT_SYMTAB:
6354         case SHT_DYNSYM:
6355           /* A symbol index - we assume that it is valid.  */
6356           break;
6357
6358         default:
6359           /* FIXME: Add support for target specific section types.  */
6360           if (section->sh_type == SHT_NOBITS)
6361             /* NOBITS section headers with non-zero sh_info fields can be
6362                created when a binary is stripped of everything but its debug
6363                information.  The stripped sections have their headers
6364                preserved but their types set to SHT_NOBITS.  So do not check
6365                this type of section.  */
6366             ;
6367           else if (section->sh_flags & SHF_INFO_LINK)
6368             {
6369               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6370                 warn (_("[%2u]: Expected link to another section in info field"), i);
6371             }
6372           else if (section->sh_type < SHT_LOOS
6373                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6374                    && section->sh_info != 0)
6375             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6376                   i, section->sh_info);
6377           break;
6378         }
6379
6380       /* Check the sh_size field.  */
6381       if (section->sh_size > filedata->file_size
6382           && section->sh_type != SHT_NOBITS
6383           && section->sh_type != SHT_NULL
6384           && section->sh_type < SHT_LOOS)
6385         warn (_("Size of section %u is larger than the entire file!\n"), i);
6386
6387       printf ("  [%2u] ", i);
6388       if (do_section_details)
6389         printf ("%s\n      ", printable_section_name (filedata, section));
6390       else
6391         print_symbol (-17, SECTION_NAME (section));
6392
6393       printf (do_wide ? " %-15s " : " %-15.15s ",
6394               get_section_type_name (filedata, section->sh_type));
6395
6396       if (is_32bit_elf)
6397         {
6398           const char * link_too_big = NULL;
6399
6400           print_vma (section->sh_addr, LONG_HEX);
6401
6402           printf ( " %6.6lx %6.6lx %2.2lx",
6403                    (unsigned long) section->sh_offset,
6404                    (unsigned long) section->sh_size,
6405                    (unsigned long) section->sh_entsize);
6406
6407           if (do_section_details)
6408             fputs ("  ", stdout);
6409           else
6410             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6411
6412           if (section->sh_link >= filedata->file_header.e_shnum)
6413             {
6414               link_too_big = "";
6415               /* The sh_link value is out of range.  Normally this indicates
6416                  an error but it can have special values in Solaris binaries.  */
6417               switch (filedata->file_header.e_machine)
6418                 {
6419                 case EM_386:
6420                 case EM_IAMCU:
6421                 case EM_X86_64:
6422                 case EM_L1OM:
6423                 case EM_K1OM:
6424                 case EM_OLD_SPARCV9:
6425                 case EM_SPARC32PLUS:
6426                 case EM_SPARCV9:
6427                 case EM_SPARC:
6428                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6429                     link_too_big = "BEFORE";
6430                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6431                     link_too_big = "AFTER";
6432                   break;
6433                 default:
6434                   break;
6435                 }
6436             }
6437
6438           if (do_section_details)
6439             {
6440               if (link_too_big != NULL && * link_too_big)
6441                 printf ("<%s> ", link_too_big);
6442               else
6443                 printf ("%2u ", section->sh_link);
6444               printf ("%3u %2lu\n", section->sh_info,
6445                       (unsigned long) section->sh_addralign);
6446             }
6447           else
6448             printf ("%2u %3u %2lu\n",
6449                     section->sh_link,
6450                     section->sh_info,
6451                     (unsigned long) section->sh_addralign);
6452
6453           if (link_too_big && ! * link_too_big)
6454             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6455                   i, section->sh_link);
6456         }
6457       else if (do_wide)
6458         {
6459           print_vma (section->sh_addr, LONG_HEX);
6460
6461           if ((long) section->sh_offset == section->sh_offset)
6462             printf (" %6.6lx", (unsigned long) section->sh_offset);
6463           else
6464             {
6465               putchar (' ');
6466               print_vma (section->sh_offset, LONG_HEX);
6467             }
6468
6469           if ((unsigned long) section->sh_size == section->sh_size)
6470             printf (" %6.6lx", (unsigned long) section->sh_size);
6471           else
6472             {
6473               putchar (' ');
6474               print_vma (section->sh_size, LONG_HEX);
6475             }
6476
6477           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6478             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6479           else
6480             {
6481               putchar (' ');
6482               print_vma (section->sh_entsize, LONG_HEX);
6483             }
6484
6485           if (do_section_details)
6486             fputs ("  ", stdout);
6487           else
6488             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6489
6490           printf ("%2u %3u ", section->sh_link, section->sh_info);
6491
6492           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6493             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6494           else
6495             {
6496               print_vma (section->sh_addralign, DEC);
6497               putchar ('\n');
6498             }
6499         }
6500       else if (do_section_details)
6501         {
6502           printf ("       %-15.15s  ",
6503                   get_section_type_name (filedata, section->sh_type));
6504           print_vma (section->sh_addr, LONG_HEX);
6505           if ((long) section->sh_offset == section->sh_offset)
6506             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6507           else
6508             {
6509               printf ("  ");
6510               print_vma (section->sh_offset, LONG_HEX);
6511             }
6512           printf ("  %u\n       ", section->sh_link);
6513           print_vma (section->sh_size, LONG_HEX);
6514           putchar (' ');
6515           print_vma (section->sh_entsize, LONG_HEX);
6516
6517           printf ("  %-16u  %lu\n",
6518                   section->sh_info,
6519                   (unsigned long) section->sh_addralign);
6520         }
6521       else
6522         {
6523           putchar (' ');
6524           print_vma (section->sh_addr, LONG_HEX);
6525           if ((long) section->sh_offset == section->sh_offset)
6526             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6527           else
6528             {
6529               printf ("  ");
6530               print_vma (section->sh_offset, LONG_HEX);
6531             }
6532           printf ("\n       ");
6533           print_vma (section->sh_size, LONG_HEX);
6534           printf ("  ");
6535           print_vma (section->sh_entsize, LONG_HEX);
6536
6537           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6538
6539           printf ("     %2u   %3u     %lu\n",
6540                   section->sh_link,
6541                   section->sh_info,
6542                   (unsigned long) section->sh_addralign);
6543         }
6544
6545       if (do_section_details)
6546         {
6547           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6548           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6549             {
6550               /* Minimum section size is 12 bytes for 32-bit compression
6551                  header + 12 bytes for compressed data header.  */
6552               unsigned char buf[24];
6553
6554               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6555               if (get_data (&buf, filedata, section->sh_offset, 1,
6556                             sizeof (buf), _("compression header")))
6557                 {
6558                   Elf_Internal_Chdr chdr;
6559
6560                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6561
6562                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6563                     printf ("       ZLIB, ");
6564                   else
6565                     printf (_("       [<unknown>: 0x%x], "),
6566                             chdr.ch_type);
6567                   print_vma (chdr.ch_size, LONG_HEX);
6568                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6569                 }
6570             }
6571         }
6572     }
6573
6574   if (!do_section_details)
6575     {
6576       /* The ordering of the letters shown here matches the ordering of the
6577          corresponding SHF_xxx values, and hence the order in which these
6578          letters will be displayed to the user.  */
6579       printf (_("Key to Flags:\n\
6580   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6581   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6582   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6583       if (filedata->file_header.e_machine == EM_X86_64
6584           || filedata->file_header.e_machine == EM_L1OM
6585           || filedata->file_header.e_machine == EM_K1OM)
6586         printf (_("l (large), "));
6587       else if (filedata->file_header.e_machine == EM_ARM)
6588         printf (_("y (purecode), "));
6589       else if (filedata->file_header.e_machine == EM_PPC)
6590         printf (_("v (VLE), "));
6591       printf ("p (processor specific)\n");
6592     }
6593
6594   return TRUE;
6595 }
6596
6597 static const char *
6598 get_group_flags (unsigned int flags)
6599 {
6600   static char buff[128];
6601
6602   if (flags == 0)
6603     return "";
6604   else if (flags == GRP_COMDAT)
6605     return "COMDAT ";
6606
6607   snprintf (buff, 14, _("[0x%x: "), flags);
6608
6609   flags &= ~ GRP_COMDAT;
6610   if (flags & GRP_MASKOS)
6611     {
6612       strcat (buff, "<OS specific>");
6613       flags &= ~ GRP_MASKOS;
6614     }
6615
6616   if (flags & GRP_MASKPROC)
6617     {
6618       strcat (buff, "<PROC specific>");
6619       flags &= ~ GRP_MASKPROC;
6620     }
6621
6622   if (flags)
6623     strcat (buff, "<unknown>");
6624
6625   strcat (buff, "]");
6626   return buff;
6627 }
6628
6629 static bfd_boolean
6630 process_section_groups (Filedata * filedata)
6631 {
6632   Elf_Internal_Shdr * section;
6633   unsigned int i;
6634   struct group * group;
6635   Elf_Internal_Shdr * symtab_sec;
6636   Elf_Internal_Shdr * strtab_sec;
6637   Elf_Internal_Sym * symtab;
6638   unsigned long num_syms;
6639   char * strtab;
6640   size_t strtab_size;
6641
6642   /* Don't process section groups unless needed.  */
6643   if (!do_unwind && !do_section_groups)
6644     return TRUE;
6645
6646   if (filedata->file_header.e_shnum == 0)
6647     {
6648       if (do_section_groups)
6649         printf (_("\nThere are no sections to group in this file.\n"));
6650
6651       return TRUE;
6652     }
6653
6654   if (filedata->section_headers == NULL)
6655     {
6656       error (_("Section headers are not available!\n"));
6657       /* PR 13622: This can happen with a corrupt ELF header.  */
6658       return FALSE;
6659     }
6660
6661   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6662                                                      sizeof (struct group *));
6663
6664   if (section_headers_groups == NULL)
6665     {
6666       error (_("Out of memory reading %u section group headers\n"),
6667              filedata->file_header.e_shnum);
6668       return FALSE;
6669     }
6670
6671   /* Scan the sections for the group section.  */
6672   group_count = 0;
6673   for (i = 0, section = filedata->section_headers;
6674        i < filedata->file_header.e_shnum;
6675        i++, section++)
6676     if (section->sh_type == SHT_GROUP)
6677       group_count++;
6678
6679   if (group_count == 0)
6680     {
6681       if (do_section_groups)
6682         printf (_("\nThere are no section groups in this file.\n"));
6683
6684       return TRUE;
6685     }
6686
6687   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6688
6689   if (section_groups == NULL)
6690     {
6691       error (_("Out of memory reading %lu groups\n"),
6692              (unsigned long) group_count);
6693       return FALSE;
6694     }
6695
6696   symtab_sec = NULL;
6697   strtab_sec = NULL;
6698   symtab = NULL;
6699   num_syms = 0;
6700   strtab = NULL;
6701   strtab_size = 0;
6702   for (i = 0, section = filedata->section_headers, group = section_groups;
6703        i < filedata->file_header.e_shnum;
6704        i++, section++)
6705     {
6706       if (section->sh_type == SHT_GROUP)
6707         {
6708           const char * name = printable_section_name (filedata, section);
6709           const char * group_name;
6710           unsigned char * start;
6711           unsigned char * indices;
6712           unsigned int entry, j, size;
6713           Elf_Internal_Shdr * sec;
6714           Elf_Internal_Sym * sym;
6715
6716           /* Get the symbol table.  */
6717           if (section->sh_link >= filedata->file_header.e_shnum
6718               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6719                   != SHT_SYMTAB))
6720             {
6721               error (_("Bad sh_link in group section `%s'\n"), name);
6722               continue;
6723             }
6724
6725           if (symtab_sec != sec)
6726             {
6727               symtab_sec = sec;
6728               if (symtab)
6729                 free (symtab);
6730               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6731             }
6732
6733           if (symtab == NULL)
6734             {
6735               error (_("Corrupt header in group section `%s'\n"), name);
6736               continue;
6737             }
6738
6739           if (section->sh_info >= num_syms)
6740             {
6741               error (_("Bad sh_info in group section `%s'\n"), name);
6742               continue;
6743             }
6744
6745           sym = symtab + section->sh_info;
6746
6747           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6748             {
6749               if (sym->st_shndx == 0
6750                   || sym->st_shndx >= filedata->file_header.e_shnum)
6751                 {
6752                   error (_("Bad sh_info in group section `%s'\n"), name);
6753                   continue;
6754                 }
6755
6756               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6757               strtab_sec = NULL;
6758               if (strtab)
6759                 free (strtab);
6760               strtab = NULL;
6761               strtab_size = 0;
6762             }
6763           else
6764             {
6765               /* Get the string table.  */
6766               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6767                 {
6768                   strtab_sec = NULL;
6769                   if (strtab)
6770                     free (strtab);
6771                   strtab = NULL;
6772                   strtab_size = 0;
6773                 }
6774               else if (strtab_sec
6775                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6776                 {
6777                   strtab_sec = sec;
6778                   if (strtab)
6779                     free (strtab);
6780
6781                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6782                                               1, strtab_sec->sh_size,
6783                                               _("string table"));
6784                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6785                 }
6786               group_name = sym->st_name < strtab_size
6787                 ? strtab + sym->st_name : _("<corrupt>");
6788             }
6789
6790           /* PR 17531: file: loop.  */
6791           if (section->sh_entsize > section->sh_size)
6792             {
6793               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6794                      printable_section_name (filedata, section),
6795                      (unsigned long) section->sh_entsize,
6796                      (unsigned long) section->sh_size);
6797               break;
6798             }
6799
6800           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6801                                               1, section->sh_size,
6802                                               _("section data"));
6803           if (start == NULL)
6804             continue;
6805
6806           indices = start;
6807           size = (section->sh_size / section->sh_entsize) - 1;
6808           entry = byte_get (indices, 4);
6809           indices += 4;
6810
6811           if (do_section_groups)
6812             {
6813               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6814                       get_group_flags (entry), i, name, group_name, size);
6815
6816               printf (_("   [Index]    Name\n"));
6817             }
6818
6819           group->group_index = i;
6820
6821           for (j = 0; j < size; j++)
6822             {
6823               struct group_list * g;
6824
6825               entry = byte_get (indices, 4);
6826               indices += 4;
6827
6828               if (entry >= filedata->file_header.e_shnum)
6829                 {
6830                   static unsigned num_group_errors = 0;
6831
6832                   if (num_group_errors ++ < 10)
6833                     {
6834                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6835                              entry, i, filedata->file_header.e_shnum - 1);
6836                       if (num_group_errors == 10)
6837                         warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6838                     }
6839                   continue;
6840                 }
6841
6842               if (section_headers_groups [entry] != NULL)
6843                 {
6844                   if (entry)
6845                     {
6846                       static unsigned num_errs = 0;
6847
6848                       if (num_errs ++ < 10)
6849                         {
6850                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6851                                  entry, i,
6852                                  section_headers_groups [entry]->group_index);
6853                           if (num_errs == 10)
6854                             warn (_("Further error messages about already contained group sections suppressed\n"));
6855                         }
6856                       continue;
6857                     }
6858                   else
6859                     {
6860                       /* Intel C/C++ compiler may put section 0 in a
6861                          section group.  We just warn it the first time
6862                          and ignore it afterwards.  */
6863                       static bfd_boolean warned = FALSE;
6864                       if (!warned)
6865                         {
6866                           error (_("section 0 in group section [%5u]\n"),
6867                                  section_headers_groups [entry]->group_index);
6868                           warned = TRUE;
6869                         }
6870                     }
6871                 }
6872
6873               section_headers_groups [entry] = group;
6874
6875               if (do_section_groups)
6876                 {
6877                   sec = filedata->section_headers + entry;
6878                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6879                 }
6880
6881               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6882               g->section_index = entry;
6883               g->next = group->root;
6884               group->root = g;
6885             }
6886
6887           if (start)
6888             free (start);
6889
6890           group++;
6891         }
6892     }
6893
6894   if (symtab)
6895     free (symtab);
6896   if (strtab)
6897     free (strtab);
6898   return TRUE;
6899 }
6900
6901 /* Data used to display dynamic fixups.  */
6902
6903 struct ia64_vms_dynfixup
6904 {
6905   bfd_vma needed_ident;         /* Library ident number.  */
6906   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6907   bfd_vma fixup_needed;         /* Index of the library.  */
6908   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6909   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6910 };
6911
6912 /* Data used to display dynamic relocations.  */
6913
6914 struct ia64_vms_dynimgrela
6915 {
6916   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6917   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6918 };
6919
6920 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6921    library).  */
6922
6923 static bfd_boolean
6924 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6925                               struct ia64_vms_dynfixup *  fixup,
6926                               const char *                strtab,
6927                               unsigned int                strtab_sz)
6928 {
6929   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6930   long i;
6931   const char * lib_name;
6932
6933   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6934                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6935                    _("dynamic section image fixups"));
6936   if (!imfs)
6937     return FALSE;
6938
6939   if (fixup->needed < strtab_sz)
6940     lib_name = strtab + fixup->needed;
6941   else
6942     {
6943       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6944             (unsigned long) fixup->needed);
6945       lib_name = "???";
6946     }
6947   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6948           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6949   printf
6950     (_("Seg Offset           Type                             SymVec DataType\n"));
6951
6952   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6953     {
6954       unsigned int type;
6955       const char *rtype;
6956
6957       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6958       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6959       type = BYTE_GET (imfs [i].type);
6960       rtype = elf_ia64_reloc_type (type);
6961       if (rtype == NULL)
6962         printf (" 0x%08x                       ", type);
6963       else
6964         printf (" %-32s ", rtype);
6965       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6966       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6967     }
6968
6969   free (imfs);
6970   return TRUE;
6971 }
6972
6973 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6974
6975 static bfd_boolean
6976 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
6977 {
6978   Elf64_External_VMS_IMAGE_RELA *imrs;
6979   long i;
6980
6981   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
6982                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6983                    _("dynamic section image relocations"));
6984   if (!imrs)
6985     return FALSE;
6986
6987   printf (_("\nImage relocs\n"));
6988   printf
6989     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6990
6991   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6992     {
6993       unsigned int type;
6994       const char *rtype;
6995
6996       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6997       printf ("%08" BFD_VMA_FMT "x ",
6998               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6999       type = BYTE_GET (imrs [i].type);
7000       rtype = elf_ia64_reloc_type (type);
7001       if (rtype == NULL)
7002         printf ("0x%08x                      ", type);
7003       else
7004         printf ("%-31s ", rtype);
7005       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7006       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7007       printf ("%08" BFD_VMA_FMT "x\n",
7008               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7009     }
7010
7011   free (imrs);
7012   return TRUE;
7013 }
7014
7015 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
7016
7017 static bfd_boolean
7018 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7019 {
7020   struct ia64_vms_dynfixup fixup;
7021   struct ia64_vms_dynimgrela imgrela;
7022   Elf_Internal_Dyn *entry;
7023   bfd_vma strtab_off = 0;
7024   bfd_vma strtab_sz = 0;
7025   char *strtab = NULL;
7026   bfd_boolean res = TRUE;
7027
7028   memset (&fixup, 0, sizeof (fixup));
7029   memset (&imgrela, 0, sizeof (imgrela));
7030
7031   /* Note: the order of the entries is specified by the OpenVMS specs.  */
7032   for (entry = dynamic_section;
7033        entry < dynamic_section + dynamic_nent;
7034        entry++)
7035     {
7036       switch (entry->d_tag)
7037         {
7038         case DT_IA_64_VMS_STRTAB_OFFSET:
7039           strtab_off = entry->d_un.d_val;
7040           break;
7041         case DT_STRSZ:
7042           strtab_sz = entry->d_un.d_val;
7043           if (strtab == NULL)
7044             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7045                                1, strtab_sz, _("dynamic string section"));
7046           break;
7047
7048         case DT_IA_64_VMS_NEEDED_IDENT:
7049           fixup.needed_ident = entry->d_un.d_val;
7050           break;
7051         case DT_NEEDED:
7052           fixup.needed = entry->d_un.d_val;
7053           break;
7054         case DT_IA_64_VMS_FIXUP_NEEDED:
7055           fixup.fixup_needed = entry->d_un.d_val;
7056           break;
7057         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7058           fixup.fixup_rela_cnt = entry->d_un.d_val;
7059           break;
7060         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7061           fixup.fixup_rela_off = entry->d_un.d_val;
7062           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7063             res = FALSE;
7064           break;
7065         case DT_IA_64_VMS_IMG_RELA_CNT:
7066           imgrela.img_rela_cnt = entry->d_un.d_val;
7067           break;
7068         case DT_IA_64_VMS_IMG_RELA_OFF:
7069           imgrela.img_rela_off = entry->d_un.d_val;
7070           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7071             res = FALSE;
7072           break;
7073
7074         default:
7075           break;
7076         }
7077     }
7078
7079   if (strtab != NULL)
7080     free (strtab);
7081
7082   return res;
7083 }
7084
7085 static struct
7086 {
7087   const char * name;
7088   int reloc;
7089   int size;
7090   int rela;
7091 }
7092   dynamic_relocations [] =
7093 {
7094   { "REL", DT_REL, DT_RELSZ, FALSE },
7095   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7096   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7097 };
7098
7099 /* Process the reloc section.  */
7100
7101 static bfd_boolean
7102 process_relocs (Filedata * filedata)
7103 {
7104   unsigned long rel_size;
7105   unsigned long rel_offset;
7106
7107   if (!do_reloc)
7108     return TRUE;
7109
7110   if (do_using_dynamic)
7111     {
7112       int          is_rela;
7113       const char * name;
7114       bfd_boolean  has_dynamic_reloc;
7115       unsigned int i;
7116
7117       has_dynamic_reloc = FALSE;
7118
7119       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7120         {
7121           is_rela = dynamic_relocations [i].rela;
7122           name = dynamic_relocations [i].name;
7123           rel_size = dynamic_info [dynamic_relocations [i].size];
7124           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7125
7126           if (rel_size)
7127             has_dynamic_reloc = TRUE;
7128
7129           if (is_rela == UNKNOWN)
7130             {
7131               if (dynamic_relocations [i].reloc == DT_JMPREL)
7132                 switch (dynamic_info[DT_PLTREL])
7133                   {
7134                   case DT_REL:
7135                     is_rela = FALSE;
7136                     break;
7137                   case DT_RELA:
7138                     is_rela = TRUE;
7139                     break;
7140                   }
7141             }
7142
7143           if (rel_size)
7144             {
7145               printf
7146                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7147                  name, rel_offset, rel_size);
7148
7149               dump_relocations (filedata,
7150                                 offset_from_vma (filedata, rel_offset, rel_size),
7151                                 rel_size,
7152                                 dynamic_symbols, num_dynamic_syms,
7153                                 dynamic_strings, dynamic_strings_length,
7154                                 is_rela, TRUE /* is_dynamic */);
7155             }
7156         }
7157
7158       if (is_ia64_vms (filedata))
7159         if (process_ia64_vms_dynamic_relocs (filedata))
7160           has_dynamic_reloc = TRUE;
7161
7162       if (! has_dynamic_reloc)
7163         printf (_("\nThere are no dynamic relocations in this file.\n"));
7164     }
7165   else
7166     {
7167       Elf_Internal_Shdr * section;
7168       unsigned long i;
7169       bfd_boolean found = FALSE;
7170
7171       for (i = 0, section = filedata->section_headers;
7172            i < filedata->file_header.e_shnum;
7173            i++, section++)
7174         {
7175           if (   section->sh_type != SHT_RELA
7176               && section->sh_type != SHT_REL)
7177             continue;
7178
7179           rel_offset = section->sh_offset;
7180           rel_size   = section->sh_size;
7181
7182           if (rel_size)
7183             {
7184               Elf_Internal_Shdr * strsec;
7185               int is_rela;
7186               unsigned long num_rela;
7187
7188               printf (_("\nRelocation section "));
7189
7190               if (filedata->string_table == NULL)
7191                 printf ("%d", section->sh_name);
7192               else
7193                 printf ("'%s'", printable_section_name (filedata, section));
7194
7195               num_rela = rel_size / section->sh_entsize;
7196               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7197                                 " at offset 0x%lx contains %lu entries:\n",
7198                                 num_rela),
7199                       rel_offset, num_rela);
7200
7201               is_rela = section->sh_type == SHT_RELA;
7202
7203               if (section->sh_link != 0
7204                   && section->sh_link < filedata->file_header.e_shnum)
7205                 {
7206                   Elf_Internal_Shdr * symsec;
7207                   Elf_Internal_Sym *  symtab;
7208                   unsigned long nsyms;
7209                   unsigned long strtablen = 0;
7210                   char * strtab = NULL;
7211
7212                   symsec = filedata->section_headers + section->sh_link;
7213                   if (symsec->sh_type != SHT_SYMTAB
7214                       && symsec->sh_type != SHT_DYNSYM)
7215                     continue;
7216
7217                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7218
7219                   if (symtab == NULL)
7220                     continue;
7221
7222                   if (symsec->sh_link != 0
7223                       && symsec->sh_link < filedata->file_header.e_shnum)
7224                     {
7225                       strsec = filedata->section_headers + symsec->sh_link;
7226
7227                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7228                                                   1, strsec->sh_size,
7229                                                   _("string table"));
7230                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7231                     }
7232
7233                   dump_relocations (filedata, rel_offset, rel_size,
7234                                     symtab, nsyms, strtab, strtablen,
7235                                     is_rela,
7236                                     symsec->sh_type == SHT_DYNSYM);
7237                   if (strtab)
7238                     free (strtab);
7239                   free (symtab);
7240                 }
7241               else
7242                 dump_relocations (filedata, rel_offset, rel_size,
7243                                   NULL, 0, NULL, 0, is_rela,
7244                                   FALSE /* is_dynamic */);
7245
7246               found = TRUE;
7247             }
7248         }
7249
7250       if (! found)
7251         {
7252           /* Users sometimes forget the -D option, so try to be helpful.  */
7253           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7254             {
7255               if (dynamic_info [dynamic_relocations [i].size])
7256                 {
7257                   printf (_("\nThere are no static relocations in this file."));
7258                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7259
7260                   break;
7261                 }
7262             }
7263           if (i == ARRAY_SIZE (dynamic_relocations))
7264             printf (_("\nThere are no relocations in this file.\n"));
7265         }
7266     }
7267
7268   return TRUE;
7269 }
7270
7271 /* An absolute address consists of a section and an offset.  If the
7272    section is NULL, the offset itself is the address, otherwise, the
7273    address equals to LOAD_ADDRESS(section) + offset.  */
7274
7275 struct absaddr
7276 {
7277   unsigned short section;
7278   bfd_vma offset;
7279 };
7280
7281 #define ABSADDR(a) \
7282   ((a).section \
7283    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7284    : (a).offset)
7285
7286 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7287    name, if found, and the offset from the symbol to ADDR.  */
7288
7289 static void
7290 find_symbol_for_address (Filedata *          filedata,
7291                          Elf_Internal_Sym *  symtab,
7292                          unsigned long       nsyms,
7293                          const char *        strtab,
7294                          unsigned long       strtab_size,
7295                          struct absaddr      addr,
7296                          const char **       symname,
7297                          bfd_vma *           offset)
7298 {
7299   bfd_vma dist = 0x100000;
7300   Elf_Internal_Sym * sym;
7301   Elf_Internal_Sym * beg;
7302   Elf_Internal_Sym * end;
7303   Elf_Internal_Sym * best = NULL;
7304
7305   REMOVE_ARCH_BITS (addr.offset);
7306   beg = symtab;
7307   end = symtab + nsyms;
7308
7309   while (beg < end)
7310     {
7311       bfd_vma value;
7312
7313       sym = beg + (end - beg) / 2;
7314
7315       value = sym->st_value;
7316       REMOVE_ARCH_BITS (value);
7317
7318       if (sym->st_name != 0
7319           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7320           && addr.offset >= value
7321           && addr.offset - value < dist)
7322         {
7323           best = sym;
7324           dist = addr.offset - value;
7325           if (!dist)
7326             break;
7327         }
7328
7329       if (addr.offset < value)
7330         end = sym;
7331       else
7332         beg = sym + 1;
7333     }
7334
7335   if (best)
7336     {
7337       *symname = (best->st_name >= strtab_size
7338                   ? _("<corrupt>") : strtab + best->st_name);
7339       *offset = dist;
7340       return;
7341     }
7342
7343   *symname = NULL;
7344   *offset = addr.offset;
7345 }
7346
7347 static /* signed */ int
7348 symcmp (const void *p, const void *q)
7349 {
7350   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7351   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7352
7353   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7354 }
7355
7356 /* Process the unwind section.  */
7357
7358 #include "unwind-ia64.h"
7359
7360 struct ia64_unw_table_entry
7361 {
7362   struct absaddr start;
7363   struct absaddr end;
7364   struct absaddr info;
7365 };
7366
7367 struct ia64_unw_aux_info
7368 {
7369   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7370   unsigned long                 table_len;      /* Length of unwind table.  */
7371   unsigned char *               info;           /* Unwind info.  */
7372   unsigned long                 info_size;      /* Size of unwind info.  */
7373   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7374   bfd_vma                       seg_base;       /* Starting address of segment.  */
7375   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7376   unsigned long                 nsyms;          /* Number of symbols.  */
7377   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7378   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7379   char *                        strtab;         /* The string table.  */
7380   unsigned long                 strtab_size;    /* Size of string table.  */
7381 };
7382
7383 static bfd_boolean
7384 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7385 {
7386   struct ia64_unw_table_entry * tp;
7387   unsigned long j, nfuns;
7388   int in_body;
7389   bfd_boolean res = TRUE;
7390
7391   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7392   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7393     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7394       aux->funtab[nfuns++] = aux->symtab[j];
7395   aux->nfuns = nfuns;
7396   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7397
7398   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7399     {
7400       bfd_vma stamp;
7401       bfd_vma offset;
7402       const unsigned char * dp;
7403       const unsigned char * head;
7404       const unsigned char * end;
7405       const char * procname;
7406
7407       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7408                                aux->strtab_size, tp->start, &procname, &offset);
7409
7410       fputs ("\n<", stdout);
7411
7412       if (procname)
7413         {
7414           fputs (procname, stdout);
7415
7416           if (offset)
7417             printf ("+%lx", (unsigned long) offset);
7418         }
7419
7420       fputs (">: [", stdout);
7421       print_vma (tp->start.offset, PREFIX_HEX);
7422       fputc ('-', stdout);
7423       print_vma (tp->end.offset, PREFIX_HEX);
7424       printf ("], info at +0x%lx\n",
7425               (unsigned long) (tp->info.offset - aux->seg_base));
7426
7427       /* PR 17531: file: 86232b32.  */
7428       if (aux->info == NULL)
7429         continue;
7430
7431       /* PR 17531: file: 0997b4d1.  */
7432       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7433         {
7434           warn (_("Invalid offset %lx in table entry %ld\n"),
7435                 (long) tp->info.offset, (long) (tp - aux->table));
7436           res = FALSE;
7437           continue;
7438         }
7439
7440       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7441       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7442
7443       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7444               (unsigned) UNW_VER (stamp),
7445               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7446               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7447               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7448               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7449
7450       if (UNW_VER (stamp) != 1)
7451         {
7452           printf (_("\tUnknown version.\n"));
7453           continue;
7454         }
7455
7456       in_body = 0;
7457       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7458       /* PR 17531: file: 16ceda89.  */
7459       if (end > aux->info + aux->info_size)
7460         end = aux->info + aux->info_size;
7461       for (dp = head + 8; dp < end;)
7462         dp = unw_decode (dp, in_body, & in_body, end);
7463     }
7464
7465   free (aux->funtab);
7466
7467   return res;
7468 }
7469
7470 static bfd_boolean
7471 slurp_ia64_unwind_table (Filedata *                  filedata,
7472                          struct ia64_unw_aux_info *  aux,
7473                          Elf_Internal_Shdr *         sec)
7474 {
7475   unsigned long size, nrelas, i;
7476   Elf_Internal_Phdr * seg;
7477   struct ia64_unw_table_entry * tep;
7478   Elf_Internal_Shdr * relsec;
7479   Elf_Internal_Rela * rela;
7480   Elf_Internal_Rela * rp;
7481   unsigned char * table;
7482   unsigned char * tp;
7483   Elf_Internal_Sym * sym;
7484   const char * relname;
7485
7486   aux->table_len = 0;
7487
7488   /* First, find the starting address of the segment that includes
7489      this section: */
7490
7491   if (filedata->file_header.e_phnum)
7492     {
7493       if (! get_program_headers (filedata))
7494           return FALSE;
7495
7496       for (seg = filedata->program_headers;
7497            seg < filedata->program_headers + filedata->file_header.e_phnum;
7498            ++seg)
7499         {
7500           if (seg->p_type != PT_LOAD)
7501             continue;
7502
7503           if (sec->sh_addr >= seg->p_vaddr
7504               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7505             {
7506               aux->seg_base = seg->p_vaddr;
7507               break;
7508             }
7509         }
7510     }
7511
7512   /* Second, build the unwind table from the contents of the unwind section:  */
7513   size = sec->sh_size;
7514   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7515                                       _("unwind table"));
7516   if (!table)
7517     return FALSE;
7518
7519   aux->table_len = size / (3 * eh_addr_size);
7520   aux->table = (struct ia64_unw_table_entry *)
7521     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7522   tep = aux->table;
7523
7524   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7525     {
7526       tep->start.section = SHN_UNDEF;
7527       tep->end.section   = SHN_UNDEF;
7528       tep->info.section  = SHN_UNDEF;
7529       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7530       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7531       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7532       tep->start.offset += aux->seg_base;
7533       tep->end.offset   += aux->seg_base;
7534       tep->info.offset  += aux->seg_base;
7535     }
7536   free (table);
7537
7538   /* Third, apply any relocations to the unwind table:  */
7539   for (relsec = filedata->section_headers;
7540        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7541        ++relsec)
7542     {
7543       if (relsec->sh_type != SHT_RELA
7544           || relsec->sh_info >= filedata->file_header.e_shnum
7545           || filedata->section_headers + relsec->sh_info != sec)
7546         continue;
7547
7548       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7549                               & rela, & nrelas))
7550         {
7551           free (aux->table);
7552           aux->table = NULL;
7553           aux->table_len = 0;
7554           return FALSE;
7555         }
7556
7557       for (rp = rela; rp < rela + nrelas; ++rp)
7558         {
7559           relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7560           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7561
7562           /* PR 17531: file: 9fa67536.  */
7563           if (relname == NULL)
7564             {
7565               warn (_("Skipping unknown relocation type: %u\n"),
7566                     get_reloc_type (filedata, rp->r_info));
7567               continue;
7568             }
7569
7570           if (! const_strneq (relname, "R_IA64_SEGREL"))
7571             {
7572               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7573               continue;
7574             }
7575
7576           i = rp->r_offset / (3 * eh_addr_size);
7577
7578           /* PR 17531: file: 5bc8d9bf.  */
7579           if (i >= aux->table_len)
7580             {
7581               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7582               continue;
7583             }
7584
7585           switch (rp->r_offset / eh_addr_size % 3)
7586             {
7587             case 0:
7588               aux->table[i].start.section = sym->st_shndx;
7589               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7590               break;
7591             case 1:
7592               aux->table[i].end.section   = sym->st_shndx;
7593               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7594               break;
7595             case 2:
7596               aux->table[i].info.section  = sym->st_shndx;
7597               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7598               break;
7599             default:
7600               break;
7601             }
7602         }
7603
7604       free (rela);
7605     }
7606
7607   return TRUE;
7608 }
7609
7610 static bfd_boolean
7611 ia64_process_unwind (Filedata * filedata)
7612 {
7613   Elf_Internal_Shdr * sec;
7614   Elf_Internal_Shdr * unwsec = NULL;
7615   Elf_Internal_Shdr * strsec;
7616   unsigned long i, unwcount = 0, unwstart = 0;
7617   struct ia64_unw_aux_info aux;
7618   bfd_boolean res = TRUE;
7619
7620   memset (& aux, 0, sizeof (aux));
7621
7622   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7623     {
7624       if (sec->sh_type == SHT_SYMTAB
7625           && sec->sh_link < filedata->file_header.e_shnum)
7626         {
7627           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7628
7629           strsec = filedata->section_headers + sec->sh_link;
7630           if (aux.strtab != NULL)
7631             {
7632               error (_("Multiple auxillary string tables encountered\n"));
7633               free (aux.strtab);
7634               res = FALSE;
7635             }
7636           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7637                                           1, strsec->sh_size,
7638                                           _("string table"));
7639           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7640         }
7641       else if (sec->sh_type == SHT_IA_64_UNWIND)
7642         unwcount++;
7643     }
7644
7645   if (!unwcount)
7646     printf (_("\nThere are no unwind sections in this file.\n"));
7647
7648   while (unwcount-- > 0)
7649     {
7650       char * suffix;
7651       size_t len, len2;
7652
7653       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7654            i < filedata->file_header.e_shnum; ++i, ++sec)
7655         if (sec->sh_type == SHT_IA_64_UNWIND)
7656           {
7657             unwsec = sec;
7658             break;
7659           }
7660       /* We have already counted the number of SHT_IA64_UNWIND
7661          sections so the loop above should never fail.  */
7662       assert (unwsec != NULL);
7663
7664       unwstart = i + 1;
7665       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7666
7667       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7668         {
7669           /* We need to find which section group it is in.  */
7670           struct group_list * g;
7671
7672           if (section_headers_groups == NULL
7673               || section_headers_groups [i] == NULL)
7674             i = filedata->file_header.e_shnum;
7675           else
7676             {
7677               g = section_headers_groups [i]->root;
7678
7679               for (; g != NULL; g = g->next)
7680                 {
7681                   sec = filedata->section_headers + g->section_index;
7682
7683                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7684                     break;
7685                 }
7686
7687               if (g == NULL)
7688                 i = filedata->file_header.e_shnum;
7689             }
7690         }
7691       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7692         {
7693           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7694           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7695           suffix = SECTION_NAME (unwsec) + len;
7696           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7697                ++i, ++sec)
7698             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7699                 && streq (SECTION_NAME (sec) + len2, suffix))
7700               break;
7701         }
7702       else
7703         {
7704           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7705              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7706           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7707           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7708           suffix = "";
7709           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7710             suffix = SECTION_NAME (unwsec) + len;
7711           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7712                ++i, ++sec)
7713             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7714                 && streq (SECTION_NAME (sec) + len2, suffix))
7715               break;
7716         }
7717
7718       if (i == filedata->file_header.e_shnum)
7719         {
7720           printf (_("\nCould not find unwind info section for "));
7721
7722           if (filedata->string_table == NULL)
7723             printf ("%d", unwsec->sh_name);
7724           else
7725             printf ("'%s'", printable_section_name (filedata, unwsec));
7726         }
7727       else
7728         {
7729           aux.info_addr = sec->sh_addr;
7730           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7731                                                  sec->sh_size,
7732                                                  _("unwind info"));
7733           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7734
7735           printf (_("\nUnwind section "));
7736
7737           if (filedata->string_table == NULL)
7738             printf ("%d", unwsec->sh_name);
7739           else
7740             printf ("'%s'", printable_section_name (filedata, unwsec));
7741
7742           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7743                   (unsigned long) unwsec->sh_offset,
7744                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7745
7746           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7747               && aux.table_len > 0)
7748             dump_ia64_unwind (filedata, & aux);
7749
7750           if (aux.table)
7751             free ((char *) aux.table);
7752           if (aux.info)
7753             free ((char *) aux.info);
7754           aux.table = NULL;
7755           aux.info = NULL;
7756         }
7757     }
7758
7759   if (aux.symtab)
7760     free (aux.symtab);
7761   if (aux.strtab)
7762     free ((char *) aux.strtab);
7763
7764   return res;
7765 }
7766
7767 struct hppa_unw_table_entry
7768 {
7769   struct absaddr start;
7770   struct absaddr end;
7771   unsigned int Cannot_unwind:1;                 /* 0 */
7772   unsigned int Millicode:1;                     /* 1 */
7773   unsigned int Millicode_save_sr0:1;            /* 2 */
7774   unsigned int Region_description:2;            /* 3..4 */
7775   unsigned int reserved1:1;                     /* 5 */
7776   unsigned int Entry_SR:1;                      /* 6 */
7777   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7778   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7779   unsigned int Args_stored:1;                   /* 16 */
7780   unsigned int Variable_Frame:1;                /* 17 */
7781   unsigned int Separate_Package_Body:1;         /* 18 */
7782   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7783   unsigned int Stack_Overflow_Check:1;          /* 20 */
7784   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7785   unsigned int Ada_Region:1;                    /* 22 */
7786   unsigned int cxx_info:1;                      /* 23 */
7787   unsigned int cxx_try_catch:1;                 /* 24 */
7788   unsigned int sched_entry_seq:1;               /* 25 */
7789   unsigned int reserved2:1;                     /* 26 */
7790   unsigned int Save_SP:1;                       /* 27 */
7791   unsigned int Save_RP:1;                       /* 28 */
7792   unsigned int Save_MRP_in_frame:1;             /* 29 */
7793   unsigned int extn_ptr_defined:1;              /* 30 */
7794   unsigned int Cleanup_defined:1;               /* 31 */
7795
7796   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7797   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7798   unsigned int Large_frame:1;                   /* 2 */
7799   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7800   unsigned int reserved4:1;                     /* 4 */
7801   unsigned int Total_frame_size:27;             /* 5..31 */
7802 };
7803
7804 struct hppa_unw_aux_info
7805 {
7806   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7807   unsigned long                  table_len;     /* Length of unwind table.  */
7808   bfd_vma                        seg_base;      /* Starting address of segment.  */
7809   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7810   unsigned long                  nsyms;         /* Number of symbols.  */
7811   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7812   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7813   char *                         strtab;        /* The string table.  */
7814   unsigned long                  strtab_size;   /* Size of string table.  */
7815 };
7816
7817 static bfd_boolean
7818 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7819 {
7820   struct hppa_unw_table_entry * tp;
7821   unsigned long j, nfuns;
7822   bfd_boolean res = TRUE;
7823
7824   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7825   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7826     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7827       aux->funtab[nfuns++] = aux->symtab[j];
7828   aux->nfuns = nfuns;
7829   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7830
7831   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7832     {
7833       bfd_vma offset;
7834       const char * procname;
7835
7836       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7837                                aux->strtab_size, tp->start, &procname,
7838                                &offset);
7839
7840       fputs ("\n<", stdout);
7841
7842       if (procname)
7843         {
7844           fputs (procname, stdout);
7845
7846           if (offset)
7847             printf ("+%lx", (unsigned long) offset);
7848         }
7849
7850       fputs (">: [", stdout);
7851       print_vma (tp->start.offset, PREFIX_HEX);
7852       fputc ('-', stdout);
7853       print_vma (tp->end.offset, PREFIX_HEX);
7854       printf ("]\n\t");
7855
7856 #define PF(_m) if (tp->_m) printf (#_m " ");
7857 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7858       PF(Cannot_unwind);
7859       PF(Millicode);
7860       PF(Millicode_save_sr0);
7861       /* PV(Region_description);  */
7862       PF(Entry_SR);
7863       PV(Entry_FR);
7864       PV(Entry_GR);
7865       PF(Args_stored);
7866       PF(Variable_Frame);
7867       PF(Separate_Package_Body);
7868       PF(Frame_Extension_Millicode);
7869       PF(Stack_Overflow_Check);
7870       PF(Two_Instruction_SP_Increment);
7871       PF(Ada_Region);
7872       PF(cxx_info);
7873       PF(cxx_try_catch);
7874       PF(sched_entry_seq);
7875       PF(Save_SP);
7876       PF(Save_RP);
7877       PF(Save_MRP_in_frame);
7878       PF(extn_ptr_defined);
7879       PF(Cleanup_defined);
7880       PF(MPE_XL_interrupt_marker);
7881       PF(HP_UX_interrupt_marker);
7882       PF(Large_frame);
7883       PF(Pseudo_SP_Set);
7884       PV(Total_frame_size);
7885 #undef PF
7886 #undef PV
7887     }
7888
7889   printf ("\n");
7890
7891   free (aux->funtab);
7892
7893   return res;
7894 }
7895
7896 static bfd_boolean
7897 slurp_hppa_unwind_table (Filedata *                  filedata,
7898                          struct hppa_unw_aux_info *  aux,
7899                          Elf_Internal_Shdr *         sec)
7900 {
7901   unsigned long size, unw_ent_size, nentries, nrelas, i;
7902   Elf_Internal_Phdr * seg;
7903   struct hppa_unw_table_entry * tep;
7904   Elf_Internal_Shdr * relsec;
7905   Elf_Internal_Rela * rela;
7906   Elf_Internal_Rela * rp;
7907   unsigned char * table;
7908   unsigned char * tp;
7909   Elf_Internal_Sym * sym;
7910   const char * relname;
7911
7912   /* First, find the starting address of the segment that includes
7913      this section.  */
7914   if (filedata->file_header.e_phnum)
7915     {
7916       if (! get_program_headers (filedata))
7917         return FALSE;
7918
7919       for (seg = filedata->program_headers;
7920            seg < filedata->program_headers + filedata->file_header.e_phnum;
7921            ++seg)
7922         {
7923           if (seg->p_type != PT_LOAD)
7924             continue;
7925
7926           if (sec->sh_addr >= seg->p_vaddr
7927               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7928             {
7929               aux->seg_base = seg->p_vaddr;
7930               break;
7931             }
7932         }
7933     }
7934
7935   /* Second, build the unwind table from the contents of the unwind
7936      section.  */
7937   size = sec->sh_size;
7938   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7939                                       _("unwind table"));
7940   if (!table)
7941     return FALSE;
7942
7943   unw_ent_size = 16;
7944   nentries = size / unw_ent_size;
7945   size = unw_ent_size * nentries;
7946
7947   tep = aux->table = (struct hppa_unw_table_entry *)
7948       xcmalloc (nentries, sizeof (aux->table[0]));
7949
7950   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7951     {
7952       unsigned int tmp1, tmp2;
7953
7954       tep->start.section = SHN_UNDEF;
7955       tep->end.section   = SHN_UNDEF;
7956
7957       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7958       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7959       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7960       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7961
7962       tep->start.offset += aux->seg_base;
7963       tep->end.offset   += aux->seg_base;
7964
7965       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7966       tep->Millicode = (tmp1 >> 30) & 0x1;
7967       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7968       tep->Region_description = (tmp1 >> 27) & 0x3;
7969       tep->reserved1 = (tmp1 >> 26) & 0x1;
7970       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7971       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7972       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7973       tep->Args_stored = (tmp1 >> 15) & 0x1;
7974       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7975       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7976       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7977       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7978       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7979       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7980       tep->cxx_info = (tmp1 >> 8) & 0x1;
7981       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7982       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7983       tep->reserved2 = (tmp1 >> 5) & 0x1;
7984       tep->Save_SP = (tmp1 >> 4) & 0x1;
7985       tep->Save_RP = (tmp1 >> 3) & 0x1;
7986       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7987       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7988       tep->Cleanup_defined = tmp1 & 0x1;
7989
7990       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7991       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7992       tep->Large_frame = (tmp2 >> 29) & 0x1;
7993       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7994       tep->reserved4 = (tmp2 >> 27) & 0x1;
7995       tep->Total_frame_size = tmp2 & 0x7ffffff;
7996     }
7997   free (table);
7998
7999   /* Third, apply any relocations to the unwind table.  */
8000   for (relsec = filedata->section_headers;
8001        relsec < filedata->section_headers + filedata->file_header.e_shnum;
8002        ++relsec)
8003     {
8004       if (relsec->sh_type != SHT_RELA
8005           || relsec->sh_info >= filedata->file_header.e_shnum
8006           || filedata->section_headers + relsec->sh_info != sec)
8007         continue;
8008
8009       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8010                               & rela, & nrelas))
8011         return FALSE;
8012
8013       for (rp = rela; rp < rela + nrelas; ++rp)
8014         {
8015           relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
8016           sym = aux->symtab + get_reloc_symindex (rp->r_info);
8017
8018           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
8019           if (! const_strneq (relname, "R_PARISC_SEGREL"))
8020             {
8021               warn (_("Skipping unexpected relocation type %s\n"), relname);
8022               continue;
8023             }
8024
8025           i = rp->r_offset / unw_ent_size;
8026
8027           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
8028             {
8029             case 0:
8030               aux->table[i].start.section = sym->st_shndx;
8031               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
8032               break;
8033             case 1:
8034               aux->table[i].end.section   = sym->st_shndx;
8035               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
8036               break;
8037             default:
8038               break;
8039             }
8040         }
8041
8042       free (rela);
8043     }
8044
8045   aux->table_len = nentries;
8046
8047   return TRUE;
8048 }
8049
8050 static bfd_boolean
8051 hppa_process_unwind (Filedata * filedata)
8052 {
8053   struct hppa_unw_aux_info aux;
8054   Elf_Internal_Shdr * unwsec = NULL;
8055   Elf_Internal_Shdr * strsec;
8056   Elf_Internal_Shdr * sec;
8057   unsigned long i;
8058   bfd_boolean res = TRUE;
8059
8060   if (filedata->string_table == NULL)
8061     return FALSE;
8062
8063   memset (& aux, 0, sizeof (aux));
8064
8065   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8066     {
8067       if (sec->sh_type == SHT_SYMTAB
8068           && sec->sh_link < filedata->file_header.e_shnum)
8069         {
8070           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8071
8072           strsec = filedata->section_headers + sec->sh_link;
8073           if (aux.strtab != NULL)
8074             {
8075               error (_("Multiple auxillary string tables encountered\n"));
8076               free (aux.strtab);
8077               res = FALSE;
8078             }
8079           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8080                                           1, strsec->sh_size,
8081                                           _("string table"));
8082           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8083         }
8084       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8085         unwsec = sec;
8086     }
8087
8088   if (!unwsec)
8089     printf (_("\nThere are no unwind sections in this file.\n"));
8090
8091   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8092     {
8093       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8094         {
8095           unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8096
8097           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8098                             "contains %lu entry:\n",
8099                             "\nUnwind section '%s' at offset 0x%lx "
8100                             "contains %lu entries:\n",
8101                             num_unwind),
8102                   printable_section_name (filedata, sec),
8103                   (unsigned long) sec->sh_offset,
8104                   num_unwind);
8105
8106           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8107             res = FALSE;
8108
8109           if (aux.table_len > 0)
8110             {
8111               if (! dump_hppa_unwind (filedata, &aux))
8112                 res = FALSE;
8113             }
8114
8115           if (aux.table)
8116             free ((char *) aux.table);
8117           aux.table = NULL;
8118         }
8119     }
8120
8121   if (aux.symtab)
8122     free (aux.symtab);
8123   if (aux.strtab)
8124     free ((char *) aux.strtab);
8125
8126   return res;
8127 }
8128
8129 struct arm_section
8130 {
8131   unsigned char *      data;            /* The unwind data.  */
8132   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8133   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8134   unsigned long        nrelas;          /* The number of relocations.  */
8135   unsigned int         rel_type;        /* REL or RELA ?  */
8136   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8137 };
8138
8139 struct arm_unw_aux_info
8140 {
8141   Filedata *          filedata;         /* The file containing the unwind sections.  */
8142   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8143   unsigned long       nsyms;            /* Number of symbols.  */
8144   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8145   unsigned long       nfuns;            /* Number of these symbols.  */
8146   char *              strtab;           /* The file's string table.  */
8147   unsigned long       strtab_size;      /* Size of string table.  */
8148 };
8149
8150 static const char *
8151 arm_print_vma_and_name (Filedata *                 filedata,
8152                         struct arm_unw_aux_info *  aux,
8153                         bfd_vma                    fn,
8154                         struct absaddr             addr)
8155 {
8156   const char *procname;
8157   bfd_vma sym_offset;
8158
8159   if (addr.section == SHN_UNDEF)
8160     addr.offset = fn;
8161
8162   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8163                            aux->strtab_size, addr, &procname,
8164                            &sym_offset);
8165
8166   print_vma (fn, PREFIX_HEX);
8167
8168   if (procname)
8169     {
8170       fputs (" <", stdout);
8171       fputs (procname, stdout);
8172
8173       if (sym_offset)
8174         printf ("+0x%lx", (unsigned long) sym_offset);
8175       fputc ('>', stdout);
8176     }
8177
8178   return procname;
8179 }
8180
8181 static void
8182 arm_free_section (struct arm_section *arm_sec)
8183 {
8184   if (arm_sec->data != NULL)
8185     free (arm_sec->data);
8186
8187   if (arm_sec->rela != NULL)
8188     free (arm_sec->rela);
8189 }
8190
8191 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8192       cached section and install SEC instead.
8193    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8194       and return its valued in * WORDP, relocating if necessary.
8195    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8196       relocation's offset in ADDR.
8197    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8198       into the string table of the symbol associated with the reloc.  If no
8199       reloc was applied store -1 there.
8200    5) Return TRUE upon success, FALSE otherwise.  */
8201
8202 static bfd_boolean
8203 get_unwind_section_word (Filedata *                 filedata,
8204                          struct arm_unw_aux_info *  aux,
8205                          struct arm_section *       arm_sec,
8206                          Elf_Internal_Shdr *        sec,
8207                          bfd_vma                    word_offset,
8208                          unsigned int *             wordp,
8209                          struct absaddr *           addr,
8210                          bfd_vma *                  sym_name)
8211 {
8212   Elf_Internal_Rela *rp;
8213   Elf_Internal_Sym *sym;
8214   const char * relname;
8215   unsigned int word;
8216   bfd_boolean wrapped;
8217
8218   if (sec == NULL || arm_sec == NULL)
8219     return FALSE;
8220
8221   addr->section = SHN_UNDEF;
8222   addr->offset = 0;
8223
8224   if (sym_name != NULL)
8225     *sym_name = (bfd_vma) -1;
8226
8227   /* If necessary, update the section cache.  */
8228   if (sec != arm_sec->sec)
8229     {
8230       Elf_Internal_Shdr *relsec;
8231
8232       arm_free_section (arm_sec);
8233
8234       arm_sec->sec = sec;
8235       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8236                                 sec->sh_size, _("unwind data"));
8237       arm_sec->rela = NULL;
8238       arm_sec->nrelas = 0;
8239
8240       for (relsec = filedata->section_headers;
8241            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8242            ++relsec)
8243         {
8244           if (relsec->sh_info >= filedata->file_header.e_shnum
8245               || filedata->section_headers + relsec->sh_info != sec
8246               /* PR 15745: Check the section type as well.  */
8247               || (relsec->sh_type != SHT_REL
8248                   && relsec->sh_type != SHT_RELA))
8249             continue;
8250
8251           arm_sec->rel_type = relsec->sh_type;
8252           if (relsec->sh_type == SHT_REL)
8253             {
8254               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8255                                      relsec->sh_size,
8256                                      & arm_sec->rela, & arm_sec->nrelas))
8257                 return FALSE;
8258             }
8259           else /* relsec->sh_type == SHT_RELA */
8260             {
8261               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8262                                       relsec->sh_size,
8263                                       & arm_sec->rela, & arm_sec->nrelas))
8264                 return FALSE;
8265             }
8266           break;
8267         }
8268
8269       arm_sec->next_rela = arm_sec->rela;
8270     }
8271
8272   /* If there is no unwind data we can do nothing.  */
8273   if (arm_sec->data == NULL)
8274     return FALSE;
8275
8276   /* If the offset is invalid then fail.  */
8277   if (/* PR 21343 *//* PR 18879 */
8278       sec->sh_size < 4
8279       || word_offset > (sec->sh_size - 4)
8280       || ((bfd_signed_vma) word_offset) < 0)
8281     return FALSE;
8282
8283   /* Get the word at the required offset.  */
8284   word = byte_get (arm_sec->data + word_offset, 4);
8285
8286   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8287   if (arm_sec->rela == NULL)
8288     {
8289       * wordp = word;
8290       return TRUE;
8291     }
8292
8293   /* Look through the relocs to find the one that applies to the provided offset.  */
8294   wrapped = FALSE;
8295   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8296     {
8297       bfd_vma prelval, offset;
8298
8299       if (rp->r_offset > word_offset && !wrapped)
8300         {
8301           rp = arm_sec->rela;
8302           wrapped = TRUE;
8303         }
8304       if (rp->r_offset > word_offset)
8305         break;
8306
8307       if (rp->r_offset & 3)
8308         {
8309           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8310                 (unsigned long) rp->r_offset);
8311           continue;
8312         }
8313
8314       if (rp->r_offset < word_offset)
8315         continue;
8316
8317       /* PR 17531: file: 027-161405-0.004  */
8318       if (aux->symtab == NULL)
8319         continue;
8320
8321       if (arm_sec->rel_type == SHT_REL)
8322         {
8323           offset = word & 0x7fffffff;
8324           if (offset & 0x40000000)
8325             offset |= ~ (bfd_vma) 0x7fffffff;
8326         }
8327       else if (arm_sec->rel_type == SHT_RELA)
8328         offset = rp->r_addend;
8329       else
8330         {
8331           error (_("Unknown section relocation type %d encountered\n"),
8332                  arm_sec->rel_type);
8333           break;
8334         }
8335
8336       /* PR 17531 file: 027-1241568-0.004.  */
8337       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8338         {
8339           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8340                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8341           break;
8342         }
8343
8344       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8345       offset += sym->st_value;
8346       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8347
8348       /* Check that we are processing the expected reloc type.  */
8349       if (filedata->file_header.e_machine == EM_ARM)
8350         {
8351           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8352           if (relname == NULL)
8353             {
8354               warn (_("Skipping unknown ARM relocation type: %d\n"),
8355                     (int) ELF32_R_TYPE (rp->r_info));
8356               continue;
8357             }
8358
8359           if (streq (relname, "R_ARM_NONE"))
8360               continue;
8361
8362           if (! streq (relname, "R_ARM_PREL31"))
8363             {
8364               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8365               continue;
8366             }
8367         }
8368       else if (filedata->file_header.e_machine == EM_TI_C6000)
8369         {
8370           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8371           if (relname == NULL)
8372             {
8373               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8374                     (int) ELF32_R_TYPE (rp->r_info));
8375               continue;
8376             }
8377
8378           if (streq (relname, "R_C6000_NONE"))
8379             continue;
8380
8381           if (! streq (relname, "R_C6000_PREL31"))
8382             {
8383               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8384               continue;
8385             }
8386
8387           prelval >>= 1;
8388         }
8389       else
8390         {
8391           /* This function currently only supports ARM and TI unwinders.  */
8392           warn (_("Only TI and ARM unwinders are currently supported\n"));
8393           break;
8394         }
8395
8396       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8397       addr->section = sym->st_shndx;
8398       addr->offset = offset;
8399
8400       if (sym_name)
8401         * sym_name = sym->st_name;
8402       break;
8403     }
8404
8405   *wordp = word;
8406   arm_sec->next_rela = rp;
8407
8408   return TRUE;
8409 }
8410
8411 static const char *tic6x_unwind_regnames[16] =
8412 {
8413   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8414   "A14", "A13", "A12", "A11", "A10",
8415   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8416 };
8417
8418 static void
8419 decode_tic6x_unwind_regmask (unsigned int mask)
8420 {
8421   int i;
8422
8423   for (i = 12; mask; mask >>= 1, i--)
8424     {
8425       if (mask & 1)
8426         {
8427           fputs (tic6x_unwind_regnames[i], stdout);
8428           if (mask > 1)
8429             fputs (", ", stdout);
8430         }
8431     }
8432 }
8433
8434 #define ADVANCE                                                 \
8435   if (remaining == 0 && more_words)                             \
8436     {                                                           \
8437       data_offset += 4;                                         \
8438       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8439                                      data_offset, & word, & addr, NULL))        \
8440         return FALSE;                                           \
8441       remaining = 4;                                            \
8442       more_words--;                                             \
8443     }                                                           \
8444
8445 #define GET_OP(OP)                      \
8446   ADVANCE;                              \
8447   if (remaining)                        \
8448     {                                   \
8449       remaining--;                      \
8450       (OP) = word >> 24;                \
8451       word <<= 8;                       \
8452     }                                   \
8453   else                                  \
8454     {                                   \
8455       printf (_("[Truncated opcode]\n"));       \
8456       return FALSE;                     \
8457     }                                   \
8458   printf ("0x%02x ", OP)
8459
8460 static bfd_boolean
8461 decode_arm_unwind_bytecode (Filedata *                 filedata,
8462                             struct arm_unw_aux_info *  aux,
8463                             unsigned int               word,
8464                             unsigned int               remaining,
8465                             unsigned int               more_words,
8466                             bfd_vma                    data_offset,
8467                             Elf_Internal_Shdr *        data_sec,
8468                             struct arm_section *       data_arm_sec)
8469 {
8470   struct absaddr addr;
8471   bfd_boolean res = TRUE;
8472
8473   /* Decode the unwinding instructions.  */
8474   while (1)
8475     {
8476       unsigned int op, op2;
8477
8478       ADVANCE;
8479       if (remaining == 0)
8480         break;
8481       remaining--;
8482       op = word >> 24;
8483       word <<= 8;
8484
8485       printf ("  0x%02x ", op);
8486
8487       if ((op & 0xc0) == 0x00)
8488         {
8489           int offset = ((op & 0x3f) << 2) + 4;
8490
8491           printf ("     vsp = vsp + %d", offset);
8492         }
8493       else if ((op & 0xc0) == 0x40)
8494         {
8495           int offset = ((op & 0x3f) << 2) + 4;
8496
8497           printf ("     vsp = vsp - %d", offset);
8498         }
8499       else if ((op & 0xf0) == 0x80)
8500         {
8501           GET_OP (op2);
8502           if (op == 0x80 && op2 == 0)
8503             printf (_("Refuse to unwind"));
8504           else
8505             {
8506               unsigned int mask = ((op & 0x0f) << 8) | op2;
8507               bfd_boolean first = TRUE;
8508               int i;
8509
8510               printf ("pop {");
8511               for (i = 0; i < 12; i++)
8512                 if (mask & (1 << i))
8513                   {
8514                     if (first)
8515                       first = FALSE;
8516                     else
8517                       printf (", ");
8518                     printf ("r%d", 4 + i);
8519                   }
8520               printf ("}");
8521             }
8522         }
8523       else if ((op & 0xf0) == 0x90)
8524         {
8525           if (op == 0x9d || op == 0x9f)
8526             printf (_("     [Reserved]"));
8527           else
8528             printf ("     vsp = r%d", op & 0x0f);
8529         }
8530       else if ((op & 0xf0) == 0xa0)
8531         {
8532           int end = 4 + (op & 0x07);
8533           bfd_boolean first = TRUE;
8534           int i;
8535
8536           printf ("     pop {");
8537           for (i = 4; i <= end; i++)
8538             {
8539               if (first)
8540                 first = FALSE;
8541               else
8542                 printf (", ");
8543               printf ("r%d", i);
8544             }
8545           if (op & 0x08)
8546             {
8547               if (!first)
8548                 printf (", ");
8549               printf ("r14");
8550             }
8551           printf ("}");
8552         }
8553       else if (op == 0xb0)
8554         printf (_("     finish"));
8555       else if (op == 0xb1)
8556         {
8557           GET_OP (op2);
8558           if (op2 == 0 || (op2 & 0xf0) != 0)
8559             printf (_("[Spare]"));
8560           else
8561             {
8562               unsigned int mask = op2 & 0x0f;
8563               bfd_boolean first = TRUE;
8564               int i;
8565
8566               printf ("pop {");
8567               for (i = 0; i < 12; i++)
8568                 if (mask & (1 << i))
8569                   {
8570                     if (first)
8571                       first = FALSE;
8572                     else
8573                       printf (", ");
8574                     printf ("r%d", i);
8575                   }
8576               printf ("}");
8577             }
8578         }
8579       else if (op == 0xb2)
8580         {
8581           unsigned char buf[9];
8582           unsigned int i, len;
8583           unsigned long offset;
8584
8585           for (i = 0; i < sizeof (buf); i++)
8586             {
8587               GET_OP (buf[i]);
8588               if ((buf[i] & 0x80) == 0)
8589                 break;
8590             }
8591           if (i == sizeof (buf))
8592             {
8593               error (_("corrupt change to vsp"));
8594               res = FALSE;
8595             }
8596           else
8597             {
8598               offset = read_uleb128 (buf, &len, buf + i + 1);
8599               assert (len == i + 1);
8600               offset = offset * 4 + 0x204;
8601               printf ("vsp = vsp + %ld", offset);
8602             }
8603         }
8604       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8605         {
8606           unsigned int first, last;
8607
8608           GET_OP (op2);
8609           first = op2 >> 4;
8610           last = op2 & 0x0f;
8611           if (op == 0xc8)
8612             first = first + 16;
8613           printf ("pop {D%d", first);
8614           if (last)
8615             printf ("-D%d", first + last);
8616           printf ("}");
8617         }
8618       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8619         {
8620           unsigned int count = op & 0x07;
8621
8622           printf ("pop {D8");
8623           if (count)
8624             printf ("-D%d", 8 + count);
8625           printf ("}");
8626         }
8627       else if (op >= 0xc0 && op <= 0xc5)
8628         {
8629           unsigned int count = op & 0x07;
8630
8631           printf ("     pop {wR10");
8632           if (count)
8633             printf ("-wR%d", 10 + count);
8634           printf ("}");
8635         }
8636       else if (op == 0xc6)
8637         {
8638           unsigned int first, last;
8639
8640           GET_OP (op2);
8641           first = op2 >> 4;
8642           last = op2 & 0x0f;
8643           printf ("pop {wR%d", first);
8644           if (last)
8645             printf ("-wR%d", first + last);
8646           printf ("}");
8647         }
8648       else if (op == 0xc7)
8649         {
8650           GET_OP (op2);
8651           if (op2 == 0 || (op2 & 0xf0) != 0)
8652             printf (_("[Spare]"));
8653           else
8654             {
8655               unsigned int mask = op2 & 0x0f;
8656               bfd_boolean first = TRUE;
8657               int i;
8658
8659               printf ("pop {");
8660               for (i = 0; i < 4; i++)
8661                 if (mask & (1 << i))
8662                   {
8663                     if (first)
8664                       first = FALSE;
8665                     else
8666                       printf (", ");
8667                     printf ("wCGR%d", i);
8668                   }
8669               printf ("}");
8670             }
8671         }
8672       else
8673         {
8674           printf (_("     [unsupported opcode]"));
8675           res = FALSE;
8676         }
8677
8678       printf ("\n");
8679     }
8680
8681   return res;
8682 }
8683
8684 static bfd_boolean
8685 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8686                               struct arm_unw_aux_info *  aux,
8687                               unsigned int               word,
8688                               unsigned int               remaining,
8689                               unsigned int               more_words,
8690                               bfd_vma                    data_offset,
8691                               Elf_Internal_Shdr *        data_sec,
8692                               struct arm_section *       data_arm_sec)
8693 {
8694   struct absaddr addr;
8695
8696   /* Decode the unwinding instructions.  */
8697   while (1)
8698     {
8699       unsigned int op, op2;
8700
8701       ADVANCE;
8702       if (remaining == 0)
8703         break;
8704       remaining--;
8705       op = word >> 24;
8706       word <<= 8;
8707
8708       printf ("  0x%02x ", op);
8709
8710       if ((op & 0xc0) == 0x00)
8711         {
8712           int offset = ((op & 0x3f) << 3) + 8;
8713           printf ("     sp = sp + %d", offset);
8714         }
8715       else if ((op & 0xc0) == 0x80)
8716         {
8717           GET_OP (op2);
8718           if (op == 0x80 && op2 == 0)
8719             printf (_("Refuse to unwind"));
8720           else
8721             {
8722               unsigned int mask = ((op & 0x1f) << 8) | op2;
8723               if (op & 0x20)
8724                 printf ("pop compact {");
8725               else
8726                 printf ("pop {");
8727
8728               decode_tic6x_unwind_regmask (mask);
8729               printf("}");
8730             }
8731         }
8732       else if ((op & 0xf0) == 0xc0)
8733         {
8734           unsigned int reg;
8735           unsigned int nregs;
8736           unsigned int i;
8737           const char *name;
8738           struct
8739           {
8740             unsigned int offset;
8741             unsigned int reg;
8742           } regpos[16];
8743
8744           /* Scan entire instruction first so that GET_OP output is not
8745              interleaved with disassembly.  */
8746           nregs = 0;
8747           for (i = 0; nregs < (op & 0xf); i++)
8748             {
8749               GET_OP (op2);
8750               reg = op2 >> 4;
8751               if (reg != 0xf)
8752                 {
8753                   regpos[nregs].offset = i * 2;
8754                   regpos[nregs].reg = reg;
8755                   nregs++;
8756                 }
8757
8758               reg = op2 & 0xf;
8759               if (reg != 0xf)
8760                 {
8761                   regpos[nregs].offset = i * 2 + 1;
8762                   regpos[nregs].reg = reg;
8763                   nregs++;
8764                 }
8765             }
8766
8767           printf (_("pop frame {"));
8768           reg = nregs - 1;
8769           for (i = i * 2; i > 0; i--)
8770             {
8771               if (regpos[reg].offset == i - 1)
8772                 {
8773                   name = tic6x_unwind_regnames[regpos[reg].reg];
8774                   if (reg > 0)
8775                     reg--;
8776                 }
8777               else
8778                 name = _("[pad]");
8779
8780               fputs (name, stdout);
8781               if (i > 1)
8782                 printf (", ");
8783             }
8784
8785           printf ("}");
8786         }
8787       else if (op == 0xd0)
8788         printf ("     MOV FP, SP");
8789       else if (op == 0xd1)
8790         printf ("     __c6xabi_pop_rts");
8791       else if (op == 0xd2)
8792         {
8793           unsigned char buf[9];
8794           unsigned int i, len;
8795           unsigned long offset;
8796
8797           for (i = 0; i < sizeof (buf); i++)
8798             {
8799               GET_OP (buf[i]);
8800               if ((buf[i] & 0x80) == 0)
8801                 break;
8802             }
8803           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8804           if (i == sizeof (buf))
8805             {
8806               warn (_("Corrupt stack pointer adjustment detected\n"));
8807               return FALSE;
8808             }
8809
8810           offset = read_uleb128 (buf, &len, buf + i + 1);
8811           assert (len == i + 1);
8812           offset = offset * 8 + 0x408;
8813           printf (_("sp = sp + %ld"), offset);
8814         }
8815       else if ((op & 0xf0) == 0xe0)
8816         {
8817           if ((op & 0x0f) == 7)
8818             printf ("     RETURN");
8819           else
8820             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8821         }
8822       else
8823         {
8824           printf (_("     [unsupported opcode]"));
8825         }
8826       putchar ('\n');
8827     }
8828
8829   return TRUE;
8830 }
8831
8832 static bfd_vma
8833 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8834 {
8835   bfd_vma offset;
8836
8837   offset = word & 0x7fffffff;
8838   if (offset & 0x40000000)
8839     offset |= ~ (bfd_vma) 0x7fffffff;
8840
8841   if (filedata->file_header.e_machine == EM_TI_C6000)
8842     offset <<= 1;
8843
8844   return offset + where;
8845 }
8846
8847 static bfd_boolean
8848 decode_arm_unwind (Filedata *                 filedata,
8849                    struct arm_unw_aux_info *  aux,
8850                    unsigned int               word,
8851                    unsigned int               remaining,
8852                    bfd_vma                    data_offset,
8853                    Elf_Internal_Shdr *        data_sec,
8854                    struct arm_section *       data_arm_sec)
8855 {
8856   int per_index;
8857   unsigned int more_words = 0;
8858   struct absaddr addr;
8859   bfd_vma sym_name = (bfd_vma) -1;
8860   bfd_boolean res = TRUE;
8861
8862   if (remaining == 0)
8863     {
8864       /* Fetch the first word.
8865          Note - when decoding an object file the address extracted
8866          here will always be 0.  So we also pass in the sym_name
8867          parameter so that we can find the symbol associated with
8868          the personality routine.  */
8869       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8870                                      & word, & addr, & sym_name))
8871         return FALSE;
8872
8873       remaining = 4;
8874     }
8875
8876   if ((word & 0x80000000) == 0)
8877     {
8878       /* Expand prel31 for personality routine.  */
8879       bfd_vma fn;
8880       const char *procname;
8881
8882       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8883       printf (_("  Personality routine: "));
8884       if (fn == 0
8885           && addr.section == SHN_UNDEF && addr.offset == 0
8886           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8887         {
8888           procname = aux->strtab + sym_name;
8889           print_vma (fn, PREFIX_HEX);
8890           if (procname)
8891             {
8892               fputs (" <", stdout);
8893               fputs (procname, stdout);
8894               fputc ('>', stdout);
8895             }
8896         }
8897       else
8898         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8899       fputc ('\n', stdout);
8900
8901       /* The GCC personality routines use the standard compact
8902          encoding, starting with one byte giving the number of
8903          words.  */
8904       if (procname != NULL
8905           && (const_strneq (procname, "__gcc_personality_v0")
8906               || const_strneq (procname, "__gxx_personality_v0")
8907               || const_strneq (procname, "__gcj_personality_v0")
8908               || const_strneq (procname, "__gnu_objc_personality_v0")))
8909         {
8910           remaining = 0;
8911           more_words = 1;
8912           ADVANCE;
8913           if (!remaining)
8914             {
8915               printf (_("  [Truncated data]\n"));
8916               return FALSE;
8917             }
8918           more_words = word >> 24;
8919           word <<= 8;
8920           remaining--;
8921           per_index = -1;
8922         }
8923       else
8924         return TRUE;
8925     }
8926   else
8927     {
8928       /* ARM EHABI Section 6.3:
8929
8930          An exception-handling table entry for the compact model looks like:
8931
8932            31 30-28 27-24 23-0
8933            -- ----- ----- ----
8934             1   0   index Data for personalityRoutine[index]    */
8935
8936       if (filedata->file_header.e_machine == EM_ARM
8937           && (word & 0x70000000))
8938         {
8939           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8940           res = FALSE;
8941         }
8942
8943       per_index = (word >> 24) & 0x7f;
8944       printf (_("  Compact model index: %d\n"), per_index);
8945       if (per_index == 0)
8946         {
8947           more_words = 0;
8948           word <<= 8;
8949           remaining--;
8950         }
8951       else if (per_index < 3)
8952         {
8953           more_words = (word >> 16) & 0xff;
8954           word <<= 16;
8955           remaining -= 2;
8956         }
8957     }
8958
8959   switch (filedata->file_header.e_machine)
8960     {
8961     case EM_ARM:
8962       if (per_index < 3)
8963         {
8964           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
8965                                             data_offset, data_sec, data_arm_sec))
8966             res = FALSE;
8967         }
8968       else
8969         {
8970           warn (_("Unknown ARM compact model index encountered\n"));
8971           printf (_("  [reserved]\n"));
8972           res = FALSE;
8973         }
8974       break;
8975
8976     case EM_TI_C6000:
8977       if (per_index < 3)
8978         {
8979           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
8980                                               data_offset, data_sec, data_arm_sec))
8981             res = FALSE;
8982         }
8983       else if (per_index < 5)
8984         {
8985           if (((word >> 17) & 0x7f) == 0x7f)
8986             printf (_("  Restore stack from frame pointer\n"));
8987           else
8988             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8989           printf (_("  Registers restored: "));
8990           if (per_index == 4)
8991             printf (" (compact) ");
8992           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8993           putchar ('\n');
8994           printf (_("  Return register: %s\n"),
8995                   tic6x_unwind_regnames[word & 0xf]);
8996         }
8997       else
8998         printf (_("  [reserved (%d)]\n"), per_index);
8999       break;
9000
9001     default:
9002       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9003              filedata->file_header.e_machine);
9004       res = FALSE;
9005     }
9006
9007   /* Decode the descriptors.  Not implemented.  */
9008
9009   return res;
9010 }
9011
9012 static bfd_boolean
9013 dump_arm_unwind (Filedata *                 filedata,
9014                  struct arm_unw_aux_info *  aux,
9015                  Elf_Internal_Shdr *        exidx_sec)
9016 {
9017   struct arm_section exidx_arm_sec, extab_arm_sec;
9018   unsigned int i, exidx_len;
9019   unsigned long j, nfuns;
9020   bfd_boolean res = TRUE;
9021
9022   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9023   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9024   exidx_len = exidx_sec->sh_size / 8;
9025
9026   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9027   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9028     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9029       aux->funtab[nfuns++] = aux->symtab[j];
9030   aux->nfuns = nfuns;
9031   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9032
9033   for (i = 0; i < exidx_len; i++)
9034     {
9035       unsigned int exidx_fn, exidx_entry;
9036       struct absaddr fn_addr, entry_addr;
9037       bfd_vma fn;
9038
9039       fputc ('\n', stdout);
9040
9041       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9042                                      8 * i, & exidx_fn, & fn_addr, NULL)
9043           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9044                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9045         {
9046           free (aux->funtab);
9047           arm_free_section (& exidx_arm_sec);
9048           arm_free_section (& extab_arm_sec);
9049           return FALSE;
9050         }
9051
9052       /* ARM EHABI, Section 5:
9053          An index table entry consists of 2 words.
9054          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9055       if (exidx_fn & 0x80000000)
9056         {
9057           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9058           res = FALSE;
9059         }
9060
9061       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9062
9063       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9064       fputs (": ", stdout);
9065
9066       if (exidx_entry == 1)
9067         {
9068           print_vma (exidx_entry, PREFIX_HEX);
9069           fputs (" [cantunwind]\n", stdout);
9070         }
9071       else if (exidx_entry & 0x80000000)
9072         {
9073           print_vma (exidx_entry, PREFIX_HEX);
9074           fputc ('\n', stdout);
9075           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9076         }
9077       else
9078         {
9079           bfd_vma table, table_offset = 0;
9080           Elf_Internal_Shdr *table_sec;
9081
9082           fputs ("@", stdout);
9083           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9084           print_vma (table, PREFIX_HEX);
9085           printf ("\n");
9086
9087           /* Locate the matching .ARM.extab.  */
9088           if (entry_addr.section != SHN_UNDEF
9089               && entry_addr.section < filedata->file_header.e_shnum)
9090             {
9091               table_sec = filedata->section_headers + entry_addr.section;
9092               table_offset = entry_addr.offset;
9093               /* PR 18879 */
9094               if (table_offset > table_sec->sh_size
9095                   || ((bfd_signed_vma) table_offset) < 0)
9096                 {
9097                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9098                         (unsigned long) table_offset,
9099                         printable_section_name (filedata, table_sec));
9100                   res = FALSE;
9101                   continue;
9102                 }
9103             }
9104           else
9105             {
9106               table_sec = find_section_by_address (filedata, table);
9107               if (table_sec != NULL)
9108                 table_offset = table - table_sec->sh_addr;
9109             }
9110
9111           if (table_sec == NULL)
9112             {
9113               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9114                     (unsigned long) table);
9115               res = FALSE;
9116               continue;
9117             }
9118
9119           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9120                                    &extab_arm_sec))
9121             res = FALSE;
9122         }
9123     }
9124
9125   printf ("\n");
9126
9127   free (aux->funtab);
9128   arm_free_section (&exidx_arm_sec);
9129   arm_free_section (&extab_arm_sec);
9130
9131   return res;
9132 }
9133
9134 /* Used for both ARM and C6X unwinding tables.  */
9135
9136 static bfd_boolean
9137 arm_process_unwind (Filedata * filedata)
9138 {
9139   struct arm_unw_aux_info aux;
9140   Elf_Internal_Shdr *unwsec = NULL;
9141   Elf_Internal_Shdr *strsec;
9142   Elf_Internal_Shdr *sec;
9143   unsigned long i;
9144   unsigned int sec_type;
9145   bfd_boolean res = TRUE;
9146
9147   switch (filedata->file_header.e_machine)
9148     {
9149     case EM_ARM:
9150       sec_type = SHT_ARM_EXIDX;
9151       break;
9152
9153     case EM_TI_C6000:
9154       sec_type = SHT_C6000_UNWIND;
9155       break;
9156
9157     default:
9158       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9159              filedata->file_header.e_machine);
9160       return FALSE;
9161     }
9162
9163   if (filedata->string_table == NULL)
9164     return FALSE;
9165
9166   memset (& aux, 0, sizeof (aux));
9167   aux.filedata = filedata;
9168
9169   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9170     {
9171       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9172         {
9173           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9174
9175           strsec = filedata->section_headers + sec->sh_link;
9176
9177           /* PR binutils/17531 file: 011-12666-0.004.  */
9178           if (aux.strtab != NULL)
9179             {
9180               error (_("Multiple string tables found in file.\n"));
9181               free (aux.strtab);
9182               res = FALSE;
9183             }
9184           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9185                                  1, strsec->sh_size, _("string table"));
9186           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9187         }
9188       else if (sec->sh_type == sec_type)
9189         unwsec = sec;
9190     }
9191
9192   if (unwsec == NULL)
9193     printf (_("\nThere are no unwind sections in this file.\n"));
9194   else
9195     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9196       {
9197         if (sec->sh_type == sec_type)
9198           {
9199             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9200             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9201                               "contains %lu entry:\n",
9202                               "\nUnwind section '%s' at offset 0x%lx "
9203                               "contains %lu entries:\n",
9204                               num_unwind),
9205                     printable_section_name (filedata, sec),
9206                     (unsigned long) sec->sh_offset,
9207                     num_unwind);
9208
9209             if (! dump_arm_unwind (filedata, &aux, sec))
9210               res = FALSE;
9211           }
9212       }
9213
9214   if (aux.symtab)
9215     free (aux.symtab);
9216   if (aux.strtab)
9217     free ((char *) aux.strtab);
9218
9219   return res;
9220 }
9221
9222 static bfd_boolean
9223 process_unwind (Filedata * filedata)
9224 {
9225   struct unwind_handler
9226   {
9227     unsigned int machtype;
9228     bfd_boolean (* handler)(Filedata *);
9229   } handlers[] =
9230   {
9231     { EM_ARM, arm_process_unwind },
9232     { EM_IA_64, ia64_process_unwind },
9233     { EM_PARISC, hppa_process_unwind },
9234     { EM_TI_C6000, arm_process_unwind },
9235     { 0, NULL }
9236   };
9237   int i;
9238
9239   if (!do_unwind)
9240     return TRUE;
9241
9242   for (i = 0; handlers[i].handler != NULL; i++)
9243     if (filedata->file_header.e_machine == handlers[i].machtype)
9244       return handlers[i].handler (filedata);
9245
9246   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9247           get_machine_name (filedata->file_header.e_machine));
9248   return TRUE;
9249 }
9250
9251 static void
9252 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9253 {
9254   switch (entry->d_tag)
9255     {
9256     case DT_MIPS_FLAGS:
9257       if (entry->d_un.d_val == 0)
9258         printf (_("NONE"));
9259       else
9260         {
9261           static const char * opts[] =
9262           {
9263             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9264             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9265             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9266             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9267             "RLD_ORDER_SAFE"
9268           };
9269           unsigned int cnt;
9270           bfd_boolean first = TRUE;
9271
9272           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9273             if (entry->d_un.d_val & (1 << cnt))
9274               {
9275                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9276                 first = FALSE;
9277               }
9278         }
9279       break;
9280
9281     case DT_MIPS_IVERSION:
9282       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9283         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9284       else
9285         {
9286           char buf[40];
9287           sprintf_vma (buf, entry->d_un.d_ptr);
9288           /* Note: coded this way so that there is a single string for translation.  */
9289           printf (_("<corrupt: %s>"), buf);
9290         }
9291       break;
9292
9293     case DT_MIPS_TIME_STAMP:
9294       {
9295         char timebuf[128];
9296         struct tm * tmp;
9297         time_t atime = entry->d_un.d_val;
9298
9299         tmp = gmtime (&atime);
9300         /* PR 17531: file: 6accc532.  */
9301         if (tmp == NULL)
9302           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9303         else
9304           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9305                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9306                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9307         printf (_("Time Stamp: %s"), timebuf);
9308       }
9309       break;
9310
9311     case DT_MIPS_RLD_VERSION:
9312     case DT_MIPS_LOCAL_GOTNO:
9313     case DT_MIPS_CONFLICTNO:
9314     case DT_MIPS_LIBLISTNO:
9315     case DT_MIPS_SYMTABNO:
9316     case DT_MIPS_UNREFEXTNO:
9317     case DT_MIPS_HIPAGENO:
9318     case DT_MIPS_DELTA_CLASS_NO:
9319     case DT_MIPS_DELTA_INSTANCE_NO:
9320     case DT_MIPS_DELTA_RELOC_NO:
9321     case DT_MIPS_DELTA_SYM_NO:
9322     case DT_MIPS_DELTA_CLASSSYM_NO:
9323     case DT_MIPS_COMPACT_SIZE:
9324       print_vma (entry->d_un.d_val, DEC);
9325       break;
9326
9327     default:
9328       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9329     }
9330     putchar ('\n');
9331 }
9332
9333 static void
9334 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9335 {
9336   switch (entry->d_tag)
9337     {
9338     case DT_HP_DLD_FLAGS:
9339       {
9340         static struct
9341         {
9342           long int bit;
9343           const char * str;
9344         }
9345         flags[] =
9346         {
9347           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9348           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9349           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9350           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9351           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9352           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9353           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9354           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9355           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9356           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9357           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9358           { DT_HP_GST, "HP_GST" },
9359           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9360           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9361           { DT_HP_NODELETE, "HP_NODELETE" },
9362           { DT_HP_GROUP, "HP_GROUP" },
9363           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9364         };
9365         bfd_boolean first = TRUE;
9366         size_t cnt;
9367         bfd_vma val = entry->d_un.d_val;
9368
9369         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9370           if (val & flags[cnt].bit)
9371             {
9372               if (! first)
9373                 putchar (' ');
9374               fputs (flags[cnt].str, stdout);
9375               first = FALSE;
9376               val ^= flags[cnt].bit;
9377             }
9378
9379         if (val != 0 || first)
9380           {
9381             if (! first)
9382               putchar (' ');
9383             print_vma (val, HEX);
9384           }
9385       }
9386       break;
9387
9388     default:
9389       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9390       break;
9391     }
9392   putchar ('\n');
9393 }
9394
9395 #ifdef BFD64
9396
9397 /* VMS vs Unix time offset and factor.  */
9398
9399 #define VMS_EPOCH_OFFSET 35067168000000000LL
9400 #define VMS_GRANULARITY_FACTOR 10000000
9401
9402 /* Display a VMS time in a human readable format.  */
9403
9404 static void
9405 print_vms_time (bfd_int64_t vmstime)
9406 {
9407   struct tm *tm;
9408   time_t unxtime;
9409
9410   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9411   tm = gmtime (&unxtime);
9412   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9413           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9414           tm->tm_hour, tm->tm_min, tm->tm_sec);
9415 }
9416 #endif /* BFD64 */
9417
9418 static void
9419 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9420 {
9421   switch (entry->d_tag)
9422     {
9423     case DT_IA_64_PLT_RESERVE:
9424       /* First 3 slots reserved.  */
9425       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9426       printf (" -- ");
9427       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9428       break;
9429
9430     case DT_IA_64_VMS_LINKTIME:
9431 #ifdef BFD64
9432       print_vms_time (entry->d_un.d_val);
9433 #endif
9434       break;
9435
9436     case DT_IA_64_VMS_LNKFLAGS:
9437       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9438       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9439         printf (" CALL_DEBUG");
9440       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9441         printf (" NOP0BUFS");
9442       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9443         printf (" P0IMAGE");
9444       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9445         printf (" MKTHREADS");
9446       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9447         printf (" UPCALLS");
9448       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9449         printf (" IMGSTA");
9450       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9451         printf (" INITIALIZE");
9452       if (entry->d_un.d_val & VMS_LF_MAIN)
9453         printf (" MAIN");
9454       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9455         printf (" EXE_INIT");
9456       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9457         printf (" TBK_IN_IMG");
9458       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9459         printf (" DBG_IN_IMG");
9460       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9461         printf (" TBK_IN_DSF");
9462       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9463         printf (" DBG_IN_DSF");
9464       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9465         printf (" SIGNATURES");
9466       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9467         printf (" REL_SEG_OFF");
9468       break;
9469
9470     default:
9471       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9472       break;
9473     }
9474   putchar ('\n');
9475 }
9476
9477 static bfd_boolean
9478 get_32bit_dynamic_section (Filedata * filedata)
9479 {
9480   Elf32_External_Dyn * edyn;
9481   Elf32_External_Dyn * ext;
9482   Elf_Internal_Dyn * entry;
9483
9484   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9485                                           dynamic_size, _("dynamic section"));
9486   if (!edyn)
9487     return FALSE;
9488
9489   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9490      might not have the luxury of section headers.  Look for the DT_NULL
9491      terminator to determine the number of entries.  */
9492   for (ext = edyn, dynamic_nent = 0;
9493        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9494        ext++)
9495     {
9496       dynamic_nent++;
9497       if (BYTE_GET (ext->d_tag) == DT_NULL)
9498         break;
9499     }
9500
9501   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9502                                                   sizeof (* entry));
9503   if (dynamic_section == NULL)
9504     {
9505       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9506              (unsigned long) dynamic_nent);
9507       free (edyn);
9508       return FALSE;
9509     }
9510
9511   for (ext = edyn, entry = dynamic_section;
9512        entry < dynamic_section + dynamic_nent;
9513        ext++, entry++)
9514     {
9515       entry->d_tag      = BYTE_GET (ext->d_tag);
9516       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9517     }
9518
9519   free (edyn);
9520
9521   return TRUE;
9522 }
9523
9524 static bfd_boolean
9525 get_64bit_dynamic_section (Filedata * filedata)
9526 {
9527   Elf64_External_Dyn * edyn;
9528   Elf64_External_Dyn * ext;
9529   Elf_Internal_Dyn * entry;
9530
9531   /* Read in the data.  */
9532   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9533                                           dynamic_size, _("dynamic section"));
9534   if (!edyn)
9535     return FALSE;
9536
9537   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9538      might not have the luxury of section headers.  Look for the DT_NULL
9539      terminator to determine the number of entries.  */
9540   for (ext = edyn, dynamic_nent = 0;
9541        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9542        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9543        ext++)
9544     {
9545       dynamic_nent++;
9546       if (BYTE_GET (ext->d_tag) == DT_NULL)
9547         break;
9548     }
9549
9550   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9551                                                   sizeof (* entry));
9552   if (dynamic_section == NULL)
9553     {
9554       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9555              (unsigned long) dynamic_nent);
9556       free (edyn);
9557       return FALSE;
9558     }
9559
9560   /* Convert from external to internal formats.  */
9561   for (ext = edyn, entry = dynamic_section;
9562        entry < dynamic_section + dynamic_nent;
9563        ext++, entry++)
9564     {
9565       entry->d_tag      = BYTE_GET (ext->d_tag);
9566       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9567     }
9568
9569   free (edyn);
9570
9571   return TRUE;
9572 }
9573
9574 static void
9575 print_dynamic_flags (bfd_vma flags)
9576 {
9577   bfd_boolean first = TRUE;
9578
9579   while (flags)
9580     {
9581       bfd_vma flag;
9582
9583       flag = flags & - flags;
9584       flags &= ~ flag;
9585
9586       if (first)
9587         first = FALSE;
9588       else
9589         putc (' ', stdout);
9590
9591       switch (flag)
9592         {
9593         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9594         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9595         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9596         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9597         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9598         default:                fputs (_("unknown"), stdout); break;
9599         }
9600     }
9601   puts ("");
9602 }
9603
9604 /* Parse and display the contents of the dynamic section.  */
9605
9606 static bfd_boolean
9607 process_dynamic_section (Filedata * filedata)
9608 {
9609   Elf_Internal_Dyn * entry;
9610
9611   if (dynamic_size == 0)
9612     {
9613       if (do_dynamic)
9614         printf (_("\nThere is no dynamic section in this file.\n"));
9615
9616       return TRUE;
9617     }
9618
9619   if (is_32bit_elf)
9620     {
9621       if (! get_32bit_dynamic_section (filedata))
9622         return FALSE;
9623     }
9624   else
9625     {
9626       if (! get_64bit_dynamic_section (filedata))
9627         return FALSE;
9628     }
9629
9630   /* Find the appropriate symbol table.  */
9631   if (dynamic_symbols == NULL)
9632     {
9633       for (entry = dynamic_section;
9634            entry < dynamic_section + dynamic_nent;
9635            ++entry)
9636         {
9637           Elf_Internal_Shdr section;
9638
9639           if (entry->d_tag != DT_SYMTAB)
9640             continue;
9641
9642           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9643
9644           /* Since we do not know how big the symbol table is,
9645              we default to reading in the entire file (!) and
9646              processing that.  This is overkill, I know, but it
9647              should work.  */
9648           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9649           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9650             {
9651               /* See PR 21379 for a reproducer.  */
9652               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9653               return FALSE;
9654             }
9655
9656           if (archive_file_offset != 0)
9657             section.sh_size = archive_file_size - section.sh_offset;
9658           else
9659             section.sh_size = filedata->file_size - section.sh_offset;
9660
9661           if (is_32bit_elf)
9662             section.sh_entsize = sizeof (Elf32_External_Sym);
9663           else
9664             section.sh_entsize = sizeof (Elf64_External_Sym);
9665           section.sh_name = filedata->string_table_length;
9666
9667           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9668           if (num_dynamic_syms < 1)
9669             {
9670               error (_("Unable to determine the number of symbols to load\n"));
9671               continue;
9672             }
9673         }
9674     }
9675
9676   /* Similarly find a string table.  */
9677   if (dynamic_strings == NULL)
9678     {
9679       for (entry = dynamic_section;
9680            entry < dynamic_section + dynamic_nent;
9681            ++entry)
9682         {
9683           unsigned long offset;
9684           long str_tab_len;
9685
9686           if (entry->d_tag != DT_STRTAB)
9687             continue;
9688
9689           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9690
9691           /* Since we do not know how big the string table is,
9692              we default to reading in the entire file (!) and
9693              processing that.  This is overkill, I know, but it
9694              should work.  */
9695
9696           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9697
9698           if (archive_file_offset != 0)
9699             str_tab_len = archive_file_size - offset;
9700           else
9701             str_tab_len = filedata->file_size - offset;
9702
9703           if (str_tab_len < 1)
9704             {
9705               error
9706                 (_("Unable to determine the length of the dynamic string table\n"));
9707               continue;
9708             }
9709
9710           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9711                                                str_tab_len,
9712                                                _("dynamic string table"));
9713           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9714           break;
9715         }
9716     }
9717
9718   /* And find the syminfo section if available.  */
9719   if (dynamic_syminfo == NULL)
9720     {
9721       unsigned long syminsz = 0;
9722
9723       for (entry = dynamic_section;
9724            entry < dynamic_section + dynamic_nent;
9725            ++entry)
9726         {
9727           if (entry->d_tag == DT_SYMINENT)
9728             {
9729               /* Note: these braces are necessary to avoid a syntax
9730                  error from the SunOS4 C compiler.  */
9731               /* PR binutils/17531: A corrupt file can trigger this test.
9732                  So do not use an assert, instead generate an error message.  */
9733               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9734                 error (_("Bad value (%d) for SYMINENT entry\n"),
9735                        (int) entry->d_un.d_val);
9736             }
9737           else if (entry->d_tag == DT_SYMINSZ)
9738             syminsz = entry->d_un.d_val;
9739           else if (entry->d_tag == DT_SYMINFO)
9740             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9741                                                       syminsz);
9742         }
9743
9744       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9745         {
9746           Elf_External_Syminfo * extsyminfo;
9747           Elf_External_Syminfo * extsym;
9748           Elf_Internal_Syminfo * syminfo;
9749
9750           /* There is a syminfo section.  Read the data.  */
9751           extsyminfo = (Elf_External_Syminfo *)
9752               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9753                         _("symbol information"));
9754           if (!extsyminfo)
9755             return FALSE;
9756
9757           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9758           if (dynamic_syminfo == NULL)
9759             {
9760               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9761                      (unsigned long) syminsz);
9762               return FALSE;
9763             }
9764
9765           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9766           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9767                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9768                ++syminfo, ++extsym)
9769             {
9770               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9771               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9772             }
9773
9774           free (extsyminfo);
9775         }
9776     }
9777
9778   if (do_dynamic && dynamic_addr)
9779     printf (ngettext ("\nDynamic section at offset 0x%lx "
9780                       "contains %lu entry:\n",
9781                       "\nDynamic section at offset 0x%lx "
9782                       "contains %lu entries:\n",
9783                       dynamic_nent),
9784             dynamic_addr, (unsigned long) dynamic_nent);
9785   if (do_dynamic)
9786     printf (_("  Tag        Type                         Name/Value\n"));
9787
9788   for (entry = dynamic_section;
9789        entry < dynamic_section + dynamic_nent;
9790        entry++)
9791     {
9792       if (do_dynamic)
9793         {
9794           const char * dtype;
9795
9796           putchar (' ');
9797           print_vma (entry->d_tag, FULL_HEX);
9798           dtype = get_dynamic_type (filedata, entry->d_tag);
9799           printf (" (%s)%*s", dtype,
9800                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9801         }
9802
9803       switch (entry->d_tag)
9804         {
9805         case DT_FLAGS:
9806           if (do_dynamic)
9807             print_dynamic_flags (entry->d_un.d_val);
9808           break;
9809
9810         case DT_AUXILIARY:
9811         case DT_FILTER:
9812         case DT_CONFIG:
9813         case DT_DEPAUDIT:
9814         case DT_AUDIT:
9815           if (do_dynamic)
9816             {
9817               switch (entry->d_tag)
9818                 {
9819                 case DT_AUXILIARY:
9820                   printf (_("Auxiliary library"));
9821                   break;
9822
9823                 case DT_FILTER:
9824                   printf (_("Filter library"));
9825                   break;
9826
9827                 case DT_CONFIG:
9828                   printf (_("Configuration file"));
9829                   break;
9830
9831                 case DT_DEPAUDIT:
9832                   printf (_("Dependency audit library"));
9833                   break;
9834
9835                 case DT_AUDIT:
9836                   printf (_("Audit library"));
9837                   break;
9838                 }
9839
9840               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9841                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9842               else
9843                 {
9844                   printf (": ");
9845                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9846                   putchar ('\n');
9847                 }
9848             }
9849           break;
9850
9851         case DT_FEATURE:
9852           if (do_dynamic)
9853             {
9854               printf (_("Flags:"));
9855
9856               if (entry->d_un.d_val == 0)
9857                 printf (_(" None\n"));
9858               else
9859                 {
9860                   unsigned long int val = entry->d_un.d_val;
9861
9862                   if (val & DTF_1_PARINIT)
9863                     {
9864                       printf (" PARINIT");
9865                       val ^= DTF_1_PARINIT;
9866                     }
9867                   if (val & DTF_1_CONFEXP)
9868                     {
9869                       printf (" CONFEXP");
9870                       val ^= DTF_1_CONFEXP;
9871                     }
9872                   if (val != 0)
9873                     printf (" %lx", val);
9874                   puts ("");
9875                 }
9876             }
9877           break;
9878
9879         case DT_POSFLAG_1:
9880           if (do_dynamic)
9881             {
9882               printf (_("Flags:"));
9883
9884               if (entry->d_un.d_val == 0)
9885                 printf (_(" None\n"));
9886               else
9887                 {
9888                   unsigned long int val = entry->d_un.d_val;
9889
9890                   if (val & DF_P1_LAZYLOAD)
9891                     {
9892                       printf (" LAZYLOAD");
9893                       val ^= DF_P1_LAZYLOAD;
9894                     }
9895                   if (val & DF_P1_GROUPPERM)
9896                     {
9897                       printf (" GROUPPERM");
9898                       val ^= DF_P1_GROUPPERM;
9899                     }
9900                   if (val != 0)
9901                     printf (" %lx", val);
9902                   puts ("");
9903                 }
9904             }
9905           break;
9906
9907         case DT_FLAGS_1:
9908           if (do_dynamic)
9909             {
9910               printf (_("Flags:"));
9911               if (entry->d_un.d_val == 0)
9912                 printf (_(" None\n"));
9913               else
9914                 {
9915                   unsigned long int val = entry->d_un.d_val;
9916
9917                   if (val & DF_1_NOW)
9918                     {
9919                       printf (" NOW");
9920                       val ^= DF_1_NOW;
9921                     }
9922                   if (val & DF_1_GLOBAL)
9923                     {
9924                       printf (" GLOBAL");
9925                       val ^= DF_1_GLOBAL;
9926                     }
9927                   if (val & DF_1_GROUP)
9928                     {
9929                       printf (" GROUP");
9930                       val ^= DF_1_GROUP;
9931                     }
9932                   if (val & DF_1_NODELETE)
9933                     {
9934                       printf (" NODELETE");
9935                       val ^= DF_1_NODELETE;
9936                     }
9937                   if (val & DF_1_LOADFLTR)
9938                     {
9939                       printf (" LOADFLTR");
9940                       val ^= DF_1_LOADFLTR;
9941                     }
9942                   if (val & DF_1_INITFIRST)
9943                     {
9944                       printf (" INITFIRST");
9945                       val ^= DF_1_INITFIRST;
9946                     }
9947                   if (val & DF_1_NOOPEN)
9948                     {
9949                       printf (" NOOPEN");
9950                       val ^= DF_1_NOOPEN;
9951                     }
9952                   if (val & DF_1_ORIGIN)
9953                     {
9954                       printf (" ORIGIN");
9955                       val ^= DF_1_ORIGIN;
9956                     }
9957                   if (val & DF_1_DIRECT)
9958                     {
9959                       printf (" DIRECT");
9960                       val ^= DF_1_DIRECT;
9961                     }
9962                   if (val & DF_1_TRANS)
9963                     {
9964                       printf (" TRANS");
9965                       val ^= DF_1_TRANS;
9966                     }
9967                   if (val & DF_1_INTERPOSE)
9968                     {
9969                       printf (" INTERPOSE");
9970                       val ^= DF_1_INTERPOSE;
9971                     }
9972                   if (val & DF_1_NODEFLIB)
9973                     {
9974                       printf (" NODEFLIB");
9975                       val ^= DF_1_NODEFLIB;
9976                     }
9977                   if (val & DF_1_NODUMP)
9978                     {
9979                       printf (" NODUMP");
9980                       val ^= DF_1_NODUMP;
9981                     }
9982                   if (val & DF_1_CONFALT)
9983                     {
9984                       printf (" CONFALT");
9985                       val ^= DF_1_CONFALT;
9986                     }
9987                   if (val & DF_1_ENDFILTEE)
9988                     {
9989                       printf (" ENDFILTEE");
9990                       val ^= DF_1_ENDFILTEE;
9991                     }
9992                   if (val & DF_1_DISPRELDNE)
9993                     {
9994                       printf (" DISPRELDNE");
9995                       val ^= DF_1_DISPRELDNE;
9996                     }
9997                   if (val & DF_1_DISPRELPND)
9998                     {
9999                       printf (" DISPRELPND");
10000                       val ^= DF_1_DISPRELPND;
10001                     }
10002                   if (val & DF_1_NODIRECT)
10003                     {
10004                       printf (" NODIRECT");
10005                       val ^= DF_1_NODIRECT;
10006                     }
10007                   if (val & DF_1_IGNMULDEF)
10008                     {
10009                       printf (" IGNMULDEF");
10010                       val ^= DF_1_IGNMULDEF;
10011                     }
10012                   if (val & DF_1_NOKSYMS)
10013                     {
10014                       printf (" NOKSYMS");
10015                       val ^= DF_1_NOKSYMS;
10016                     }
10017                   if (val & DF_1_NOHDR)
10018                     {
10019                       printf (" NOHDR");
10020                       val ^= DF_1_NOHDR;
10021                     }
10022                   if (val & DF_1_EDITED)
10023                     {
10024                       printf (" EDITED");
10025                       val ^= DF_1_EDITED;
10026                     }
10027                   if (val & DF_1_NORELOC)
10028                     {
10029                       printf (" NORELOC");
10030                       val ^= DF_1_NORELOC;
10031                     }
10032                   if (val & DF_1_SYMINTPOSE)
10033                     {
10034                       printf (" SYMINTPOSE");
10035                       val ^= DF_1_SYMINTPOSE;
10036                     }
10037                   if (val & DF_1_GLOBAUDIT)
10038                     {
10039                       printf (" GLOBAUDIT");
10040                       val ^= DF_1_GLOBAUDIT;
10041                     }
10042                   if (val & DF_1_SINGLETON)
10043                     {
10044                       printf (" SINGLETON");
10045                       val ^= DF_1_SINGLETON;
10046                     }
10047                   if (val & DF_1_STUB)
10048                     {
10049                       printf (" STUB");
10050                       val ^= DF_1_STUB;
10051                     }
10052                   if (val & DF_1_PIE)
10053                     {
10054                       printf (" PIE");
10055                       val ^= DF_1_PIE;
10056                     }
10057                   if (val & DF_1_KMOD)
10058                     {
10059                       printf (" KMOD");
10060                       val ^= DF_1_KMOD;
10061                     }
10062                   if (val & DF_1_WEAKFILTER)
10063                     {
10064                       printf (" WEAKFILTER");
10065                       val ^= DF_1_WEAKFILTER;
10066                     }
10067                   if (val & DF_1_NOCOMMON)
10068                     {
10069                       printf (" NOCOMMON");
10070                       val ^= DF_1_NOCOMMON;
10071                     }
10072                   if (val != 0)
10073                     printf (" %lx", val);
10074                   puts ("");
10075                 }
10076             }
10077           break;
10078
10079         case DT_PLTREL:
10080           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10081           if (do_dynamic)
10082             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10083           break;
10084
10085         case DT_NULL    :
10086         case DT_NEEDED  :
10087         case DT_PLTGOT  :
10088         case DT_HASH    :
10089         case DT_STRTAB  :
10090         case DT_SYMTAB  :
10091         case DT_RELA    :
10092         case DT_INIT    :
10093         case DT_FINI    :
10094         case DT_SONAME  :
10095         case DT_RPATH   :
10096         case DT_SYMBOLIC:
10097         case DT_REL     :
10098         case DT_DEBUG   :
10099         case DT_TEXTREL :
10100         case DT_JMPREL  :
10101         case DT_RUNPATH :
10102           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10103
10104           if (do_dynamic)
10105             {
10106               char * name;
10107
10108               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10109                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10110               else
10111                 name = NULL;
10112
10113               if (name)
10114                 {
10115                   switch (entry->d_tag)
10116                     {
10117                     case DT_NEEDED:
10118                       printf (_("Shared library: [%s]"), name);
10119
10120                       if (streq (name, program_interpreter))
10121                         printf (_(" program interpreter"));
10122                       break;
10123
10124                     case DT_SONAME:
10125                       printf (_("Library soname: [%s]"), name);
10126                       break;
10127
10128                     case DT_RPATH:
10129                       printf (_("Library rpath: [%s]"), name);
10130                       break;
10131
10132                     case DT_RUNPATH:
10133                       printf (_("Library runpath: [%s]"), name);
10134                       break;
10135
10136                     default:
10137                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10138                       break;
10139                     }
10140                 }
10141               else
10142                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10143
10144               putchar ('\n');
10145             }
10146           break;
10147
10148         case DT_PLTRELSZ:
10149         case DT_RELASZ  :
10150         case DT_STRSZ   :
10151         case DT_RELSZ   :
10152         case DT_RELAENT :
10153         case DT_SYMENT  :
10154         case DT_RELENT  :
10155           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10156           /* Fall through.  */
10157         case DT_PLTPADSZ:
10158         case DT_MOVEENT :
10159         case DT_MOVESZ  :
10160         case DT_INIT_ARRAYSZ:
10161         case DT_FINI_ARRAYSZ:
10162         case DT_GNU_CONFLICTSZ:
10163         case DT_GNU_LIBLISTSZ:
10164           if (do_dynamic)
10165             {
10166               print_vma (entry->d_un.d_val, UNSIGNED);
10167               printf (_(" (bytes)\n"));
10168             }
10169           break;
10170
10171         case DT_VERDEFNUM:
10172         case DT_VERNEEDNUM:
10173         case DT_RELACOUNT:
10174         case DT_RELCOUNT:
10175           if (do_dynamic)
10176             {
10177               print_vma (entry->d_un.d_val, UNSIGNED);
10178               putchar ('\n');
10179             }
10180           break;
10181
10182         case DT_SYMINSZ:
10183         case DT_SYMINENT:
10184         case DT_SYMINFO:
10185         case DT_USED:
10186         case DT_INIT_ARRAY:
10187         case DT_FINI_ARRAY:
10188           if (do_dynamic)
10189             {
10190               if (entry->d_tag == DT_USED
10191                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10192                 {
10193                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10194
10195                   if (*name)
10196                     {
10197                       printf (_("Not needed object: [%s]\n"), name);
10198                       break;
10199                     }
10200                 }
10201
10202               print_vma (entry->d_un.d_val, PREFIX_HEX);
10203               putchar ('\n');
10204             }
10205           break;
10206
10207         case DT_BIND_NOW:
10208           /* The value of this entry is ignored.  */
10209           if (do_dynamic)
10210             putchar ('\n');
10211           break;
10212
10213         case DT_GNU_PRELINKED:
10214           if (do_dynamic)
10215             {
10216               struct tm * tmp;
10217               time_t atime = entry->d_un.d_val;
10218
10219               tmp = gmtime (&atime);
10220               /* PR 17533 file: 041-1244816-0.004.  */
10221               if (tmp == NULL)
10222                 printf (_("<corrupt time val: %lx"),
10223                         (unsigned long) atime);
10224               else
10225                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10226                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10227                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10228
10229             }
10230           break;
10231
10232         case DT_GNU_HASH:
10233           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10234           if (do_dynamic)
10235             {
10236               print_vma (entry->d_un.d_val, PREFIX_HEX);
10237               putchar ('\n');
10238             }
10239           break;
10240
10241         default:
10242           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10243             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10244               entry->d_un.d_val;
10245
10246           if (do_dynamic)
10247             {
10248               switch (filedata->file_header.e_machine)
10249                 {
10250                 case EM_MIPS:
10251                 case EM_MIPS_RS3_LE:
10252                   dynamic_section_mips_val (entry);
10253                   break;
10254                 case EM_PARISC:
10255                   dynamic_section_parisc_val (entry);
10256                   break;
10257                 case EM_IA_64:
10258                   dynamic_section_ia64_val (entry);
10259                   break;
10260                 default:
10261                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10262                   putchar ('\n');
10263                 }
10264             }
10265           break;
10266         }
10267     }
10268
10269   return TRUE;
10270 }
10271
10272 static char *
10273 get_ver_flags (unsigned int flags)
10274 {
10275   static char buff[128];
10276
10277   buff[0] = 0;
10278
10279   if (flags == 0)
10280     return _("none");
10281
10282   if (flags & VER_FLG_BASE)
10283     strcat (buff, "BASE");
10284
10285   if (flags & VER_FLG_WEAK)
10286     {
10287       if (flags & VER_FLG_BASE)
10288         strcat (buff, " | ");
10289
10290       strcat (buff, "WEAK");
10291     }
10292
10293   if (flags & VER_FLG_INFO)
10294     {
10295       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10296         strcat (buff, " | ");
10297
10298       strcat (buff, "INFO");
10299     }
10300
10301   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10302     {
10303       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10304         strcat (buff, " | ");
10305
10306       strcat (buff, _("<unknown>"));
10307     }
10308
10309   return buff;
10310 }
10311
10312 /* Display the contents of the version sections.  */
10313
10314 static bfd_boolean
10315 process_version_sections (Filedata * filedata)
10316 {
10317   Elf_Internal_Shdr * section;
10318   unsigned i;
10319   bfd_boolean found = FALSE;
10320
10321   if (! do_version)
10322     return TRUE;
10323
10324   for (i = 0, section = filedata->section_headers;
10325        i < filedata->file_header.e_shnum;
10326        i++, section++)
10327     {
10328       switch (section->sh_type)
10329         {
10330         case SHT_GNU_verdef:
10331           {
10332             Elf_External_Verdef * edefs;
10333             unsigned long idx;
10334             unsigned long cnt;
10335             char * endbuf;
10336
10337             found = TRUE;
10338
10339             printf (ngettext ("\nVersion definition section '%s' "
10340                               "contains %u entry:\n",
10341                               "\nVersion definition section '%s' "
10342                               "contains %u entries:\n",
10343                               section->sh_info),
10344                     printable_section_name (filedata, section),
10345                     section->sh_info);
10346
10347             printf (_("  Addr: 0x"));
10348             printf_vma (section->sh_addr);
10349             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10350                     (unsigned long) section->sh_offset, section->sh_link,
10351                     printable_section_name_from_index (filedata, section->sh_link));
10352
10353             edefs = (Elf_External_Verdef *)
10354                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10355                           _("version definition section"));
10356             if (!edefs)
10357               break;
10358             endbuf = (char *) edefs + section->sh_size;
10359
10360             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10361               {
10362                 char * vstart;
10363                 Elf_External_Verdef * edef;
10364                 Elf_Internal_Verdef ent;
10365                 Elf_External_Verdaux * eaux;
10366                 Elf_Internal_Verdaux aux;
10367                 unsigned long isum;
10368                 int j;
10369
10370                 vstart = ((char *) edefs) + idx;
10371                 if (vstart + sizeof (*edef) > endbuf)
10372                   break;
10373
10374                 edef = (Elf_External_Verdef *) vstart;
10375
10376                 ent.vd_version = BYTE_GET (edef->vd_version);
10377                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10378                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10379                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10380                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10381                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10382                 ent.vd_next    = BYTE_GET (edef->vd_next);
10383
10384                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10385                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10386
10387                 printf (_("  Index: %d  Cnt: %d  "),
10388                         ent.vd_ndx, ent.vd_cnt);
10389
10390                 /* Check for overflow.  */
10391                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10392                   break;
10393
10394                 vstart += ent.vd_aux;
10395
10396                 if (vstart + sizeof (*eaux) > endbuf)
10397                   break;
10398                 eaux = (Elf_External_Verdaux *) vstart;
10399
10400                 aux.vda_name = BYTE_GET (eaux->vda_name);
10401                 aux.vda_next = BYTE_GET (eaux->vda_next);
10402
10403                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10404                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10405                 else
10406                   printf (_("Name index: %ld\n"), aux.vda_name);
10407
10408                 isum = idx + ent.vd_aux;
10409
10410                 for (j = 1; j < ent.vd_cnt; j++)
10411                   {
10412                     if (aux.vda_next < sizeof (*eaux)
10413                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10414                       {
10415                         warn (_("Invalid vda_next field of %lx\n"),
10416                               aux.vda_next);
10417                         j = ent.vd_cnt;
10418                         break;
10419                       }
10420                     /* Check for overflow.  */
10421                     if (aux.vda_next > (size_t) (endbuf - vstart))
10422                       break;
10423
10424                     isum   += aux.vda_next;
10425                     vstart += aux.vda_next;
10426
10427                     if (vstart + sizeof (*eaux) > endbuf)
10428                       break;
10429                     eaux = (Elf_External_Verdaux *) vstart;
10430
10431                     aux.vda_name = BYTE_GET (eaux->vda_name);
10432                     aux.vda_next = BYTE_GET (eaux->vda_next);
10433
10434                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10435                       printf (_("  %#06lx: Parent %d: %s\n"),
10436                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10437                     else
10438                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10439                               isum, j, aux.vda_name);
10440                   }
10441
10442                 if (j < ent.vd_cnt)
10443                   printf (_("  Version def aux past end of section\n"));
10444
10445                 /* PR 17531:
10446                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10447                 if (ent.vd_next < sizeof (*edef)
10448                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10449                   {
10450                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10451                     cnt = section->sh_info;
10452                     break;
10453                   }
10454                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10455                   break;
10456
10457                 idx += ent.vd_next;
10458               }
10459
10460             if (cnt < section->sh_info)
10461               printf (_("  Version definition past end of section\n"));
10462
10463             free (edefs);
10464           }
10465           break;
10466
10467         case SHT_GNU_verneed:
10468           {
10469             Elf_External_Verneed * eneed;
10470             unsigned long idx;
10471             unsigned long cnt;
10472             char * endbuf;
10473
10474             found = TRUE;
10475
10476             printf (ngettext ("\nVersion needs section '%s' "
10477                               "contains %u entry:\n",
10478                               "\nVersion needs section '%s' "
10479                               "contains %u entries:\n",
10480                               section->sh_info),
10481                     printable_section_name (filedata, section), section->sh_info);
10482
10483             printf (_(" Addr: 0x"));
10484             printf_vma (section->sh_addr);
10485             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10486                     (unsigned long) section->sh_offset, section->sh_link,
10487                     printable_section_name_from_index (filedata, section->sh_link));
10488
10489             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10490                                                        section->sh_offset, 1,
10491                                                        section->sh_size,
10492                                                        _("Version Needs section"));
10493             if (!eneed)
10494               break;
10495             endbuf = (char *) eneed + section->sh_size;
10496
10497             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10498               {
10499                 Elf_External_Verneed * entry;
10500                 Elf_Internal_Verneed ent;
10501                 unsigned long isum;
10502                 int j;
10503                 char * vstart;
10504
10505                 vstart = ((char *) eneed) + idx;
10506                 if (vstart + sizeof (*entry) > endbuf)
10507                   break;
10508
10509                 entry = (Elf_External_Verneed *) vstart;
10510
10511                 ent.vn_version = BYTE_GET (entry->vn_version);
10512                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10513                 ent.vn_file    = BYTE_GET (entry->vn_file);
10514                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10515                 ent.vn_next    = BYTE_GET (entry->vn_next);
10516
10517                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10518
10519                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10520                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10521                 else
10522                   printf (_("  File: %lx"), ent.vn_file);
10523
10524                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10525
10526                 /* Check for overflow.  */
10527                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10528                   break;
10529                 vstart += ent.vn_aux;
10530
10531                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10532                   {
10533                     Elf_External_Vernaux * eaux;
10534                     Elf_Internal_Vernaux aux;
10535
10536                     if (vstart + sizeof (*eaux) > endbuf)
10537                       break;
10538                     eaux = (Elf_External_Vernaux *) vstart;
10539
10540                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10541                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10542                     aux.vna_other = BYTE_GET (eaux->vna_other);
10543                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10544                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10545
10546                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10547                       printf (_("  %#06lx:   Name: %s"),
10548                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10549                     else
10550                       printf (_("  %#06lx:   Name index: %lx"),
10551                               isum, aux.vna_name);
10552
10553                     printf (_("  Flags: %s  Version: %d\n"),
10554                             get_ver_flags (aux.vna_flags), aux.vna_other);
10555
10556                     if (aux.vna_next < sizeof (*eaux)
10557                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10558                       {
10559                         warn (_("Invalid vna_next field of %lx\n"),
10560                               aux.vna_next);
10561                         j = ent.vn_cnt;
10562                         break;
10563                       }
10564                     /* Check for overflow.  */
10565                     if (aux.vna_next > (size_t) (endbuf - vstart))
10566                       break;
10567                     isum   += aux.vna_next;
10568                     vstart += aux.vna_next;
10569                   }
10570
10571                 if (j < ent.vn_cnt)
10572                   warn (_("Missing Version Needs auxillary information\n"));
10573
10574                 if (ent.vn_next < sizeof (*entry)
10575                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10576                   {
10577                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10578                     cnt = section->sh_info;
10579                     break;
10580                   }
10581                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10582                   break;
10583                 idx += ent.vn_next;
10584               }
10585
10586             if (cnt < section->sh_info)
10587               warn (_("Missing Version Needs information\n"));
10588
10589             free (eneed);
10590           }
10591           break;
10592
10593         case SHT_GNU_versym:
10594           {
10595             Elf_Internal_Shdr * link_section;
10596             size_t total;
10597             unsigned int cnt;
10598             unsigned char * edata;
10599             unsigned short * data;
10600             char * strtab;
10601             Elf_Internal_Sym * symbols;
10602             Elf_Internal_Shdr * string_sec;
10603             unsigned long num_syms;
10604             long off;
10605
10606             if (section->sh_link >= filedata->file_header.e_shnum)
10607               break;
10608
10609             link_section = filedata->section_headers + section->sh_link;
10610             total = section->sh_size / sizeof (Elf_External_Versym);
10611
10612             if (link_section->sh_link >= filedata->file_header.e_shnum)
10613               break;
10614
10615             found = TRUE;
10616
10617             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10618             if (symbols == NULL)
10619               break;
10620
10621             string_sec = filedata->section_headers + link_section->sh_link;
10622
10623             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10624                                         string_sec->sh_size,
10625                                         _("version string table"));
10626             if (!strtab)
10627               {
10628                 free (symbols);
10629                 break;
10630               }
10631
10632             printf (ngettext ("\nVersion symbols section '%s' "
10633                               "contains %lu entry:\n",
10634                               "\nVersion symbols section '%s' "
10635                               "contains %lu entries:\n",
10636                               total),
10637                     printable_section_name (filedata, section), (unsigned long) total);
10638
10639             printf (_(" Addr: "));
10640             printf_vma (section->sh_addr);
10641             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10642                     (unsigned long) section->sh_offset, section->sh_link,
10643                     printable_section_name (filedata, link_section));
10644
10645             off = offset_from_vma (filedata,
10646                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10647                                    total * sizeof (short));
10648             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10649                                                 sizeof (short),
10650                                                 _("version symbol data"));
10651             if (!edata)
10652               {
10653                 free (strtab);
10654                 free (symbols);
10655                 break;
10656               }
10657
10658             data = (short unsigned int *) cmalloc (total, sizeof (short));
10659
10660             for (cnt = total; cnt --;)
10661               data[cnt] = byte_get (edata + cnt * sizeof (short),
10662                                     sizeof (short));
10663
10664             free (edata);
10665
10666             for (cnt = 0; cnt < total; cnt += 4)
10667               {
10668                 int j, nn;
10669                 char *name;
10670                 char *invalid = _("*invalid*");
10671
10672                 printf ("  %03x:", cnt);
10673
10674                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10675                   switch (data[cnt + j])
10676                     {
10677                     case 0:
10678                       fputs (_("   0 (*local*)    "), stdout);
10679                       break;
10680
10681                     case 1:
10682                       fputs (_("   1 (*global*)   "), stdout);
10683                       break;
10684
10685                     default:
10686                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10687                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10688
10689                       /* If this index value is greater than the size of the symbols
10690                          array, break to avoid an out-of-bounds read.  */
10691                       if ((unsigned long)(cnt + j) >= num_syms)
10692                         {
10693                           warn (_("invalid index into symbol array\n"));
10694                           break;
10695                         }
10696
10697                       name = NULL;
10698                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10699                         {
10700                           Elf_Internal_Verneed ivn;
10701                           unsigned long offset;
10702
10703                           offset = offset_from_vma
10704                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10705                              sizeof (Elf_External_Verneed));
10706
10707                           do
10708                             {
10709                               Elf_Internal_Vernaux ivna;
10710                               Elf_External_Verneed evn;
10711                               Elf_External_Vernaux evna;
10712                               unsigned long a_off;
10713
10714                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10715                                             _("version need")) == NULL)
10716                                 break;
10717
10718                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10719                               ivn.vn_next = BYTE_GET (evn.vn_next);
10720
10721                               a_off = offset + ivn.vn_aux;
10722
10723                               do
10724                                 {
10725                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10726                                                 1, _("version need aux (2)")) == NULL)
10727                                     {
10728                                       ivna.vna_next  = 0;
10729                                       ivna.vna_other = 0;
10730                                     }
10731                                   else
10732                                     {
10733                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10734                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10735                                     }
10736
10737                                   a_off += ivna.vna_next;
10738                                 }
10739                               while (ivna.vna_other != data[cnt + j]
10740                                      && ivna.vna_next != 0);
10741
10742                               if (ivna.vna_other == data[cnt + j])
10743                                 {
10744                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10745
10746                                   if (ivna.vna_name >= string_sec->sh_size)
10747                                     name = invalid;
10748                                   else
10749                                     name = strtab + ivna.vna_name;
10750                                   break;
10751                                 }
10752
10753                               offset += ivn.vn_next;
10754                             }
10755                           while (ivn.vn_next);
10756                         }
10757
10758                       if (data[cnt + j] != 0x8001
10759                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10760                         {
10761                           Elf_Internal_Verdef ivd;
10762                           Elf_External_Verdef evd;
10763                           unsigned long offset;
10764
10765                           offset = offset_from_vma
10766                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10767                              sizeof evd);
10768
10769                           do
10770                             {
10771                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10772                                             _("version def")) == NULL)
10773                                 {
10774                                   ivd.vd_next = 0;
10775                                   /* PR 17531: file: 046-1082287-0.004.  */
10776                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10777                                   break;
10778                                 }
10779                               else
10780                                 {
10781                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10782                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10783                                 }
10784
10785                               offset += ivd.vd_next;
10786                             }
10787                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10788                                  && ivd.vd_next != 0);
10789
10790                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10791                             {
10792                               Elf_External_Verdaux evda;
10793                               Elf_Internal_Verdaux ivda;
10794
10795                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10796
10797                               if (get_data (&evda, filedata,
10798                                             offset - ivd.vd_next + ivd.vd_aux,
10799                                             sizeof (evda), 1,
10800                                             _("version def aux")) == NULL)
10801                                 break;
10802
10803                               ivda.vda_name = BYTE_GET (evda.vda_name);
10804
10805                               if (ivda.vda_name >= string_sec->sh_size)
10806                                 name = invalid;
10807                               else if (name != NULL && name != invalid)
10808                                 name = _("*both*");
10809                               else
10810                                 name = strtab + ivda.vda_name;
10811                             }
10812                         }
10813                       if (name != NULL)
10814                         nn += printf ("(%s%-*s",
10815                                       name,
10816                                       12 - (int) strlen (name),
10817                                       ")");
10818
10819                       if (nn < 18)
10820                         printf ("%*c", 18 - nn, ' ');
10821                     }
10822
10823                 putchar ('\n');
10824               }
10825
10826             free (data);
10827             free (strtab);
10828             free (symbols);
10829           }
10830           break;
10831
10832         default:
10833           break;
10834         }
10835     }
10836
10837   if (! found)
10838     printf (_("\nNo version information found in this file.\n"));
10839
10840   return TRUE;
10841 }
10842
10843 static const char *
10844 get_symbol_binding (Filedata * filedata, unsigned int binding)
10845 {
10846   static char buff[32];
10847
10848   switch (binding)
10849     {
10850     case STB_LOCAL:     return "LOCAL";
10851     case STB_GLOBAL:    return "GLOBAL";
10852     case STB_WEAK:      return "WEAK";
10853     default:
10854       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10855         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10856                   binding);
10857       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10858         {
10859           if (binding == STB_GNU_UNIQUE
10860               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10861                   /* GNU is still using the default value 0.  */
10862                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10863             return "UNIQUE";
10864           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10865         }
10866       else
10867         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10868       return buff;
10869     }
10870 }
10871
10872 static const char *
10873 get_symbol_type (Filedata * filedata, unsigned int type)
10874 {
10875   static char buff[32];
10876
10877   switch (type)
10878     {
10879     case STT_NOTYPE:    return "NOTYPE";
10880     case STT_OBJECT:    return "OBJECT";
10881     case STT_FUNC:      return "FUNC";
10882     case STT_SECTION:   return "SECTION";
10883     case STT_FILE:      return "FILE";
10884     case STT_COMMON:    return "COMMON";
10885     case STT_TLS:       return "TLS";
10886     case STT_RELC:      return "RELC";
10887     case STT_SRELC:     return "SRELC";
10888     default:
10889       if (type >= STT_LOPROC && type <= STT_HIPROC)
10890         {
10891           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10892             return "THUMB_FUNC";
10893
10894           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10895             return "REGISTER";
10896
10897           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10898             return "PARISC_MILLI";
10899
10900           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10901         }
10902       else if (type >= STT_LOOS && type <= STT_HIOS)
10903         {
10904           if (filedata->file_header.e_machine == EM_PARISC)
10905             {
10906               if (type == STT_HP_OPAQUE)
10907                 return "HP_OPAQUE";
10908               if (type == STT_HP_STUB)
10909                 return "HP_STUB";
10910             }
10911
10912           if (type == STT_GNU_IFUNC
10913               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10914                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10915                   /* GNU is still using the default value 0.  */
10916                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10917             return "IFUNC";
10918
10919           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10920         }
10921       else
10922         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10923       return buff;
10924     }
10925 }
10926
10927 static const char *
10928 get_symbol_visibility (unsigned int visibility)
10929 {
10930   switch (visibility)
10931     {
10932     case STV_DEFAULT:   return "DEFAULT";
10933     case STV_INTERNAL:  return "INTERNAL";
10934     case STV_HIDDEN:    return "HIDDEN";
10935     case STV_PROTECTED: return "PROTECTED";
10936     default:
10937       error (_("Unrecognized visibility value: %u"), visibility);
10938       return _("<unknown>");
10939     }
10940 }
10941
10942 static const char *
10943 get_solaris_symbol_visibility (unsigned int visibility)
10944 {
10945   switch (visibility)
10946     {
10947     case 4: return "EXPORTED";
10948     case 5: return "SINGLETON";
10949     case 6: return "ELIMINATE";
10950     default: return get_symbol_visibility (visibility);
10951     }
10952 }
10953
10954 static const char *
10955 get_mips_symbol_other (unsigned int other)
10956 {
10957   switch (other)
10958     {
10959     case STO_OPTIONAL:      return "OPTIONAL";
10960     case STO_MIPS_PLT:      return "MIPS PLT";
10961     case STO_MIPS_PIC:      return "MIPS PIC";
10962     case STO_MICROMIPS:     return "MICROMIPS";
10963     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10964     case STO_MIPS16:        return "MIPS16";
10965     default:                return NULL;
10966     }
10967 }
10968
10969 static const char *
10970 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
10971 {
10972   if (is_ia64_vms (filedata))
10973     {
10974       static char res[32];
10975
10976       res[0] = 0;
10977
10978       /* Function types is for images and .STB files only.  */
10979       switch (filedata->file_header.e_type)
10980         {
10981         case ET_DYN:
10982         case ET_EXEC:
10983           switch (VMS_ST_FUNC_TYPE (other))
10984             {
10985             case VMS_SFT_CODE_ADDR:
10986               strcat (res, " CA");
10987               break;
10988             case VMS_SFT_SYMV_IDX:
10989               strcat (res, " VEC");
10990               break;
10991             case VMS_SFT_FD:
10992               strcat (res, " FD");
10993               break;
10994             case VMS_SFT_RESERVE:
10995               strcat (res, " RSV");
10996               break;
10997             default:
10998               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10999                     VMS_ST_FUNC_TYPE (other));
11000               strcat (res, " <unknown>");
11001               break;
11002             }
11003           break;
11004         default:
11005           break;
11006         }
11007       switch (VMS_ST_LINKAGE (other))
11008         {
11009         case VMS_STL_IGNORE:
11010           strcat (res, " IGN");
11011           break;
11012         case VMS_STL_RESERVE:
11013           strcat (res, " RSV");
11014           break;
11015         case VMS_STL_STD:
11016           strcat (res, " STD");
11017           break;
11018         case VMS_STL_LNK:
11019           strcat (res, " LNK");
11020           break;
11021         default:
11022           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11023                 VMS_ST_LINKAGE (other));
11024           strcat (res, " <unknown>");
11025           break;
11026         }
11027
11028       if (res[0] != 0)
11029         return res + 1;
11030       else
11031         return res;
11032     }
11033   return NULL;
11034 }
11035
11036 static const char *
11037 get_ppc64_symbol_other (unsigned int other)
11038 {
11039   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
11040     {
11041       static char buf[32];
11042       snprintf (buf, sizeof buf, _("<localentry>: %d"),
11043                 PPC64_LOCAL_ENTRY_OFFSET (other));
11044       return buf;
11045     }
11046   return NULL;
11047 }
11048
11049 static const char *
11050 get_symbol_other (Filedata * filedata, unsigned int other)
11051 {
11052   const char * result = NULL;
11053   static char buff [32];
11054
11055   if (other == 0)
11056     return "";
11057
11058   switch (filedata->file_header.e_machine)
11059     {
11060     case EM_MIPS:
11061       result = get_mips_symbol_other (other);
11062       break;
11063     case EM_IA_64:
11064       result = get_ia64_symbol_other (filedata, other);
11065       break;
11066     case EM_PPC64:
11067       result = get_ppc64_symbol_other (other);
11068       break;
11069     default:
11070       result = NULL;
11071       break;
11072     }
11073
11074   if (result)
11075     return result;
11076
11077   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11078   return buff;
11079 }
11080
11081 static const char *
11082 get_symbol_index_type (Filedata * filedata, unsigned int type)
11083 {
11084   static char buff[32];
11085
11086   switch (type)
11087     {
11088     case SHN_UNDEF:     return "UND";
11089     case SHN_ABS:       return "ABS";
11090     case SHN_COMMON:    return "COM";
11091     default:
11092       if (type == SHN_IA_64_ANSI_COMMON
11093           && filedata->file_header.e_machine == EM_IA_64
11094           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11095         return "ANSI_COM";
11096       else if ((filedata->file_header.e_machine == EM_X86_64
11097                 || filedata->file_header.e_machine == EM_L1OM
11098                 || filedata->file_header.e_machine == EM_K1OM)
11099                && type == SHN_X86_64_LCOMMON)
11100         return "LARGE_COM";
11101       else if ((type == SHN_MIPS_SCOMMON
11102                 && filedata->file_header.e_machine == EM_MIPS)
11103                || (type == SHN_TIC6X_SCOMMON
11104                    && filedata->file_header.e_machine == EM_TI_C6000))
11105         return "SCOM";
11106       else if (type == SHN_MIPS_SUNDEFINED
11107                && filedata->file_header.e_machine == EM_MIPS)
11108         return "SUND";
11109       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11110         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11111       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11112         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11113       else if (type >= SHN_LORESERVE)
11114         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11115       else if (type >= filedata->file_header.e_shnum)
11116         sprintf (buff, _("bad section index[%3d]"), type);
11117       else
11118         sprintf (buff, "%3d", type);
11119       break;
11120     }
11121
11122   return buff;
11123 }
11124
11125 static bfd_vma *
11126 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11127 {
11128   unsigned char * e_data;
11129   bfd_vma * i_data;
11130
11131   /* If the size_t type is smaller than the bfd_size_type, eg because
11132      you are building a 32-bit tool on a 64-bit host, then make sure
11133      that when (number) is cast to (size_t) no information is lost.  */
11134   if (sizeof (size_t) < sizeof (bfd_size_type)
11135       && (bfd_size_type) ((size_t) number) != number)
11136     {
11137       error (_("Size truncation prevents reading %s elements of size %u\n"),
11138              bfd_vmatoa ("u", number), ent_size);
11139       return NULL;
11140     }
11141
11142   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11143      attempting to allocate memory when the read is bound to fail.  */
11144   if (ent_size * number > filedata->file_size)
11145     {
11146       error (_("Invalid number of dynamic entries: %s\n"),
11147              bfd_vmatoa ("u", number));
11148       return NULL;
11149     }
11150
11151   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11152   if (e_data == NULL)
11153     {
11154       error (_("Out of memory reading %s dynamic entries\n"),
11155              bfd_vmatoa ("u", number));
11156       return NULL;
11157     }
11158
11159   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11160     {
11161       error (_("Unable to read in %s bytes of dynamic data\n"),
11162              bfd_vmatoa ("u", number * ent_size));
11163       free (e_data);
11164       return NULL;
11165     }
11166
11167   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11168   if (i_data == NULL)
11169     {
11170       error (_("Out of memory allocating space for %s dynamic entries\n"),
11171              bfd_vmatoa ("u", number));
11172       free (e_data);
11173       return NULL;
11174     }
11175
11176   while (number--)
11177     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11178
11179   free (e_data);
11180
11181   return i_data;
11182 }
11183
11184 static void
11185 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11186 {
11187   Elf_Internal_Sym * psym;
11188   int n;
11189
11190   n = print_vma (si, DEC_5);
11191   if (n < 5)
11192     fputs (&"     "[n], stdout);
11193   printf (" %3lu: ", hn);
11194
11195   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11196     {
11197       printf (_("<No info available for dynamic symbol number %lu>\n"),
11198               (unsigned long) si);
11199       return;
11200     }
11201
11202   psym = dynamic_symbols + si;
11203   print_vma (psym->st_value, LONG_HEX);
11204   putchar (' ');
11205   print_vma (psym->st_size, DEC_5);
11206
11207   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11208   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11209
11210   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11211     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11212   else
11213     {
11214       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11215
11216       printf (" %-7s",  get_symbol_visibility (vis));
11217       /* Check to see if any other bits in the st_other field are set.
11218          Note - displaying this information disrupts the layout of the
11219          table being generated, but for the moment this case is very
11220          rare.  */
11221       if (psym->st_other ^ vis)
11222         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11223     }
11224
11225   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11226   if (VALID_DYNAMIC_NAME (psym->st_name))
11227     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11228   else
11229     printf (_(" <corrupt: %14ld>"), psym->st_name);
11230   putchar ('\n');
11231 }
11232
11233 static const char *
11234 get_symbol_version_string (Filedata *                   filedata,
11235                            bfd_boolean                  is_dynsym,
11236                            const char *                 strtab,
11237                            unsigned long int            strtab_size,
11238                            unsigned int                 si,
11239                            Elf_Internal_Sym *           psym,
11240                            enum versioned_symbol_info * sym_info,
11241                            unsigned short *             vna_other)
11242 {
11243   unsigned char data[2];
11244   unsigned short vers_data;
11245   unsigned long offset;
11246
11247   if (!is_dynsym
11248       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11249     return NULL;
11250
11251   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11252                             sizeof data + si * sizeof (vers_data));
11253
11254   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11255                 sizeof (data), 1, _("version data")) == NULL)
11256     return NULL;
11257
11258   vers_data = byte_get (data, 2);
11259
11260   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11261     return NULL;
11262
11263   /* Usually we'd only see verdef for defined symbols, and verneed for
11264      undefined symbols.  However, symbols defined by the linker in
11265      .dynbss for variables copied from a shared library in order to
11266      avoid text relocations are defined yet have verneed.  We could
11267      use a heuristic to detect the special case, for example, check
11268      for verneed first on symbols defined in SHT_NOBITS sections, but
11269      it is simpler and more reliable to just look for both verdef and
11270      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11271
11272   if (psym->st_shndx != SHN_UNDEF
11273       && vers_data != 0x8001
11274       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11275     {
11276       Elf_Internal_Verdef ivd;
11277       Elf_Internal_Verdaux ivda;
11278       Elf_External_Verdaux evda;
11279       unsigned long off;
11280
11281       off = offset_from_vma (filedata,
11282                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11283                              sizeof (Elf_External_Verdef));
11284
11285       do
11286         {
11287           Elf_External_Verdef evd;
11288
11289           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11290                         _("version def")) == NULL)
11291             {
11292               ivd.vd_ndx = 0;
11293               ivd.vd_aux = 0;
11294               ivd.vd_next = 0;
11295             }
11296           else
11297             {
11298               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11299               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11300               ivd.vd_next = BYTE_GET (evd.vd_next);
11301             }
11302
11303           off += ivd.vd_next;
11304         }
11305       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11306
11307       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11308         {
11309           off -= ivd.vd_next;
11310           off += ivd.vd_aux;
11311
11312           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11313                         _("version def aux")) != NULL)
11314             {
11315               ivda.vda_name = BYTE_GET (evda.vda_name);
11316
11317               if (psym->st_name != ivda.vda_name)
11318                 {
11319                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11320                                ? symbol_hidden : symbol_public);
11321                   return (ivda.vda_name < strtab_size
11322                           ? strtab + ivda.vda_name : _("<corrupt>"));
11323                 }
11324             }
11325         }
11326     }
11327
11328   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11329     {
11330       Elf_External_Verneed evn;
11331       Elf_Internal_Verneed ivn;
11332       Elf_Internal_Vernaux ivna;
11333
11334       offset = offset_from_vma (filedata,
11335                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11336                                 sizeof evn);
11337       do
11338         {
11339           unsigned long vna_off;
11340
11341           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11342                         _("version need")) == NULL)
11343             {
11344               ivna.vna_next = 0;
11345               ivna.vna_other = 0;
11346               ivna.vna_name = 0;
11347               break;
11348             }
11349
11350           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11351           ivn.vn_next = BYTE_GET (evn.vn_next);
11352
11353           vna_off = offset + ivn.vn_aux;
11354
11355           do
11356             {
11357               Elf_External_Vernaux evna;
11358
11359               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11360                             _("version need aux (3)")) == NULL)
11361                 {
11362                   ivna.vna_next = 0;
11363                   ivna.vna_other = 0;
11364                   ivna.vna_name = 0;
11365                 }
11366               else
11367                 {
11368                   ivna.vna_other = BYTE_GET (evna.vna_other);
11369                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11370                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11371                 }
11372
11373               vna_off += ivna.vna_next;
11374             }
11375           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11376
11377           if (ivna.vna_other == vers_data)
11378             break;
11379
11380           offset += ivn.vn_next;
11381         }
11382       while (ivn.vn_next != 0);
11383
11384       if (ivna.vna_other == vers_data)
11385         {
11386           *sym_info = symbol_undefined;
11387           *vna_other = ivna.vna_other;
11388           return (ivna.vna_name < strtab_size
11389                   ? strtab + ivna.vna_name : _("<corrupt>"));
11390         }
11391     }
11392   return NULL;
11393 }
11394
11395 /* Dump the symbol table.  */
11396 static bfd_boolean
11397 process_symbol_table (Filedata * filedata)
11398 {
11399   Elf_Internal_Shdr * section;
11400   bfd_size_type nbuckets = 0;
11401   bfd_size_type nchains = 0;
11402   bfd_vma * buckets = NULL;
11403   bfd_vma * chains = NULL;
11404   bfd_vma ngnubuckets = 0;
11405   bfd_vma * gnubuckets = NULL;
11406   bfd_vma * gnuchains = NULL;
11407   bfd_vma gnusymidx = 0;
11408   bfd_size_type ngnuchains = 0;
11409
11410   if (!do_syms && !do_dyn_syms && !do_histogram)
11411     return TRUE;
11412
11413   if (dynamic_info[DT_HASH]
11414       && (do_histogram
11415           || (do_using_dynamic
11416               && !do_dyn_syms
11417               && dynamic_strings != NULL)))
11418     {
11419       unsigned char nb[8];
11420       unsigned char nc[8];
11421       unsigned int hash_ent_size = 4;
11422
11423       if ((filedata->file_header.e_machine == EM_ALPHA
11424            || filedata->file_header.e_machine == EM_S390
11425            || filedata->file_header.e_machine == EM_S390_OLD)
11426           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11427         hash_ent_size = 8;
11428
11429       if (fseek (filedata->handle,
11430                  (archive_file_offset
11431                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11432                                      sizeof nb + sizeof nc)),
11433                  SEEK_SET))
11434         {
11435           error (_("Unable to seek to start of dynamic information\n"));
11436           goto no_hash;
11437         }
11438
11439       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11440         {
11441           error (_("Failed to read in number of buckets\n"));
11442           goto no_hash;
11443         }
11444
11445       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11446         {
11447           error (_("Failed to read in number of chains\n"));
11448           goto no_hash;
11449         }
11450
11451       nbuckets = byte_get (nb, hash_ent_size);
11452       nchains  = byte_get (nc, hash_ent_size);
11453
11454       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11455       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11456
11457     no_hash:
11458       if (buckets == NULL || chains == NULL)
11459         {
11460           if (do_using_dynamic)
11461             return FALSE;
11462           free (buckets);
11463           free (chains);
11464           buckets = NULL;
11465           chains = NULL;
11466           nbuckets = 0;
11467           nchains = 0;
11468         }
11469     }
11470
11471   if (dynamic_info_DT_GNU_HASH
11472       && (do_histogram
11473           || (do_using_dynamic
11474               && !do_dyn_syms
11475               && dynamic_strings != NULL)))
11476     {
11477       unsigned char nb[16];
11478       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11479       bfd_vma buckets_vma;
11480
11481       if (fseek (filedata->handle,
11482                  (archive_file_offset
11483                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11484                                      sizeof nb)),
11485                  SEEK_SET))
11486         {
11487           error (_("Unable to seek to start of dynamic information\n"));
11488           goto no_gnu_hash;
11489         }
11490
11491       if (fread (nb, 16, 1, filedata->handle) != 1)
11492         {
11493           error (_("Failed to read in number of buckets\n"));
11494           goto no_gnu_hash;
11495         }
11496
11497       ngnubuckets = byte_get (nb, 4);
11498       gnusymidx = byte_get (nb + 4, 4);
11499       bitmaskwords = byte_get (nb + 8, 4);
11500       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11501       if (is_32bit_elf)
11502         buckets_vma += bitmaskwords * 4;
11503       else
11504         buckets_vma += bitmaskwords * 8;
11505
11506       if (fseek (filedata->handle,
11507                  (archive_file_offset
11508                   + offset_from_vma (filedata, buckets_vma, 4)),
11509                  SEEK_SET))
11510         {
11511           error (_("Unable to seek to start of dynamic information\n"));
11512           goto no_gnu_hash;
11513         }
11514
11515       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11516
11517       if (gnubuckets == NULL)
11518         goto no_gnu_hash;
11519
11520       for (i = 0; i < ngnubuckets; i++)
11521         if (gnubuckets[i] != 0)
11522           {
11523             if (gnubuckets[i] < gnusymidx)
11524               return FALSE;
11525
11526             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11527               maxchain = gnubuckets[i];
11528           }
11529
11530       if (maxchain == 0xffffffff)
11531         goto no_gnu_hash;
11532
11533       maxchain -= gnusymidx;
11534
11535       if (fseek (filedata->handle,
11536                  (archive_file_offset
11537                   + offset_from_vma (filedata, buckets_vma
11538                                            + 4 * (ngnubuckets + maxchain), 4)),
11539                  SEEK_SET))
11540         {
11541           error (_("Unable to seek to start of dynamic information\n"));
11542           goto no_gnu_hash;
11543         }
11544
11545       do
11546         {
11547           if (fread (nb, 4, 1, filedata->handle) != 1)
11548             {
11549               error (_("Failed to determine last chain length\n"));
11550               goto no_gnu_hash;
11551             }
11552
11553           if (maxchain + 1 == 0)
11554             goto no_gnu_hash;
11555
11556           ++maxchain;
11557         }
11558       while ((byte_get (nb, 4) & 1) == 0);
11559
11560       if (fseek (filedata->handle,
11561                  (archive_file_offset
11562                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11563                  SEEK_SET))
11564         {
11565           error (_("Unable to seek to start of dynamic information\n"));
11566           goto no_gnu_hash;
11567         }
11568
11569       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11570       ngnuchains = maxchain;
11571
11572     no_gnu_hash:
11573       if (gnuchains == NULL)
11574         {
11575           free (gnubuckets);
11576           gnubuckets = NULL;
11577           ngnubuckets = 0;
11578           if (do_using_dynamic)
11579             return FALSE;
11580         }
11581     }
11582
11583   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11584       && do_syms
11585       && do_using_dynamic
11586       && dynamic_strings != NULL
11587       && dynamic_symbols != NULL)
11588     {
11589       unsigned long hn;
11590
11591       if (dynamic_info[DT_HASH])
11592         {
11593           bfd_vma si;
11594           char *visited;
11595
11596           printf (_("\nSymbol table for image:\n"));
11597           if (is_32bit_elf)
11598             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11599           else
11600             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11601
11602           visited = xcmalloc (nchains, 1);
11603           memset (visited, 0, nchains);
11604           for (hn = 0; hn < nbuckets; hn++)
11605             {
11606               for (si = buckets[hn]; si > 0; si = chains[si])
11607                 {
11608                   print_dynamic_symbol (filedata, si, hn);
11609                   if (si >= nchains || visited[si])
11610                     {
11611                       error (_("histogram chain is corrupt\n"));
11612                       break;
11613                     }
11614                   visited[si] = 1;
11615                 }
11616             }
11617           free (visited);
11618         }
11619
11620       if (dynamic_info_DT_GNU_HASH)
11621         {
11622           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11623           if (is_32bit_elf)
11624             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11625           else
11626             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11627
11628           for (hn = 0; hn < ngnubuckets; ++hn)
11629             if (gnubuckets[hn] != 0)
11630               {
11631                 bfd_vma si = gnubuckets[hn];
11632                 bfd_vma off = si - gnusymidx;
11633
11634                 do
11635                   {
11636                     print_dynamic_symbol (filedata, si, hn);
11637                     si++;
11638                   }
11639                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11640               }
11641         }
11642     }
11643   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11644            && filedata->section_headers != NULL)
11645     {
11646       unsigned int i;
11647
11648       for (i = 0, section = filedata->section_headers;
11649            i < filedata->file_header.e_shnum;
11650            i++, section++)
11651         {
11652           unsigned int si;
11653           char * strtab = NULL;
11654           unsigned long int strtab_size = 0;
11655           Elf_Internal_Sym * symtab;
11656           Elf_Internal_Sym * psym;
11657           unsigned long num_syms;
11658
11659           if ((section->sh_type != SHT_SYMTAB
11660                && section->sh_type != SHT_DYNSYM)
11661               || (!do_syms
11662                   && section->sh_type == SHT_SYMTAB))
11663             continue;
11664
11665           if (section->sh_entsize == 0)
11666             {
11667               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11668                       printable_section_name (filedata, section));
11669               continue;
11670             }
11671
11672           num_syms = section->sh_size / section->sh_entsize;
11673           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11674                             "\nSymbol table '%s' contains %lu entries:\n",
11675                             num_syms),
11676                   printable_section_name (filedata, section),
11677                   num_syms);
11678
11679           if (is_32bit_elf)
11680             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11681           else
11682             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11683
11684           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11685           if (symtab == NULL)
11686             continue;
11687
11688           if (section->sh_link == filedata->file_header.e_shstrndx)
11689             {
11690               strtab = filedata->string_table;
11691               strtab_size = filedata->string_table_length;
11692             }
11693           else if (section->sh_link < filedata->file_header.e_shnum)
11694             {
11695               Elf_Internal_Shdr * string_sec;
11696
11697               string_sec = filedata->section_headers + section->sh_link;
11698
11699               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11700                                           1, string_sec->sh_size,
11701                                           _("string table"));
11702               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11703             }
11704
11705           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11706             {
11707               const char *version_string;
11708               enum versioned_symbol_info sym_info;
11709               unsigned short vna_other;
11710
11711               printf ("%6d: ", si);
11712               print_vma (psym->st_value, LONG_HEX);
11713               putchar (' ');
11714               print_vma (psym->st_size, DEC_5);
11715               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11716               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11717               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11718                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11719               else
11720                 {
11721                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11722
11723                   printf (" %-7s", get_symbol_visibility (vis));
11724                   /* Check to see if any other bits in the st_other field are set.
11725                      Note - displaying this information disrupts the layout of the
11726                      table being generated, but for the moment this case is very rare.  */
11727                   if (psym->st_other ^ vis)
11728                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11729                 }
11730               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11731               print_symbol (25, psym->st_name < strtab_size
11732                             ? strtab + psym->st_name : _("<corrupt>"));
11733
11734               version_string
11735                 = get_symbol_version_string (filedata,
11736                                              section->sh_type == SHT_DYNSYM,
11737                                              strtab, strtab_size, si,
11738                                              psym, &sym_info, &vna_other);
11739               if (version_string)
11740                 {
11741                   if (sym_info == symbol_undefined)
11742                     printf ("@%s (%d)", version_string, vna_other);
11743                   else
11744                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11745                             version_string);
11746                 }
11747
11748               putchar ('\n');
11749
11750               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11751                   && si >= section->sh_info
11752                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11753                   && filedata->file_header.e_machine != EM_MIPS
11754                   /* Solaris binaries have been found to violate this requirement as
11755                      well.  Not sure if this is a bug or an ABI requirement.  */
11756                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11757                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11758                       si, printable_section_name (filedata, section), section->sh_info);
11759             }
11760
11761           free (symtab);
11762           if (strtab != filedata->string_table)
11763             free (strtab);
11764         }
11765     }
11766   else if (do_syms)
11767     printf
11768       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11769
11770   if (do_histogram && buckets != NULL)
11771     {
11772       unsigned long * lengths;
11773       unsigned long * counts;
11774       unsigned long hn;
11775       bfd_vma si;
11776       unsigned long maxlength = 0;
11777       unsigned long nzero_counts = 0;
11778       unsigned long nsyms = 0;
11779       char *visited;
11780
11781       printf (ngettext ("\nHistogram for bucket list length "
11782                         "(total of %lu bucket):\n",
11783                         "\nHistogram for bucket list length "
11784                         "(total of %lu buckets):\n",
11785                         (unsigned long) nbuckets),
11786               (unsigned long) nbuckets);
11787
11788       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11789       if (lengths == NULL)
11790         {
11791           error (_("Out of memory allocating space for histogram buckets\n"));
11792           return FALSE;
11793         }
11794       visited = xcmalloc (nchains, 1);
11795       memset (visited, 0, nchains);
11796
11797       printf (_(" Length  Number     %% of total  Coverage\n"));
11798       for (hn = 0; hn < nbuckets; ++hn)
11799         {
11800           for (si = buckets[hn]; si > 0; si = chains[si])
11801             {
11802               ++nsyms;
11803               if (maxlength < ++lengths[hn])
11804                 ++maxlength;
11805               if (si >= nchains || visited[si])
11806                 {
11807                   error (_("histogram chain is corrupt\n"));
11808                   break;
11809                 }
11810               visited[si] = 1;
11811             }
11812         }
11813       free (visited);
11814
11815       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11816       if (counts == NULL)
11817         {
11818           free (lengths);
11819           error (_("Out of memory allocating space for histogram counts\n"));
11820           return FALSE;
11821         }
11822
11823       for (hn = 0; hn < nbuckets; ++hn)
11824         ++counts[lengths[hn]];
11825
11826       if (nbuckets > 0)
11827         {
11828           unsigned long i;
11829           printf ("      0  %-10lu (%5.1f%%)\n",
11830                   counts[0], (counts[0] * 100.0) / nbuckets);
11831           for (i = 1; i <= maxlength; ++i)
11832             {
11833               nzero_counts += counts[i] * i;
11834               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11835                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11836                       (nzero_counts * 100.0) / nsyms);
11837             }
11838         }
11839
11840       free (counts);
11841       free (lengths);
11842     }
11843
11844   if (buckets != NULL)
11845     {
11846       free (buckets);
11847       free (chains);
11848     }
11849
11850   if (do_histogram && gnubuckets != NULL)
11851     {
11852       unsigned long * lengths;
11853       unsigned long * counts;
11854       unsigned long hn;
11855       unsigned long maxlength = 0;
11856       unsigned long nzero_counts = 0;
11857       unsigned long nsyms = 0;
11858
11859       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11860                         "(total of %lu bucket):\n",
11861                         "\nHistogram for `.gnu.hash' bucket list length "
11862                         "(total of %lu buckets):\n",
11863                         (unsigned long) ngnubuckets),
11864               (unsigned long) ngnubuckets);
11865
11866       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11867       if (lengths == NULL)
11868         {
11869           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11870           return FALSE;
11871         }
11872
11873       printf (_(" Length  Number     %% of total  Coverage\n"));
11874
11875       for (hn = 0; hn < ngnubuckets; ++hn)
11876         if (gnubuckets[hn] != 0)
11877           {
11878             bfd_vma off, length = 1;
11879
11880             for (off = gnubuckets[hn] - gnusymidx;
11881                  /* PR 17531 file: 010-77222-0.004.  */
11882                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11883                  ++off)
11884               ++length;
11885             lengths[hn] = length;
11886             if (length > maxlength)
11887               maxlength = length;
11888             nsyms += length;
11889           }
11890
11891       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11892       if (counts == NULL)
11893         {
11894           free (lengths);
11895           error (_("Out of memory allocating space for gnu histogram counts\n"));
11896           return FALSE;
11897         }
11898
11899       for (hn = 0; hn < ngnubuckets; ++hn)
11900         ++counts[lengths[hn]];
11901
11902       if (ngnubuckets > 0)
11903         {
11904           unsigned long j;
11905           printf ("      0  %-10lu (%5.1f%%)\n",
11906                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11907           for (j = 1; j <= maxlength; ++j)
11908             {
11909               nzero_counts += counts[j] * j;
11910               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11911                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11912                       (nzero_counts * 100.0) / nsyms);
11913             }
11914         }
11915
11916       free (counts);
11917       free (lengths);
11918       free (gnubuckets);
11919       free (gnuchains);
11920     }
11921
11922   return TRUE;
11923 }
11924
11925 static bfd_boolean
11926 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11927 {
11928   unsigned int i;
11929
11930   if (dynamic_syminfo == NULL
11931       || !do_dynamic)
11932     /* No syminfo, this is ok.  */
11933     return TRUE;
11934
11935   /* There better should be a dynamic symbol section.  */
11936   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11937     return FALSE;
11938
11939   if (dynamic_addr)
11940     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11941                       "contains %d entry:\n",
11942                       "\nDynamic info segment at offset 0x%lx "
11943                       "contains %d entries:\n",
11944                       dynamic_syminfo_nent),
11945             dynamic_syminfo_offset, dynamic_syminfo_nent);
11946
11947   printf (_(" Num: Name                           BoundTo     Flags\n"));
11948   for (i = 0; i < dynamic_syminfo_nent; ++i)
11949     {
11950       unsigned short int flags = dynamic_syminfo[i].si_flags;
11951
11952       printf ("%4d: ", i);
11953       if (i >= num_dynamic_syms)
11954         printf (_("<corrupt index>"));
11955       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11956         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11957       else
11958         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11959       putchar (' ');
11960
11961       switch (dynamic_syminfo[i].si_boundto)
11962         {
11963         case SYMINFO_BT_SELF:
11964           fputs ("SELF       ", stdout);
11965           break;
11966         case SYMINFO_BT_PARENT:
11967           fputs ("PARENT     ", stdout);
11968           break;
11969         default:
11970           if (dynamic_syminfo[i].si_boundto > 0
11971               && dynamic_syminfo[i].si_boundto < dynamic_nent
11972               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11973             {
11974               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11975               putchar (' ' );
11976             }
11977           else
11978             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11979           break;
11980         }
11981
11982       if (flags & SYMINFO_FLG_DIRECT)
11983         printf (" DIRECT");
11984       if (flags & SYMINFO_FLG_PASSTHRU)
11985         printf (" PASSTHRU");
11986       if (flags & SYMINFO_FLG_COPY)
11987         printf (" COPY");
11988       if (flags & SYMINFO_FLG_LAZYLOAD)
11989         printf (" LAZYLOAD");
11990
11991       puts ("");
11992     }
11993
11994   return TRUE;
11995 }
11996
11997 #define IN_RANGE(START,END,ADDR,OFF)            \
11998   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11999
12000 /* Check to see if the given reloc needs to be handled in a target specific
12001    manner.  If so then process the reloc and return TRUE otherwise return
12002    FALSE.
12003
12004    If called with reloc == NULL, then this is a signal that reloc processing
12005    for the current section has finished, and any saved state should be
12006    discarded.  */
12007
12008 static bfd_boolean
12009 target_specific_reloc_handling (Filedata *           filedata,
12010                                 Elf_Internal_Rela *  reloc,
12011                                 unsigned char *      start,
12012                                 unsigned char *      end,
12013                                 Elf_Internal_Sym *   symtab,
12014                                 unsigned long        num_syms)
12015 {
12016   unsigned int reloc_type = 0;
12017   unsigned long sym_index = 0;
12018
12019   if (reloc)
12020     {
12021       reloc_type = get_reloc_type (filedata, reloc->r_info);
12022       sym_index = get_reloc_symindex (reloc->r_info);
12023     }
12024
12025   switch (filedata->file_header.e_machine)
12026     {
12027     case EM_MSP430:
12028     case EM_MSP430_OLD:
12029       {
12030         static Elf_Internal_Sym * saved_sym = NULL;
12031
12032         if (reloc == NULL)
12033           {
12034             saved_sym = NULL;
12035             return TRUE;
12036           }
12037
12038         switch (reloc_type)
12039           {
12040           case 10: /* R_MSP430_SYM_DIFF */
12041             if (uses_msp430x_relocs (filedata))
12042               break;
12043             /* Fall through.  */
12044           case 21: /* R_MSP430X_SYM_DIFF */
12045             /* PR 21139.  */
12046             if (sym_index >= num_syms)
12047               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12048                      sym_index);
12049             else
12050               saved_sym = symtab + sym_index;
12051             return TRUE;
12052
12053           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12054           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12055             goto handle_sym_diff;
12056
12057           case 5: /* R_MSP430_16_BYTE */
12058           case 9: /* R_MSP430_8 */
12059             if (uses_msp430x_relocs (filedata))
12060               break;
12061             goto handle_sym_diff;
12062
12063           case 2: /* R_MSP430_ABS16 */
12064           case 15: /* R_MSP430X_ABS16 */
12065             if (! uses_msp430x_relocs (filedata))
12066               break;
12067             goto handle_sym_diff;
12068
12069           handle_sym_diff:
12070             if (saved_sym != NULL)
12071               {
12072                 int reloc_size = reloc_type == 1 ? 4 : 2;
12073                 bfd_vma value;
12074
12075                 if (sym_index >= num_syms)
12076                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12077                          sym_index);
12078                 else
12079                   {
12080                     value = reloc->r_addend + (symtab[sym_index].st_value
12081                                                - saved_sym->st_value);
12082
12083                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12084                       byte_put (start + reloc->r_offset, value, reloc_size);
12085                     else
12086                       /* PR 21137 */
12087                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12088                              (long) reloc->r_offset);
12089                   }
12090
12091                 saved_sym = NULL;
12092                 return TRUE;
12093               }
12094             break;
12095
12096           default:
12097             if (saved_sym != NULL)
12098               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12099             break;
12100           }
12101         break;
12102       }
12103
12104     case EM_MN10300:
12105     case EM_CYGNUS_MN10300:
12106       {
12107         static Elf_Internal_Sym * saved_sym = NULL;
12108
12109         if (reloc == NULL)
12110           {
12111             saved_sym = NULL;
12112             return TRUE;
12113           }
12114
12115         switch (reloc_type)
12116           {
12117           case 34: /* R_MN10300_ALIGN */
12118             return TRUE;
12119           case 33: /* R_MN10300_SYM_DIFF */
12120             if (sym_index >= num_syms)
12121               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12122                      sym_index);
12123             else
12124               saved_sym = symtab + sym_index;
12125             return TRUE;
12126
12127           case 1: /* R_MN10300_32 */
12128           case 2: /* R_MN10300_16 */
12129             if (saved_sym != NULL)
12130               {
12131                 int reloc_size = reloc_type == 1 ? 4 : 2;
12132                 bfd_vma value;
12133
12134                 if (sym_index >= num_syms)
12135                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12136                          sym_index);
12137                 else
12138                   {
12139                     value = reloc->r_addend + (symtab[sym_index].st_value
12140                                                - saved_sym->st_value);
12141
12142                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12143                       byte_put (start + reloc->r_offset, value, reloc_size);
12144                     else
12145                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12146                              (long) reloc->r_offset);
12147                   }
12148
12149                 saved_sym = NULL;
12150                 return TRUE;
12151               }
12152             break;
12153           default:
12154             if (saved_sym != NULL)
12155               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12156             break;
12157           }
12158         break;
12159       }
12160
12161     case EM_RL78:
12162       {
12163         static bfd_vma saved_sym1 = 0;
12164         static bfd_vma saved_sym2 = 0;
12165         static bfd_vma value;
12166
12167         if (reloc == NULL)
12168           {
12169             saved_sym1 = saved_sym2 = 0;
12170             return TRUE;
12171           }
12172
12173         switch (reloc_type)
12174           {
12175           case 0x80: /* R_RL78_SYM.  */
12176             saved_sym1 = saved_sym2;
12177             if (sym_index >= num_syms)
12178               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12179                      sym_index);
12180             else
12181               {
12182                 saved_sym2 = symtab[sym_index].st_value;
12183                 saved_sym2 += reloc->r_addend;
12184               }
12185             return TRUE;
12186
12187           case 0x83: /* R_RL78_OPsub.  */
12188             value = saved_sym1 - saved_sym2;
12189             saved_sym2 = saved_sym1 = 0;
12190             return TRUE;
12191             break;
12192
12193           case 0x41: /* R_RL78_ABS32.  */
12194             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12195               byte_put (start + reloc->r_offset, value, 4);
12196             else
12197               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12198                      (long) reloc->r_offset);
12199             value = 0;
12200             return TRUE;
12201
12202           case 0x43: /* R_RL78_ABS16.  */
12203             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12204               byte_put (start + reloc->r_offset, value, 2);
12205             else
12206               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12207                      (long) reloc->r_offset);
12208             value = 0;
12209             return TRUE;
12210
12211           default:
12212             break;
12213           }
12214         break;
12215       }
12216     }
12217
12218   return FALSE;
12219 }
12220
12221 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12222    DWARF debug sections.  This is a target specific test.  Note - we do not
12223    go through the whole including-target-headers-multiple-times route, (as
12224    we have already done with <elf/h8.h>) because this would become very
12225    messy and even then this function would have to contain target specific
12226    information (the names of the relocs instead of their numeric values).
12227    FIXME: This is not the correct way to solve this problem.  The proper way
12228    is to have target specific reloc sizing and typing functions created by
12229    the reloc-macros.h header, in the same way that it already creates the
12230    reloc naming functions.  */
12231
12232 static bfd_boolean
12233 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12234 {
12235   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12236   switch (filedata->file_header.e_machine)
12237     {
12238     case EM_386:
12239     case EM_IAMCU:
12240       return reloc_type == 1; /* R_386_32.  */
12241     case EM_68K:
12242       return reloc_type == 1; /* R_68K_32.  */
12243     case EM_860:
12244       return reloc_type == 1; /* R_860_32.  */
12245     case EM_960:
12246       return reloc_type == 2; /* R_960_32.  */
12247     case EM_AARCH64:
12248       return (reloc_type == 258
12249               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12250     case EM_ADAPTEVA_EPIPHANY:
12251       return reloc_type == 3;
12252     case EM_ALPHA:
12253       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12254     case EM_ARC:
12255       return reloc_type == 1; /* R_ARC_32.  */
12256     case EM_ARC_COMPACT:
12257     case EM_ARC_COMPACT2:
12258       return reloc_type == 4; /* R_ARC_32.  */
12259     case EM_ARM:
12260       return reloc_type == 2; /* R_ARM_ABS32 */
12261     case EM_AVR_OLD:
12262     case EM_AVR:
12263       return reloc_type == 1;
12264     case EM_BLACKFIN:
12265       return reloc_type == 0x12; /* R_byte4_data.  */
12266     case EM_CRIS:
12267       return reloc_type == 3; /* R_CRIS_32.  */
12268     case EM_CR16:
12269       return reloc_type == 3; /* R_CR16_NUM32.  */
12270     case EM_CRX:
12271       return reloc_type == 15; /* R_CRX_NUM32.  */
12272     case EM_CYGNUS_FRV:
12273       return reloc_type == 1;
12274     case EM_CYGNUS_D10V:
12275     case EM_D10V:
12276       return reloc_type == 6; /* R_D10V_32.  */
12277     case EM_CYGNUS_D30V:
12278     case EM_D30V:
12279       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12280     case EM_DLX:
12281       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12282     case EM_CYGNUS_FR30:
12283     case EM_FR30:
12284       return reloc_type == 3; /* R_FR30_32.  */
12285     case EM_FT32:
12286       return reloc_type == 1; /* R_FT32_32.  */
12287     case EM_H8S:
12288     case EM_H8_300:
12289     case EM_H8_300H:
12290       return reloc_type == 1; /* R_H8_DIR32.  */
12291     case EM_IA_64:
12292       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12293               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12294               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12295               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12296     case EM_IP2K_OLD:
12297     case EM_IP2K:
12298       return reloc_type == 2; /* R_IP2K_32.  */
12299     case EM_IQ2000:
12300       return reloc_type == 2; /* R_IQ2000_32.  */
12301     case EM_LATTICEMICO32:
12302       return reloc_type == 3; /* R_LM32_32.  */
12303     case EM_M32C_OLD:
12304     case EM_M32C:
12305       return reloc_type == 3; /* R_M32C_32.  */
12306     case EM_M32R:
12307       return reloc_type == 34; /* R_M32R_32_RELA.  */
12308     case EM_68HC11:
12309     case EM_68HC12:
12310       return reloc_type == 6; /* R_M68HC11_32.  */
12311     case EM_MCORE:
12312       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12313     case EM_CYGNUS_MEP:
12314       return reloc_type == 4; /* R_MEP_32.  */
12315     case EM_METAG:
12316       return reloc_type == 2; /* R_METAG_ADDR32.  */
12317     case EM_MICROBLAZE:
12318       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12319     case EM_MIPS:
12320       return reloc_type == 2; /* R_MIPS_32.  */
12321     case EM_MMIX:
12322       return reloc_type == 4; /* R_MMIX_32.  */
12323     case EM_CYGNUS_MN10200:
12324     case EM_MN10200:
12325       return reloc_type == 1; /* R_MN10200_32.  */
12326     case EM_CYGNUS_MN10300:
12327     case EM_MN10300:
12328       return reloc_type == 1; /* R_MN10300_32.  */
12329     case EM_MOXIE:
12330       return reloc_type == 1; /* R_MOXIE_32.  */
12331     case EM_MSP430_OLD:
12332     case EM_MSP430:
12333       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12334     case EM_MT:
12335       return reloc_type == 2; /* R_MT_32.  */
12336     case EM_NDS32:
12337       return reloc_type == 20; /* R_NDS32_RELA.  */
12338     case EM_ALTERA_NIOS2:
12339       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12340     case EM_NIOS32:
12341       return reloc_type == 1; /* R_NIOS_32.  */
12342     case EM_OR1K:
12343       return reloc_type == 1; /* R_OR1K_32.  */
12344     case EM_PARISC:
12345       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12346               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12347               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12348     case EM_PJ:
12349     case EM_PJ_OLD:
12350       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12351     case EM_PPC64:
12352       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12353     case EM_PPC:
12354       return reloc_type == 1; /* R_PPC_ADDR32.  */
12355     case EM_TI_PRU:
12356       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12357     case EM_RISCV:
12358       return reloc_type == 1; /* R_RISCV_32.  */
12359     case EM_RL78:
12360       return reloc_type == 1; /* R_RL78_DIR32.  */
12361     case EM_RX:
12362       return reloc_type == 1; /* R_RX_DIR32.  */
12363     case EM_S370:
12364       return reloc_type == 1; /* R_I370_ADDR31.  */
12365     case EM_S390_OLD:
12366     case EM_S390:
12367       return reloc_type == 4; /* R_S390_32.  */
12368     case EM_SCORE:
12369       return reloc_type == 8; /* R_SCORE_ABS32.  */
12370     case EM_SH:
12371       return reloc_type == 1; /* R_SH_DIR32.  */
12372     case EM_SPARC32PLUS:
12373     case EM_SPARCV9:
12374     case EM_SPARC:
12375       return reloc_type == 3 /* R_SPARC_32.  */
12376         || reloc_type == 23; /* R_SPARC_UA32.  */
12377     case EM_SPU:
12378       return reloc_type == 6; /* R_SPU_ADDR32 */
12379     case EM_TI_C6000:
12380       return reloc_type == 1; /* R_C6000_ABS32.  */
12381     case EM_TILEGX:
12382       return reloc_type == 2; /* R_TILEGX_32.  */
12383     case EM_TILEPRO:
12384       return reloc_type == 1; /* R_TILEPRO_32.  */
12385     case EM_CYGNUS_V850:
12386     case EM_V850:
12387       return reloc_type == 6; /* R_V850_ABS32.  */
12388     case EM_V800:
12389       return reloc_type == 0x33; /* R_V810_WORD.  */
12390     case EM_VAX:
12391       return reloc_type == 1; /* R_VAX_32.  */
12392     case EM_VISIUM:
12393       return reloc_type == 3;  /* R_VISIUM_32. */
12394     case EM_WEBASSEMBLY:
12395       return reloc_type == 1;  /* R_WASM32_32.  */
12396     case EM_X86_64:
12397     case EM_L1OM:
12398     case EM_K1OM:
12399       return reloc_type == 10; /* R_X86_64_32.  */
12400     case EM_XC16X:
12401     case EM_C166:
12402       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12403     case EM_XGATE:
12404       return reloc_type == 4; /* R_XGATE_32.  */
12405     case EM_XSTORMY16:
12406       return reloc_type == 1; /* R_XSTROMY16_32.  */
12407     case EM_XTENSA_OLD:
12408     case EM_XTENSA:
12409       return reloc_type == 1; /* R_XTENSA_32.  */
12410     default:
12411       {
12412         static unsigned int prev_warn = 0;
12413
12414         /* Avoid repeating the same warning multiple times.  */
12415         if (prev_warn != filedata->file_header.e_machine)
12416           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12417                  filedata->file_header.e_machine);
12418         prev_warn = filedata->file_header.e_machine;
12419         return FALSE;
12420       }
12421     }
12422 }
12423
12424 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12425    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12426
12427 static bfd_boolean
12428 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12429 {
12430   switch (filedata->file_header.e_machine)
12431   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12432     {
12433     case EM_386:
12434     case EM_IAMCU:
12435       return reloc_type == 2;  /* R_386_PC32.  */
12436     case EM_68K:
12437       return reloc_type == 4;  /* R_68K_PC32.  */
12438     case EM_AARCH64:
12439       return reloc_type == 261; /* R_AARCH64_PREL32 */
12440     case EM_ADAPTEVA_EPIPHANY:
12441       return reloc_type == 6;
12442     case EM_ALPHA:
12443       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12444     case EM_ARC_COMPACT:
12445     case EM_ARC_COMPACT2:
12446       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12447     case EM_ARM:
12448       return reloc_type == 3;  /* R_ARM_REL32 */
12449     case EM_AVR_OLD:
12450     case EM_AVR:
12451       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12452     case EM_MICROBLAZE:
12453       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12454     case EM_OR1K:
12455       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12456     case EM_PARISC:
12457       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12458     case EM_PPC:
12459       return reloc_type == 26; /* R_PPC_REL32.  */
12460     case EM_PPC64:
12461       return reloc_type == 26; /* R_PPC64_REL32.  */
12462     case EM_S390_OLD:
12463     case EM_S390:
12464       return reloc_type == 5;  /* R_390_PC32.  */
12465     case EM_SH:
12466       return reloc_type == 2;  /* R_SH_REL32.  */
12467     case EM_SPARC32PLUS:
12468     case EM_SPARCV9:
12469     case EM_SPARC:
12470       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12471     case EM_SPU:
12472       return reloc_type == 13; /* R_SPU_REL32.  */
12473     case EM_TILEGX:
12474       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12475     case EM_TILEPRO:
12476       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12477     case EM_VISIUM:
12478       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12479     case EM_X86_64:
12480     case EM_L1OM:
12481     case EM_K1OM:
12482       return reloc_type == 2;  /* R_X86_64_PC32.  */
12483     case EM_XTENSA_OLD:
12484     case EM_XTENSA:
12485       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12486     default:
12487       /* Do not abort or issue an error message here.  Not all targets use
12488          pc-relative 32-bit relocs in their DWARF debug information and we
12489          have already tested for target coverage in is_32bit_abs_reloc.  A
12490          more helpful warning message will be generated by apply_relocations
12491          anyway, so just return.  */
12492       return FALSE;
12493     }
12494 }
12495
12496 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12497    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12498
12499 static bfd_boolean
12500 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12501 {
12502   switch (filedata->file_header.e_machine)
12503     {
12504     case EM_AARCH64:
12505       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12506     case EM_ALPHA:
12507       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12508     case EM_IA_64:
12509       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12510               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12511     case EM_PARISC:
12512       return reloc_type == 80; /* R_PARISC_DIR64.  */
12513     case EM_PPC64:
12514       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12515     case EM_RISCV:
12516       return reloc_type == 2; /* R_RISCV_64.  */
12517     case EM_SPARC32PLUS:
12518     case EM_SPARCV9:
12519     case EM_SPARC:
12520       return reloc_type == 32 /* R_SPARC_64.  */
12521         || reloc_type == 54; /* R_SPARC_UA64.  */
12522     case EM_X86_64:
12523     case EM_L1OM:
12524     case EM_K1OM:
12525       return reloc_type == 1; /* R_X86_64_64.  */
12526     case EM_S390_OLD:
12527     case EM_S390:
12528       return reloc_type == 22;  /* R_S390_64.  */
12529     case EM_TILEGX:
12530       return reloc_type == 1; /* R_TILEGX_64.  */
12531     case EM_MIPS:
12532       return reloc_type == 18;  /* R_MIPS_64.  */
12533     default:
12534       return FALSE;
12535     }
12536 }
12537
12538 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12539    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12540
12541 static bfd_boolean
12542 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12543 {
12544   switch (filedata->file_header.e_machine)
12545     {
12546     case EM_AARCH64:
12547       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12548     case EM_ALPHA:
12549       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12550     case EM_IA_64:
12551       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12552               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12553     case EM_PARISC:
12554       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12555     case EM_PPC64:
12556       return reloc_type == 44; /* R_PPC64_REL64.  */
12557     case EM_SPARC32PLUS:
12558     case EM_SPARCV9:
12559     case EM_SPARC:
12560       return reloc_type == 46; /* R_SPARC_DISP64.  */
12561     case EM_X86_64:
12562     case EM_L1OM:
12563     case EM_K1OM:
12564       return reloc_type == 24; /* R_X86_64_PC64.  */
12565     case EM_S390_OLD:
12566     case EM_S390:
12567       return reloc_type == 23;  /* R_S390_PC64.  */
12568     case EM_TILEGX:
12569       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12570     default:
12571       return FALSE;
12572     }
12573 }
12574
12575 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12576    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12577
12578 static bfd_boolean
12579 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12580 {
12581   switch (filedata->file_header.e_machine)
12582     {
12583     case EM_CYGNUS_MN10200:
12584     case EM_MN10200:
12585       return reloc_type == 4; /* R_MN10200_24.  */
12586     case EM_FT32:
12587       return reloc_type == 5; /* R_FT32_20.  */
12588     default:
12589       return FALSE;
12590     }
12591 }
12592
12593 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12594    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12595
12596 static bfd_boolean
12597 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12598 {
12599   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12600   switch (filedata->file_header.e_machine)
12601     {
12602     case EM_ARC:
12603     case EM_ARC_COMPACT:
12604     case EM_ARC_COMPACT2:
12605       return reloc_type == 2; /* R_ARC_16.  */
12606     case EM_ADAPTEVA_EPIPHANY:
12607       return reloc_type == 5;
12608     case EM_AVR_OLD:
12609     case EM_AVR:
12610       return reloc_type == 4; /* R_AVR_16.  */
12611     case EM_CYGNUS_D10V:
12612     case EM_D10V:
12613       return reloc_type == 3; /* R_D10V_16.  */
12614     case EM_FT32:
12615       return reloc_type == 2; /* R_FT32_16.  */
12616     case EM_H8S:
12617     case EM_H8_300:
12618     case EM_H8_300H:
12619       return reloc_type == R_H8_DIR16;
12620     case EM_IP2K_OLD:
12621     case EM_IP2K:
12622       return reloc_type == 1; /* R_IP2K_16.  */
12623     case EM_M32C_OLD:
12624     case EM_M32C:
12625       return reloc_type == 1; /* R_M32C_16 */
12626     case EM_CYGNUS_MN10200:
12627     case EM_MN10200:
12628       return reloc_type == 2; /* R_MN10200_16.  */
12629     case EM_CYGNUS_MN10300:
12630     case EM_MN10300:
12631       return reloc_type == 2; /* R_MN10300_16.  */
12632     case EM_MSP430:
12633       if (uses_msp430x_relocs (filedata))
12634         return reloc_type == 2; /* R_MSP430_ABS16.  */
12635       /* Fall through.  */
12636     case EM_MSP430_OLD:
12637       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12638     case EM_NDS32:
12639       return reloc_type == 19; /* R_NDS32_RELA.  */
12640     case EM_ALTERA_NIOS2:
12641       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12642     case EM_NIOS32:
12643       return reloc_type == 9; /* R_NIOS_16.  */
12644     case EM_OR1K:
12645       return reloc_type == 2; /* R_OR1K_16.  */
12646     case EM_TI_PRU:
12647       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12648     case EM_TI_C6000:
12649       return reloc_type == 2; /* R_C6000_ABS16.  */
12650     case EM_VISIUM:
12651       return reloc_type == 2; /* R_VISIUM_16. */
12652     case EM_XC16X:
12653     case EM_C166:
12654       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12655     case EM_XGATE:
12656       return reloc_type == 3; /* R_XGATE_16.  */
12657     default:
12658       return FALSE;
12659     }
12660 }
12661
12662 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12663    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12664
12665 static bfd_boolean
12666 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12667 {
12668   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12669   switch (filedata->file_header.e_machine)
12670     {
12671     case EM_RISCV:
12672       return reloc_type == 35; /* R_RISCV_ADD32.  */
12673     default:
12674       return FALSE;
12675     }
12676 }
12677
12678 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12679    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12680
12681 static bfd_boolean
12682 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12683 {
12684   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12685   switch (filedata->file_header.e_machine)
12686     {
12687     case EM_RISCV:
12688       return reloc_type == 39; /* R_RISCV_SUB32.  */
12689     default:
12690       return FALSE;
12691     }
12692 }
12693
12694 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12695    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12696
12697 static bfd_boolean
12698 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12699 {
12700   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12701   switch (filedata->file_header.e_machine)
12702     {
12703     case EM_RISCV:
12704       return reloc_type == 36; /* R_RISCV_ADD64.  */
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 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12712
12713 static bfd_boolean
12714 is_64bit_inplace_sub_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 == 40; /* R_RISCV_SUB64.  */
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 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12728
12729 static bfd_boolean
12730 is_16bit_inplace_add_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 == 34; /* R_RISCV_ADD16.  */
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 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12744
12745 static bfd_boolean
12746 is_16bit_inplace_sub_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 == 38; /* R_RISCV_SUB16.  */
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 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12760
12761 static bfd_boolean
12762 is_8bit_inplace_add_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 == 33; /* R_RISCV_ADD8.  */
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 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12776
12777 static bfd_boolean
12778 is_8bit_inplace_sub_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 == 37; /* R_RISCV_SUB8.  */
12785     default:
12786       return FALSE;
12787     }
12788 }
12789
12790 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12791    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12792
12793 static bfd_boolean
12794 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12795 {
12796   switch (filedata->file_header.e_machine)
12797     {
12798     case EM_386:     /* R_386_NONE.  */
12799     case EM_68K:     /* R_68K_NONE.  */
12800     case EM_ADAPTEVA_EPIPHANY:
12801     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12802     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12803     case EM_ARC:     /* R_ARC_NONE.  */
12804     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12805     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12806     case EM_ARM:     /* R_ARM_NONE.  */
12807     case EM_C166:    /* R_XC16X_NONE.  */
12808     case EM_CRIS:    /* R_CRIS_NONE.  */
12809     case EM_FT32:    /* R_FT32_NONE.  */
12810     case EM_IA_64:   /* R_IA64_NONE.  */
12811     case EM_K1OM:    /* R_X86_64_NONE.  */
12812     case EM_L1OM:    /* R_X86_64_NONE.  */
12813     case EM_M32R:    /* R_M32R_NONE.  */
12814     case EM_MIPS:    /* R_MIPS_NONE.  */
12815     case EM_MN10300: /* R_MN10300_NONE.  */
12816     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12817     case EM_NIOS32:  /* R_NIOS_NONE.  */
12818     case EM_OR1K:    /* R_OR1K_NONE. */
12819     case EM_PARISC:  /* R_PARISC_NONE.  */
12820     case EM_PPC64:   /* R_PPC64_NONE.  */
12821     case EM_PPC:     /* R_PPC_NONE.  */
12822     case EM_RISCV:   /* R_RISCV_NONE.  */
12823     case EM_S390:    /* R_390_NONE.  */
12824     case EM_S390_OLD:
12825     case EM_SH:      /* R_SH_NONE.  */
12826     case EM_SPARC32PLUS:
12827     case EM_SPARC:   /* R_SPARC_NONE.  */
12828     case EM_SPARCV9:
12829     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12830     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12831     case EM_TI_C6000:/* R_C6000_NONE.  */
12832     case EM_X86_64:  /* R_X86_64_NONE.  */
12833     case EM_XC16X:
12834     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12835       return reloc_type == 0;
12836
12837     case EM_AARCH64:
12838       return reloc_type == 0 || reloc_type == 256;
12839     case EM_AVR_OLD:
12840     case EM_AVR:
12841       return (reloc_type == 0 /* R_AVR_NONE.  */
12842               || reloc_type == 30 /* R_AVR_DIFF8.  */
12843               || reloc_type == 31 /* R_AVR_DIFF16.  */
12844               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12845     case EM_METAG:
12846       return reloc_type == 3; /* R_METAG_NONE.  */
12847     case EM_NDS32:
12848       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12849               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12850               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12851               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12852               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12853     case EM_TI_PRU:
12854       return (reloc_type == 0       /* R_PRU_NONE.  */
12855               || reloc_type == 65   /* R_PRU_DIFF8.  */
12856               || reloc_type == 66   /* R_PRU_DIFF16.  */
12857               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12858     case EM_XTENSA_OLD:
12859     case EM_XTENSA:
12860       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12861               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12862               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12863               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12864     }
12865   return FALSE;
12866 }
12867
12868 /* Returns TRUE if there is a relocation against
12869    section NAME at OFFSET bytes.  */
12870
12871 bfd_boolean
12872 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12873 {
12874   Elf_Internal_Rela * relocs;
12875   Elf_Internal_Rela * rp;
12876
12877   if (dsec == NULL || dsec->reloc_info == NULL)
12878     return FALSE;
12879
12880   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12881
12882   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12883     if (rp->r_offset == offset)
12884       return TRUE;
12885
12886    return FALSE;
12887 }
12888
12889 /* Apply relocations to a section.
12890    Returns TRUE upon success, FALSE otherwise.
12891    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12892    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12893    will be set to the number of relocs loaded.
12894
12895    Note: So far support has been added only for those relocations
12896    which can be found in debug sections. FIXME: Add support for
12897    more relocations ?  */
12898
12899 static bfd_boolean
12900 apply_relocations (Filedata *                 filedata,
12901                    const Elf_Internal_Shdr *  section,
12902                    unsigned char *            start,
12903                    bfd_size_type              size,
12904                    void **                    relocs_return,
12905                    unsigned long *            num_relocs_return)
12906 {
12907   Elf_Internal_Shdr * relsec;
12908   unsigned char * end = start + size;
12909   bfd_boolean res = TRUE;
12910
12911   if (relocs_return != NULL)
12912     {
12913       * (Elf_Internal_Rela **) relocs_return = NULL;
12914       * num_relocs_return = 0;
12915     }
12916
12917   if (filedata->file_header.e_type != ET_REL)
12918     /* No relocs to apply.  */
12919     return TRUE;
12920
12921   /* Find the reloc section associated with the section.  */
12922   for (relsec = filedata->section_headers;
12923        relsec < filedata->section_headers + filedata->file_header.e_shnum;
12924        ++relsec)
12925     {
12926       bfd_boolean is_rela;
12927       unsigned long num_relocs;
12928       Elf_Internal_Rela * relocs;
12929       Elf_Internal_Rela * rp;
12930       Elf_Internal_Shdr * symsec;
12931       Elf_Internal_Sym * symtab;
12932       unsigned long num_syms;
12933       Elf_Internal_Sym * sym;
12934
12935       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12936           || relsec->sh_info >= filedata->file_header.e_shnum
12937           || filedata->section_headers + relsec->sh_info != section
12938           || relsec->sh_size == 0
12939           || relsec->sh_link >= filedata->file_header.e_shnum)
12940         continue;
12941
12942       is_rela = relsec->sh_type == SHT_RELA;
12943
12944       if (is_rela)
12945         {
12946           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
12947                                   relsec->sh_size, & relocs, & num_relocs))
12948             return FALSE;
12949         }
12950       else
12951         {
12952           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
12953                                  relsec->sh_size, & relocs, & num_relocs))
12954             return FALSE;
12955         }
12956
12957       /* SH uses RELA but uses in place value instead of the addend field.  */
12958       if (filedata->file_header.e_machine == EM_SH)
12959         is_rela = FALSE;
12960
12961       symsec = filedata->section_headers + relsec->sh_link;
12962       if (symsec->sh_type != SHT_SYMTAB
12963           && symsec->sh_type != SHT_DYNSYM)
12964         return FALSE;
12965       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
12966
12967       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12968         {
12969           bfd_vma         addend;
12970           unsigned int    reloc_type;
12971           unsigned int    reloc_size;
12972           bfd_boolean     reloc_inplace = FALSE;
12973           bfd_boolean     reloc_subtract = FALSE;
12974           unsigned char * rloc;
12975           unsigned long   sym_index;
12976
12977           reloc_type = get_reloc_type (filedata, rp->r_info);
12978
12979           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
12980             continue;
12981           else if (is_none_reloc (filedata, reloc_type))
12982             continue;
12983           else if (is_32bit_abs_reloc (filedata, reloc_type)
12984                    || is_32bit_pcrel_reloc (filedata, reloc_type))
12985             reloc_size = 4;
12986           else if (is_64bit_abs_reloc (filedata, reloc_type)
12987                    || is_64bit_pcrel_reloc (filedata, reloc_type))
12988             reloc_size = 8;
12989           else if (is_24bit_abs_reloc (filedata, reloc_type))
12990             reloc_size = 3;
12991           else if (is_16bit_abs_reloc (filedata, reloc_type))
12992             reloc_size = 2;
12993           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
12994                                                                  reloc_type))
12995                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
12996             {
12997               reloc_size = 4;
12998               reloc_inplace = TRUE;
12999             }
13000           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13001                                                                  reloc_type))
13002                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13003             {
13004               reloc_size = 8;
13005               reloc_inplace = TRUE;
13006             }
13007           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13008                                                                  reloc_type))
13009                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13010             {
13011               reloc_size = 2;
13012               reloc_inplace = TRUE;
13013             }
13014           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13015                                                                 reloc_type))
13016                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13017             {
13018               reloc_size = 1;
13019               reloc_inplace = TRUE;
13020             }
13021           else
13022             {
13023               static unsigned int prev_reloc = 0;
13024
13025               if (reloc_type != prev_reloc)
13026                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13027                       reloc_type, printable_section_name (filedata, section));
13028               prev_reloc = reloc_type;
13029               res = FALSE;
13030               continue;
13031             }
13032
13033           rloc = start + rp->r_offset;
13034           if ((rloc + reloc_size) > end || (rloc < start))
13035             {
13036               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13037                     (unsigned long) rp->r_offset,
13038                     printable_section_name (filedata, section));
13039               res = FALSE;
13040               continue;
13041             }
13042
13043           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13044           if (sym_index >= num_syms)
13045             {
13046               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13047                     sym_index, printable_section_name (filedata, section));
13048               res = FALSE;
13049               continue;
13050             }
13051           sym = symtab + sym_index;
13052
13053           /* If the reloc has a symbol associated with it,
13054              make sure that it is of an appropriate type.
13055
13056              Relocations against symbols without type can happen.
13057              Gcc -feliminate-dwarf2-dups may generate symbols
13058              without type for debug info.
13059
13060              Icc generates relocations against function symbols
13061              instead of local labels.
13062
13063              Relocations against object symbols can happen, eg when
13064              referencing a global array.  For an example of this see
13065              the _clz.o binary in libgcc.a.  */
13066           if (sym != symtab
13067               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13068               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13069             {
13070               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13071                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13072                     printable_section_name (filedata, relsec),
13073                     (long int)(rp - relocs));
13074               res = FALSE;
13075               continue;
13076             }
13077
13078           addend = 0;
13079           if (is_rela)
13080             addend += rp->r_addend;
13081           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13082              partial_inplace.  */
13083           if (!is_rela
13084               || (filedata->file_header.e_machine == EM_XTENSA
13085                   && reloc_type == 1)
13086               || ((filedata->file_header.e_machine == EM_PJ
13087                    || filedata->file_header.e_machine == EM_PJ_OLD)
13088                   && reloc_type == 1)
13089               || ((filedata->file_header.e_machine == EM_D30V
13090                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13091                   && reloc_type == 12)
13092               || reloc_inplace)
13093             addend += byte_get (rloc, reloc_size);
13094
13095           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13096               || is_64bit_pcrel_reloc (filedata, reloc_type))
13097             {
13098               /* On HPPA, all pc-relative relocations are biased by 8.  */
13099               if (filedata->file_header.e_machine == EM_PARISC)
13100                 addend -= 8;
13101               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13102                         reloc_size);
13103             }
13104           else if (reloc_subtract)
13105             byte_put (rloc, addend - sym->st_value, reloc_size);
13106           else
13107             byte_put (rloc, addend + sym->st_value, reloc_size);
13108         }
13109
13110       free (symtab);
13111       /* Let the target specific reloc processing code know that
13112          we have finished with these relocs.  */
13113       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13114
13115       if (relocs_return)
13116         {
13117           * (Elf_Internal_Rela **) relocs_return = relocs;
13118           * num_relocs_return = num_relocs;
13119         }
13120       else
13121         free (relocs);
13122
13123       break;
13124     }
13125
13126   return res;
13127 }
13128
13129 #ifdef SUPPORT_DISASSEMBLY
13130 static bfd_boolean
13131 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13132 {
13133   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13134
13135   /* FIXME: XXX -- to be done --- XXX */
13136
13137   return TRUE;
13138 }
13139 #endif
13140
13141 /* Reads in the contents of SECTION from FILE, returning a pointer
13142    to a malloc'ed buffer or NULL if something went wrong.  */
13143
13144 static char *
13145 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13146 {
13147   bfd_size_type num_bytes = section->sh_size;
13148
13149   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13150     {
13151       printf (_("Section '%s' has no data to dump.\n"),
13152               printable_section_name (filedata, section));
13153       return NULL;
13154     }
13155
13156   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13157                              _("section contents"));
13158 }
13159
13160 /* Uncompresses a section that was compressed using zlib, in place.  */
13161
13162 static bfd_boolean
13163 uncompress_section_contents (unsigned char **   buffer,
13164                              dwarf_size_type    uncompressed_size,
13165                              dwarf_size_type *  size)
13166 {
13167   dwarf_size_type compressed_size = *size;
13168   unsigned char * compressed_buffer = *buffer;
13169   unsigned char * uncompressed_buffer;
13170   z_stream strm;
13171   int rc;
13172
13173   /* It is possible the section consists of several compressed
13174      buffers concatenated together, so we uncompress in a loop.  */
13175   /* PR 18313: The state field in the z_stream structure is supposed
13176      to be invisible to the user (ie us), but some compilers will
13177      still complain about it being used without initialisation.  So
13178      we first zero the entire z_stream structure and then set the fields
13179      that we need.  */
13180   memset (& strm, 0, sizeof strm);
13181   strm.avail_in = compressed_size;
13182   strm.next_in = (Bytef *) compressed_buffer;
13183   strm.avail_out = uncompressed_size;
13184   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13185
13186   rc = inflateInit (& strm);
13187   while (strm.avail_in > 0)
13188     {
13189       if (rc != Z_OK)
13190         goto fail;
13191       strm.next_out = ((Bytef *) uncompressed_buffer
13192                        + (uncompressed_size - strm.avail_out));
13193       rc = inflate (&strm, Z_FINISH);
13194       if (rc != Z_STREAM_END)
13195         goto fail;
13196       rc = inflateReset (& strm);
13197     }
13198   rc = inflateEnd (& strm);
13199   if (rc != Z_OK
13200       || strm.avail_out != 0)
13201     goto fail;
13202
13203   *buffer = uncompressed_buffer;
13204   *size = uncompressed_size;
13205   return TRUE;
13206
13207  fail:
13208   free (uncompressed_buffer);
13209   /* Indicate decompression failure.  */
13210   *buffer = NULL;
13211   return FALSE;
13212 }
13213
13214 static bfd_boolean
13215 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13216 {
13217   Elf_Internal_Shdr *  relsec;
13218   bfd_size_type        num_bytes;
13219   unsigned char *      data;
13220   unsigned char *      end;
13221   unsigned char *      real_start;
13222   unsigned char *      start;
13223   bfd_boolean          some_strings_shown;
13224
13225   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13226   if (start == NULL)
13227     /* PR 21820: Do not fail if the section was empty.  */
13228     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13229
13230   num_bytes = section->sh_size;
13231
13232   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13233
13234   if (decompress_dumps)
13235     {
13236       dwarf_size_type new_size = num_bytes;
13237       dwarf_size_type uncompressed_size = 0;
13238
13239       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13240         {
13241           Elf_Internal_Chdr chdr;
13242           unsigned int compression_header_size
13243             = get_compression_header (& chdr, (unsigned char *) start,
13244                                       num_bytes);
13245
13246           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13247             {
13248               warn (_("section '%s' has unsupported compress type: %d\n"),
13249                     printable_section_name (filedata, section), chdr.ch_type);
13250               return FALSE;
13251             }
13252           else if (chdr.ch_addralign != section->sh_addralign)
13253             {
13254               warn (_("compressed section '%s' is corrupted\n"),
13255                     printable_section_name (filedata, section));
13256               return FALSE;
13257             }
13258           uncompressed_size = chdr.ch_size;
13259           start += compression_header_size;
13260           new_size -= compression_header_size;
13261         }
13262       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13263         {
13264           /* Read the zlib header.  In this case, it should be "ZLIB"
13265              followed by the uncompressed section size, 8 bytes in
13266              big-endian order.  */
13267           uncompressed_size = start[4]; uncompressed_size <<= 8;
13268           uncompressed_size += start[5]; uncompressed_size <<= 8;
13269           uncompressed_size += start[6]; uncompressed_size <<= 8;
13270           uncompressed_size += start[7]; uncompressed_size <<= 8;
13271           uncompressed_size += start[8]; uncompressed_size <<= 8;
13272           uncompressed_size += start[9]; uncompressed_size <<= 8;
13273           uncompressed_size += start[10]; uncompressed_size <<= 8;
13274           uncompressed_size += start[11];
13275           start += 12;
13276           new_size -= 12;
13277         }
13278
13279       if (uncompressed_size)
13280         {
13281           if (uncompress_section_contents (& start,
13282                                            uncompressed_size, & new_size))
13283             num_bytes = new_size;
13284           else
13285             {
13286               error (_("Unable to decompress section %s\n"),
13287                      printable_section_name (filedata, section));
13288               return FALSE;
13289             }
13290         }
13291       else
13292         start = real_start;
13293     }
13294
13295   /* If the section being dumped has relocations against it the user might
13296      be expecting these relocations to have been applied.  Check for this
13297      case and issue a warning message in order to avoid confusion.
13298      FIXME: Maybe we ought to have an option that dumps a section with
13299      relocs applied ?  */
13300   for (relsec = filedata->section_headers;
13301        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13302        ++relsec)
13303     {
13304       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13305           || relsec->sh_info >= filedata->file_header.e_shnum
13306           || filedata->section_headers + relsec->sh_info != section
13307           || relsec->sh_size == 0
13308           || relsec->sh_link >= filedata->file_header.e_shnum)
13309         continue;
13310
13311       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13312       break;
13313     }
13314
13315   data = start;
13316   end  = start + num_bytes;
13317   some_strings_shown = FALSE;
13318
13319   while (data < end)
13320     {
13321       while (!ISPRINT (* data))
13322         if (++ data >= end)
13323           break;
13324
13325       if (data < end)
13326         {
13327           size_t maxlen = end - data;
13328
13329 #ifndef __MSVCRT__
13330           /* PR 11128: Use two separate invocations in order to work
13331              around bugs in the Solaris 8 implementation of printf.  */
13332           printf ("  [%6tx]  ", data - start);
13333 #else
13334           printf ("  [%6Ix]  ", (size_t) (data - start));
13335 #endif
13336           if (maxlen > 0)
13337             {
13338               print_symbol ((int) maxlen, (const char *) data);
13339               putchar ('\n');
13340               data += strnlen ((const char *) data, maxlen);
13341             }
13342           else
13343             {
13344               printf (_("<corrupt>\n"));
13345               data = end;
13346             }
13347           some_strings_shown = TRUE;
13348         }
13349     }
13350
13351   if (! some_strings_shown)
13352     printf (_("  No strings found in this section."));
13353
13354   free (real_start);
13355
13356   putchar ('\n');
13357   return TRUE;
13358 }
13359
13360 static bfd_boolean
13361 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13362                        Filedata *           filedata,
13363                        bfd_boolean          relocate)
13364 {
13365   Elf_Internal_Shdr * relsec;
13366   bfd_size_type       bytes;
13367   bfd_size_type       section_size;
13368   bfd_vma             addr;
13369   unsigned char *     data;
13370   unsigned char *     real_start;
13371   unsigned char *     start;
13372
13373   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13374   if (start == NULL)
13375     /* PR 21820: Do not fail if the section was empty.  */
13376     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13377
13378   section_size = section->sh_size;
13379
13380   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13381
13382   if (decompress_dumps)
13383     {
13384       dwarf_size_type new_size = section_size;
13385       dwarf_size_type uncompressed_size = 0;
13386
13387       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13388         {
13389           Elf_Internal_Chdr chdr;
13390           unsigned int compression_header_size
13391             = get_compression_header (& chdr, start, section_size);
13392
13393           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13394             {
13395               warn (_("section '%s' has unsupported compress type: %d\n"),
13396                     printable_section_name (filedata, section), chdr.ch_type);
13397               return FALSE;
13398             }
13399           else if (chdr.ch_addralign != section->sh_addralign)
13400             {
13401               warn (_("compressed section '%s' is corrupted\n"),
13402                     printable_section_name (filedata, section));
13403               return FALSE;
13404             }
13405           uncompressed_size = chdr.ch_size;
13406           start += compression_header_size;
13407           new_size -= compression_header_size;
13408         }
13409       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13410         {
13411           /* Read the zlib header.  In this case, it should be "ZLIB"
13412              followed by the uncompressed section size, 8 bytes in
13413              big-endian order.  */
13414           uncompressed_size = start[4]; uncompressed_size <<= 8;
13415           uncompressed_size += start[5]; uncompressed_size <<= 8;
13416           uncompressed_size += start[6]; uncompressed_size <<= 8;
13417           uncompressed_size += start[7]; uncompressed_size <<= 8;
13418           uncompressed_size += start[8]; uncompressed_size <<= 8;
13419           uncompressed_size += start[9]; uncompressed_size <<= 8;
13420           uncompressed_size += start[10]; uncompressed_size <<= 8;
13421           uncompressed_size += start[11];
13422           start += 12;
13423           new_size -= 12;
13424         }
13425
13426       if (uncompressed_size)
13427         {
13428           if (uncompress_section_contents (& start, uncompressed_size,
13429                                            & new_size))
13430             {
13431               section_size = new_size;
13432             }
13433           else
13434             {
13435               error (_("Unable to decompress section %s\n"),
13436                      printable_section_name (filedata, section));
13437               /* FIXME: Print the section anyway ?  */
13438               return FALSE;
13439             }
13440         }
13441       else
13442         start = real_start;
13443     }
13444
13445   if (relocate)
13446     {
13447       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13448         return FALSE;
13449     }
13450   else
13451     {
13452       /* If the section being dumped has relocations against it the user might
13453          be expecting these relocations to have been applied.  Check for this
13454          case and issue a warning message in order to avoid confusion.
13455          FIXME: Maybe we ought to have an option that dumps a section with
13456          relocs applied ?  */
13457       for (relsec = filedata->section_headers;
13458            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13459            ++relsec)
13460         {
13461           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13462               || relsec->sh_info >= filedata->file_header.e_shnum
13463               || filedata->section_headers + relsec->sh_info != section
13464               || relsec->sh_size == 0
13465               || relsec->sh_link >= filedata->file_header.e_shnum)
13466             continue;
13467
13468           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13469           break;
13470         }
13471     }
13472
13473   addr = section->sh_addr;
13474   bytes = section_size;
13475   data = start;
13476
13477   while (bytes)
13478     {
13479       int j;
13480       int k;
13481       int lbytes;
13482
13483       lbytes = (bytes > 16 ? 16 : bytes);
13484
13485       printf ("  0x%8.8lx ", (unsigned long) addr);
13486
13487       for (j = 0; j < 16; j++)
13488         {
13489           if (j < lbytes)
13490             printf ("%2.2x", data[j]);
13491           else
13492             printf ("  ");
13493
13494           if ((j & 3) == 3)
13495             printf (" ");
13496         }
13497
13498       for (j = 0; j < lbytes; j++)
13499         {
13500           k = data[j];
13501           if (k >= ' ' && k < 0x7f)
13502             printf ("%c", k);
13503           else
13504             printf (".");
13505         }
13506
13507       putchar ('\n');
13508
13509       data  += lbytes;
13510       addr  += lbytes;
13511       bytes -= lbytes;
13512     }
13513
13514   free (real_start);
13515
13516   putchar ('\n');
13517   return TRUE;
13518 }
13519
13520 static bfd_boolean
13521 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13522                              const Elf_Internal_Shdr *        sec,
13523                              void *                           data)
13524 {
13525   struct dwarf_section * section = &debug_displays [debug].section;
13526   char buf [64];
13527   Filedata * filedata = (Filedata *) data;
13528
13529   if (section->start != NULL)
13530     {
13531       /* If it is already loaded, do nothing.  */
13532       if (streq (section->filename, filedata->file_name))
13533         return TRUE;
13534       free (section->start);
13535     }
13536
13537   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13538   section->address = sec->sh_addr;
13539   section->user_data = NULL;
13540   section->filename = filedata->file_name;
13541   section->start = (unsigned char *) get_data (NULL, filedata,
13542                                                sec->sh_offset, 1,
13543                                                sec->sh_size, buf);
13544   if (section->start == NULL)
13545     section->size = 0;
13546   else
13547     {
13548       unsigned char *start = section->start;
13549       dwarf_size_type size = sec->sh_size;
13550       dwarf_size_type uncompressed_size = 0;
13551
13552       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13553         {
13554           Elf_Internal_Chdr chdr;
13555           unsigned int compression_header_size;
13556
13557           if (size < (is_32bit_elf
13558                       ? sizeof (Elf32_External_Chdr)
13559                       : sizeof (Elf64_External_Chdr)))
13560             {
13561               warn (_("compressed section %s is too small to contain a compression header"),
13562                     section->name);
13563               return FALSE;
13564             }
13565
13566           compression_header_size = get_compression_header (&chdr, start, size);
13567
13568           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13569             {
13570               warn (_("section '%s' has unsupported compress type: %d\n"),
13571                     section->name, chdr.ch_type);
13572               return FALSE;
13573             }
13574           else if (chdr.ch_addralign != sec->sh_addralign)
13575             {
13576               warn (_("compressed section '%s' is corrupted\n"),
13577                     section->name);
13578               return FALSE;
13579             }
13580           uncompressed_size = chdr.ch_size;
13581           start += compression_header_size;
13582           size -= compression_header_size;
13583         }
13584       else if (size > 12 && streq ((char *) start, "ZLIB"))
13585         {
13586           /* Read the zlib header.  In this case, it should be "ZLIB"
13587              followed by the uncompressed section size, 8 bytes in
13588              big-endian order.  */
13589           uncompressed_size = start[4]; uncompressed_size <<= 8;
13590           uncompressed_size += start[5]; uncompressed_size <<= 8;
13591           uncompressed_size += start[6]; uncompressed_size <<= 8;
13592           uncompressed_size += start[7]; uncompressed_size <<= 8;
13593           uncompressed_size += start[8]; uncompressed_size <<= 8;
13594           uncompressed_size += start[9]; uncompressed_size <<= 8;
13595           uncompressed_size += start[10]; uncompressed_size <<= 8;
13596           uncompressed_size += start[11];
13597           start += 12;
13598           size -= 12;
13599         }
13600
13601       if (uncompressed_size)
13602         {
13603           if (uncompress_section_contents (&start, uncompressed_size,
13604                                            &size))
13605             {
13606               /* Free the compressed buffer, update the section buffer
13607                  and the section size if uncompress is successful.  */
13608               free (section->start);
13609               section->start = start;
13610             }
13611           else
13612             {
13613               error (_("Unable to decompress section %s\n"),
13614                      printable_section_name (filedata, sec));
13615               return FALSE;
13616             }
13617         }
13618
13619       section->size = size;
13620     }
13621
13622   if (section->start == NULL)
13623     return FALSE;
13624
13625   if (debug_displays [debug].relocate)
13626     {
13627       if (! apply_relocations (filedata, sec, section->start, section->size,
13628                                & section->reloc_info, & section->num_relocs))
13629         return FALSE;
13630     }
13631   else
13632     {
13633       section->reloc_info = NULL;
13634       section->num_relocs = 0;
13635     }
13636
13637   return TRUE;
13638 }
13639
13640 /* If this is not NULL, load_debug_section will only look for sections
13641    within the list of sections given here.  */
13642 static unsigned int * section_subset = NULL;
13643
13644 bfd_boolean
13645 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13646 {
13647   struct dwarf_section * section = &debug_displays [debug].section;
13648   Elf_Internal_Shdr * sec;
13649   Filedata * filedata = (Filedata *) data;
13650
13651   /* Without section headers we cannot find any sections.  */
13652   if (filedata->section_headers == NULL)
13653     return FALSE;
13654
13655   if (filedata->string_table == NULL
13656       && filedata->file_header.e_shstrndx != SHN_UNDEF
13657       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13658     {
13659       Elf_Internal_Shdr * strs;
13660
13661       /* Read in the string table, so that we have section names to scan.  */
13662       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13663
13664       if (strs != NULL && strs->sh_size != 0)
13665         {
13666           filedata->string_table
13667             = (char *) get_data (NULL, filedata, strs->sh_offset,
13668                                  1, strs->sh_size, _("string table"));
13669
13670           filedata->string_table_length
13671             = filedata->string_table != NULL ? strs->sh_size : 0;
13672         }
13673     }
13674
13675   /* Locate the debug section.  */
13676   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13677   if (sec != NULL)
13678     section->name = section->uncompressed_name;
13679   else
13680     {
13681       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13682       if (sec != NULL)
13683         section->name = section->compressed_name;
13684     }
13685   if (sec == NULL)
13686     return FALSE;
13687
13688   /* If we're loading from a subset of sections, and we've loaded
13689      a section matching this name before, it's likely that it's a
13690      different one.  */
13691   if (section_subset != NULL)
13692     free_debug_section (debug);
13693
13694   return load_specific_debug_section (debug, sec, data);
13695 }
13696
13697 void
13698 free_debug_section (enum dwarf_section_display_enum debug)
13699 {
13700   struct dwarf_section * section = &debug_displays [debug].section;
13701
13702   if (section->start == NULL)
13703     return;
13704
13705   free ((char *) section->start);
13706   section->start = NULL;
13707   section->address = 0;
13708   section->size = 0;
13709 }
13710
13711 static bfd_boolean
13712 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13713 {
13714   char * name = SECTION_NAME (section);
13715   const char * print_name = printable_section_name (filedata, section);
13716   bfd_size_type length;
13717   bfd_boolean result = TRUE;
13718   int i;
13719
13720   length = section->sh_size;
13721   if (length == 0)
13722     {
13723       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13724       return TRUE;
13725     }
13726   if (section->sh_type == SHT_NOBITS)
13727     {
13728       /* There is no point in dumping the contents of a debugging section
13729          which has the NOBITS type - the bits in the file will be random.
13730          This can happen when a file containing a .eh_frame section is
13731          stripped with the --only-keep-debug command line option.  */
13732       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13733               print_name);
13734       return FALSE;
13735     }
13736
13737   if (const_strneq (name, ".gnu.linkonce.wi."))
13738     name = ".debug_info";
13739
13740   /* See if we know how to display the contents of this section.  */
13741   for (i = 0; i < max; i++)
13742     {
13743       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13744       struct dwarf_section_display *   display = debug_displays + i;
13745       struct dwarf_section *           sec = & display->section;
13746
13747       if (streq (sec->uncompressed_name, name)
13748           || (id == line && const_strneq (name, ".debug_line."))
13749           || streq (sec->compressed_name, name))
13750         {
13751           bfd_boolean secondary = (section != find_section (filedata, name));
13752
13753           if (secondary)
13754             free_debug_section (id);
13755
13756           if (i == line && const_strneq (name, ".debug_line."))
13757             sec->name = name;
13758           else if (streq (sec->uncompressed_name, name))
13759             sec->name = sec->uncompressed_name;
13760           else
13761             sec->name = sec->compressed_name;
13762
13763           if (load_specific_debug_section (id, section, filedata))
13764             {
13765               /* If this debug section is part of a CU/TU set in a .dwp file,
13766                  restrict load_debug_section to the sections in that set.  */
13767               section_subset = find_cu_tu_set (filedata, shndx);
13768
13769               result &= display->display (sec, filedata);
13770
13771               section_subset = NULL;
13772
13773               if (secondary || (id != info && id != abbrev))
13774                 free_debug_section (id);
13775             }
13776           break;
13777         }
13778     }
13779
13780   if (i == max)
13781     {
13782       printf (_("Unrecognized debug section: %s\n"), print_name);
13783       result = FALSE;
13784     }
13785
13786   return result;
13787 }
13788
13789 /* Set DUMP_SECTS for all sections where dumps were requested
13790    based on section name.  */
13791
13792 static void
13793 initialise_dumps_byname (Filedata * filedata)
13794 {
13795   struct dump_list_entry * cur;
13796
13797   for (cur = dump_sects_byname; cur; cur = cur->next)
13798     {
13799       unsigned int i;
13800       bfd_boolean any = FALSE;
13801
13802       for (i = 0; i < filedata->file_header.e_shnum; i++)
13803         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13804           {
13805             request_dump_bynumber (filedata, i, cur->type);
13806             any = TRUE;
13807           }
13808
13809       if (!any)
13810         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13811               cur->name);
13812     }
13813 }
13814
13815 static bfd_boolean
13816 process_section_contents (Filedata * filedata)
13817 {
13818   Elf_Internal_Shdr * section;
13819   unsigned int i;
13820   bfd_boolean res = TRUE;
13821
13822   if (! do_dump)
13823     return TRUE;
13824
13825   initialise_dumps_byname (filedata);
13826
13827   for (i = 0, section = filedata->section_headers;
13828        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13829        i++, section++)
13830     {
13831       dump_type dump = filedata->dump_sects[i];
13832
13833 #ifdef SUPPORT_DISASSEMBLY
13834       if (dump & DISASS_DUMP)
13835         {
13836           if (! disassemble_section (section, filedata))
13837             res = FALSE;
13838         }
13839 #endif
13840       if (dump & HEX_DUMP)
13841         {
13842           if (! dump_section_as_bytes (section, filedata, FALSE))
13843             res = FALSE;
13844         }
13845
13846       if (dump & RELOC_DUMP)
13847         {
13848           if (! dump_section_as_bytes (section, filedata, TRUE))
13849             res = FALSE;
13850         }
13851
13852       if (dump & STRING_DUMP)
13853         {
13854           if (! dump_section_as_strings (section, filedata))
13855             res = FALSE;
13856         }
13857
13858       if (dump & DEBUG_DUMP)
13859         {
13860           if (! display_debug_section (i, section, filedata))
13861             res = FALSE;
13862         }
13863     }
13864
13865   /* Check to see if the user requested a
13866      dump of a section that does not exist.  */
13867   while (i < filedata->num_dump_sects)
13868     {
13869       if (filedata->dump_sects[i])
13870         {
13871           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13872           res = FALSE;
13873         }
13874       i++;
13875     }
13876
13877   return res;
13878 }
13879
13880 static void
13881 process_mips_fpe_exception (int mask)
13882 {
13883   if (mask)
13884     {
13885       bfd_boolean first = TRUE;
13886
13887       if (mask & OEX_FPU_INEX)
13888         fputs ("INEX", stdout), first = FALSE;
13889       if (mask & OEX_FPU_UFLO)
13890         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13891       if (mask & OEX_FPU_OFLO)
13892         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13893       if (mask & OEX_FPU_DIV0)
13894         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13895       if (mask & OEX_FPU_INVAL)
13896         printf ("%sINVAL", first ? "" : "|");
13897     }
13898   else
13899     fputs ("0", stdout);
13900 }
13901
13902 /* Display's the value of TAG at location P.  If TAG is
13903    greater than 0 it is assumed to be an unknown tag, and
13904    a message is printed to this effect.  Otherwise it is
13905    assumed that a message has already been printed.
13906
13907    If the bottom bit of TAG is set it assumed to have a
13908    string value, otherwise it is assumed to have an integer
13909    value.
13910
13911    Returns an updated P pointing to the first unread byte
13912    beyond the end of TAG's value.
13913
13914    Reads at or beyond END will not be made.  */
13915
13916 static unsigned char *
13917 display_tag_value (signed int tag,
13918                    unsigned char * p,
13919                    const unsigned char * const end)
13920 {
13921   unsigned long val;
13922
13923   if (tag > 0)
13924     printf ("  Tag_unknown_%d: ", tag);
13925
13926   if (p >= end)
13927     {
13928       warn (_("<corrupt tag>\n"));
13929     }
13930   else if (tag & 1)
13931     {
13932       /* PR 17531 file: 027-19978-0.004.  */
13933       size_t maxlen = (end - p) - 1;
13934
13935       putchar ('"');
13936       if (maxlen > 0)
13937         {
13938           print_symbol ((int) maxlen, (const char *) p);
13939           p += strnlen ((char *) p, maxlen) + 1;
13940         }
13941       else
13942         {
13943           printf (_("<corrupt string tag>"));
13944           p = (unsigned char *) end;
13945         }
13946       printf ("\"\n");
13947     }
13948   else
13949     {
13950       unsigned int len;
13951
13952       val = read_uleb128 (p, &len, end);
13953       p += len;
13954       printf ("%ld (0x%lx)\n", val, val);
13955     }
13956
13957   assert (p <= end);
13958   return p;
13959 }
13960
13961 /* ARC ABI attributes section.  */
13962
13963 static unsigned char *
13964 display_arc_attribute (unsigned char * p,
13965                        const unsigned char * const end)
13966 {
13967   unsigned int tag;
13968   unsigned int len;
13969   unsigned int val;
13970
13971   tag = read_uleb128 (p, &len, end);
13972   p += len;
13973
13974   switch (tag)
13975     {
13976     case Tag_ARC_PCS_config:
13977       val = read_uleb128 (p, &len, end);
13978       p += len;
13979       printf ("  Tag_ARC_PCS_config: ");
13980       switch (val)
13981         {
13982         case 0:
13983           printf (_("Absent/Non standard\n"));
13984           break;
13985         case 1:
13986           printf (_("Bare metal/mwdt\n"));
13987           break;
13988         case 2:
13989           printf (_("Bare metal/newlib\n"));
13990           break;
13991         case 3:
13992           printf (_("Linux/uclibc\n"));
13993           break;
13994         case 4:
13995           printf (_("Linux/glibc\n"));
13996           break;
13997         default:
13998           printf (_("Unknown\n"));
13999           break;
14000         }
14001       break;
14002
14003     case Tag_ARC_CPU_base:
14004       val = read_uleb128 (p, &len, end);
14005       p += len;
14006       printf ("  Tag_ARC_CPU_base: ");
14007       switch (val)
14008         {
14009         default:
14010         case TAG_CPU_NONE:
14011           printf (_("Absent\n"));
14012           break;
14013         case TAG_CPU_ARC6xx:
14014           printf ("ARC6xx\n");
14015           break;
14016         case TAG_CPU_ARC7xx:
14017           printf ("ARC7xx\n");
14018           break;
14019         case TAG_CPU_ARCEM:
14020           printf ("ARCEM\n");
14021           break;
14022         case TAG_CPU_ARCHS:
14023           printf ("ARCHS\n");
14024           break;
14025         }
14026       break;
14027
14028     case Tag_ARC_CPU_variation:
14029       val = read_uleb128 (p, &len, end);
14030       p += len;
14031       printf ("  Tag_ARC_CPU_variation: ");
14032       switch (val)
14033         {
14034         default:
14035           if (val > 0 && val < 16)
14036               printf ("Core%d\n", val);
14037           else
14038               printf ("Unknown\n");
14039           break;
14040
14041         case 0:
14042           printf (_("Absent\n"));
14043           break;
14044         }
14045       break;
14046
14047     case Tag_ARC_CPU_name:
14048       printf ("  Tag_ARC_CPU_name: ");
14049       p = display_tag_value (-1, p, end);
14050       break;
14051
14052     case Tag_ARC_ABI_rf16:
14053       val = read_uleb128 (p, &len, end);
14054       p += len;
14055       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14056       break;
14057
14058     case Tag_ARC_ABI_osver:
14059       val = read_uleb128 (p, &len, end);
14060       p += len;
14061       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14062       break;
14063
14064     case Tag_ARC_ABI_pic:
14065     case Tag_ARC_ABI_sda:
14066       val = read_uleb128 (p, &len, end);
14067       p += len;
14068       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14069               : "  Tag_ARC_ABI_pic: ");
14070       switch (val)
14071         {
14072         case 0:
14073           printf (_("Absent\n"));
14074           break;
14075         case 1:
14076           printf ("MWDT\n");
14077           break;
14078         case 2:
14079           printf ("GNU\n");
14080           break;
14081         default:
14082           printf (_("Unknown\n"));
14083           break;
14084         }
14085       break;
14086
14087     case Tag_ARC_ABI_tls:
14088       val = read_uleb128 (p, &len, end);
14089       p += len;
14090       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14091       break;
14092
14093     case Tag_ARC_ABI_enumsize:
14094       val = read_uleb128 (p, &len, end);
14095       p += len;
14096       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14097               _("smallest"));
14098       break;
14099
14100     case Tag_ARC_ABI_exceptions:
14101       val = read_uleb128 (p, &len, end);
14102       p += len;
14103       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14104               : _("default"));
14105       break;
14106
14107     case Tag_ARC_ABI_double_size:
14108       val = read_uleb128 (p, &len, end);
14109       p += len;
14110       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14111       break;
14112
14113     case Tag_ARC_ISA_config:
14114       printf ("  Tag_ARC_ISA_config: ");
14115       p = display_tag_value (-1, p, end);
14116       break;
14117
14118     case Tag_ARC_ISA_apex:
14119       printf ("  Tag_ARC_ISA_apex: ");
14120       p = display_tag_value (-1, p, end);
14121       break;
14122
14123     case Tag_ARC_ISA_mpy_option:
14124       val = read_uleb128 (p, &len, end);
14125       p += len;
14126       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14127       break;
14128
14129     default:
14130       return display_tag_value (tag & 1, p, end);
14131     }
14132
14133   return p;
14134 }
14135
14136 /* ARM EABI attributes section.  */
14137 typedef struct
14138 {
14139   unsigned int tag;
14140   const char * name;
14141   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14142   unsigned int type;
14143   const char ** table;
14144 } arm_attr_public_tag;
14145
14146 static const char * arm_attr_tag_CPU_arch[] =
14147   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14148    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14149    "v8-M.mainline"};
14150 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14151 static const char * arm_attr_tag_THUMB_ISA_use[] =
14152   {"No", "Thumb-1", "Thumb-2", "Yes"};
14153 static const char * arm_attr_tag_FP_arch[] =
14154   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14155    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14156 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14157 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14158   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14159    "NEON for ARMv8.1"};
14160 static const char * arm_attr_tag_PCS_config[] =
14161   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14162    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14163 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14164   {"V6", "SB", "TLS", "Unused"};
14165 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14166   {"Absolute", "PC-relative", "SB-relative", "None"};
14167 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14168   {"Absolute", "PC-relative", "None"};
14169 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14170   {"None", "direct", "GOT-indirect"};
14171 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14172   {"None", "??? 1", "2", "??? 3", "4"};
14173 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14174 static const char * arm_attr_tag_ABI_FP_denormal[] =
14175   {"Unused", "Needed", "Sign only"};
14176 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14177 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14178 static const char * arm_attr_tag_ABI_FP_number_model[] =
14179   {"Unused", "Finite", "RTABI", "IEEE 754"};
14180 static const char * arm_attr_tag_ABI_enum_size[] =
14181   {"Unused", "small", "int", "forced to int"};
14182 static const char * arm_attr_tag_ABI_HardFP_use[] =
14183   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14184 static const char * arm_attr_tag_ABI_VFP_args[] =
14185   {"AAPCS", "VFP registers", "custom", "compatible"};
14186 static const char * arm_attr_tag_ABI_WMMX_args[] =
14187   {"AAPCS", "WMMX registers", "custom"};
14188 static const char * arm_attr_tag_ABI_optimization_goals[] =
14189   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14190     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14191 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14192   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14193     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14194 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14195 static const char * arm_attr_tag_FP_HP_extension[] =
14196   {"Not Allowed", "Allowed"};
14197 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14198   {"None", "IEEE 754", "Alternative Format"};
14199 static const char * arm_attr_tag_DSP_extension[] =
14200   {"Follow architecture", "Allowed"};
14201 static const char * arm_attr_tag_MPextension_use[] =
14202   {"Not Allowed", "Allowed"};
14203 static const char * arm_attr_tag_DIV_use[] =
14204   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14205     "Allowed in v7-A with integer division extension"};
14206 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14207 static const char * arm_attr_tag_Virtualization_use[] =
14208   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14209     "TrustZone and Virtualization Extensions"};
14210 static const char * arm_attr_tag_MPextension_use_legacy[] =
14211   {"Not Allowed", "Allowed"};
14212
14213 #define LOOKUP(id, name) \
14214   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14215 static arm_attr_public_tag arm_attr_public_tags[] =
14216 {
14217   {4, "CPU_raw_name", 1, NULL},
14218   {5, "CPU_name", 1, NULL},
14219   LOOKUP(6, CPU_arch),
14220   {7, "CPU_arch_profile", 0, NULL},
14221   LOOKUP(8, ARM_ISA_use),
14222   LOOKUP(9, THUMB_ISA_use),
14223   LOOKUP(10, FP_arch),
14224   LOOKUP(11, WMMX_arch),
14225   LOOKUP(12, Advanced_SIMD_arch),
14226   LOOKUP(13, PCS_config),
14227   LOOKUP(14, ABI_PCS_R9_use),
14228   LOOKUP(15, ABI_PCS_RW_data),
14229   LOOKUP(16, ABI_PCS_RO_data),
14230   LOOKUP(17, ABI_PCS_GOT_use),
14231   LOOKUP(18, ABI_PCS_wchar_t),
14232   LOOKUP(19, ABI_FP_rounding),
14233   LOOKUP(20, ABI_FP_denormal),
14234   LOOKUP(21, ABI_FP_exceptions),
14235   LOOKUP(22, ABI_FP_user_exceptions),
14236   LOOKUP(23, ABI_FP_number_model),
14237   {24, "ABI_align_needed", 0, NULL},
14238   {25, "ABI_align_preserved", 0, NULL},
14239   LOOKUP(26, ABI_enum_size),
14240   LOOKUP(27, ABI_HardFP_use),
14241   LOOKUP(28, ABI_VFP_args),
14242   LOOKUP(29, ABI_WMMX_args),
14243   LOOKUP(30, ABI_optimization_goals),
14244   LOOKUP(31, ABI_FP_optimization_goals),
14245   {32, "compatibility", 0, NULL},
14246   LOOKUP(34, CPU_unaligned_access),
14247   LOOKUP(36, FP_HP_extension),
14248   LOOKUP(38, ABI_FP_16bit_format),
14249   LOOKUP(42, MPextension_use),
14250   LOOKUP(44, DIV_use),
14251   LOOKUP(46, DSP_extension),
14252   {64, "nodefaults", 0, NULL},
14253   {65, "also_compatible_with", 0, NULL},
14254   LOOKUP(66, T2EE_use),
14255   {67, "conformance", 1, NULL},
14256   LOOKUP(68, Virtualization_use),
14257   LOOKUP(70, MPextension_use_legacy)
14258 };
14259 #undef LOOKUP
14260
14261 static unsigned char *
14262 display_arm_attribute (unsigned char * p,
14263                        const unsigned char * const end)
14264 {
14265   unsigned int tag;
14266   unsigned int len;
14267   unsigned int val;
14268   arm_attr_public_tag * attr;
14269   unsigned i;
14270   unsigned int type;
14271
14272   tag = read_uleb128 (p, &len, end);
14273   p += len;
14274   attr = NULL;
14275   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14276     {
14277       if (arm_attr_public_tags[i].tag == tag)
14278         {
14279           attr = &arm_attr_public_tags[i];
14280           break;
14281         }
14282     }
14283
14284   if (attr)
14285     {
14286       printf ("  Tag_%s: ", attr->name);
14287       switch (attr->type)
14288         {
14289         case 0:
14290           switch (tag)
14291             {
14292             case 7: /* Tag_CPU_arch_profile.  */
14293               val = read_uleb128 (p, &len, end);
14294               p += len;
14295               switch (val)
14296                 {
14297                 case 0: printf (_("None\n")); break;
14298                 case 'A': printf (_("Application\n")); break;
14299                 case 'R': printf (_("Realtime\n")); break;
14300                 case 'M': printf (_("Microcontroller\n")); break;
14301                 case 'S': printf (_("Application or Realtime\n")); break;
14302                 default: printf ("??? (%d)\n", val); break;
14303                 }
14304               break;
14305
14306             case 24: /* Tag_align_needed.  */
14307               val = read_uleb128 (p, &len, end);
14308               p += len;
14309               switch (val)
14310                 {
14311                 case 0: printf (_("None\n")); break;
14312                 case 1: printf (_("8-byte\n")); break;
14313                 case 2: printf (_("4-byte\n")); break;
14314                 case 3: printf ("??? 3\n"); break;
14315                 default:
14316                   if (val <= 12)
14317                     printf (_("8-byte and up to %d-byte extended\n"),
14318                             1 << val);
14319                   else
14320                     printf ("??? (%d)\n", val);
14321                   break;
14322                 }
14323               break;
14324
14325             case 25: /* Tag_align_preserved.  */
14326               val = read_uleb128 (p, &len, end);
14327               p += len;
14328               switch (val)
14329                 {
14330                 case 0: printf (_("None\n")); break;
14331                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14332                 case 2: printf (_("8-byte\n")); break;
14333                 case 3: printf ("??? 3\n"); break;
14334                 default:
14335                   if (val <= 12)
14336                     printf (_("8-byte and up to %d-byte extended\n"),
14337                             1 << val);
14338                   else
14339                     printf ("??? (%d)\n", val);
14340                   break;
14341                 }
14342               break;
14343
14344             case 32: /* Tag_compatibility.  */
14345               {
14346                 val = read_uleb128 (p, &len, end);
14347                 p += len;
14348                 printf (_("flag = %d, vendor = "), val);
14349                 if (p < end - 1)
14350                   {
14351                     size_t maxlen = (end - p) - 1;
14352
14353                     print_symbol ((int) maxlen, (const char *) p);
14354                     p += strnlen ((char *) p, maxlen) + 1;
14355                   }
14356                 else
14357                   {
14358                     printf (_("<corrupt>"));
14359                     p = (unsigned char *) end;
14360                   }
14361                 putchar ('\n');
14362               }
14363               break;
14364
14365             case 64: /* Tag_nodefaults.  */
14366               /* PR 17531: file: 001-505008-0.01.  */
14367               if (p < end)
14368                 p++;
14369               printf (_("True\n"));
14370               break;
14371
14372             case 65: /* Tag_also_compatible_with.  */
14373               val = read_uleb128 (p, &len, end);
14374               p += len;
14375               if (val == 6 /* Tag_CPU_arch.  */)
14376                 {
14377                   val = read_uleb128 (p, &len, end);
14378                   p += len;
14379                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14380                     printf ("??? (%d)\n", val);
14381                   else
14382                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14383                 }
14384               else
14385                 printf ("???\n");
14386               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14387                 ;
14388               break;
14389
14390             default:
14391               printf (_("<unknown: %d>\n"), tag);
14392               break;
14393             }
14394           return p;
14395
14396         case 1:
14397           return display_tag_value (-1, p, end);
14398         case 2:
14399           return display_tag_value (0, p, end);
14400
14401         default:
14402           assert (attr->type & 0x80);
14403           val = read_uleb128 (p, &len, end);
14404           p += len;
14405           type = attr->type & 0x7f;
14406           if (val >= type)
14407             printf ("??? (%d)\n", val);
14408           else
14409             printf ("%s\n", attr->table[val]);
14410           return p;
14411         }
14412     }
14413
14414   return display_tag_value (tag, p, end);
14415 }
14416
14417 static unsigned char *
14418 display_gnu_attribute (unsigned char * p,
14419                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14420                        const unsigned char * const end)
14421 {
14422   int tag;
14423   unsigned int len;
14424   unsigned int val;
14425
14426   tag = read_uleb128 (p, &len, end);
14427   p += len;
14428
14429   /* Tag_compatibility is the only generic GNU attribute defined at
14430      present.  */
14431   if (tag == 32)
14432     {
14433       val = read_uleb128 (p, &len, end);
14434       p += len;
14435
14436       printf (_("flag = %d, vendor = "), val);
14437       if (p == end)
14438         {
14439           printf (_("<corrupt>\n"));
14440           warn (_("corrupt vendor attribute\n"));
14441         }
14442       else
14443         {
14444           if (p < end - 1)
14445             {
14446               size_t maxlen = (end - p) - 1;
14447
14448               print_symbol ((int) maxlen, (const char *) p);
14449               p += strnlen ((char *) p, maxlen) + 1;
14450             }
14451           else
14452             {
14453               printf (_("<corrupt>"));
14454               p = (unsigned char *) end;
14455             }
14456           putchar ('\n');
14457         }
14458       return p;
14459     }
14460
14461   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14462     return display_proc_gnu_attribute (p, tag, end);
14463
14464   return display_tag_value (tag, p, end);
14465 }
14466
14467 static unsigned char *
14468 display_power_gnu_attribute (unsigned char * p,
14469                              unsigned int tag,
14470                              const unsigned char * const end)
14471 {
14472   unsigned int len;
14473   unsigned int val;
14474
14475   if (tag == Tag_GNU_Power_ABI_FP)
14476     {
14477       val = read_uleb128 (p, &len, end);
14478       p += len;
14479       printf ("  Tag_GNU_Power_ABI_FP: ");
14480       if (len == 0)
14481         {
14482           printf (_("<corrupt>\n"));
14483           return p;
14484         }
14485
14486       if (val > 15)
14487         printf ("(%#x), ", val);
14488
14489       switch (val & 3)
14490         {
14491         case 0:
14492           printf (_("unspecified hard/soft float, "));
14493           break;
14494         case 1:
14495           printf (_("hard float, "));
14496           break;
14497         case 2:
14498           printf (_("soft float, "));
14499           break;
14500         case 3:
14501           printf (_("single-precision hard float, "));
14502           break;
14503         }
14504
14505       switch (val & 0xC)
14506         {
14507         case 0:
14508           printf (_("unspecified long double\n"));
14509           break;
14510         case 4:
14511           printf (_("128-bit IBM long double\n"));
14512           break;
14513         case 8:
14514           printf (_("64-bit long double\n"));
14515           break;
14516         case 12:
14517           printf (_("128-bit IEEE long double\n"));
14518           break;
14519         }
14520       return p;
14521     }
14522
14523   if (tag == Tag_GNU_Power_ABI_Vector)
14524     {
14525       val = read_uleb128 (p, &len, end);
14526       p += len;
14527       printf ("  Tag_GNU_Power_ABI_Vector: ");
14528       if (len == 0)
14529         {
14530           printf (_("<corrupt>\n"));
14531           return p;
14532         }
14533
14534       if (val > 3)
14535         printf ("(%#x), ", val);
14536
14537       switch (val & 3)
14538         {
14539         case 0:
14540           printf (_("unspecified\n"));
14541           break;
14542         case 1:
14543           printf (_("generic\n"));
14544           break;
14545         case 2:
14546           printf ("AltiVec\n");
14547           break;
14548         case 3:
14549           printf ("SPE\n");
14550           break;
14551         }
14552       return p;
14553     }
14554
14555   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14556     {
14557       val = read_uleb128 (p, &len, end);
14558       p += len;
14559       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14560       if (len == 0)
14561         {
14562           printf (_("<corrupt>\n"));
14563           return p;
14564         }
14565
14566       if (val > 2)
14567         printf ("(%#x), ", val);
14568
14569       switch (val & 3)
14570         {
14571         case 0:
14572           printf (_("unspecified\n"));
14573           break;
14574         case 1:
14575           printf ("r3/r4\n");
14576           break;
14577         case 2:
14578           printf (_("memory\n"));
14579           break;
14580         case 3:
14581           printf ("???\n");
14582           break;
14583         }
14584       return p;
14585     }
14586
14587   return display_tag_value (tag & 1, p, end);
14588 }
14589
14590 static unsigned char *
14591 display_s390_gnu_attribute (unsigned char * p,
14592                             unsigned int tag,
14593                             const unsigned char * const end)
14594 {
14595   unsigned int len;
14596   int val;
14597
14598   if (tag == Tag_GNU_S390_ABI_Vector)
14599     {
14600       val = read_uleb128 (p, &len, end);
14601       p += len;
14602       printf ("  Tag_GNU_S390_ABI_Vector: ");
14603
14604       switch (val)
14605         {
14606         case 0:
14607           printf (_("any\n"));
14608           break;
14609         case 1:
14610           printf (_("software\n"));
14611           break;
14612         case 2:
14613           printf (_("hardware\n"));
14614           break;
14615         default:
14616           printf ("??? (%d)\n", val);
14617           break;
14618         }
14619       return p;
14620    }
14621
14622   return display_tag_value (tag & 1, p, end);
14623 }
14624
14625 static void
14626 display_sparc_hwcaps (unsigned int mask)
14627 {
14628   if (mask)
14629     {
14630       bfd_boolean first = TRUE;
14631
14632       if (mask & ELF_SPARC_HWCAP_MUL32)
14633         fputs ("mul32", stdout), first = FALSE;
14634       if (mask & ELF_SPARC_HWCAP_DIV32)
14635         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14636       if (mask & ELF_SPARC_HWCAP_FSMULD)
14637         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14638       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14639         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14640       if (mask & ELF_SPARC_HWCAP_POPC)
14641         printf ("%spopc", first ? "" : "|"), first = FALSE;
14642       if (mask & ELF_SPARC_HWCAP_VIS)
14643         printf ("%svis", first ? "" : "|"), first = FALSE;
14644       if (mask & ELF_SPARC_HWCAP_VIS2)
14645         printf ("%svis2", first ? "" : "|"), first = FALSE;
14646       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14647         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14648       if (mask & ELF_SPARC_HWCAP_FMAF)
14649         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14650       if (mask & ELF_SPARC_HWCAP_VIS3)
14651         printf ("%svis3", first ? "" : "|"), first = FALSE;
14652       if (mask & ELF_SPARC_HWCAP_HPC)
14653         printf ("%shpc", first ? "" : "|"), first = FALSE;
14654       if (mask & ELF_SPARC_HWCAP_RANDOM)
14655         printf ("%srandom", first ? "" : "|"), first = FALSE;
14656       if (mask & ELF_SPARC_HWCAP_TRANS)
14657         printf ("%strans", first ? "" : "|"), first = FALSE;
14658       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14659         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14660       if (mask & ELF_SPARC_HWCAP_IMA)
14661         printf ("%sima", first ? "" : "|"), first = FALSE;
14662       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14663         printf ("%scspare", first ? "" : "|"), first = FALSE;
14664     }
14665   else
14666     fputc ('0', stdout);
14667   fputc ('\n', stdout);
14668 }
14669
14670 static void
14671 display_sparc_hwcaps2 (unsigned int mask)
14672 {
14673   if (mask)
14674     {
14675       bfd_boolean first = TRUE;
14676
14677       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14678         fputs ("fjathplus", stdout), first = FALSE;
14679       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14680         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14681       if (mask & ELF_SPARC_HWCAP2_ADP)
14682         printf ("%sadp", first ? "" : "|"), first = FALSE;
14683       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14684         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14685       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14686         printf ("%smwait", first ? "" : "|"), first = FALSE;
14687       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14688         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14689       if (mask & ELF_SPARC_HWCAP2_XMONT)
14690         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14691       if (mask & ELF_SPARC_HWCAP2_NSEC)
14692         printf ("%snsec", first ? "" : "|"), first = FALSE;
14693       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14694         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14695       if (mask & ELF_SPARC_HWCAP2_FJDES)
14696         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14697       if (mask & ELF_SPARC_HWCAP2_FJAES)
14698         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14699     }
14700   else
14701     fputc ('0', stdout);
14702   fputc ('\n', stdout);
14703 }
14704
14705 static unsigned char *
14706 display_sparc_gnu_attribute (unsigned char * p,
14707                              unsigned int tag,
14708                              const unsigned char * const end)
14709 {
14710   unsigned int len;
14711   int val;
14712
14713   if (tag == Tag_GNU_Sparc_HWCAPS)
14714     {
14715       val = read_uleb128 (p, &len, end);
14716       p += len;
14717       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14718       display_sparc_hwcaps (val);
14719       return p;
14720     }
14721   if (tag == Tag_GNU_Sparc_HWCAPS2)
14722     {
14723       val = read_uleb128 (p, &len, end);
14724       p += len;
14725       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14726       display_sparc_hwcaps2 (val);
14727       return p;
14728     }
14729
14730   return display_tag_value (tag, p, end);
14731 }
14732
14733 static void
14734 print_mips_fp_abi_value (unsigned int val)
14735 {
14736   switch (val)
14737     {
14738     case Val_GNU_MIPS_ABI_FP_ANY:
14739       printf (_("Hard or soft float\n"));
14740       break;
14741     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14742       printf (_("Hard float (double precision)\n"));
14743       break;
14744     case Val_GNU_MIPS_ABI_FP_SINGLE:
14745       printf (_("Hard float (single precision)\n"));
14746       break;
14747     case Val_GNU_MIPS_ABI_FP_SOFT:
14748       printf (_("Soft float\n"));
14749       break;
14750     case Val_GNU_MIPS_ABI_FP_OLD_64:
14751       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14752       break;
14753     case Val_GNU_MIPS_ABI_FP_XX:
14754       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14755       break;
14756     case Val_GNU_MIPS_ABI_FP_64:
14757       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14758       break;
14759     case Val_GNU_MIPS_ABI_FP_64A:
14760       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14761       break;
14762     case Val_GNU_MIPS_ABI_FP_NAN2008:
14763       printf (_("NaN 2008 compatibility\n"));
14764       break;
14765     default:
14766       printf ("??? (%d)\n", val);
14767       break;
14768     }
14769 }
14770
14771 static unsigned char *
14772 display_mips_gnu_attribute (unsigned char * p,
14773                             unsigned int tag,
14774                             const unsigned char * const end)
14775 {
14776   if (tag == Tag_GNU_MIPS_ABI_FP)
14777     {
14778       unsigned int len;
14779       unsigned int val;
14780
14781       val = read_uleb128 (p, &len, end);
14782       p += len;
14783       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14784
14785       print_mips_fp_abi_value (val);
14786
14787       return p;
14788    }
14789
14790   if (tag == Tag_GNU_MIPS_ABI_MSA)
14791     {
14792       unsigned int len;
14793       unsigned int val;
14794
14795       val = read_uleb128 (p, &len, end);
14796       p += len;
14797       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14798
14799       switch (val)
14800         {
14801         case Val_GNU_MIPS_ABI_MSA_ANY:
14802           printf (_("Any MSA or not\n"));
14803           break;
14804         case Val_GNU_MIPS_ABI_MSA_128:
14805           printf (_("128-bit MSA\n"));
14806           break;
14807         default:
14808           printf ("??? (%d)\n", val);
14809           break;
14810         }
14811       return p;
14812     }
14813
14814   return display_tag_value (tag & 1, p, end);
14815 }
14816
14817 static unsigned char *
14818 display_tic6x_attribute (unsigned char * p,
14819                          const unsigned char * const end)
14820 {
14821   unsigned int tag;
14822   unsigned int len;
14823   int val;
14824
14825   tag = read_uleb128 (p, &len, end);
14826   p += len;
14827
14828   switch (tag)
14829     {
14830     case Tag_ISA:
14831       val = read_uleb128 (p, &len, end);
14832       p += len;
14833       printf ("  Tag_ISA: ");
14834
14835       switch (val)
14836         {
14837         case C6XABI_Tag_ISA_none:
14838           printf (_("None\n"));
14839           break;
14840         case C6XABI_Tag_ISA_C62X:
14841           printf ("C62x\n");
14842           break;
14843         case C6XABI_Tag_ISA_C67X:
14844           printf ("C67x\n");
14845           break;
14846         case C6XABI_Tag_ISA_C67XP:
14847           printf ("C67x+\n");
14848           break;
14849         case C6XABI_Tag_ISA_C64X:
14850           printf ("C64x\n");
14851           break;
14852         case C6XABI_Tag_ISA_C64XP:
14853           printf ("C64x+\n");
14854           break;
14855         case C6XABI_Tag_ISA_C674X:
14856           printf ("C674x\n");
14857           break;
14858         default:
14859           printf ("??? (%d)\n", val);
14860           break;
14861         }
14862       return p;
14863
14864     case Tag_ABI_wchar_t:
14865       val = read_uleb128 (p, &len, end);
14866       p += len;
14867       printf ("  Tag_ABI_wchar_t: ");
14868       switch (val)
14869         {
14870         case 0:
14871           printf (_("Not used\n"));
14872           break;
14873         case 1:
14874           printf (_("2 bytes\n"));
14875           break;
14876         case 2:
14877           printf (_("4 bytes\n"));
14878           break;
14879         default:
14880           printf ("??? (%d)\n", val);
14881           break;
14882         }
14883       return p;
14884
14885     case Tag_ABI_stack_align_needed:
14886       val = read_uleb128 (p, &len, end);
14887       p += len;
14888       printf ("  Tag_ABI_stack_align_needed: ");
14889       switch (val)
14890         {
14891         case 0:
14892           printf (_("8-byte\n"));
14893           break;
14894         case 1:
14895           printf (_("16-byte\n"));
14896           break;
14897         default:
14898           printf ("??? (%d)\n", val);
14899           break;
14900         }
14901       return p;
14902
14903     case Tag_ABI_stack_align_preserved:
14904       val = read_uleb128 (p, &len, end);
14905       p += len;
14906       printf ("  Tag_ABI_stack_align_preserved: ");
14907       switch (val)
14908         {
14909         case 0:
14910           printf (_("8-byte\n"));
14911           break;
14912         case 1:
14913           printf (_("16-byte\n"));
14914           break;
14915         default:
14916           printf ("??? (%d)\n", val);
14917           break;
14918         }
14919       return p;
14920
14921     case Tag_ABI_DSBT:
14922       val = read_uleb128 (p, &len, end);
14923       p += len;
14924       printf ("  Tag_ABI_DSBT: ");
14925       switch (val)
14926         {
14927         case 0:
14928           printf (_("DSBT addressing not used\n"));
14929           break;
14930         case 1:
14931           printf (_("DSBT addressing used\n"));
14932           break;
14933         default:
14934           printf ("??? (%d)\n", val);
14935           break;
14936         }
14937       return p;
14938
14939     case Tag_ABI_PID:
14940       val = read_uleb128 (p, &len, end);
14941       p += len;
14942       printf ("  Tag_ABI_PID: ");
14943       switch (val)
14944         {
14945         case 0:
14946           printf (_("Data addressing position-dependent\n"));
14947           break;
14948         case 1:
14949           printf (_("Data addressing position-independent, GOT near DP\n"));
14950           break;
14951         case 2:
14952           printf (_("Data addressing position-independent, GOT far from DP\n"));
14953           break;
14954         default:
14955           printf ("??? (%d)\n", val);
14956           break;
14957         }
14958       return p;
14959
14960     case Tag_ABI_PIC:
14961       val = read_uleb128 (p, &len, end);
14962       p += len;
14963       printf ("  Tag_ABI_PIC: ");
14964       switch (val)
14965         {
14966         case 0:
14967           printf (_("Code addressing position-dependent\n"));
14968           break;
14969         case 1:
14970           printf (_("Code addressing position-independent\n"));
14971           break;
14972         default:
14973           printf ("??? (%d)\n", val);
14974           break;
14975         }
14976       return p;
14977
14978     case Tag_ABI_array_object_alignment:
14979       val = read_uleb128 (p, &len, end);
14980       p += len;
14981       printf ("  Tag_ABI_array_object_alignment: ");
14982       switch (val)
14983         {
14984         case 0:
14985           printf (_("8-byte\n"));
14986           break;
14987         case 1:
14988           printf (_("4-byte\n"));
14989           break;
14990         case 2:
14991           printf (_("16-byte\n"));
14992           break;
14993         default:
14994           printf ("??? (%d)\n", val);
14995           break;
14996         }
14997       return p;
14998
14999     case Tag_ABI_array_object_align_expected:
15000       val = read_uleb128 (p, &len, end);
15001       p += len;
15002       printf ("  Tag_ABI_array_object_align_expected: ");
15003       switch (val)
15004         {
15005         case 0:
15006           printf (_("8-byte\n"));
15007           break;
15008         case 1:
15009           printf (_("4-byte\n"));
15010           break;
15011         case 2:
15012           printf (_("16-byte\n"));
15013           break;
15014         default:
15015           printf ("??? (%d)\n", val);
15016           break;
15017         }
15018       return p;
15019
15020     case Tag_ABI_compatibility:
15021       {
15022         val = read_uleb128 (p, &len, end);
15023         p += len;
15024         printf ("  Tag_ABI_compatibility: ");
15025         printf (_("flag = %d, vendor = "), val);
15026         if (p < end - 1)
15027           {
15028             size_t maxlen = (end - p) - 1;
15029
15030             print_symbol ((int) maxlen, (const char *) p);
15031             p += strnlen ((char *) p, maxlen) + 1;
15032           }
15033         else
15034           {
15035             printf (_("<corrupt>"));
15036             p = (unsigned char *) end;
15037           }
15038         putchar ('\n');
15039         return p;
15040       }
15041
15042     case Tag_ABI_conformance:
15043       {
15044         printf ("  Tag_ABI_conformance: \"");
15045         if (p < end - 1)
15046           {
15047             size_t maxlen = (end - p) - 1;
15048
15049             print_symbol ((int) maxlen, (const char *) p);
15050             p += strnlen ((char *) p, maxlen) + 1;
15051           }
15052         else
15053           {
15054             printf (_("<corrupt>"));
15055             p = (unsigned char *) end;
15056           }
15057         printf ("\"\n");
15058         return p;
15059       }
15060     }
15061
15062   return display_tag_value (tag, p, end);
15063 }
15064
15065 static void
15066 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15067 {
15068   unsigned long addr = 0;
15069   size_t bytes = end - p;
15070
15071   assert (end > p);
15072   while (bytes)
15073     {
15074       int j;
15075       int k;
15076       int lbytes = (bytes > 16 ? 16 : bytes);
15077
15078       printf ("  0x%8.8lx ", addr);
15079
15080       for (j = 0; j < 16; j++)
15081         {
15082           if (j < lbytes)
15083             printf ("%2.2x", p[j]);
15084           else
15085             printf ("  ");
15086
15087           if ((j & 3) == 3)
15088             printf (" ");
15089         }
15090
15091       for (j = 0; j < lbytes; j++)
15092         {
15093           k = p[j];
15094           if (k >= ' ' && k < 0x7f)
15095             printf ("%c", k);
15096           else
15097             printf (".");
15098         }
15099
15100       putchar ('\n');
15101
15102       p  += lbytes;
15103       bytes -= lbytes;
15104       addr += lbytes;
15105     }
15106
15107   putchar ('\n');
15108 }
15109
15110 static unsigned char *
15111 display_msp430x_attribute (unsigned char * p,
15112                            const unsigned char * const end)
15113 {
15114   unsigned int len;
15115   unsigned int val;
15116   unsigned int tag;
15117
15118   tag = read_uleb128 (p, & len, end);
15119   p += len;
15120
15121   switch (tag)
15122     {
15123     case OFBA_MSPABI_Tag_ISA:
15124       val = read_uleb128 (p, &len, end);
15125       p += len;
15126       printf ("  Tag_ISA: ");
15127       switch (val)
15128         {
15129         case 0: printf (_("None\n")); break;
15130         case 1: printf (_("MSP430\n")); break;
15131         case 2: printf (_("MSP430X\n")); break;
15132         default: printf ("??? (%d)\n", val); break;
15133         }
15134       break;
15135
15136     case OFBA_MSPABI_Tag_Code_Model:
15137       val = read_uleb128 (p, &len, end);
15138       p += len;
15139       printf ("  Tag_Code_Model: ");
15140       switch (val)
15141         {
15142         case 0: printf (_("None\n")); break;
15143         case 1: printf (_("Small\n")); break;
15144         case 2: printf (_("Large\n")); break;
15145         default: printf ("??? (%d)\n", val); break;
15146         }
15147       break;
15148
15149     case OFBA_MSPABI_Tag_Data_Model:
15150       val = read_uleb128 (p, &len, end);
15151       p += len;
15152       printf ("  Tag_Data_Model: ");
15153       switch (val)
15154         {
15155         case 0: printf (_("None\n")); break;
15156         case 1: printf (_("Small\n")); break;
15157         case 2: printf (_("Large\n")); break;
15158         case 3: printf (_("Restricted Large\n")); break;
15159         default: printf ("??? (%d)\n", val); break;
15160         }
15161       break;
15162
15163     default:
15164       printf (_("  <unknown tag %d>: "), tag);
15165
15166       if (tag & 1)
15167         {
15168           putchar ('"');
15169           if (p < end - 1)
15170             {
15171               size_t maxlen = (end - p) - 1;
15172
15173               print_symbol ((int) maxlen, (const char *) p);
15174               p += strnlen ((char *) p, maxlen) + 1;
15175             }
15176           else
15177             {
15178               printf (_("<corrupt>"));
15179               p = (unsigned char *) end;
15180             }
15181           printf ("\"\n");
15182         }
15183       else
15184         {
15185           val = read_uleb128 (p, &len, end);
15186           p += len;
15187           printf ("%d (0x%x)\n", val, val);
15188         }
15189       break;
15190    }
15191
15192   assert (p <= end);
15193   return p;
15194 }
15195
15196 static bfd_boolean
15197 process_attributes (Filedata * filedata,
15198                     const char * public_name,
15199                     unsigned int proc_type,
15200                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15201                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15202 {
15203   Elf_Internal_Shdr * sect;
15204   unsigned i;
15205   bfd_boolean res = TRUE;
15206
15207   /* Find the section header so that we get the size.  */
15208   for (i = 0, sect = filedata->section_headers;
15209        i < filedata->file_header.e_shnum;
15210        i++, sect++)
15211     {
15212       unsigned char * contents;
15213       unsigned char * p;
15214
15215       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15216         continue;
15217
15218       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15219                                              sect->sh_size, _("attributes"));
15220       if (contents == NULL)
15221         {
15222           res = FALSE;
15223           continue;
15224         }
15225
15226       p = contents;
15227       /* The first character is the version of the attributes.
15228          Currently only version 1, (aka 'A') is recognised here.  */
15229       if (*p != 'A')
15230         {
15231           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15232           res = FALSE;
15233         }
15234       else
15235         {
15236           bfd_vma section_len;
15237
15238           section_len = sect->sh_size - 1;
15239           p++;
15240
15241           while (section_len > 0)
15242             {
15243               bfd_vma attr_len;
15244               unsigned int namelen;
15245               bfd_boolean public_section;
15246               bfd_boolean gnu_section;
15247
15248               if (section_len <= 4)
15249                 {
15250                   error (_("Tag section ends prematurely\n"));
15251                   res = FALSE;
15252                   break;
15253                 }
15254               attr_len = byte_get (p, 4);
15255               p += 4;
15256
15257               if (attr_len > section_len)
15258                 {
15259                   error (_("Bad attribute length (%u > %u)\n"),
15260                           (unsigned) attr_len, (unsigned) section_len);
15261                   attr_len = section_len;
15262                   res = FALSE;
15263                 }
15264               /* PR 17531: file: 001-101425-0.004  */
15265               else if (attr_len < 5)
15266                 {
15267                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15268                   res = FALSE;
15269                   break;
15270                 }
15271
15272               section_len -= attr_len;
15273               attr_len -= 4;
15274
15275               namelen = strnlen ((char *) p, attr_len) + 1;
15276               if (namelen == 0 || namelen >= attr_len)
15277                 {
15278                   error (_("Corrupt attribute section name\n"));
15279                   res = FALSE;
15280                   break;
15281                 }
15282
15283               printf (_("Attribute Section: "));
15284               print_symbol (INT_MAX, (const char *) p);
15285               putchar ('\n');
15286
15287               if (public_name && streq ((char *) p, public_name))
15288                 public_section = TRUE;
15289               else
15290                 public_section = FALSE;
15291
15292               if (streq ((char *) p, "gnu"))
15293                 gnu_section = TRUE;
15294               else
15295                 gnu_section = FALSE;
15296
15297               p += namelen;
15298               attr_len -= namelen;
15299
15300               while (attr_len > 0 && p < contents + sect->sh_size)
15301                 {
15302                   int tag;
15303                   int val;
15304                   bfd_vma size;
15305                   unsigned char * end;
15306
15307                   /* PR binutils/17531: Safe handling of corrupt files.  */
15308                   if (attr_len < 6)
15309                     {
15310                       error (_("Unused bytes at end of section\n"));
15311                       res = FALSE;
15312                       section_len = 0;
15313                       break;
15314                     }
15315
15316                   tag = *(p++);
15317                   size = byte_get (p, 4);
15318                   if (size > attr_len)
15319                     {
15320                       error (_("Bad subsection length (%u > %u)\n"),
15321                               (unsigned) size, (unsigned) attr_len);
15322                       res = FALSE;
15323                       size = attr_len;
15324                     }
15325                   /* PR binutils/17531: Safe handling of corrupt files.  */
15326                   if (size < 6)
15327                     {
15328                       error (_("Bad subsection length (%u < 6)\n"),
15329                               (unsigned) size);
15330                       res = FALSE;
15331                       section_len = 0;
15332                       break;
15333                     }
15334
15335                   attr_len -= size;
15336                   end = p + size - 1;
15337                   assert (end <= contents + sect->sh_size);
15338                   p += 4;
15339
15340                   switch (tag)
15341                     {
15342                     case 1:
15343                       printf (_("File Attributes\n"));
15344                       break;
15345                     case 2:
15346                       printf (_("Section Attributes:"));
15347                       goto do_numlist;
15348                     case 3:
15349                       printf (_("Symbol Attributes:"));
15350                       /* Fall through.  */
15351                     do_numlist:
15352                       for (;;)
15353                         {
15354                           unsigned int j;
15355
15356                           val = read_uleb128 (p, &j, end);
15357                           p += j;
15358                           if (val == 0)
15359                             break;
15360                           printf (" %d", val);
15361                         }
15362                       printf ("\n");
15363                       break;
15364                     default:
15365                       printf (_("Unknown tag: %d\n"), tag);
15366                       public_section = FALSE;
15367                       break;
15368                     }
15369
15370                   if (public_section && display_pub_attribute != NULL)
15371                     {
15372                       while (p < end)
15373                         p = display_pub_attribute (p, end);
15374                       assert (p == end);
15375                     }
15376                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15377                     {
15378                       while (p < end)
15379                         p = display_gnu_attribute (p,
15380                                                    display_proc_gnu_attribute,
15381                                                    end);
15382                       assert (p == end);
15383                     }
15384                   else if (p < end)
15385                     {
15386                       printf (_("  Unknown attribute:\n"));
15387                       display_raw_attribute (p, end);
15388                       p = end;
15389                     }
15390                   else
15391                     attr_len = 0;
15392                 }
15393             }
15394         }
15395
15396       free (contents);
15397     }
15398
15399   return res;
15400 }
15401
15402 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15403    Print the Address, Access and Initial fields of an entry at VMA ADDR
15404    and return the VMA of the next entry, or -1 if there was a problem.
15405    Does not read from DATA_END or beyond.  */
15406
15407 static bfd_vma
15408 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15409                       unsigned char * data_end)
15410 {
15411   printf ("  ");
15412   print_vma (addr, LONG_HEX);
15413   printf (" ");
15414   if (addr < pltgot + 0xfff0)
15415     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15416   else
15417     printf ("%10s", "");
15418   printf (" ");
15419   if (data == NULL)
15420     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15421   else
15422     {
15423       bfd_vma entry;
15424       unsigned char * from = data + addr - pltgot;
15425
15426       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15427         {
15428           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15429           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15430           return (bfd_vma) -1;
15431         }
15432       else
15433         {
15434           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15435           print_vma (entry, LONG_HEX);
15436         }
15437     }
15438   return addr + (is_32bit_elf ? 4 : 8);
15439 }
15440
15441 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15442    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15443    ADDR and return the VMA of the next entry.  */
15444
15445 static bfd_vma
15446 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15447 {
15448   printf ("  ");
15449   print_vma (addr, LONG_HEX);
15450   printf (" ");
15451   if (data == NULL)
15452     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15453   else
15454     {
15455       bfd_vma entry;
15456
15457       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15458       print_vma (entry, LONG_HEX);
15459     }
15460   return addr + (is_32bit_elf ? 4 : 8);
15461 }
15462
15463 static void
15464 print_mips_ases (unsigned int mask)
15465 {
15466   if (mask & AFL_ASE_DSP)
15467     fputs ("\n\tDSP ASE", stdout);
15468   if (mask & AFL_ASE_DSPR2)
15469     fputs ("\n\tDSP R2 ASE", stdout);
15470   if (mask & AFL_ASE_DSPR3)
15471     fputs ("\n\tDSP R3 ASE", stdout);
15472   if (mask & AFL_ASE_EVA)
15473     fputs ("\n\tEnhanced VA Scheme", stdout);
15474   if (mask & AFL_ASE_MCU)
15475     fputs ("\n\tMCU (MicroController) ASE", stdout);
15476   if (mask & AFL_ASE_MDMX)
15477     fputs ("\n\tMDMX ASE", stdout);
15478   if (mask & AFL_ASE_MIPS3D)
15479     fputs ("\n\tMIPS-3D ASE", stdout);
15480   if (mask & AFL_ASE_MT)
15481     fputs ("\n\tMT ASE", stdout);
15482   if (mask & AFL_ASE_SMARTMIPS)
15483     fputs ("\n\tSmartMIPS ASE", stdout);
15484   if (mask & AFL_ASE_VIRT)
15485     fputs ("\n\tVZ ASE", stdout);
15486   if (mask & AFL_ASE_MSA)
15487     fputs ("\n\tMSA ASE", stdout);
15488   if (mask & AFL_ASE_MIPS16)
15489     fputs ("\n\tMIPS16 ASE", stdout);
15490   if (mask & AFL_ASE_MICROMIPS)
15491     fputs ("\n\tMICROMIPS ASE", stdout);
15492   if (mask & AFL_ASE_XPA)
15493     fputs ("\n\tXPA ASE", stdout);
15494   if (mask & AFL_ASE_MIPS16E2)
15495     fputs ("\n\tMIPS16e2 ASE", stdout);
15496   if (mask == 0)
15497     fprintf (stdout, "\n\t%s", _("None"));
15498   else if ((mask & ~AFL_ASE_MASK) != 0)
15499     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15500 }
15501
15502 static void
15503 print_mips_isa_ext (unsigned int isa_ext)
15504 {
15505   switch (isa_ext)
15506     {
15507     case 0:
15508       fputs (_("None"), stdout);
15509       break;
15510     case AFL_EXT_XLR:
15511       fputs ("RMI XLR", stdout);
15512       break;
15513     case AFL_EXT_OCTEON3:
15514       fputs ("Cavium Networks Octeon3", stdout);
15515       break;
15516     case AFL_EXT_OCTEON2:
15517       fputs ("Cavium Networks Octeon2", stdout);
15518       break;
15519     case AFL_EXT_OCTEONP:
15520       fputs ("Cavium Networks OcteonP", stdout);
15521       break;
15522     case AFL_EXT_LOONGSON_3A:
15523       fputs ("Loongson 3A", stdout);
15524       break;
15525     case AFL_EXT_OCTEON:
15526       fputs ("Cavium Networks Octeon", stdout);
15527       break;
15528     case AFL_EXT_5900:
15529       fputs ("Toshiba R5900", stdout);
15530       break;
15531     case AFL_EXT_4650:
15532       fputs ("MIPS R4650", stdout);
15533       break;
15534     case AFL_EXT_4010:
15535       fputs ("LSI R4010", stdout);
15536       break;
15537     case AFL_EXT_4100:
15538       fputs ("NEC VR4100", stdout);
15539       break;
15540     case AFL_EXT_3900:
15541       fputs ("Toshiba R3900", stdout);
15542       break;
15543     case AFL_EXT_10000:
15544       fputs ("MIPS R10000", stdout);
15545       break;
15546     case AFL_EXT_SB1:
15547       fputs ("Broadcom SB-1", stdout);
15548       break;
15549     case AFL_EXT_4111:
15550       fputs ("NEC VR4111/VR4181", stdout);
15551       break;
15552     case AFL_EXT_4120:
15553       fputs ("NEC VR4120", stdout);
15554       break;
15555     case AFL_EXT_5400:
15556       fputs ("NEC VR5400", stdout);
15557       break;
15558     case AFL_EXT_5500:
15559       fputs ("NEC VR5500", stdout);
15560       break;
15561     case AFL_EXT_LOONGSON_2E:
15562       fputs ("ST Microelectronics Loongson 2E", stdout);
15563       break;
15564     case AFL_EXT_LOONGSON_2F:
15565       fputs ("ST Microelectronics Loongson 2F", stdout);
15566       break;
15567     case AFL_EXT_INTERAPTIV_MR2:
15568       fputs ("Imagination interAptiv MR2", stdout);
15569       break;
15570     default:
15571       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15572     }
15573 }
15574
15575 static signed int
15576 get_mips_reg_size (int reg_size)
15577 {
15578   return (reg_size == AFL_REG_NONE) ? 0
15579          : (reg_size == AFL_REG_32) ? 32
15580          : (reg_size == AFL_REG_64) ? 64
15581          : (reg_size == AFL_REG_128) ? 128
15582          : -1;
15583 }
15584
15585 static bfd_boolean
15586 process_mips_specific (Filedata * filedata)
15587 {
15588   Elf_Internal_Dyn * entry;
15589   Elf_Internal_Shdr *sect = NULL;
15590   size_t liblist_offset = 0;
15591   size_t liblistno = 0;
15592   size_t conflictsno = 0;
15593   size_t options_offset = 0;
15594   size_t conflicts_offset = 0;
15595   size_t pltrelsz = 0;
15596   size_t pltrel = 0;
15597   bfd_vma pltgot = 0;
15598   bfd_vma mips_pltgot = 0;
15599   bfd_vma jmprel = 0;
15600   bfd_vma local_gotno = 0;
15601   bfd_vma gotsym = 0;
15602   bfd_vma symtabno = 0;
15603   bfd_boolean res = TRUE;
15604
15605   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15606                             display_mips_gnu_attribute))
15607     res = FALSE;
15608
15609   sect = find_section (filedata, ".MIPS.abiflags");
15610
15611   if (sect != NULL)
15612     {
15613       Elf_External_ABIFlags_v0 *abiflags_ext;
15614       Elf_Internal_ABIFlags_v0 abiflags_in;
15615
15616       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15617         {
15618           error (_("Corrupt MIPS ABI Flags section.\n"));
15619           res = FALSE;
15620         }
15621       else
15622         {
15623           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15624                                    sect->sh_size, _("MIPS ABI Flags section"));
15625           if (abiflags_ext)
15626             {
15627               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15628               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15629               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15630               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15631               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15632               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15633               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15634               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15635               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15636               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15637               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15638
15639               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15640               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15641               if (abiflags_in.isa_rev > 1)
15642                 printf ("r%d", abiflags_in.isa_rev);
15643               printf ("\nGPR size: %d",
15644                       get_mips_reg_size (abiflags_in.gpr_size));
15645               printf ("\nCPR1 size: %d",
15646                       get_mips_reg_size (abiflags_in.cpr1_size));
15647               printf ("\nCPR2 size: %d",
15648                       get_mips_reg_size (abiflags_in.cpr2_size));
15649               fputs ("\nFP ABI: ", stdout);
15650               print_mips_fp_abi_value (abiflags_in.fp_abi);
15651               fputs ("ISA Extension: ", stdout);
15652               print_mips_isa_ext (abiflags_in.isa_ext);
15653               fputs ("\nASEs:", stdout);
15654               print_mips_ases (abiflags_in.ases);
15655               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15656               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15657               fputc ('\n', stdout);
15658               free (abiflags_ext);
15659             }
15660         }
15661     }
15662
15663   /* We have a lot of special sections.  Thanks SGI!  */
15664   if (dynamic_section == NULL)
15665     {
15666       /* No dynamic information available.  See if there is static GOT.  */
15667       sect = find_section (filedata, ".got");
15668       if (sect != NULL)
15669         {
15670           unsigned char *data_end;
15671           unsigned char *data;
15672           bfd_vma ent, end;
15673           int addr_size;
15674
15675           pltgot = sect->sh_addr;
15676
15677           ent = pltgot;
15678           addr_size = (is_32bit_elf ? 4 : 8);
15679           end = pltgot + sect->sh_size;
15680
15681           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15682                                              end - pltgot, 1,
15683                                              _("Global Offset Table data"));
15684           /* PR 12855: Null data is handled gracefully throughout.  */
15685           data_end = data + (end - pltgot);
15686
15687           printf (_("\nStatic GOT:\n"));
15688           printf (_(" Canonical gp value: "));
15689           print_vma (ent + 0x7ff0, LONG_HEX);
15690           printf ("\n\n");
15691
15692           /* In a dynamic binary GOT[0] is reserved for the dynamic
15693              loader to store the lazy resolver pointer, however in
15694              a static binary it may well have been omitted and GOT
15695              reduced to a table of addresses.
15696              PR 21344: Check for the entry being fully available
15697              before fetching it.  */
15698           if (data
15699               && data + ent - pltgot + addr_size <= data_end
15700               && byte_get (data + ent - pltgot, addr_size) == 0)
15701             {
15702               printf (_(" Reserved entries:\n"));
15703               printf (_("  %*s %10s %*s\n"),
15704                       addr_size * 2, _("Address"), _("Access"),
15705                       addr_size * 2, _("Value"));
15706               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15707               printf ("\n");
15708               if (ent == (bfd_vma) -1)
15709                 goto sgot_print_fail;
15710
15711               /* Check for the MSB of GOT[1] being set, identifying a
15712                  GNU object.  This entry will be used by some runtime
15713                  loaders, to store the module pointer.  Otherwise this
15714                  is an ordinary local entry.
15715                  PR 21344: Check for the entry being fully available
15716                  before fetching it.  */
15717               if (data
15718                   && data + ent - pltgot + addr_size <= data_end
15719                   && (byte_get (data + ent - pltgot, addr_size)
15720                       >> (addr_size * 8 - 1)) != 0)
15721                 {
15722                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15723                   printf ("\n");
15724                   if (ent == (bfd_vma) -1)
15725                     goto sgot_print_fail;
15726                 }
15727               printf ("\n");
15728             }
15729
15730           if (data != NULL && ent < end)
15731             {
15732               printf (_(" Local entries:\n"));
15733               printf ("  %*s %10s %*s\n",
15734                       addr_size * 2, _("Address"), _("Access"),
15735                       addr_size * 2, _("Value"));
15736               while (ent < end)
15737                 {
15738                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15739                   printf ("\n");
15740                   if (ent == (bfd_vma) -1)
15741                     goto sgot_print_fail;
15742                 }
15743               printf ("\n");
15744             }
15745
15746         sgot_print_fail:
15747           if (data)
15748             free (data);
15749         }
15750       return res;
15751     }
15752
15753   for (entry = dynamic_section;
15754        /* PR 17531 file: 012-50589-0.004.  */
15755        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15756        ++entry)
15757     switch (entry->d_tag)
15758       {
15759       case DT_MIPS_LIBLIST:
15760         liblist_offset
15761           = offset_from_vma (filedata, entry->d_un.d_val,
15762                              liblistno * sizeof (Elf32_External_Lib));
15763         break;
15764       case DT_MIPS_LIBLISTNO:
15765         liblistno = entry->d_un.d_val;
15766         break;
15767       case DT_MIPS_OPTIONS:
15768         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15769         break;
15770       case DT_MIPS_CONFLICT:
15771         conflicts_offset
15772           = offset_from_vma (filedata, entry->d_un.d_val,
15773                              conflictsno * sizeof (Elf32_External_Conflict));
15774         break;
15775       case DT_MIPS_CONFLICTNO:
15776         conflictsno = entry->d_un.d_val;
15777         break;
15778       case DT_PLTGOT:
15779         pltgot = entry->d_un.d_ptr;
15780         break;
15781       case DT_MIPS_LOCAL_GOTNO:
15782         local_gotno = entry->d_un.d_val;
15783         break;
15784       case DT_MIPS_GOTSYM:
15785         gotsym = entry->d_un.d_val;
15786         break;
15787       case DT_MIPS_SYMTABNO:
15788         symtabno = entry->d_un.d_val;
15789         break;
15790       case DT_MIPS_PLTGOT:
15791         mips_pltgot = entry->d_un.d_ptr;
15792         break;
15793       case DT_PLTREL:
15794         pltrel = entry->d_un.d_val;
15795         break;
15796       case DT_PLTRELSZ:
15797         pltrelsz = entry->d_un.d_val;
15798         break;
15799       case DT_JMPREL:
15800         jmprel = entry->d_un.d_ptr;
15801         break;
15802       default:
15803         break;
15804       }
15805
15806   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15807     {
15808       Elf32_External_Lib * elib;
15809       size_t cnt;
15810
15811       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15812                                               liblistno,
15813                                               sizeof (Elf32_External_Lib),
15814                                               _("liblist section data"));
15815       if (elib)
15816         {
15817           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15818                             "\nSection '.liblist' contains %lu entries:\n",
15819                             (unsigned long) liblistno),
15820                   (unsigned long) liblistno);
15821           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15822                  stdout);
15823
15824           for (cnt = 0; cnt < liblistno; ++cnt)
15825             {
15826               Elf32_Lib liblist;
15827               time_t atime;
15828               char timebuf[128];
15829               struct tm * tmp;
15830
15831               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15832               atime = BYTE_GET (elib[cnt].l_time_stamp);
15833               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15834               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15835               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15836
15837               tmp = gmtime (&atime);
15838               snprintf (timebuf, sizeof (timebuf),
15839                         "%04u-%02u-%02uT%02u:%02u:%02u",
15840                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15841                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15842
15843               printf ("%3lu: ", (unsigned long) cnt);
15844               if (VALID_DYNAMIC_NAME (liblist.l_name))
15845                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15846               else
15847                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15848               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15849                       liblist.l_version);
15850
15851               if (liblist.l_flags == 0)
15852                 puts (_(" NONE"));
15853               else
15854                 {
15855                   static const struct
15856                   {
15857                     const char * name;
15858                     int bit;
15859                   }
15860                   l_flags_vals[] =
15861                   {
15862                     { " EXACT_MATCH", LL_EXACT_MATCH },
15863                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15864                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15865                     { " EXPORTS", LL_EXPORTS },
15866                     { " DELAY_LOAD", LL_DELAY_LOAD },
15867                     { " DELTA", LL_DELTA }
15868                   };
15869                   int flags = liblist.l_flags;
15870                   size_t fcnt;
15871
15872                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15873                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15874                       {
15875                         fputs (l_flags_vals[fcnt].name, stdout);
15876                         flags ^= l_flags_vals[fcnt].bit;
15877                       }
15878                   if (flags != 0)
15879                     printf (" %#x", (unsigned int) flags);
15880
15881                   puts ("");
15882                 }
15883             }
15884
15885           free (elib);
15886         }
15887       else
15888         res = FALSE;
15889     }
15890
15891   if (options_offset != 0)
15892     {
15893       Elf_External_Options * eopt;
15894       Elf_Internal_Options * iopt;
15895       Elf_Internal_Options * option;
15896       size_t offset;
15897       int cnt;
15898       sect = filedata->section_headers;
15899
15900       /* Find the section header so that we get the size.  */
15901       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
15902       /* PR 17533 file: 012-277276-0.004.  */
15903       if (sect == NULL)
15904         {
15905           error (_("No MIPS_OPTIONS header found\n"));
15906           return FALSE;
15907         }
15908
15909       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
15910                                                 sect->sh_size, _("options"));
15911       if (eopt)
15912         {
15913           iopt = (Elf_Internal_Options *)
15914               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15915           if (iopt == NULL)
15916             {
15917               error (_("Out of memory allocating space for MIPS options\n"));
15918               return FALSE;
15919             }
15920
15921           offset = cnt = 0;
15922           option = iopt;
15923
15924           while (offset <= sect->sh_size - sizeof (* eopt))
15925             {
15926               Elf_External_Options * eoption;
15927
15928               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15929
15930               option->kind = BYTE_GET (eoption->kind);
15931               option->size = BYTE_GET (eoption->size);
15932               option->section = BYTE_GET (eoption->section);
15933               option->info = BYTE_GET (eoption->info);
15934
15935               /* PR 17531: file: ffa0fa3b.  */
15936               if (option->size < sizeof (* eopt)
15937                   || offset + option->size > sect->sh_size)
15938                 {
15939                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15940                   return FALSE;
15941                 }
15942               offset += option->size;
15943
15944               ++option;
15945               ++cnt;
15946             }
15947
15948           printf (ngettext ("\nSection '%s' contains %d entry:\n",
15949                             "\nSection '%s' contains %d entries:\n",
15950                             cnt),
15951                   printable_section_name (filedata, sect), cnt);
15952
15953           option = iopt;
15954           offset = 0;
15955
15956           while (cnt-- > 0)
15957             {
15958               size_t len;
15959
15960               switch (option->kind)
15961                 {
15962                 case ODK_NULL:
15963                   /* This shouldn't happen.  */
15964                   printf (" NULL       %d %lx", option->section, option->info);
15965                   break;
15966                 case ODK_REGINFO:
15967                   printf (" REGINFO    ");
15968                   if (filedata->file_header.e_machine == EM_MIPS)
15969                     {
15970                       /* 32bit form.  */
15971                       Elf32_External_RegInfo * ereg;
15972                       Elf32_RegInfo reginfo;
15973
15974                       ereg = (Elf32_External_RegInfo *) (option + 1);
15975                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15976                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15977                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15978                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15979                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15980                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15981
15982                       printf ("GPR %08lx  GP 0x%lx\n",
15983                               reginfo.ri_gprmask,
15984                               (unsigned long) reginfo.ri_gp_value);
15985                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15986                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15987                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15988                     }
15989                   else
15990                     {
15991                       /* 64 bit form.  */
15992                       Elf64_External_RegInfo * ereg;
15993                       Elf64_Internal_RegInfo reginfo;
15994
15995                       ereg = (Elf64_External_RegInfo *) (option + 1);
15996                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15997                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15998                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15999                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16000                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16001                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16002
16003                       printf ("GPR %08lx  GP 0x",
16004                               reginfo.ri_gprmask);
16005                       printf_vma (reginfo.ri_gp_value);
16006                       printf ("\n");
16007
16008                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16009                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16010                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16011                     }
16012                   ++option;
16013                   continue;
16014                 case ODK_EXCEPTIONS:
16015                   fputs (" EXCEPTIONS fpe_min(", stdout);
16016                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16017                   fputs (") fpe_max(", stdout);
16018                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16019                   fputs (")", stdout);
16020
16021                   if (option->info & OEX_PAGE0)
16022                     fputs (" PAGE0", stdout);
16023                   if (option->info & OEX_SMM)
16024                     fputs (" SMM", stdout);
16025                   if (option->info & OEX_FPDBUG)
16026                     fputs (" FPDBUG", stdout);
16027                   if (option->info & OEX_DISMISS)
16028                     fputs (" DISMISS", stdout);
16029                   break;
16030                 case ODK_PAD:
16031                   fputs (" PAD       ", stdout);
16032                   if (option->info & OPAD_PREFIX)
16033                     fputs (" PREFIX", stdout);
16034                   if (option->info & OPAD_POSTFIX)
16035                     fputs (" POSTFIX", stdout);
16036                   if (option->info & OPAD_SYMBOL)
16037                     fputs (" SYMBOL", stdout);
16038                   break;
16039                 case ODK_HWPATCH:
16040                   fputs (" HWPATCH   ", stdout);
16041                   if (option->info & OHW_R4KEOP)
16042                     fputs (" R4KEOP", stdout);
16043                   if (option->info & OHW_R8KPFETCH)
16044                     fputs (" R8KPFETCH", stdout);
16045                   if (option->info & OHW_R5KEOP)
16046                     fputs (" R5KEOP", stdout);
16047                   if (option->info & OHW_R5KCVTL)
16048                     fputs (" R5KCVTL", stdout);
16049                   break;
16050                 case ODK_FILL:
16051                   fputs (" FILL       ", stdout);
16052                   /* XXX Print content of info word?  */
16053                   break;
16054                 case ODK_TAGS:
16055                   fputs (" TAGS       ", stdout);
16056                   /* XXX Print content of info word?  */
16057                   break;
16058                 case ODK_HWAND:
16059                   fputs (" HWAND     ", stdout);
16060                   if (option->info & OHWA0_R4KEOP_CHECKED)
16061                     fputs (" R4KEOP_CHECKED", stdout);
16062                   if (option->info & OHWA0_R4KEOP_CLEAN)
16063                     fputs (" R4KEOP_CLEAN", stdout);
16064                   break;
16065                 case ODK_HWOR:
16066                   fputs (" HWOR      ", stdout);
16067                   if (option->info & OHWA0_R4KEOP_CHECKED)
16068                     fputs (" R4KEOP_CHECKED", stdout);
16069                   if (option->info & OHWA0_R4KEOP_CLEAN)
16070                     fputs (" R4KEOP_CLEAN", stdout);
16071                   break;
16072                 case ODK_GP_GROUP:
16073                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16074                           option->info & OGP_GROUP,
16075                           (option->info & OGP_SELF) >> 16);
16076                   break;
16077                 case ODK_IDENT:
16078                   printf (" IDENT     %#06lx  self-contained %#06lx",
16079                           option->info & OGP_GROUP,
16080                           (option->info & OGP_SELF) >> 16);
16081                   break;
16082                 default:
16083                   /* This shouldn't happen.  */
16084                   printf (" %3d ???     %d %lx",
16085                           option->kind, option->section, option->info);
16086                   break;
16087                 }
16088
16089               len = sizeof (* eopt);
16090               while (len < option->size)
16091                 {
16092                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16093
16094                   if (ISPRINT (datum))
16095                     printf ("%c", datum);
16096                   else
16097                     printf ("\\%03o", datum);
16098                   len ++;
16099                 }
16100               fputs ("\n", stdout);
16101
16102               offset += option->size;
16103               ++option;
16104             }
16105
16106           free (eopt);
16107         }
16108       else
16109         res = FALSE;
16110     }
16111
16112   if (conflicts_offset != 0 && conflictsno != 0)
16113     {
16114       Elf32_Conflict * iconf;
16115       size_t cnt;
16116
16117       if (dynamic_symbols == NULL)
16118         {
16119           error (_("conflict list found without a dynamic symbol table\n"));
16120           return FALSE;
16121         }
16122
16123       /* PR 21345 - print a slightly more helpful error message
16124          if we are sure that the cmalloc will fail.  */
16125       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16126         {
16127           error (_("Overlarge number of conflicts detected: %lx\n"),
16128                  (long) conflictsno);
16129           return FALSE;
16130         }
16131
16132       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16133       if (iconf == NULL)
16134         {
16135           error (_("Out of memory allocating space for dynamic conflicts\n"));
16136           return FALSE;
16137         }
16138
16139       if (is_32bit_elf)
16140         {
16141           Elf32_External_Conflict * econf32;
16142
16143           econf32 = (Elf32_External_Conflict *)
16144               get_data (NULL, filedata, conflicts_offset, conflictsno,
16145                         sizeof (* econf32), _("conflict"));
16146           if (!econf32)
16147             return FALSE;
16148
16149           for (cnt = 0; cnt < conflictsno; ++cnt)
16150             iconf[cnt] = BYTE_GET (econf32[cnt]);
16151
16152           free (econf32);
16153         }
16154       else
16155         {
16156           Elf64_External_Conflict * econf64;
16157
16158           econf64 = (Elf64_External_Conflict *)
16159               get_data (NULL, filedata, conflicts_offset, conflictsno,
16160                         sizeof (* econf64), _("conflict"));
16161           if (!econf64)
16162             return FALSE;
16163
16164           for (cnt = 0; cnt < conflictsno; ++cnt)
16165             iconf[cnt] = BYTE_GET (econf64[cnt]);
16166
16167           free (econf64);
16168         }
16169
16170       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16171                         "\nSection '.conflict' contains %lu entries:\n",
16172                         (unsigned long) conflictsno),
16173               (unsigned long) conflictsno);
16174       puts (_("  Num:    Index       Value  Name"));
16175
16176       for (cnt = 0; cnt < conflictsno; ++cnt)
16177         {
16178           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16179
16180           if (iconf[cnt] >= num_dynamic_syms)
16181             printf (_("<corrupt symbol index>"));
16182           else
16183             {
16184               Elf_Internal_Sym * psym;
16185
16186               psym = & dynamic_symbols[iconf[cnt]];
16187               print_vma (psym->st_value, FULL_HEX);
16188               putchar (' ');
16189               if (VALID_DYNAMIC_NAME (psym->st_name))
16190                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16191               else
16192                 printf (_("<corrupt: %14ld>"), psym->st_name);
16193             }
16194           putchar ('\n');
16195         }
16196
16197       free (iconf);
16198     }
16199
16200   if (pltgot != 0 && local_gotno != 0)
16201     {
16202       bfd_vma ent, local_end, global_end;
16203       size_t i, offset;
16204       unsigned char * data;
16205       unsigned char * data_end;
16206       int addr_size;
16207
16208       ent = pltgot;
16209       addr_size = (is_32bit_elf ? 4 : 8);
16210       local_end = pltgot + local_gotno * addr_size;
16211
16212       /* PR binutils/17533 file: 012-111227-0.004  */
16213       if (symtabno < gotsym)
16214         {
16215           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16216                  (unsigned long) gotsym, (unsigned long) symtabno);
16217           return FALSE;
16218         }
16219
16220       global_end = local_end + (symtabno - gotsym) * addr_size;
16221       /* PR 17531: file: 54c91a34.  */
16222       if (global_end < local_end)
16223         {
16224           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16225           return FALSE;
16226         }
16227
16228       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16229       data = (unsigned char *) get_data (NULL, filedata, offset,
16230                                          global_end - pltgot, 1,
16231                                          _("Global Offset Table data"));
16232       /* PR 12855: Null data is handled gracefully throughout.  */
16233       data_end = data + (global_end - pltgot);
16234
16235       printf (_("\nPrimary GOT:\n"));
16236       printf (_(" Canonical gp value: "));
16237       print_vma (pltgot + 0x7ff0, LONG_HEX);
16238       printf ("\n\n");
16239
16240       printf (_(" Reserved entries:\n"));
16241       printf (_("  %*s %10s %*s Purpose\n"),
16242               addr_size * 2, _("Address"), _("Access"),
16243               addr_size * 2, _("Initial"));
16244       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16245       printf (_(" Lazy resolver\n"));
16246       if (ent == (bfd_vma) -1)
16247         goto got_print_fail;
16248
16249       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16250          This entry will be used by some runtime loaders, to store the
16251          module pointer.  Otherwise this is an ordinary local entry.
16252          PR 21344: Check for the entry being fully available before
16253          fetching it.  */
16254       if (data
16255           && data + ent - pltgot + addr_size <= data_end
16256           && (byte_get (data + ent - pltgot, addr_size)
16257               >> (addr_size * 8 - 1)) != 0)
16258         {
16259           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16260           printf (_(" Module pointer (GNU extension)\n"));
16261           if (ent == (bfd_vma) -1)
16262             goto got_print_fail;
16263         }
16264       printf ("\n");
16265
16266       if (data != NULL && ent < local_end)
16267         {
16268           printf (_(" Local entries:\n"));
16269           printf ("  %*s %10s %*s\n",
16270                   addr_size * 2, _("Address"), _("Access"),
16271                   addr_size * 2, _("Initial"));
16272           while (ent < local_end)
16273             {
16274               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16275               printf ("\n");
16276               if (ent == (bfd_vma) -1)
16277                 goto got_print_fail;
16278             }
16279           printf ("\n");
16280         }
16281
16282       if (data != NULL && gotsym < symtabno)
16283         {
16284           int sym_width;
16285
16286           printf (_(" Global entries:\n"));
16287           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16288                   addr_size * 2, _("Address"),
16289                   _("Access"),
16290                   addr_size * 2, _("Initial"),
16291                   addr_size * 2, _("Sym.Val."),
16292                   _("Type"),
16293                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16294                   _("Ndx"), _("Name"));
16295
16296           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16297
16298           for (i = gotsym; i < symtabno; i++)
16299             {
16300               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16301               printf (" ");
16302
16303               if (dynamic_symbols == NULL)
16304                 printf (_("<no dynamic symbols>"));
16305               else if (i < num_dynamic_syms)
16306                 {
16307                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16308
16309                   print_vma (psym->st_value, LONG_HEX);
16310                   printf (" %-7s %3s ",
16311                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16312                           get_symbol_index_type (filedata, psym->st_shndx));
16313
16314                   if (VALID_DYNAMIC_NAME (psym->st_name))
16315                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16316                   else
16317                     printf (_("<corrupt: %14ld>"), psym->st_name);
16318                 }
16319               else
16320                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16321                         (unsigned long) i);
16322
16323               printf ("\n");
16324               if (ent == (bfd_vma) -1)
16325                 break;
16326             }
16327           printf ("\n");
16328         }
16329
16330     got_print_fail:
16331       if (data)
16332         free (data);
16333     }
16334
16335   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16336     {
16337       bfd_vma ent, end;
16338       size_t offset, rel_offset;
16339       unsigned long count, i;
16340       unsigned char * data;
16341       int addr_size, sym_width;
16342       Elf_Internal_Rela * rels;
16343
16344       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16345       if (pltrel == DT_RELA)
16346         {
16347           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16348             return FALSE;
16349         }
16350       else
16351         {
16352           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16353             return FALSE;
16354         }
16355
16356       ent = mips_pltgot;
16357       addr_size = (is_32bit_elf ? 4 : 8);
16358       end = mips_pltgot + (2 + count) * addr_size;
16359
16360       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16361       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16362                                          1, _("Procedure Linkage Table data"));
16363       if (data == NULL)
16364         return FALSE;
16365
16366       printf ("\nPLT GOT:\n\n");
16367       printf (_(" Reserved entries:\n"));
16368       printf (_("  %*s %*s Purpose\n"),
16369               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16370       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16371       printf (_(" PLT lazy resolver\n"));
16372       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16373       printf (_(" Module pointer\n"));
16374       printf ("\n");
16375
16376       printf (_(" Entries:\n"));
16377       printf ("  %*s %*s %*s %-7s %3s %s\n",
16378               addr_size * 2, _("Address"),
16379               addr_size * 2, _("Initial"),
16380               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16381       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16382       for (i = 0; i < count; i++)
16383         {
16384           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16385
16386           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16387           printf (" ");
16388
16389           if (idx >= num_dynamic_syms)
16390             printf (_("<corrupt symbol index: %lu>"), idx);
16391           else
16392             {
16393               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16394
16395               print_vma (psym->st_value, LONG_HEX);
16396               printf (" %-7s %3s ",
16397                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16398                       get_symbol_index_type (filedata, psym->st_shndx));
16399               if (VALID_DYNAMIC_NAME (psym->st_name))
16400                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16401               else
16402                 printf (_("<corrupt: %14ld>"), psym->st_name);
16403             }
16404           printf ("\n");
16405         }
16406       printf ("\n");
16407
16408       if (data)
16409         free (data);
16410       free (rels);
16411     }
16412
16413   return res;
16414 }
16415
16416 static bfd_boolean
16417 process_nds32_specific (Filedata * filedata)
16418 {
16419   Elf_Internal_Shdr *sect = NULL;
16420
16421   sect = find_section (filedata, ".nds32_e_flags");
16422   if (sect != NULL)
16423     {
16424       unsigned int *flag;
16425
16426       printf ("\nNDS32 elf flags section:\n");
16427       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16428                        sect->sh_size, _("NDS32 elf flags section"));
16429
16430       if (! flag)
16431         return FALSE;
16432
16433       switch ((*flag) & 0x3)
16434         {
16435         case 0:
16436           printf ("(VEC_SIZE):\tNo entry.\n");
16437           break;
16438         case 1:
16439           printf ("(VEC_SIZE):\t4 bytes\n");
16440           break;
16441         case 2:
16442           printf ("(VEC_SIZE):\t16 bytes\n");
16443           break;
16444         case 3:
16445           printf ("(VEC_SIZE):\treserved\n");
16446           break;
16447         }
16448     }
16449
16450   return TRUE;
16451 }
16452
16453 static bfd_boolean
16454 process_gnu_liblist (Filedata * filedata)
16455 {
16456   Elf_Internal_Shdr * section;
16457   Elf_Internal_Shdr * string_sec;
16458   Elf32_External_Lib * elib;
16459   char * strtab;
16460   size_t strtab_size;
16461   size_t cnt;
16462   unsigned long num_liblist;
16463   unsigned i;
16464   bfd_boolean res = TRUE;
16465
16466   if (! do_arch)
16467     return TRUE;
16468
16469   for (i = 0, section = filedata->section_headers;
16470        i < filedata->file_header.e_shnum;
16471        i++, section++)
16472     {
16473       switch (section->sh_type)
16474         {
16475         case SHT_GNU_LIBLIST:
16476           if (section->sh_link >= filedata->file_header.e_shnum)
16477             break;
16478
16479           elib = (Elf32_External_Lib *)
16480               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16481                         _("liblist section data"));
16482
16483           if (elib == NULL)
16484             {
16485               res = FALSE;
16486               break;
16487             }
16488
16489           string_sec = filedata->section_headers + section->sh_link;
16490           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16491                                       string_sec->sh_size,
16492                                       _("liblist string table"));
16493           if (strtab == NULL
16494               || section->sh_entsize != sizeof (Elf32_External_Lib))
16495             {
16496               free (elib);
16497               free (strtab);
16498               res = FALSE;
16499               break;
16500             }
16501           strtab_size = string_sec->sh_size;
16502
16503           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16504           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16505                             "\nLibrary list section '%s' contains %lu entries:\n",
16506                             num_liblist),
16507                   printable_section_name (filedata, section),
16508                   num_liblist);
16509
16510           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16511
16512           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16513                ++cnt)
16514             {
16515               Elf32_Lib liblist;
16516               time_t atime;
16517               char timebuf[128];
16518               struct tm * tmp;
16519
16520               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16521               atime = BYTE_GET (elib[cnt].l_time_stamp);
16522               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16523               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16524               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16525
16526               tmp = gmtime (&atime);
16527               snprintf (timebuf, sizeof (timebuf),
16528                         "%04u-%02u-%02uT%02u:%02u:%02u",
16529                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16530                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16531
16532               printf ("%3lu: ", (unsigned long) cnt);
16533               if (do_wide)
16534                 printf ("%-20s", liblist.l_name < strtab_size
16535                         ? strtab + liblist.l_name : _("<corrupt>"));
16536               else
16537                 printf ("%-20.20s", liblist.l_name < strtab_size
16538                         ? strtab + liblist.l_name : _("<corrupt>"));
16539               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16540                       liblist.l_version, liblist.l_flags);
16541             }
16542
16543           free (elib);
16544           free (strtab);
16545         }
16546     }
16547
16548   return res;
16549 }
16550
16551 static const char *
16552 get_note_type (Filedata * filedata, unsigned e_type)
16553 {
16554   static char buff[64];
16555
16556   if (filedata->file_header.e_type == ET_CORE)
16557     switch (e_type)
16558       {
16559       case NT_AUXV:
16560         return _("NT_AUXV (auxiliary vector)");
16561       case NT_PRSTATUS:
16562         return _("NT_PRSTATUS (prstatus structure)");
16563       case NT_FPREGSET:
16564         return _("NT_FPREGSET (floating point registers)");
16565       case NT_PRPSINFO:
16566         return _("NT_PRPSINFO (prpsinfo structure)");
16567       case NT_TASKSTRUCT:
16568         return _("NT_TASKSTRUCT (task structure)");
16569       case NT_PRXFPREG:
16570         return _("NT_PRXFPREG (user_xfpregs structure)");
16571       case NT_PPC_VMX:
16572         return _("NT_PPC_VMX (ppc Altivec registers)");
16573       case NT_PPC_VSX:
16574         return _("NT_PPC_VSX (ppc VSX registers)");
16575       case NT_PPC_TAR:
16576         return _("NT_PPC_TAR (ppc TAR register)");
16577       case NT_PPC_PPR:
16578         return _("NT_PPC_PPR (ppc PPR register)");
16579       case NT_PPC_DSCR:
16580         return _("NT_PPC_DSCR (ppc DSCR register)");
16581       case NT_PPC_EBB:
16582         return _("NT_PPC_EBB (ppc EBB registers)");
16583       case NT_PPC_PMU:
16584         return _("NT_PPC_PMU (ppc PMU registers)");
16585       case NT_PPC_TM_CGPR:
16586         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16587       case NT_PPC_TM_CFPR:
16588         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16589       case NT_PPC_TM_CVMX:
16590         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16591       case NT_PPC_TM_CVSX:
16592         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16593       case NT_PPC_TM_SPR:
16594         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16595       case NT_PPC_TM_CTAR:
16596         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16597       case NT_PPC_TM_CPPR:
16598         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16599       case NT_PPC_TM_CDSCR:
16600         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16601       case NT_386_TLS:
16602         return _("NT_386_TLS (x86 TLS information)");
16603       case NT_386_IOPERM:
16604         return _("NT_386_IOPERM (x86 I/O permissions)");
16605       case NT_X86_XSTATE:
16606         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16607       case NT_S390_HIGH_GPRS:
16608         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16609       case NT_S390_TIMER:
16610         return _("NT_S390_TIMER (s390 timer register)");
16611       case NT_S390_TODCMP:
16612         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16613       case NT_S390_TODPREG:
16614         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16615       case NT_S390_CTRS:
16616         return _("NT_S390_CTRS (s390 control registers)");
16617       case NT_S390_PREFIX:
16618         return _("NT_S390_PREFIX (s390 prefix register)");
16619       case NT_S390_LAST_BREAK:
16620         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16621       case NT_S390_SYSTEM_CALL:
16622         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16623       case NT_S390_TDB:
16624         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16625       case NT_S390_VXRS_LOW:
16626         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16627       case NT_S390_VXRS_HIGH:
16628         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16629       case NT_S390_GS_CB:
16630         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16631       case NT_S390_GS_BC:
16632         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16633       case NT_ARM_VFP:
16634         return _("NT_ARM_VFP (arm VFP registers)");
16635       case NT_ARM_TLS:
16636         return _("NT_ARM_TLS (AArch TLS registers)");
16637       case NT_ARM_HW_BREAK:
16638         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16639       case NT_ARM_HW_WATCH:
16640         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16641       case NT_PSTATUS:
16642         return _("NT_PSTATUS (pstatus structure)");
16643       case NT_FPREGS:
16644         return _("NT_FPREGS (floating point registers)");
16645       case NT_PSINFO:
16646         return _("NT_PSINFO (psinfo structure)");
16647       case NT_LWPSTATUS:
16648         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16649       case NT_LWPSINFO:
16650         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16651       case NT_WIN32PSTATUS:
16652         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16653       case NT_SIGINFO:
16654         return _("NT_SIGINFO (siginfo_t data)");
16655       case NT_FILE:
16656         return _("NT_FILE (mapped files)");
16657       default:
16658         break;
16659       }
16660   else
16661     switch (e_type)
16662       {
16663       case NT_VERSION:
16664         return _("NT_VERSION (version)");
16665       case NT_ARCH:
16666         return _("NT_ARCH (architecture)");
16667       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16668         return _("OPEN");
16669       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16670         return _("func");
16671       default:
16672         break;
16673       }
16674
16675   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16676   return buff;
16677 }
16678
16679 static bfd_boolean
16680 print_core_note (Elf_Internal_Note *pnote)
16681 {
16682   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16683   bfd_vma count, page_size;
16684   unsigned char *descdata, *filenames, *descend;
16685
16686   if (pnote->type != NT_FILE)
16687     {
16688       if (do_wide)
16689         printf ("\n");
16690       return TRUE;
16691     }
16692
16693 #ifndef BFD64
16694   if (!is_32bit_elf)
16695     {
16696       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16697       /* Still "successful".  */
16698       return TRUE;
16699     }
16700 #endif
16701
16702   if (pnote->descsz < 2 * addr_size)
16703     {
16704       error (_("    Malformed note - too short for header\n"));
16705       return FALSE;
16706     }
16707
16708   descdata = (unsigned char *) pnote->descdata;
16709   descend = descdata + pnote->descsz;
16710
16711   if (descdata[pnote->descsz - 1] != '\0')
16712     {
16713       error (_("    Malformed note - does not end with \\0\n"));
16714       return FALSE;
16715     }
16716
16717   count = byte_get (descdata, addr_size);
16718   descdata += addr_size;
16719
16720   page_size = byte_get (descdata, addr_size);
16721   descdata += addr_size;
16722
16723   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16724       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16725     {
16726       error (_("    Malformed note - too short for supplied file count\n"));
16727       return FALSE;
16728     }
16729
16730   printf (_("    Page size: "));
16731   print_vma (page_size, DEC);
16732   printf ("\n");
16733
16734   printf (_("    %*s%*s%*s\n"),
16735           (int) (2 + 2 * addr_size), _("Start"),
16736           (int) (4 + 2 * addr_size), _("End"),
16737           (int) (4 + 2 * addr_size), _("Page Offset"));
16738   filenames = descdata + count * 3 * addr_size;
16739   while (count-- > 0)
16740     {
16741       bfd_vma start, end, file_ofs;
16742
16743       if (filenames == descend)
16744         {
16745           error (_("    Malformed note - filenames end too early\n"));
16746           return FALSE;
16747         }
16748
16749       start = byte_get (descdata, addr_size);
16750       descdata += addr_size;
16751       end = byte_get (descdata, addr_size);
16752       descdata += addr_size;
16753       file_ofs = byte_get (descdata, addr_size);
16754       descdata += addr_size;
16755
16756       printf ("    ");
16757       print_vma (start, FULL_HEX);
16758       printf ("  ");
16759       print_vma (end, FULL_HEX);
16760       printf ("  ");
16761       print_vma (file_ofs, FULL_HEX);
16762       printf ("\n        %s\n", filenames);
16763
16764       filenames += 1 + strlen ((char *) filenames);
16765     }
16766
16767   return TRUE;
16768 }
16769
16770 static const char *
16771 get_gnu_elf_note_type (unsigned e_type)
16772 {
16773   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16774   switch (e_type)
16775     {
16776     case NT_GNU_ABI_TAG:
16777       return _("NT_GNU_ABI_TAG (ABI version tag)");
16778     case NT_GNU_HWCAP:
16779       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16780     case NT_GNU_BUILD_ID:
16781       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16782     case NT_GNU_GOLD_VERSION:
16783       return _("NT_GNU_GOLD_VERSION (gold version)");
16784     case NT_GNU_PROPERTY_TYPE_0:
16785       return _("NT_GNU_PROPERTY_TYPE_0");
16786     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16787       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16788     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16789       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16790     default:
16791       {
16792         static char buff[64];
16793
16794         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16795         return buff;
16796       }
16797     }
16798 }
16799
16800 static void
16801 decode_x86_isa (unsigned int bitmask)
16802 {
16803   while (bitmask)
16804     {
16805       unsigned int bit = bitmask & (- bitmask);
16806
16807       bitmask &= ~ bit;
16808       switch (bit)
16809         {
16810         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16811         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16812         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16813         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16814         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16815         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16816         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16817         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16818         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16819         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16820         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16821         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16822         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16823         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16824         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16825         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16826         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16827         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16828         default: printf (_("<unknown: %x>"), bit); break;
16829         }
16830       if (bitmask)
16831         printf (", ");
16832     }
16833 }
16834
16835 static void
16836 decode_x86_feature (unsigned int type, unsigned int bitmask)
16837 {
16838   while (bitmask)
16839     {
16840       unsigned int bit = bitmask & (- bitmask);
16841
16842       bitmask &= ~ bit;
16843       switch (bit)
16844         {
16845         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16846           switch (type)
16847             {
16848             case GNU_PROPERTY_X86_FEATURE_1_AND:
16849               printf ("IBT");
16850               break;
16851             default:
16852               /* This should never happen.  */
16853               abort ();
16854             }
16855           break;
16856         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16857           switch (type)
16858             {
16859             case GNU_PROPERTY_X86_FEATURE_1_AND:
16860               printf ("SHSTK");
16861               break;
16862             default:
16863               /* This should never happen.  */
16864               abort ();
16865             }
16866           break;
16867         default:
16868           printf (_("<unknown: %x>"), bit);
16869           break;
16870         }
16871       if (bitmask)
16872         printf (", ");
16873     }
16874 }
16875
16876 static void
16877 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
16878 {
16879   unsigned char * ptr = (unsigned char *) pnote->descdata;
16880   unsigned char * ptr_end = ptr + pnote->descsz;
16881   unsigned int    size = is_32bit_elf ? 4 : 8;
16882
16883   printf (_("      Properties: "));
16884
16885   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16886     {
16887       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16888       return;
16889     }
16890
16891   while (ptr < ptr_end)
16892     {
16893       unsigned int j;
16894       unsigned int type;
16895       unsigned int datasz;
16896
16897       if ((size_t) (ptr_end - ptr) < 8)
16898         {
16899           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16900           break;
16901         }
16902
16903       type = byte_get (ptr, 4);
16904       datasz = byte_get (ptr + 4, 4);
16905
16906       ptr += 8;
16907
16908       if (datasz > (size_t) (ptr_end - ptr))
16909         {
16910           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16911                   type, datasz);
16912           break;
16913         }
16914
16915       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16916         {
16917           if (filedata->file_header.e_machine == EM_X86_64
16918               || filedata->file_header.e_machine == EM_IAMCU
16919               || filedata->file_header.e_machine == EM_386)
16920             {
16921               switch (type)
16922                 {
16923                 case GNU_PROPERTY_X86_ISA_1_USED:
16924                   printf ("x86 ISA used: ");
16925                   if (datasz != 4)
16926                     printf (_("<corrupt length: %#x> "), datasz);
16927                   else
16928                     decode_x86_isa (byte_get (ptr, 4));
16929                   goto next;
16930
16931                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16932                   printf ("x86 ISA needed: ");
16933                   if (datasz != 4)
16934                     printf (_("<corrupt length: %#x> "), datasz);
16935                   else
16936                     decode_x86_isa (byte_get (ptr, 4));
16937                   goto next;
16938
16939                 case GNU_PROPERTY_X86_FEATURE_1_AND:
16940                   printf ("x86 feature: ");
16941                   if (datasz != 4)
16942                     printf (_("<corrupt length: %#x> "), datasz);
16943                   else
16944                     decode_x86_feature (type, byte_get (ptr, 4));
16945                   goto next;
16946
16947                 default:
16948                   break;
16949                 }
16950             }
16951         }
16952       else
16953         {
16954           switch (type)
16955             {
16956             case GNU_PROPERTY_STACK_SIZE:
16957               printf (_("stack size: "));
16958               if (datasz != size)
16959                 printf (_("<corrupt length: %#x> "), datasz);
16960               else
16961                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16962               goto next;
16963
16964             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16965               printf ("no copy on protected ");
16966               if (datasz)
16967                 printf (_("<corrupt length: %#x> "), datasz);
16968               goto next;
16969
16970             default:
16971               break;
16972             }
16973         }
16974
16975       if (type < GNU_PROPERTY_LOPROC)
16976         printf (_("<unknown type %#x data: "), type);
16977       else if (type < GNU_PROPERTY_LOUSER)
16978         printf (_("<procesor-specific type %#x data: "), type);
16979       else
16980         printf (_("<application-specific type %#x data: "), type);
16981       for (j = 0; j < datasz; ++j)
16982         printf ("%02x ", ptr[j] & 0xff);
16983       printf (">");
16984
16985 next:
16986       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16987       if (ptr == ptr_end)
16988         break;
16989
16990       if (do_wide)
16991         printf (", ");
16992       else
16993         printf ("\n\t");
16994     }
16995
16996   printf ("\n");
16997 }
16998
16999 static bfd_boolean
17000 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17001 {
17002   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17003   switch (pnote->type)
17004     {
17005     case NT_GNU_BUILD_ID:
17006       {
17007         unsigned long i;
17008
17009         printf (_("    Build ID: "));
17010         for (i = 0; i < pnote->descsz; ++i)
17011           printf ("%02x", pnote->descdata[i] & 0xff);
17012         printf ("\n");
17013       }
17014       break;
17015
17016     case NT_GNU_ABI_TAG:
17017       {
17018         unsigned long os, major, minor, subminor;
17019         const char *osname;
17020
17021         /* PR 17531: file: 030-599401-0.004.  */
17022         if (pnote->descsz < 16)
17023           {
17024             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17025             break;
17026           }
17027
17028         os = byte_get ((unsigned char *) pnote->descdata, 4);
17029         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17030         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17031         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17032
17033         switch (os)
17034           {
17035           case GNU_ABI_TAG_LINUX:
17036             osname = "Linux";
17037             break;
17038           case GNU_ABI_TAG_HURD:
17039             osname = "Hurd";
17040             break;
17041           case GNU_ABI_TAG_SOLARIS:
17042             osname = "Solaris";
17043             break;
17044           case GNU_ABI_TAG_FREEBSD:
17045             osname = "FreeBSD";
17046             break;
17047           case GNU_ABI_TAG_NETBSD:
17048             osname = "NetBSD";
17049             break;
17050           case GNU_ABI_TAG_SYLLABLE:
17051             osname = "Syllable";
17052             break;
17053           case GNU_ABI_TAG_NACL:
17054             osname = "NaCl";
17055             break;
17056           default:
17057             osname = "Unknown";
17058             break;
17059           }
17060
17061         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17062                 major, minor, subminor);
17063       }
17064       break;
17065
17066     case NT_GNU_GOLD_VERSION:
17067       {
17068         unsigned long i;
17069
17070         printf (_("    Version: "));
17071         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17072           printf ("%c", pnote->descdata[i]);
17073         printf ("\n");
17074       }
17075       break;
17076
17077     case NT_GNU_HWCAP:
17078       {
17079         unsigned long num_entries, mask;
17080
17081         /* Hardware capabilities information.  Word 0 is the number of entries.
17082            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17083            is a series of entries, where each entry is a single byte followed
17084            by a nul terminated string.  The byte gives the bit number to test
17085            if enabled in the bitmask.  */
17086         printf (_("      Hardware Capabilities: "));
17087         if (pnote->descsz < 8)
17088           {
17089             error (_("<corrupt GNU_HWCAP>\n"));
17090             return FALSE;
17091           }
17092         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17093         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17094         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17095         /* FIXME: Add code to display the entries... */
17096       }
17097       break;
17098
17099     case NT_GNU_PROPERTY_TYPE_0:
17100       print_gnu_property_note (filedata, pnote);
17101       break;
17102
17103     default:
17104       /* Handle unrecognised types.  An error message should have already been
17105          created by get_gnu_elf_note_type(), so all that we need to do is to
17106          display the data.  */
17107       {
17108         unsigned long i;
17109
17110         printf (_("    Description data: "));
17111         for (i = 0; i < pnote->descsz; ++i)
17112           printf ("%02x ", pnote->descdata[i] & 0xff);
17113         printf ("\n");
17114       }
17115       break;
17116     }
17117
17118   return TRUE;
17119 }
17120
17121 static const char *
17122 get_v850_elf_note_type (enum v850_notes n_type)
17123 {
17124   static char buff[64];
17125
17126   switch (n_type)
17127     {
17128     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17129     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17130     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17131     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17132     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17133     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17134     default:
17135       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17136       return buff;
17137     }
17138 }
17139
17140 static bfd_boolean
17141 print_v850_note (Elf_Internal_Note * pnote)
17142 {
17143   unsigned int val;
17144
17145   if (pnote->descsz != 4)
17146     return FALSE;
17147
17148   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17149
17150   if (val == 0)
17151     {
17152       printf (_("not set\n"));
17153       return TRUE;
17154     }
17155
17156   switch (pnote->type)
17157     {
17158     case V850_NOTE_ALIGNMENT:
17159       switch (val)
17160         {
17161         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17162         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17163         }
17164       break;
17165
17166     case V850_NOTE_DATA_SIZE:
17167       switch (val)
17168         {
17169         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17170         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17171         }
17172       break;
17173
17174     case V850_NOTE_FPU_INFO:
17175       switch (val)
17176         {
17177         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17178         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17179         }
17180       break;
17181
17182     case V850_NOTE_MMU_INFO:
17183     case V850_NOTE_CACHE_INFO:
17184     case V850_NOTE_SIMD_INFO:
17185       if (val == EF_RH850_SIMD)
17186         {
17187           printf (_("yes\n"));
17188           return TRUE;
17189         }
17190       break;
17191
17192     default:
17193       /* An 'unknown note type' message will already have been displayed.  */
17194       break;
17195     }
17196
17197   printf (_("unknown value: %x\n"), val);
17198   return FALSE;
17199 }
17200
17201 static bfd_boolean
17202 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17203 {
17204   unsigned int version;
17205
17206   switch (pnote->type)
17207     {
17208     case NT_NETBSD_IDENT:
17209       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17210       if ((version / 10000) % 100)
17211         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17212                 version, version / 100000000, (version / 1000000) % 100,
17213                 (version / 10000) % 100 > 26 ? "Z" : "",
17214                 'A' + (version / 10000) % 26);
17215       else
17216         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17217                 version, version / 100000000, (version / 1000000) % 100,
17218                 (version / 100) % 100);
17219       return TRUE;
17220
17221     case NT_NETBSD_MARCH:
17222       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17223               pnote->descdata);
17224       return TRUE;
17225
17226     default:
17227       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17228               pnote->type);
17229       return FALSE;
17230     }
17231 }
17232
17233 static const char *
17234 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17235 {
17236   switch (e_type)
17237     {
17238     case NT_FREEBSD_THRMISC:
17239       return _("NT_THRMISC (thrmisc structure)");
17240     case NT_FREEBSD_PROCSTAT_PROC:
17241       return _("NT_PROCSTAT_PROC (proc data)");
17242     case NT_FREEBSD_PROCSTAT_FILES:
17243       return _("NT_PROCSTAT_FILES (files data)");
17244     case NT_FREEBSD_PROCSTAT_VMMAP:
17245       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17246     case NT_FREEBSD_PROCSTAT_GROUPS:
17247       return _("NT_PROCSTAT_GROUPS (groups data)");
17248     case NT_FREEBSD_PROCSTAT_UMASK:
17249       return _("NT_PROCSTAT_UMASK (umask data)");
17250     case NT_FREEBSD_PROCSTAT_RLIMIT:
17251       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17252     case NT_FREEBSD_PROCSTAT_OSREL:
17253       return _("NT_PROCSTAT_OSREL (osreldate data)");
17254     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17255       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17256     case NT_FREEBSD_PROCSTAT_AUXV:
17257       return _("NT_PROCSTAT_AUXV (auxv data)");
17258     case NT_FREEBSD_PTLWPINFO:
17259       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17260     }
17261   return get_note_type (filedata, e_type);
17262 }
17263
17264 static const char *
17265 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17266 {
17267   static char buff[64];
17268
17269   if (e_type == NT_NETBSDCORE_PROCINFO)
17270     return _("NetBSD procinfo structure");
17271
17272   /* As of Jan 2002 there are no other machine-independent notes
17273      defined for NetBSD core files.  If the note type is less
17274      than the start of the machine-dependent note types, we don't
17275      understand it.  */
17276
17277   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17278     {
17279       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17280       return buff;
17281     }
17282
17283   switch (filedata->file_header.e_machine)
17284     {
17285     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17286        and PT_GETFPREGS == mach+2.  */
17287
17288     case EM_OLD_ALPHA:
17289     case EM_ALPHA:
17290     case EM_SPARC:
17291     case EM_SPARC32PLUS:
17292     case EM_SPARCV9:
17293       switch (e_type)
17294         {
17295         case NT_NETBSDCORE_FIRSTMACH + 0:
17296           return _("PT_GETREGS (reg structure)");
17297         case NT_NETBSDCORE_FIRSTMACH + 2:
17298           return _("PT_GETFPREGS (fpreg structure)");
17299         default:
17300           break;
17301         }
17302       break;
17303
17304     /* On all other arch's, PT_GETREGS == mach+1 and
17305        PT_GETFPREGS == mach+3.  */
17306     default:
17307       switch (e_type)
17308         {
17309         case NT_NETBSDCORE_FIRSTMACH + 1:
17310           return _("PT_GETREGS (reg structure)");
17311         case NT_NETBSDCORE_FIRSTMACH + 3:
17312           return _("PT_GETFPREGS (fpreg structure)");
17313         default:
17314           break;
17315         }
17316     }
17317
17318   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17319             e_type - NT_NETBSDCORE_FIRSTMACH);
17320   return buff;
17321 }
17322
17323 static const char *
17324 get_stapsdt_note_type (unsigned e_type)
17325 {
17326   static char buff[64];
17327
17328   switch (e_type)
17329     {
17330     case NT_STAPSDT:
17331       return _("NT_STAPSDT (SystemTap probe descriptors)");
17332
17333     default:
17334       break;
17335     }
17336
17337   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17338   return buff;
17339 }
17340
17341 static bfd_boolean
17342 print_stapsdt_note (Elf_Internal_Note *pnote)
17343 {
17344   int addr_size = is_32bit_elf ? 4 : 8;
17345   char *data = pnote->descdata;
17346   char *data_end = pnote->descdata + pnote->descsz;
17347   bfd_vma pc, base_addr, semaphore;
17348   char *provider, *probe, *arg_fmt;
17349
17350   pc = byte_get ((unsigned char *) data, addr_size);
17351   data += addr_size;
17352   base_addr = byte_get ((unsigned char *) data, addr_size);
17353   data += addr_size;
17354   semaphore = byte_get ((unsigned char *) data, addr_size);
17355   data += addr_size;
17356
17357   provider = data;
17358   data += strlen (data) + 1;
17359   probe = data;
17360   data += strlen (data) + 1;
17361   arg_fmt = data;
17362   data += strlen (data) + 1;
17363
17364   printf (_("    Provider: %s\n"), provider);
17365   printf (_("    Name: %s\n"), probe);
17366   printf (_("    Location: "));
17367   print_vma (pc, FULL_HEX);
17368   printf (_(", Base: "));
17369   print_vma (base_addr, FULL_HEX);
17370   printf (_(", Semaphore: "));
17371   print_vma (semaphore, FULL_HEX);
17372   printf ("\n");
17373   printf (_("    Arguments: %s\n"), arg_fmt);
17374
17375   return data == data_end;
17376 }
17377
17378 static const char *
17379 get_ia64_vms_note_type (unsigned e_type)
17380 {
17381   static char buff[64];
17382
17383   switch (e_type)
17384     {
17385     case NT_VMS_MHD:
17386       return _("NT_VMS_MHD (module header)");
17387     case NT_VMS_LNM:
17388       return _("NT_VMS_LNM (language name)");
17389     case NT_VMS_SRC:
17390       return _("NT_VMS_SRC (source files)");
17391     case NT_VMS_TITLE:
17392       return "NT_VMS_TITLE";
17393     case NT_VMS_EIDC:
17394       return _("NT_VMS_EIDC (consistency check)");
17395     case NT_VMS_FPMODE:
17396       return _("NT_VMS_FPMODE (FP mode)");
17397     case NT_VMS_LINKTIME:
17398       return "NT_VMS_LINKTIME";
17399     case NT_VMS_IMGNAM:
17400       return _("NT_VMS_IMGNAM (image name)");
17401     case NT_VMS_IMGID:
17402       return _("NT_VMS_IMGID (image id)");
17403     case NT_VMS_LINKID:
17404       return _("NT_VMS_LINKID (link id)");
17405     case NT_VMS_IMGBID:
17406       return _("NT_VMS_IMGBID (build id)");
17407     case NT_VMS_GSTNAM:
17408       return _("NT_VMS_GSTNAM (sym table name)");
17409     case NT_VMS_ORIG_DYN:
17410       return "NT_VMS_ORIG_DYN";
17411     case NT_VMS_PATCHTIME:
17412       return "NT_VMS_PATCHTIME";
17413     default:
17414       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17415       return buff;
17416     }
17417 }
17418
17419 static bfd_boolean
17420 print_ia64_vms_note (Elf_Internal_Note * pnote)
17421 {
17422   switch (pnote->type)
17423     {
17424     case NT_VMS_MHD:
17425       if (pnote->descsz > 36)
17426         {
17427           size_t l = strlen (pnote->descdata + 34);
17428           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17429           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17430           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17431           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17432         }
17433       else
17434         printf (_("    Invalid size\n"));
17435       break;
17436     case NT_VMS_LNM:
17437       printf (_("   Language: %s\n"), pnote->descdata);
17438       break;
17439 #ifdef BFD64
17440     case NT_VMS_FPMODE:
17441       printf (_("   Floating Point mode: "));
17442       printf ("0x%016" BFD_VMA_FMT "x\n",
17443               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17444       break;
17445     case NT_VMS_LINKTIME:
17446       printf (_("   Link time: "));
17447       print_vms_time
17448         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17449       printf ("\n");
17450       break;
17451     case NT_VMS_PATCHTIME:
17452       printf (_("   Patch time: "));
17453       print_vms_time
17454         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17455       printf ("\n");
17456       break;
17457     case NT_VMS_ORIG_DYN:
17458       printf (_("   Major id: %u,  minor id: %u\n"),
17459               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17460               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17461       printf (_("   Last modified  : "));
17462       print_vms_time
17463         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17464       printf (_("\n   Link flags  : "));
17465       printf ("0x%016" BFD_VMA_FMT "x\n",
17466               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17467       printf (_("   Header flags: 0x%08x\n"),
17468               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17469       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17470       break;
17471 #endif
17472     case NT_VMS_IMGNAM:
17473       printf (_("    Image name: %s\n"), pnote->descdata);
17474       break;
17475     case NT_VMS_GSTNAM:
17476       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17477       break;
17478     case NT_VMS_IMGID:
17479       printf (_("    Image id: %s\n"), pnote->descdata);
17480       break;
17481     case NT_VMS_LINKID:
17482       printf (_("    Linker id: %s\n"), pnote->descdata);
17483       break;
17484     default:
17485       return FALSE;
17486     }
17487   return TRUE;
17488 }
17489
17490 /* Find the symbol associated with a build attribute that is attached
17491    to address OFFSET.  If PNAME is non-NULL then store the name of
17492    the symbol (if found) in the provided pointer,  Returns NULL if a
17493    symbol could not be found.  */
17494
17495 static Elf_Internal_Sym *
17496 get_symbol_for_build_attribute (Filedata *       filedata,
17497                                 unsigned long    offset,
17498                                 bfd_boolean      is_open_attr,
17499                                 const char **    pname)
17500 {
17501   static Filedata *         saved_filedata = NULL;
17502   static char *             strtab;
17503   static unsigned long      strtablen;
17504   static Elf_Internal_Sym * symtab;
17505   static unsigned long      nsyms;
17506   Elf_Internal_Sym *        saved_sym = NULL;
17507   Elf_Internal_Sym *        sym;
17508
17509   if (filedata->section_headers != NULL
17510       && (saved_filedata == NULL || filedata != saved_filedata))
17511     {
17512       Elf_Internal_Shdr * symsec;
17513
17514       /* Load the symbol and string sections.  */
17515       for (symsec = filedata->section_headers;
17516            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17517            symsec ++)
17518         {
17519           if (symsec->sh_type == SHT_SYMTAB)
17520             {
17521               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17522
17523               if (symsec->sh_link < filedata->file_header.e_shnum)
17524                 {
17525                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17526
17527                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17528                                               1, strtab_sec->sh_size,
17529                                               _("string table"));
17530                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17531                 }
17532             }
17533         }
17534       saved_filedata = filedata;
17535     }
17536
17537   if (symtab == NULL || strtab == NULL)
17538     return NULL;
17539
17540   /* Find a symbol whose value matches offset.  */
17541   for (sym = symtab; sym < symtab + nsyms; sym ++)
17542     if (sym->st_value == offset)
17543       {
17544         if (sym->st_name >= strtablen)
17545           /* Huh ?  This should not happen.  */
17546           continue;
17547
17548         if (strtab[sym->st_name] == 0)
17549           continue;
17550
17551         /* The AArch64 and ARM architectures define mapping symbols
17552            (eg $d, $x, $t) which we want to ignore.  */
17553         if (strtab[sym->st_name] == '$'
17554             && strtab[sym->st_name + 1] != 0
17555             && strtab[sym->st_name + 2] == 0)
17556           continue;
17557
17558         if (is_open_attr)
17559           {
17560             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17561                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17562                FUNC symbols entirely.  */
17563             switch (ELF_ST_TYPE (sym->st_info))
17564               {
17565               case STT_OBJECT:
17566               case STT_FILE:
17567                 saved_sym = sym;
17568                 if (sym->st_size)
17569                   {
17570                     /* If the symbol has a size associated
17571                        with it then we can stop searching.  */
17572                     sym = symtab + nsyms;
17573                   }
17574                 continue;
17575
17576               case STT_FUNC:
17577                 /* Ignore function symbols.  */
17578                 continue;
17579
17580               default:
17581                 break;
17582               }
17583
17584             switch (ELF_ST_BIND (sym->st_info))
17585               {
17586               case STB_GLOBAL:
17587                 if (saved_sym == NULL
17588                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17589                   saved_sym = sym;
17590                 break;
17591
17592               case STB_LOCAL:
17593                 if (saved_sym == NULL)
17594                   saved_sym = sym;
17595                 break;
17596
17597               default:
17598                 break;
17599               }
17600           }
17601         else
17602           {
17603             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17604               continue;
17605
17606             saved_sym = sym;
17607             break;
17608           }
17609       }
17610
17611   if (saved_sym && pname)
17612     * pname = strtab + saved_sym->st_name;
17613
17614   return saved_sym;
17615 }
17616
17617 static bfd_boolean
17618 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
17619                                        Filedata *           filedata)
17620 {
17621   static unsigned long  global_offset = 0;
17622   static unsigned long  global_end = 0;
17623   static unsigned long  func_offset = 0;
17624   static unsigned long  func_end = 0;
17625
17626   Elf_Internal_Sym *    sym;
17627   const char *          name;
17628   unsigned long         start;
17629   unsigned long         end;
17630   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17631
17632   switch (pnote->descsz)
17633     {
17634     case 0:
17635       /* A zero-length description means that the range of
17636          the previous note of the same type should be used.  */
17637       if (is_open_attr)
17638         {
17639           if (global_end > global_offset)
17640             printf (_("    Applies to region from %#lx to %#lx\n"),
17641                     global_offset, global_end);
17642           else
17643             printf (_("    Applies to region from %#lx\n"), global_offset);
17644         }
17645       else
17646         {
17647           if (func_end > func_offset)
17648             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
17649           else
17650             printf (_("    Applies to region from %#lx\n"), func_offset);
17651         }
17652       return TRUE;
17653
17654     case 4:
17655       start = byte_get ((unsigned char *) pnote->descdata, 4);
17656       end = 0;
17657       break;
17658
17659     case 8:
17660       if (is_32bit_elf)
17661         {
17662           /* FIXME: We should check that version 3+ notes are being used here...  */
17663           start = byte_get ((unsigned char *) pnote->descdata, 4);
17664           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17665         }
17666       else
17667         {
17668           start = byte_get ((unsigned char *) pnote->descdata, 8);
17669           end = 0;
17670         }
17671       break;
17672
17673     case 16:
17674       start = byte_get ((unsigned char *) pnote->descdata, 8);
17675       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
17676       break;
17677
17678     default:
17679       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17680       printf (_("    <invalid descsz>"));
17681       return FALSE;
17682     }
17683
17684   name = NULL;
17685   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
17686   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17687      in order to avoid them being confused with the start address of the
17688      first function in the file...  */
17689   if (sym == NULL && is_open_attr)
17690     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
17691                                           & name);
17692
17693   if (end == 0 && sym != NULL && sym->st_size > 0)
17694     end = start + sym->st_size;
17695
17696   if (is_open_attr)
17697     {
17698       /* FIXME: Need to properly allow for section alignment.  16 is just the alignment used on x86_64.  */
17699       if (global_end > 0 && start > BFD_ALIGN (global_end, 16))
17700         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17701               global_end + 1, start - 1);
17702
17703       printf (_("    Applies to region from %#lx"), start);
17704       global_offset = start;
17705
17706       if (end)
17707         {
17708           printf (_(" to %#lx"), end);
17709           global_end = end;
17710         }
17711     }
17712   else
17713     {
17714       printf (_("    Applies to region from %#lx"), start);
17715       func_offset = start;
17716
17717       if (end)
17718         {
17719           printf (_(" to %#lx"), end);
17720           func_end = end;
17721         }
17722     }
17723
17724   if (sym && name)
17725     printf (_(" (%s)"), name);
17726
17727   printf ("\n");
17728   return TRUE;
17729 }
17730
17731 static bfd_boolean
17732 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17733 {
17734   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17735   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17736   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17737   char         name_type;
17738   char         name_attribute;
17739   const char * expected_types;
17740   const char * name = pnote->namedata;
17741   const char * text;
17742   signed int   left;
17743
17744   if (name == NULL || pnote->namesz < 2)
17745     {
17746       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17747       print_symbol (-20, _("  <corrupt name>"));
17748       return FALSE;
17749     }
17750
17751   if (do_wide)
17752     left = 28;
17753   else
17754     left = 20;
17755
17756   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17757   if (name[0] == 'G' && name[1] == 'A')
17758     {
17759       if (pnote->namesz < 4)
17760         {
17761           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17762           print_symbol (-20, _("  <corrupt name>"));
17763           return FALSE;
17764         }
17765
17766       printf ("GA");
17767       name += 2;
17768       left -= 2;
17769     }
17770
17771   switch ((name_type = * name))
17772     {
17773     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17774     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17775     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17776     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17777       printf ("%c", * name);
17778       left --;
17779       break;
17780     default:
17781       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17782       print_symbol (-20, _("<unknown name type>"));
17783       return FALSE;
17784     }
17785
17786   ++ name;
17787   text = NULL;
17788
17789   switch ((name_attribute = * name))
17790     {
17791     case GNU_BUILD_ATTRIBUTE_VERSION:
17792       text = _("<version>");
17793       expected_types = string_expected;
17794       ++ name;
17795       break;
17796     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17797       text = _("<stack prot>");
17798       expected_types = "!+*";
17799       ++ name;
17800       break;
17801     case GNU_BUILD_ATTRIBUTE_RELRO:
17802       text = _("<relro>");
17803       expected_types = bool_expected;
17804       ++ name;
17805       break;
17806     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17807       text = _("<stack size>");
17808       expected_types = number_expected;
17809       ++ name;
17810       break;
17811     case GNU_BUILD_ATTRIBUTE_TOOL:
17812       text = _("<tool>");
17813       expected_types = string_expected;
17814       ++ name;
17815       break;
17816     case GNU_BUILD_ATTRIBUTE_ABI:
17817       text = _("<ABI>");
17818       expected_types = "$*";
17819       ++ name;
17820       break;
17821     case GNU_BUILD_ATTRIBUTE_PIC:
17822       text = _("<PIC>");
17823       expected_types = number_expected;
17824       ++ name;
17825       break;
17826     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17827       text = _("<short enum>");
17828       expected_types = bool_expected;
17829       ++ name;
17830       break;
17831     default:
17832       if (ISPRINT (* name))
17833         {
17834           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17835
17836           if (len > left && ! do_wide)
17837             len = left;
17838           printf ("%.*s:", len, name);
17839           left -= len;
17840           name += len;
17841         }
17842       else
17843         {
17844           static char tmpbuf [128];
17845
17846           error (_("unrecognised byte in name field: %d\n"), * name);
17847           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17848           text = tmpbuf;
17849           name ++;
17850         }
17851       expected_types = "*$!+";
17852       break;
17853     }
17854
17855   if (text)
17856     left -= printf ("%s", text);
17857
17858   if (strchr (expected_types, name_type) == NULL)
17859     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17860
17861   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17862     {
17863       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17864              (unsigned long) pnote->namesz,
17865              (long) (name - pnote->namedata));
17866       return FALSE;
17867     }
17868
17869   if (left < 1 && ! do_wide)
17870     return TRUE;
17871
17872   switch (name_type)
17873     {
17874     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17875       {
17876         unsigned int        bytes;
17877         unsigned long long  val = 0;
17878         unsigned int        shift = 0;
17879         char *              decoded = NULL;
17880
17881         bytes = pnote->namesz - (name - pnote->namedata);
17882         if (bytes > 0)
17883           /* The -1 is because the name field is always 0 terminated, and we
17884              want to be able to ensure that the shift in the while loop below
17885              will not overflow.  */
17886           -- bytes;
17887
17888         if (bytes > sizeof (val))
17889           {
17890             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17891                    bytes);
17892             bytes = sizeof (val);
17893           }
17894         /* We do not bother to warn if bytes == 0 as this can
17895            happen with some early versions of the gcc plugin.  */
17896
17897         while (bytes --)
17898           {
17899             unsigned long byte = (* name ++) & 0xff;
17900
17901             val |= byte << shift;
17902             shift += 8;
17903           }
17904
17905         switch (name_attribute)
17906           {
17907           case GNU_BUILD_ATTRIBUTE_PIC:
17908             switch (val)
17909               {
17910               case 0: decoded = "static"; break;
17911               case 1: decoded = "pic"; break;
17912               case 2: decoded = "PIC"; break;
17913               case 3: decoded = "pie"; break;
17914               case 4: decoded = "PIE"; break;
17915               default: break;
17916               }
17917             break;
17918           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17919             switch (val)
17920               {
17921                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17922               case 0: decoded = "off"; break;
17923               case 1: decoded = "on"; break;
17924               case 2: decoded = "all"; break;
17925               case 3: decoded = "strong"; break;
17926               case 4: decoded = "explicit"; break;
17927               default: break;
17928               }
17929             break;
17930           default:
17931             break;
17932           }
17933
17934         if (decoded != NULL)
17935           {
17936             print_symbol (-left, decoded);
17937             left = 0;
17938           }
17939         else if (val == 0)
17940           {
17941             printf ("0x0");
17942             left -= 3;
17943           }
17944         else
17945           {
17946             if (do_wide)
17947               left -= printf ("0x%llx", val);
17948             else
17949               left -= printf ("0x%-.*llx", left, val);
17950           }
17951       }
17952       break;
17953     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17954       left -= print_symbol (- left, name);
17955       break;
17956     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17957       left -= print_symbol (- left, "true");
17958       break;
17959     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17960       left -= print_symbol (- left, "false");
17961       break;
17962     }
17963
17964   if (do_wide && left > 0)
17965     printf ("%-*s", left, " ");
17966
17967   return TRUE;
17968 }
17969
17970 /* Note that by the ELF standard, the name field is already null byte
17971    terminated, and namesz includes the terminating null byte.
17972    I.E. the value of namesz for the name "FSF" is 4.
17973
17974    If the value of namesz is zero, there is no name present.  */
17975
17976 static bfd_boolean
17977 process_note (Elf_Internal_Note *  pnote,
17978               Filedata *           filedata)
17979 {
17980   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17981   const char * nt;
17982
17983   if (pnote->namesz == 0)
17984     /* If there is no note name, then use the default set of
17985        note type strings.  */
17986     nt = get_note_type (filedata, pnote->type);
17987
17988   else if (const_strneq (pnote->namedata, "GNU"))
17989     /* GNU-specific object file notes.  */
17990     nt = get_gnu_elf_note_type (pnote->type);
17991
17992   else if (const_strneq (pnote->namedata, "FreeBSD"))
17993     /* FreeBSD-specific core file notes.  */
17994     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
17995
17996   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17997     /* NetBSD-specific core file notes.  */
17998     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
17999
18000   else if (const_strneq (pnote->namedata, "NetBSD"))
18001     /* NetBSD-specific core file notes.  */
18002     return process_netbsd_elf_note (pnote);
18003
18004   else if (strneq (pnote->namedata, "SPU/", 4))
18005     {
18006       /* SPU-specific core file notes.  */
18007       nt = pnote->namedata + 4;
18008       name = "SPU";
18009     }
18010
18011   else if (const_strneq (pnote->namedata, "IPF/VMS"))
18012     /* VMS/ia64-specific file notes.  */
18013     nt = get_ia64_vms_note_type (pnote->type);
18014
18015   else if (const_strneq (pnote->namedata, "stapsdt"))
18016     nt = get_stapsdt_note_type (pnote->type);
18017
18018   else
18019     /* Don't recognize this note name; just use the default set of
18020        note type strings.  */
18021     nt = get_note_type (filedata, pnote->type);
18022
18023   printf ("  ");
18024
18025   if (((const_strneq (pnote->namedata, "GA")
18026         && strchr ("*$!+", pnote->namedata[2]) != NULL)
18027        || strchr ("*$!+", pnote->namedata[0]) != NULL)
18028       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18029           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18030     print_gnu_build_attribute_name (pnote);
18031   else
18032     print_symbol (-20, name);
18033
18034   if (do_wide)
18035     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18036   else
18037     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18038
18039   if (const_strneq (pnote->namedata, "IPF/VMS"))
18040     return print_ia64_vms_note (pnote);
18041   else if (const_strneq (pnote->namedata, "GNU"))
18042     return print_gnu_note (filedata, pnote);
18043   else if (const_strneq (pnote->namedata, "stapsdt"))
18044     return print_stapsdt_note (pnote);
18045   else if (const_strneq (pnote->namedata, "CORE"))
18046     return print_core_note (pnote);
18047   else if (((const_strneq (pnote->namedata, "GA")
18048              && strchr ("*$!+", pnote->namedata[2]) != NULL)
18049             || strchr ("*$!+", pnote->namedata[0]) != NULL)
18050            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18051                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18052     return print_gnu_build_attribute_description (pnote, filedata);
18053
18054   if (pnote->descsz)
18055     {
18056       unsigned long i;
18057
18058       printf (_("   description data: "));
18059       for (i = 0; i < pnote->descsz; i++)
18060         printf ("%02x ", pnote->descdata[i]);
18061       if (!do_wide)
18062         printf ("\n");
18063     }
18064
18065   if (do_wide)
18066     printf ("\n");
18067
18068   return TRUE;
18069 }
18070
18071 static bfd_boolean
18072 process_notes_at (Filedata *           filedata,
18073                   Elf_Internal_Shdr *  section,
18074                   bfd_vma              offset,
18075                   bfd_vma              length,
18076                   bfd_vma              align)
18077 {
18078   Elf_External_Note * pnotes;
18079   Elf_External_Note * external;
18080   char *              end;
18081   bfd_boolean         res = TRUE;
18082
18083   if (length <= 0)
18084     return FALSE;
18085
18086   if (section)
18087     {
18088       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18089       if (pnotes)
18090         {
18091           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18092             return FALSE;
18093         }
18094     }
18095   else
18096     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18097                                              _("notes"));
18098
18099   if (pnotes == NULL)
18100     return FALSE;
18101
18102   external = pnotes;
18103
18104   if (section)
18105     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18106   else
18107     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18108             (unsigned long) offset, (unsigned long) length);
18109
18110   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18111      specifies that notes should be aligned to 4 bytes in 32-bit
18112      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18113      we also support 4 byte alignment in 64-bit objects.  If section
18114      alignment is less than 4, we treate alignment as 4 bytes.   */
18115   if (align < 4)
18116     align = 4;
18117   else if (align != 4 && align != 8)
18118     {
18119       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18120             (long) align);
18121       return FALSE;
18122     }
18123
18124   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18125
18126   end = (char *) pnotes + length;
18127   while ((char *) external < end)
18128     {
18129       Elf_Internal_Note inote;
18130       size_t min_notesz;
18131       char * next;
18132       char * temp = NULL;
18133       size_t data_remaining = end - (char *) external;
18134
18135       if (!is_ia64_vms (filedata))
18136         {
18137           /* PR binutils/15191
18138              Make sure that there is enough data to read.  */
18139           min_notesz = offsetof (Elf_External_Note, name);
18140           if (data_remaining < min_notesz)
18141             {
18142               warn (ngettext ("Corrupt note: only %ld byte remains, "
18143                               "not enough for a full note\n",
18144                               "Corrupt note: only %ld bytes remain, "
18145                               "not enough for a full note\n",
18146                               data_remaining),
18147                     (long) data_remaining);
18148               break;
18149             }
18150           data_remaining -= min_notesz;
18151
18152           inote.type     = BYTE_GET (external->type);
18153           inote.namesz   = BYTE_GET (external->namesz);
18154           inote.namedata = external->name;
18155           inote.descsz   = BYTE_GET (external->descsz);
18156           inote.descdata = ((char *) external
18157                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18158           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18159           next = ((char *) external
18160                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18161         }
18162       else
18163         {
18164           Elf64_External_VMS_Note *vms_external;
18165
18166           /* PR binutils/15191
18167              Make sure that there is enough data to read.  */
18168           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18169           if (data_remaining < min_notesz)
18170             {
18171               warn (ngettext ("Corrupt note: only %ld byte remains, "
18172                               "not enough for a full note\n",
18173                               "Corrupt note: only %ld bytes remain, "
18174                               "not enough for a full note\n",
18175                               data_remaining),
18176                     (long) data_remaining);
18177               break;
18178             }
18179           data_remaining -= min_notesz;
18180
18181           vms_external = (Elf64_External_VMS_Note *) external;
18182           inote.type     = BYTE_GET (vms_external->type);
18183           inote.namesz   = BYTE_GET (vms_external->namesz);
18184           inote.namedata = vms_external->name;
18185           inote.descsz   = BYTE_GET (vms_external->descsz);
18186           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18187           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18188           next = inote.descdata + align_power (inote.descsz, 3);
18189         }
18190
18191       /* PR 17531: file: 3443835e.  */
18192       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18193       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18194           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18195           || (size_t) (next - inote.descdata) < inote.descsz
18196           || ((size_t) (next - inote.descdata)
18197               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18198         {
18199           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18200                 (unsigned long) ((char *) external - (char *) pnotes));
18201           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18202                 inote.type, inote.namesz, inote.descsz, (int) align);
18203           break;
18204         }
18205
18206       external = (Elf_External_Note *) next;
18207
18208       /* Verify that name is null terminated.  It appears that at least
18209          one version of Linux (RedHat 6.0) generates corefiles that don't
18210          comply with the ELF spec by failing to include the null byte in
18211          namesz.  */
18212       if (inote.namedata[inote.namesz - 1] != '\0')
18213         {
18214           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18215             {
18216               temp = (char *) malloc (inote.namesz + 1);
18217               if (temp == NULL)
18218                 {
18219                   error (_("Out of memory allocating space for inote name\n"));
18220                   res = FALSE;
18221                   break;
18222                 }
18223
18224               memcpy (temp, inote.namedata, inote.namesz);
18225               inote.namedata = temp;
18226             }
18227           inote.namedata[inote.namesz] = 0;
18228         }
18229
18230       if (! process_note (& inote, filedata))
18231         res = FALSE;
18232
18233       if (temp != NULL)
18234         {
18235           free (temp);
18236           temp = NULL;
18237         }
18238     }
18239
18240   free (pnotes);
18241
18242   return res;
18243 }
18244
18245 static bfd_boolean
18246 process_corefile_note_segments (Filedata * filedata)
18247 {
18248   Elf_Internal_Phdr * segment;
18249   unsigned int i;
18250   bfd_boolean res = TRUE;
18251
18252   if (! get_program_headers (filedata))
18253     return TRUE;
18254
18255   for (i = 0, segment = filedata->program_headers;
18256        i < filedata->file_header.e_phnum;
18257        i++, segment++)
18258     {
18259       if (segment->p_type == PT_NOTE)
18260         if (! process_notes_at (filedata, NULL,
18261                                 (bfd_vma) segment->p_offset,
18262                                 (bfd_vma) segment->p_filesz,
18263                                 (bfd_vma) segment->p_align))
18264           res = FALSE;
18265     }
18266
18267   return res;
18268 }
18269
18270 static bfd_boolean
18271 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18272 {
18273   Elf_External_Note * pnotes;
18274   Elf_External_Note * external;
18275   char * end;
18276   bfd_boolean res = TRUE;
18277
18278   if (length <= 0)
18279     return FALSE;
18280
18281   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18282                                            _("v850 notes"));
18283   if (pnotes == NULL)
18284     return FALSE;
18285
18286   external = pnotes;
18287   end = (char*) pnotes + length;
18288
18289   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18290           (unsigned long) offset, (unsigned long) length);
18291
18292   while ((char *) external + sizeof (Elf_External_Note) < end)
18293     {
18294       Elf_External_Note * next;
18295       Elf_Internal_Note inote;
18296
18297       inote.type     = BYTE_GET (external->type);
18298       inote.namesz   = BYTE_GET (external->namesz);
18299       inote.namedata = external->name;
18300       inote.descsz   = BYTE_GET (external->descsz);
18301       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18302       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18303
18304       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18305         {
18306           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18307           inote.descdata = inote.namedata;
18308           inote.namesz   = 0;
18309         }
18310
18311       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18312
18313       if (   ((char *) next > end)
18314           || ((char *) next <  (char *) pnotes))
18315         {
18316           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18317                 (unsigned long) ((char *) external - (char *) pnotes));
18318           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18319                 inote.type, inote.namesz, inote.descsz);
18320           break;
18321         }
18322
18323       external = next;
18324
18325       /* Prevent out-of-bounds indexing.  */
18326       if (   inote.namedata + inote.namesz > end
18327           || inote.namedata + inote.namesz < inote.namedata)
18328         {
18329           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18330                 (unsigned long) ((char *) external - (char *) pnotes));
18331           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18332                 inote.type, inote.namesz, inote.descsz);
18333           break;
18334         }
18335
18336       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18337
18338       if (! print_v850_note (& inote))
18339         {
18340           res = FALSE;
18341           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18342                   inote.namesz, inote.descsz);
18343         }
18344     }
18345
18346   free (pnotes);
18347
18348   return res;
18349 }
18350
18351 static bfd_boolean
18352 process_note_sections (Filedata * filedata)
18353 {
18354   Elf_Internal_Shdr * section;
18355   unsigned long i;
18356   unsigned int n = 0;
18357   bfd_boolean res = TRUE;
18358
18359   for (i = 0, section = filedata->section_headers;
18360        i < filedata->file_header.e_shnum && section != NULL;
18361        i++, section++)
18362     {
18363       if (section->sh_type == SHT_NOTE)
18364         {
18365           if (! process_notes_at (filedata, section,
18366                                   (bfd_vma) section->sh_offset,
18367                                   (bfd_vma) section->sh_size,
18368                                   (bfd_vma) section->sh_addralign))
18369             res = FALSE;
18370           n++;
18371         }
18372
18373       if ((   filedata->file_header.e_machine == EM_V800
18374            || filedata->file_header.e_machine == EM_V850
18375            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18376           && section->sh_type == SHT_RENESAS_INFO)
18377         {
18378           if (! process_v850_notes (filedata,
18379                                     (bfd_vma) section->sh_offset,
18380                                     (bfd_vma) section->sh_size))
18381             res = FALSE;
18382           n++;
18383         }
18384     }
18385
18386   if (n == 0)
18387     /* Try processing NOTE segments instead.  */
18388     return process_corefile_note_segments (filedata);
18389
18390   return res;
18391 }
18392
18393 static bfd_boolean
18394 process_notes (Filedata * filedata)
18395 {
18396   /* If we have not been asked to display the notes then do nothing.  */
18397   if (! do_notes)
18398     return TRUE;
18399
18400   if (filedata->file_header.e_type != ET_CORE)
18401     return process_note_sections (filedata);
18402
18403   /* No program headers means no NOTE segment.  */
18404   if (filedata->file_header.e_phnum > 0)
18405     return process_corefile_note_segments (filedata);
18406
18407   printf (_("No note segments present in the core file.\n"));
18408   return TRUE;
18409 }
18410
18411 static unsigned char *
18412 display_public_gnu_attributes (unsigned char * start,
18413                                const unsigned char * const end)
18414 {
18415   printf (_("  Unknown GNU attribute: %s\n"), start);
18416
18417   start += strnlen ((char *) start, end - start);
18418   display_raw_attribute (start, end);
18419
18420   return (unsigned char *) end;
18421 }
18422
18423 static unsigned char *
18424 display_generic_attribute (unsigned char * start,
18425                            unsigned int tag,
18426                            const unsigned char * const end)
18427 {
18428   if (tag == 0)
18429     return (unsigned char *) end;
18430
18431   return display_tag_value (tag, start, end);
18432 }
18433
18434 static bfd_boolean
18435 process_arch_specific (Filedata * filedata)
18436 {
18437   if (! do_arch)
18438     return TRUE;
18439
18440   switch (filedata->file_header.e_machine)
18441     {
18442     case EM_ARC:
18443     case EM_ARC_COMPACT:
18444     case EM_ARC_COMPACT2:
18445       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18446                                  display_arc_attribute,
18447                                  display_generic_attribute);
18448     case EM_ARM:
18449       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18450                                  display_arm_attribute,
18451                                  display_generic_attribute);
18452
18453     case EM_MIPS:
18454     case EM_MIPS_RS3_LE:
18455       return process_mips_specific (filedata);
18456
18457     case EM_MSP430:
18458      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18459                                 display_msp430x_attribute,
18460                                 display_generic_attribute);
18461
18462     case EM_NDS32:
18463       return process_nds32_specific (filedata);
18464
18465     case EM_PPC:
18466     case EM_PPC64:
18467       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18468                                  display_power_gnu_attribute);
18469
18470     case EM_S390:
18471     case EM_S390_OLD:
18472       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18473                                  display_s390_gnu_attribute);
18474
18475     case EM_SPARC:
18476     case EM_SPARC32PLUS:
18477     case EM_SPARCV9:
18478       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18479                                  display_sparc_gnu_attribute);
18480
18481     case EM_TI_C6000:
18482       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18483                                  display_tic6x_attribute,
18484                                  display_generic_attribute);
18485
18486     default:
18487       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18488                                  display_public_gnu_attributes,
18489                                  display_generic_attribute);
18490     }
18491 }
18492
18493 static bfd_boolean
18494 get_file_header (Filedata * filedata)
18495 {
18496   /* Read in the identity array.  */
18497   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18498     return FALSE;
18499
18500   /* Determine how to read the rest of the header.  */
18501   switch (filedata->file_header.e_ident[EI_DATA])
18502     {
18503     default:
18504     case ELFDATANONE:
18505     case ELFDATA2LSB:
18506       byte_get = byte_get_little_endian;
18507       byte_put = byte_put_little_endian;
18508       break;
18509     case ELFDATA2MSB:
18510       byte_get = byte_get_big_endian;
18511       byte_put = byte_put_big_endian;
18512       break;
18513     }
18514
18515   /* For now we only support 32 bit and 64 bit ELF files.  */
18516   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18517
18518   /* Read in the rest of the header.  */
18519   if (is_32bit_elf)
18520     {
18521       Elf32_External_Ehdr ehdr32;
18522
18523       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18524         return FALSE;
18525
18526       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18527       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18528       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18529       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18530       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18531       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18532       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18533       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18534       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18535       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18536       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18537       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18538       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18539     }
18540   else
18541     {
18542       Elf64_External_Ehdr ehdr64;
18543
18544       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18545          we will not be able to cope with the 64bit data found in
18546          64 ELF files.  Detect this now and abort before we start
18547          overwriting things.  */
18548       if (sizeof (bfd_vma) < 8)
18549         {
18550           error (_("This instance of readelf has been built without support for a\n\
18551 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18552           return FALSE;
18553         }
18554
18555       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18556         return FALSE;
18557
18558       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18559       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18560       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18561       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18562       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18563       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18564       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18565       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18566       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18567       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18568       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18569       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18570       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18571     }
18572
18573   if (filedata->file_header.e_shoff)
18574     {
18575       /* There may be some extensions in the first section header.  Don't
18576          bomb if we can't read it.  */
18577       if (is_32bit_elf)
18578         get_32bit_section_headers (filedata, TRUE);
18579       else
18580         get_64bit_section_headers (filedata, TRUE);
18581     }
18582
18583   return TRUE;
18584 }
18585
18586 static void
18587 close_file (Filedata * filedata)
18588 {
18589   if (filedata)
18590     {
18591       if (filedata->handle)
18592         fclose (filedata->handle);
18593       free (filedata);
18594     }
18595 }
18596
18597 void
18598 close_debug_file (void * data)
18599 {
18600   close_file ((Filedata *) data);
18601 }
18602
18603 static Filedata *
18604 open_file (const char * pathname)
18605 {
18606   struct stat  statbuf;
18607   Filedata *   filedata = NULL;
18608
18609   if (stat (pathname, & statbuf) < 0
18610       || ! S_ISREG (statbuf.st_mode))
18611     goto fail;
18612
18613   filedata = calloc (1, sizeof * filedata);
18614   if (filedata == NULL)
18615     goto fail;
18616
18617   filedata->handle = fopen (pathname, "rb");
18618   if (filedata->handle == NULL)
18619     goto fail;
18620
18621   filedata->file_size = (bfd_size_type) statbuf.st_size;
18622   filedata->file_name = pathname;
18623
18624   if (! get_file_header (filedata))
18625     goto fail;
18626
18627   if (filedata->file_header.e_shoff)
18628     {
18629       bfd_boolean res;
18630
18631       /* Read the section headers again, this time for real.  */
18632       if (is_32bit_elf)
18633         res = get_32bit_section_headers (filedata, FALSE);
18634       else
18635         res = get_64bit_section_headers (filedata, FALSE);
18636
18637       if (!res)
18638         goto fail;
18639     }
18640
18641   return filedata;
18642
18643  fail:
18644   if (filedata)
18645     {
18646       if (filedata->handle)
18647         fclose (filedata->handle);
18648       free (filedata);
18649     }
18650   return NULL;
18651 }
18652
18653 void *
18654 open_debug_file (const char * pathname)
18655 {
18656   return open_file (pathname);
18657 }
18658
18659 /* Process one ELF object file according to the command line options.
18660    This file may actually be stored in an archive.  The file is
18661    positioned at the start of the ELF object.  Returns TRUE if no
18662    problems were encountered, FALSE otherwise.  */
18663
18664 static bfd_boolean
18665 process_object (Filedata * filedata)
18666 {
18667   Filedata * separates;
18668   unsigned int i;
18669   bfd_boolean res = TRUE;
18670
18671   if (! get_file_header (filedata))
18672     {
18673       error (_("%s: Failed to read file header\n"), filedata->file_name);
18674       return FALSE;
18675     }
18676
18677   /* Initialise per file variables.  */
18678   for (i = ARRAY_SIZE (version_info); i--;)
18679     version_info[i] = 0;
18680
18681   for (i = ARRAY_SIZE (dynamic_info); i--;)
18682     dynamic_info[i] = 0;
18683   dynamic_info_DT_GNU_HASH = 0;
18684
18685   /* Process the file.  */
18686   if (show_name)
18687     printf (_("\nFile: %s\n"), filedata->file_name);
18688
18689   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18690      Note we do this even if cmdline_dump_sects is empty because we
18691      must make sure that the dump_sets array is zeroed out before each
18692      object file is processed.  */
18693   if (filedata->num_dump_sects > cmdline.num_dump_sects)
18694     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
18695
18696   if (cmdline.num_dump_sects > 0)
18697     {
18698       if (filedata->num_dump_sects == 0)
18699         /* A sneaky way of allocating the dump_sects array.  */
18700         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
18701
18702       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
18703       memcpy (filedata->dump_sects, cmdline.dump_sects,
18704               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
18705     }
18706
18707   if (! process_file_header (filedata))
18708     return FALSE;
18709
18710   if (! process_section_headers (filedata))
18711     {
18712       /* Without loaded section headers we cannot process lots of things.  */
18713       do_unwind = do_version = do_dump = do_arch = FALSE;
18714
18715       if (! do_using_dynamic)
18716         do_syms = do_dyn_syms = do_reloc = FALSE;
18717     }
18718
18719   if (! process_section_groups (filedata))
18720     /* Without loaded section groups we cannot process unwind.  */
18721     do_unwind = FALSE;
18722
18723   if (process_program_headers (filedata))
18724     process_dynamic_section (filedata);
18725   else
18726     res = FALSE;
18727
18728   if (! process_relocs (filedata))
18729     res = FALSE;
18730
18731   if (! process_unwind (filedata))
18732     res = FALSE;
18733
18734   if (! process_symbol_table (filedata))
18735     res = FALSE;
18736
18737   if (! process_syminfo (filedata))
18738     res = FALSE;
18739
18740   if (! process_version_sections (filedata))
18741     res = FALSE;
18742
18743   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
18744     separates = load_separate_debug_file (filedata, filedata->file_name);
18745   else
18746     separates = NULL;
18747
18748   if (! process_section_contents (filedata))
18749     res = FALSE;
18750
18751   if (separates)
18752     {
18753       if (! process_section_headers (separates))
18754         res = FALSE;
18755       else if (! process_section_contents (separates))
18756         res = FALSE;
18757     }
18758
18759   if (! process_notes (filedata))
18760     res = FALSE;
18761
18762   if (! process_gnu_liblist (filedata))
18763     res = FALSE;
18764
18765   if (! process_arch_specific (filedata))
18766     res = FALSE;
18767
18768   free (filedata->program_headers);
18769   filedata->program_headers = NULL;
18770
18771   free (filedata->section_headers);
18772   filedata->section_headers = NULL;
18773
18774   free (filedata->string_table);
18775   filedata->string_table = NULL;
18776   filedata->string_table_length = 0;
18777
18778   if (dynamic_strings)
18779     {
18780       free (dynamic_strings);
18781       dynamic_strings = NULL;
18782       dynamic_strings_length = 0;
18783     }
18784
18785   if (dynamic_symbols)
18786     {
18787       free (dynamic_symbols);
18788       dynamic_symbols = NULL;
18789       num_dynamic_syms = 0;
18790     }
18791
18792   if (dynamic_syminfo)
18793     {
18794       free (dynamic_syminfo);
18795       dynamic_syminfo = NULL;
18796     }
18797
18798   if (dynamic_section)
18799     {
18800       free (dynamic_section);
18801       dynamic_section = NULL;
18802     }
18803
18804   if (section_headers_groups)
18805     {
18806       free (section_headers_groups);
18807       section_headers_groups = NULL;
18808     }
18809
18810   if (section_groups)
18811     {
18812       struct group_list * g;
18813       struct group_list * next;
18814
18815       for (i = 0; i < group_count; i++)
18816         {
18817           for (g = section_groups [i].root; g != NULL; g = next)
18818             {
18819               next = g->next;
18820               free (g);
18821             }
18822         }
18823
18824       free (section_groups);
18825       section_groups = NULL;
18826     }
18827
18828   free_debug_memory ();
18829
18830   return res;
18831 }
18832
18833 /* Process an ELF archive.
18834    On entry the file is positioned just after the ARMAG string.
18835    Returns TRUE upon success, FALSE otherwise.  */
18836
18837 static bfd_boolean
18838 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
18839 {
18840   struct archive_info arch;
18841   struct archive_info nested_arch;
18842   size_t got;
18843   bfd_boolean ret = TRUE;
18844
18845   show_name = TRUE;
18846
18847   /* The ARCH structure is used to hold information about this archive.  */
18848   arch.file_name = NULL;
18849   arch.file = NULL;
18850   arch.index_array = NULL;
18851   arch.sym_table = NULL;
18852   arch.longnames = NULL;
18853
18854   /* The NESTED_ARCH structure is used as a single-item cache of information
18855      about a nested archive (when members of a thin archive reside within
18856      another regular archive file).  */
18857   nested_arch.file_name = NULL;
18858   nested_arch.file = NULL;
18859   nested_arch.index_array = NULL;
18860   nested_arch.sym_table = NULL;
18861   nested_arch.longnames = NULL;
18862
18863   if (setup_archive (&arch, filedata->file_name, filedata->handle,
18864                      is_thin_archive, do_archive_index) != 0)
18865     {
18866       ret = FALSE;
18867       goto out;
18868     }
18869
18870   if (do_archive_index)
18871     {
18872       if (arch.sym_table == NULL)
18873         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
18874       else
18875         {
18876           unsigned long i, l;
18877           unsigned long current_pos;
18878
18879           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18880                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
18881
18882           current_pos = ftell (filedata->handle);
18883
18884           for (i = l = 0; i < arch.index_num; i++)
18885             {
18886               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18887                 {
18888                   char * member_name;
18889
18890                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18891
18892                   if (member_name != NULL)
18893                     {
18894                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18895
18896                       if (qualified_name != NULL)
18897                         {
18898                           printf (_("Contents of binary %s at offset "), qualified_name);
18899                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18900                           putchar ('\n');
18901                           free (qualified_name);
18902                         }
18903                     }
18904                 }
18905
18906               if (l >= arch.sym_size)
18907                 {
18908                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18909                          filedata->file_name);
18910                   ret = FALSE;
18911                   break;
18912                 }
18913               /* PR 17531: file: 0b6630b2.  */
18914               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18915               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18916             }
18917
18918           if (arch.uses_64bit_indicies)
18919             l = (l + 7) & ~ 7;
18920           else
18921             l += l & 1;
18922
18923           if (l < arch.sym_size)
18924             {
18925               error (ngettext ("%s: %ld byte remains in the symbol table, "
18926                                "but without corresponding entries in "
18927                                "the index table\n",
18928                                "%s: %ld bytes remain in the symbol table, "
18929                                "but without corresponding entries in "
18930                                "the index table\n",
18931                                arch.sym_size - l),
18932                      filedata->file_name, arch.sym_size - l);
18933               ret = FALSE;
18934             }
18935
18936           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
18937             {
18938               error (_("%s: failed to seek back to start of object files in the archive\n"),
18939                      filedata->file_name);
18940               ret = FALSE;
18941               goto out;
18942             }
18943         }
18944
18945       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18946           && !do_segments && !do_header && !do_dump && !do_version
18947           && !do_histogram && !do_debugging && !do_arch && !do_notes
18948           && !do_section_groups && !do_dyn_syms)
18949         {
18950           ret = TRUE; /* Archive index only.  */
18951           goto out;
18952         }
18953     }
18954
18955   while (1)
18956     {
18957       char * name;
18958       size_t namelen;
18959       char * qualified_name;
18960
18961       /* Read the next archive header.  */
18962       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
18963         {
18964           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
18965           return FALSE;
18966         }
18967       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
18968       if (got != sizeof arch.arhdr)
18969         {
18970           if (got == 0)
18971             break;
18972           error (_("%s: failed to read archive header\n"), filedata->file_name);
18973           ret = FALSE;
18974           break;
18975         }
18976       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18977         {
18978           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18979           ret = FALSE;
18980           break;
18981         }
18982
18983       arch.next_arhdr_offset += sizeof arch.arhdr;
18984
18985       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18986       if (archive_file_size & 01)
18987         ++archive_file_size;
18988
18989       name = get_archive_member_name (&arch, &nested_arch);
18990       if (name == NULL)
18991         {
18992           error (_("%s: bad archive file name\n"), filedata->file_name);
18993           ret = FALSE;
18994           break;
18995         }
18996       namelen = strlen (name);
18997
18998       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18999       if (qualified_name == NULL)
19000         {
19001           error (_("%s: bad archive file name\n"), filedata->file_name);
19002           ret = FALSE;
19003           break;
19004         }
19005
19006       if (is_thin_archive && arch.nested_member_origin == 0)
19007         {
19008           /* This is a proxy for an external member of a thin archive.  */
19009           Filedata * member_filedata;
19010           char * member_file_name = adjust_relative_path
19011             (filedata->file_name, name, namelen);
19012
19013           if (member_file_name == NULL)
19014             {
19015               ret = FALSE;
19016               break;
19017             }
19018
19019           member_filedata = open_file (member_file_name);
19020           if (member_filedata == NULL)
19021             {
19022               error (_("Input file '%s' is not readable.\n"), member_file_name);
19023               free (member_file_name);
19024               ret = FALSE;
19025               break;
19026             }
19027
19028           archive_file_offset = arch.nested_member_origin;
19029           member_filedata->file_name = qualified_name;
19030
19031           if (! process_object (member_filedata))
19032             ret = FALSE;
19033
19034           close_file (member_filedata);
19035           free (member_file_name);
19036         }
19037       else if (is_thin_archive)
19038         {
19039           Filedata thin_filedata;
19040
19041           memset (&thin_filedata, 0, sizeof (thin_filedata));
19042
19043           /* PR 15140: Allow for corrupt thin archives.  */
19044           if (nested_arch.file == NULL)
19045             {
19046               error (_("%s: contains corrupt thin archive: %s\n"),
19047                      filedata->file_name, name);
19048               ret = FALSE;
19049               break;
19050             }
19051
19052           /* This is a proxy for a member of a nested archive.  */
19053           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19054
19055           /* The nested archive file will have been opened and setup by
19056              get_archive_member_name.  */
19057           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19058             {
19059               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19060               ret = FALSE;
19061               break;
19062             }
19063
19064           thin_filedata.handle = nested_arch.file;
19065           thin_filedata.file_name = qualified_name;
19066
19067           if (! process_object (& thin_filedata))
19068             ret = FALSE;
19069         }
19070       else
19071         {
19072           archive_file_offset = arch.next_arhdr_offset;
19073           arch.next_arhdr_offset += archive_file_size;
19074
19075           filedata->file_name = qualified_name;
19076           if (! process_object (filedata))
19077             ret = FALSE;
19078         }
19079
19080       if (filedata->dump_sects != NULL)
19081         {
19082           free (filedata->dump_sects);
19083           filedata->dump_sects = NULL;
19084           filedata->num_dump_sects = 0;
19085         }
19086
19087       free (qualified_name);
19088     }
19089
19090  out:
19091   if (nested_arch.file != NULL)
19092     fclose (nested_arch.file);
19093   release_archive (&nested_arch);
19094   release_archive (&arch);
19095
19096   return ret;
19097 }
19098
19099 static bfd_boolean
19100 process_file (char * file_name)
19101 {
19102   Filedata * filedata = NULL;
19103   struct stat statbuf;
19104   char armag[SARMAG];
19105   bfd_boolean ret = TRUE;
19106
19107   if (stat (file_name, &statbuf) < 0)
19108     {
19109       if (errno == ENOENT)
19110         error (_("'%s': No such file\n"), file_name);
19111       else
19112         error (_("Could not locate '%s'.  System error message: %s\n"),
19113                file_name, strerror (errno));
19114       return FALSE;
19115     }
19116
19117   if (! S_ISREG (statbuf.st_mode))
19118     {
19119       error (_("'%s' is not an ordinary file\n"), file_name);
19120       return FALSE;
19121     }
19122
19123   filedata = calloc (1, sizeof * filedata);
19124   if (filedata == NULL)
19125     {
19126       error (_("Out of memory allocating file data structure\n"));
19127       return FALSE;
19128     }
19129
19130   filedata->file_name = file_name;
19131   filedata->handle = fopen (file_name, "rb");
19132   if (filedata->handle == NULL)
19133     {
19134       error (_("Input file '%s' is not readable.\n"), file_name);
19135       free (filedata);
19136       return FALSE;
19137     }
19138
19139   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19140     {
19141       error (_("%s: Failed to read file's magic number\n"), file_name);
19142       fclose (filedata->handle);
19143       free (filedata);
19144       return FALSE;
19145     }
19146
19147   filedata->file_size = (bfd_size_type) statbuf.st_size;
19148
19149   if (memcmp (armag, ARMAG, SARMAG) == 0)
19150     {
19151       if (! process_archive (filedata, FALSE))
19152         ret = FALSE;
19153     }
19154   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19155     {
19156       if ( ! process_archive (filedata, TRUE))
19157         ret = FALSE;
19158     }
19159   else
19160     {
19161       if (do_archive_index)
19162         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19163                file_name);
19164
19165       rewind (filedata->handle);
19166       archive_file_size = archive_file_offset = 0;
19167
19168       if (! process_object (filedata))
19169         ret = FALSE;
19170     }
19171
19172   fclose (filedata->handle);
19173   free (filedata);
19174
19175   return ret;
19176 }
19177
19178 #ifdef SUPPORT_DISASSEMBLY
19179 /* Needed by the i386 disassembler.  For extra credit, someone could
19180    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19181    symbols.  */
19182
19183 void
19184 print_address (unsigned int addr, FILE * outfile)
19185 {
19186   fprintf (outfile,"0x%8.8x", addr);
19187 }
19188
19189 /* Needed by the i386 disassembler.  */
19190
19191 void
19192 db_task_printsym (unsigned int addr)
19193 {
19194   print_address (addr, stderr);
19195 }
19196 #endif
19197
19198 int
19199 main (int argc, char ** argv)
19200 {
19201   int err;
19202
19203 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19204   setlocale (LC_MESSAGES, "");
19205 #endif
19206 #if defined (HAVE_SETLOCALE)
19207   setlocale (LC_CTYPE, "");
19208 #endif
19209   bindtextdomain (PACKAGE, LOCALEDIR);
19210   textdomain (PACKAGE);
19211
19212   expandargv (&argc, &argv);
19213
19214   cmdline.file_name = "<cmdline>";
19215   parse_args (& cmdline, argc, argv);
19216
19217   if (optind < (argc - 1))
19218     show_name = TRUE;
19219   else if (optind >= argc)
19220     {
19221       warn (_("Nothing to do.\n"));
19222       usage (stderr);
19223     }
19224
19225   err = FALSE;
19226   while (optind < argc)
19227     if (! process_file (argv[optind++]))
19228       err = TRUE;
19229
19230   if (cmdline.dump_sects != NULL)
19231     free (cmdline.dump_sects);
19232
19233   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19234 }