binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2019 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #include <zlib.h>
  47 #ifdef HAVE_WCHAR_H
  48 #include <wchar.h>
  49 #endif
  50
  51 #if __GNUC__ >= 2
  52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  53    as this will allow us to read in and parse 64bit and 32bit ELF files.
  54    Only do this if we believe that the compiler can support a 64 bit
  55    data type.  For now we only rely on GCC being able to do this.  */
  56 #define BFD64
  57 #endif
  58
  59 #include "bfd.h"
  60 #include "bucomm.h"
  61 #include "elfcomm.h"
  62 #include "dwarf.h"
  63
  64 #include "elf/common.h"
  65 #include "elf/external.h"
  66 #include "elf/internal.h"
  67
  68
  69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  70    we can obtain the H8 reloc numbers.  We need these for the
  71    get_reloc_size() function.  We include h8.h again after defining
  72    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  73
  74 #include "elf/h8.h"
  75 #undef _ELF_H8_H
  76
  77 /* Undo the effects of #including reloc-macros.h.  */
  78
  79 #undef START_RELOC_NUMBERS
  80 #undef RELOC_NUMBER
  81 #undef FAKE_RELOC
  82 #undef EMPTY_RELOC
  83 #undef END_RELOC_NUMBERS
  84 #undef _RELOC_MACROS_H
  85
  86 /* The following headers use the elf/reloc-macros.h file to
  87    automatically generate relocation recognition functions
  88    such as elf_mips_reloc_type()  */
  89
  90 #define RELOC_MACROS_GEN_FUNC
  91
  92 #include "elf/aarch64.h"
  93 #include "elf/alpha.h"
  94 #include "elf/arc.h"
  95 #include "elf/arm.h"
  96 #include "elf/avr.h"
  97 #include "elf/bfin.h"
  98 #include "elf/cr16.h"
  99 #include "elf/cris.h"
 100 #include "elf/crx.h"
 101 #include "elf/csky.h"
 102 #include "elf/d10v.h"
 103 #include "elf/d30v.h"
 104 #include "elf/dlx.h"
 105 #include "elf/epiphany.h"
 106 #include "elf/fr30.h"
 107 #include "elf/frv.h"
 108 #include "elf/ft32.h"
 109 #include "elf/h8.h"
 110 #include "elf/hppa.h"
 111 #include "elf/i386.h"
 112 #include "elf/i370.h"
 113 #include "elf/i860.h"
 114 #include "elf/i960.h"
 115 #include "elf/ia64.h"
 116 #include "elf/ip2k.h"
 117 #include "elf/lm32.h"
 118 #include "elf/iq2000.h"
 119 #include "elf/m32c.h"
 120 #include "elf/m32r.h"
 121 #include "elf/m68k.h"
 122 #include "elf/m68hc11.h"
 123 #include "elf/s12z.h"
 124 #include "elf/mcore.h"
 125 #include "elf/mep.h"
 126 #include "elf/metag.h"
 127 #include "elf/microblaze.h"
 128 #include "elf/mips.h"
 129 #include "elf/mmix.h"
 130 #include "elf/mn10200.h"
 131 #include "elf/mn10300.h"
 132 #include "elf/moxie.h"
 133 #include "elf/mt.h"
 134 #include "elf/msp430.h"
 135 #include "elf/nds32.h"
 136 #include "elf/nfp.h"
 137 #include "elf/nios2.h"
 138 #include "elf/or1k.h"
 139 #include "elf/pj.h"
 140 #include "elf/ppc.h"
 141 #include "elf/ppc64.h"
 142 #include "elf/pru.h"
 143 #include "elf/riscv.h"
 144 #include "elf/rl78.h"
 145 #include "elf/rx.h"
 146 #include "elf/s390.h"
 147 #include "elf/score.h"
 148 #include "elf/sh.h"
 149 #include "elf/sparc.h"
 150 #include "elf/spu.h"
 151 #include "elf/tic6x.h"
 152 #include "elf/tilegx.h"
 153 #include "elf/tilepro.h"
 154 #include "elf/v850.h"
 155 #include "elf/vax.h"
 156 #include "elf/visium.h"
 157 #include "elf/wasm32.h"
 158 #include "elf/x86-64.h"
 159 #include "elf/xc16x.h"
 160 #include "elf/xgate.h"
 161 #include "elf/xstormy16.h"
 162 #include "elf/xtensa.h"
 163
 164 #include "getopt.h"
 165 #include "libiberty.h"
 166 #include "safe-ctype.h"
 167 #include "filenames.h"
 168
 169 #ifndef offsetof
 170 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 171 #endif
 172
 173 typedef struct elf_section_list
 174 {
 175   Elf_Internal_Shdr *        hdr;
 176   struct elf_section_list *  next;
 177 } elf_section_list;
 178
 179 /* Flag bits indicating particular types of dump.  */
 180 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 181 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 182 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 183 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 184 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 185
 186 typedef unsigned char dump_type;
 187
 188 /* A linked list of the section names for which dumps were requested.  */
 189 struct dump_list_entry
 190 {
 191   char *                    name;
 192   dump_type                 type;
 193   struct dump_list_entry *  next;
 194 };
 195
 196 typedef struct filedata
 197 {
 198   const char *         file_name;
 199   FILE *               handle;
 200   bfd_size_type        file_size;
 201   Elf_Internal_Ehdr    file_header;
 202   Elf_Internal_Shdr *  section_headers;
 203   Elf_Internal_Phdr *  program_headers;
 204   char *               string_table;
 205   unsigned long        string_table_length;
 206   /* A dynamic array of flags indicating for which sections a dump of
 207      some kind has been requested.  It is reset on a per-object file
 208      basis and then initialised from the cmdline_dump_sects array,
 209      the results of interpreting the -w switch, and the
 210      dump_sects_byname list.  */
 211   dump_type *          dump_sects;
 212   unsigned int         num_dump_sects;
 213 } Filedata;
 214
 215 char * program_name = "readelf";
 216
 217 static unsigned long archive_file_offset;
 218 static unsigned long archive_file_size;
 219 static unsigned long dynamic_addr;
 220 static bfd_size_type dynamic_size;
 221 static size_t dynamic_nent;
 222 static char * dynamic_strings;
 223 static unsigned long dynamic_strings_length;
 224 static unsigned long num_dynamic_syms;
 225 static Elf_Internal_Sym * dynamic_symbols;
 226 static Elf_Internal_Syminfo * dynamic_syminfo;
 227 static unsigned long dynamic_syminfo_offset;
 228 static unsigned int dynamic_syminfo_nent;
 229 static char program_interpreter[PATH_MAX];
 230 static bfd_vma dynamic_info[DT_ENCODING];
 231 static bfd_vma dynamic_info_DT_GNU_HASH;
 232 static bfd_vma version_info[16];
 233 static Elf_Internal_Dyn *  dynamic_section;
 234 static elf_section_list * symtab_shndx_list;
 235 static bfd_boolean show_name = FALSE;
 236 static bfd_boolean do_dynamic = FALSE;
 237 static bfd_boolean do_syms = FALSE;
 238 static bfd_boolean do_dyn_syms = FALSE;
 239 static bfd_boolean do_reloc = FALSE;
 240 static bfd_boolean do_sections = FALSE;
 241 static bfd_boolean do_section_groups = FALSE;
 242 static bfd_boolean do_section_details = FALSE;
 243 static bfd_boolean do_segments = FALSE;
 244 static bfd_boolean do_unwind = FALSE;
 245 static bfd_boolean do_using_dynamic = FALSE;
 246 static bfd_boolean do_header = FALSE;
 247 static bfd_boolean do_dump = FALSE;
 248 static bfd_boolean do_version = FALSE;
 249 static bfd_boolean do_histogram = FALSE;
 250 static bfd_boolean do_debugging = FALSE;
 251 static bfd_boolean do_arch = FALSE;
 252 static bfd_boolean do_notes = FALSE;
 253 static bfd_boolean do_archive_index = FALSE;
 254 static bfd_boolean is_32bit_elf = FALSE;
 255 static bfd_boolean decompress_dumps = FALSE;
 256
 257 struct group_list
 258 {
 259   struct group_list *  next;
 260   unsigned int         section_index;
 261 };
 262
 263 struct group
 264 {
 265   struct group_list *  root;
 266   unsigned int         group_index;
 267 };
 268
 269 static size_t           group_count;
 270 static struct group *   section_groups;
 271 static struct group **  section_headers_groups;
 272
 273 /* A dynamic array of flags indicating for which sections a dump
 274    has been requested via command line switches.  */
 275 static Filedata         cmdline;
 276
 277 static struct dump_list_entry * dump_sects_byname;
 278
 279 /* How to print a vma value.  */
 280 typedef enum print_mode
 281 {
 282   HEX,
 283   DEC,
 284   DEC_5,
 285   UNSIGNED,
 286   PREFIX_HEX,
 287   FULL_HEX,
 288   LONG_HEX
 289 }
 290 print_mode;
 291
 292 /* Versioned symbol info.  */
 293 enum versioned_symbol_info
 294 {
 295   symbol_undefined,
 296   symbol_hidden,
 297   symbol_public
 298 };
 299
 300 static const char * get_symbol_version_string
 301   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 302    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 303
 304 #define UNKNOWN -1
 305
 306 #define SECTION_NAME(X)                                         \
 307   ((X) == NULL ? _("<none>")                                    \
 308    : filedata->string_table == NULL ? _("<no-strings>")         \
 309    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 310   : filedata->string_table + (X)->sh_name))
 311
 312 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 313
 314 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 315   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 316    : get_64bit_elf_symbols (file, section, sym_count))
 317
 318 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 319 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 320    already been called and verified that the string exists.  */
 321 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 322
 323 #define REMOVE_ARCH_BITS(ADDR)                  \
 324   do                                            \
 325     {                                           \
 326       if (filedata->file_header.e_machine == EM_ARM)    \
 327         (ADDR) &= ~1;                           \
 328     }                                           \
 329   while (0)
 330 \f
 331 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 332    BFD_FMA_FMT can't be used in translated strings.  */
 333
 334 static const char *
 335 bfd_vmatoa (char *fmtch, bfd_vma value)
 336 {
 337   /* bfd_vmatoa is used more then once in a printf call for output.
 338      Cycle through an array of buffers.  */
 339   static int buf_pos = 0;
 340   static struct bfd_vmatoa_buf
 341   {
 342     char place[64];
 343   } buf[4];
 344   char *ret;
 345   char fmt[32];
 346
 347   ret = buf[buf_pos++].place;
 348   buf_pos %= ARRAY_SIZE (buf);
 349
 350   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 351   snprintf (ret, sizeof (buf[0].place), fmt, value);
 352   return ret;
 353 }
 354
 355 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 356    OFFSET + the offset of the current archive member, if we are examining an
 357    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 358    allocate a buffer using malloc and fill that.  In either case return the
 359    pointer to the start of the retrieved data or NULL if something went wrong.
 360    If something does go wrong and REASON is not NULL then emit an error
 361    message using REASON as part of the context.  */
 362
 363 static void *
 364 get_data (void *         var,
 365           Filedata *     filedata,
 366           unsigned long  offset,
 367           bfd_size_type  size,
 368           bfd_size_type  nmemb,
 369           const char *   reason)
 370 {
 371   void * mvar;
 372   bfd_size_type amt = size * nmemb;
 373
 374   if (size == 0 || nmemb == 0)
 375     return NULL;
 376
 377   /* If the size_t type is smaller than the bfd_size_type, eg because
 378      you are building a 32-bit tool on a 64-bit host, then make sure
 379      that when the sizes are cast to (size_t) no information is lost.  */
 380   if (sizeof (size_t) < sizeof (bfd_size_type)
 381       && (   (bfd_size_type) ((size_t) size) != size
 382           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 383     {
 384       if (reason)
 385         error (_("Size truncation prevents reading %s"
 386                  " elements of size %s for %s\n"),
 387                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 388       return NULL;
 389     }
 390
 391   /* Check for size overflow.  */
 392   if (amt < nmemb)
 393     {
 394       if (reason)
 395         error (_("Size overflow prevents reading %s"
 396                  " elements of size %s for %s\n"),
 397                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 398       return NULL;
 399     }
 400
 401   /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
 402      attempting to allocate memory when the read is bound to fail.  */
 403   if (archive_file_offset > filedata->file_size
 404       || offset > filedata->file_size - archive_file_offset
 405       || amt > filedata->file_size - archive_file_offset - offset)
 406     {
 407       if (reason)
 408         error (_("Reading %s bytes extends past end of file for %s\n"),
 409                bfd_vmatoa ("u", amt), reason);
 410       return NULL;
 411     }
 412
 413   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 414     {
 415       if (reason)
 416         error (_("Unable to seek to 0x%lx for %s\n"),
 417                archive_file_offset + offset, reason);
 418       return NULL;
 419     }
 420
 421   mvar = var;
 422   if (mvar == NULL)
 423     {
 424       /* Check for overflow.  */
 425       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 426         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 427         mvar = malloc ((size_t) amt + 1);
 428
 429       if (mvar == NULL)
 430         {
 431           if (reason)
 432             error (_("Out of memory allocating %s bytes for %s\n"),
 433                    bfd_vmatoa ("u", amt), reason);
 434           return NULL;
 435         }
 436
 437       ((char *) mvar)[amt] = '\0';
 438     }
 439
 440   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 441     {
 442       if (reason)
 443         error (_("Unable to read in %s bytes of %s\n"),
 444                bfd_vmatoa ("u", amt), reason);
 445       if (mvar != var)
 446         free (mvar);
 447       return NULL;
 448     }
 449
 450   return mvar;
 451 }
 452
 453 /* Print a VMA value in the MODE specified.
 454    Returns the number of characters displayed.  */
 455
 456 static unsigned int
 457 print_vma (bfd_vma vma, print_mode mode)
 458 {
 459   unsigned int nc = 0;
 460
 461   switch (mode)
 462     {
 463     case FULL_HEX:
 464       nc = printf ("0x");
 465       /* Fall through.  */
 466     case LONG_HEX:
 467 #ifdef BFD64
 468       if (is_32bit_elf)
 469         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 470 #endif
 471       printf_vma (vma);
 472       return nc + 16;
 473
 474     case DEC_5:
 475       if (vma <= 99999)
 476         return printf ("%5" BFD_VMA_FMT "d", vma);
 477       /* Fall through.  */
 478     case PREFIX_HEX:
 479       nc = printf ("0x");
 480       /* Fall through.  */
 481     case HEX:
 482       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 483
 484     case DEC:
 485       return printf ("%" BFD_VMA_FMT "d", vma);
 486
 487     case UNSIGNED:
 488       return printf ("%" BFD_VMA_FMT "u", vma);
 489
 490     default:
 491       /* FIXME: Report unrecognised mode ?  */
 492       return 0;
 493     }
 494 }
 495
 496 /* Display a symbol on stdout.  Handles the display of control characters and
 497    multibye characters (assuming the host environment supports them).
 498
 499    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 500
 501    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 502    padding as necessary.
 503
 504    Returns the number of emitted characters.  */
 505
 506 static unsigned int
 507 print_symbol (signed int width, const char *symbol)
 508 {
 509   bfd_boolean extra_padding = FALSE;
 510   signed int num_printed = 0;
 511 #ifdef HAVE_MBSTATE_T
 512   mbstate_t state;
 513 #endif
 514   unsigned int width_remaining;
 515
 516   if (width < 0)
 517     {
 518       /* Keep the width positive.  This helps the code below.  */
 519       width = - width;
 520       extra_padding = TRUE;
 521     }
 522   else if (width == 0)
 523     return 0;
 524
 525   if (do_wide)
 526     /* Set the remaining width to a very large value.
 527        This simplifies the code below.  */
 528     width_remaining = INT_MAX;
 529   else
 530     width_remaining = width;
 531
 532 #ifdef HAVE_MBSTATE_T
 533   /* Initialise the multibyte conversion state.  */
 534   memset (& state, 0, sizeof (state));
 535 #endif
 536
 537   while (width_remaining)
 538     {
 539       size_t  n;
 540       const char c = *symbol++;
 541
 542       if (c == 0)
 543         break;
 544
 545       /* Do not print control characters directly as they can affect terminal
 546          settings.  Such characters usually appear in the names generated
 547          by the assembler for local labels.  */
 548       if (ISCNTRL (c))
 549         {
 550           if (width_remaining < 2)
 551             break;
 552
 553           printf ("^%c", c + 0x40);
 554           width_remaining -= 2;
 555           num_printed += 2;
 556         }
 557       else if (ISPRINT (c))
 558         {
 559           putchar (c);
 560           width_remaining --;
 561           num_printed ++;
 562         }
 563       else
 564         {
 565 #ifdef HAVE_MBSTATE_T
 566           wchar_t w;
 567 #endif
 568           /* Let printf do the hard work of displaying multibyte characters.  */
 569           printf ("%.1s", symbol - 1);
 570           width_remaining --;
 571           num_printed ++;
 572
 573 #ifdef HAVE_MBSTATE_T
 574           /* Try to find out how many bytes made up the character that was
 575              just printed.  Advance the symbol pointer past the bytes that
 576              were displayed.  */
 577           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 578 #else
 579           n = 1;
 580 #endif
 581           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 582             symbol += (n - 1);
 583         }
 584     }
 585
 586   if (extra_padding && num_printed < width)
 587     {
 588       /* Fill in the remaining spaces.  */
 589       printf ("%-*s", width - num_printed, " ");
 590       num_printed = width;
 591     }
 592
 593   return num_printed;
 594 }
 595
 596 /* Returns a pointer to a static buffer containing a printable version of
 597    the given section's name.  Like print_symbol, except that it does not try
 598    to print multibyte characters, it just interprets them as hex values.  */
 599
 600 static const char *
 601 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 602 {
 603 #define MAX_PRINT_SEC_NAME_LEN 128
 604   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 605   const char * name = SECTION_NAME (sec);
 606   char *       buf = sec_name_buf;
 607   char         c;
 608   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 609
 610   while ((c = * name ++) != 0)
 611     {
 612       if (ISCNTRL (c))
 613         {
 614           if (remaining < 2)
 615             break;
 616
 617           * buf ++ = '^';
 618           * buf ++ = c + 0x40;
 619           remaining -= 2;
 620         }
 621       else if (ISPRINT (c))
 622         {
 623           * buf ++ = c;
 624           remaining -= 1;
 625         }
 626       else
 627         {
 628           static char hex[17] = "0123456789ABCDEF";
 629
 630           if (remaining < 4)
 631             break;
 632           * buf ++ = '<';
 633           * buf ++ = hex[(c & 0xf0) >> 4];
 634           * buf ++ = hex[c & 0x0f];
 635           * buf ++ = '>';
 636           remaining -= 4;
 637         }
 638
 639       if (remaining == 0)
 640         break;
 641     }
 642
 643   * buf = 0;
 644   return sec_name_buf;
 645 }
 646
 647 static const char *
 648 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 649 {
 650   if (ndx >= filedata->file_header.e_shnum)
 651     return _("<corrupt>");
 652
 653   return printable_section_name (filedata, filedata->section_headers + ndx);
 654 }
 655
 656 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 657
 658 static Elf_Internal_Shdr *
 659 find_section (Filedata * filedata, const char * name)
 660 {
 661   unsigned int i;
 662
 663   if (filedata->section_headers == NULL)
 664     return NULL;
 665
 666   for (i = 0; i < filedata->file_header.e_shnum; i++)
 667     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 668       return filedata->section_headers + i;
 669
 670   return NULL;
 671 }
 672
 673 /* Return a pointer to a section containing ADDR, or NULL if no such
 674    section exists.  */
 675
 676 static Elf_Internal_Shdr *
 677 find_section_by_address (Filedata * filedata, bfd_vma addr)
 678 {
 679   unsigned int i;
 680
 681   if (filedata->section_headers == NULL)
 682     return NULL;
 683
 684   for (i = 0; i < filedata->file_header.e_shnum; i++)
 685     {
 686       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 687
 688       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 689         return sec;
 690     }
 691
 692   return NULL;
 693 }
 694
 695 static Elf_Internal_Shdr *
 696 find_section_by_type (Filedata * filedata, unsigned int type)
 697 {
 698   unsigned int i;
 699
 700   if (filedata->section_headers == NULL)
 701     return NULL;
 702
 703   for (i = 0; i < filedata->file_header.e_shnum; i++)
 704     {
 705       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 706
 707       if (sec->sh_type == type)
 708         return sec;
 709     }
 710
 711   return NULL;
 712 }
 713
 714 /* Return a pointer to section NAME, or NULL if no such section exists,
 715    restricted to the list of sections given in SET.  */
 716
 717 static Elf_Internal_Shdr *
 718 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 719 {
 720   unsigned int i;
 721
 722   if (filedata->section_headers == NULL)
 723     return NULL;
 724
 725   if (set != NULL)
 726     {
 727       while ((i = *set++) > 0)
 728         {
 729           /* See PR 21156 for a reproducer.  */
 730           if (i >= filedata->file_header.e_shnum)
 731             continue; /* FIXME: Should we issue an error message ?  */
 732
 733           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 734             return filedata->section_headers + i;
 735         }
 736     }
 737
 738   return find_section (filedata, name);
 739 }
 740
 741 /* Read an unsigned LEB128 encoded value from DATA.
 742    Set *LENGTH_RETURN to the number of bytes read.  */
 743
 744 static inline unsigned long
 745 read_uleb128 (unsigned char * data,
 746               unsigned int * length_return,
 747               const unsigned char * const end)
 748 {
 749   return read_leb128 (data, length_return, FALSE, end);
 750 }
 751
 752 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 753    This OS has so many departures from the ELF standard that we test it at
 754    many places.  */
 755
 756 static inline bfd_boolean
 757 is_ia64_vms (Filedata * filedata)
 758 {
 759   return filedata->file_header.e_machine == EM_IA_64
 760     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 761 }
 762
 763 /* Guess the relocation size commonly used by the specific machines.  */
 764
 765 static bfd_boolean
 766 guess_is_rela (unsigned int e_machine)
 767 {
 768   switch (e_machine)
 769     {
 770       /* Targets that use REL relocations.  */
 771     case EM_386:
 772     case EM_IAMCU:
 773     case EM_960:
 774     case EM_ARM:
 775     case EM_D10V:
 776     case EM_CYGNUS_D10V:
 777     case EM_DLX:
 778     case EM_MIPS:
 779     case EM_MIPS_RS3_LE:
 780     case EM_CYGNUS_M32R:
 781     case EM_SCORE:
 782     case EM_XGATE:
 783     case EM_NFP:
 784       return FALSE;
 785
 786       /* Targets that use RELA relocations.  */
 787     case EM_68K:
 788     case EM_860:
 789     case EM_AARCH64:
 790     case EM_ADAPTEVA_EPIPHANY:
 791     case EM_ALPHA:
 792     case EM_ALTERA_NIOS2:
 793     case EM_ARC:
 794     case EM_ARC_COMPACT:
 795     case EM_ARC_COMPACT2:
 796     case EM_AVR:
 797     case EM_AVR_OLD:
 798     case EM_BLACKFIN:
 799     case EM_CR16:
 800     case EM_CRIS:
 801     case EM_CRX:
 802     case EM_CSKY:
 803     case EM_D30V:
 804     case EM_CYGNUS_D30V:
 805     case EM_FR30:
 806     case EM_FT32:
 807     case EM_CYGNUS_FR30:
 808     case EM_CYGNUS_FRV:
 809     case EM_H8S:
 810     case EM_H8_300:
 811     case EM_H8_300H:
 812     case EM_IA_64:
 813     case EM_IP2K:
 814     case EM_IP2K_OLD:
 815     case EM_IQ2000:
 816     case EM_LATTICEMICO32:
 817     case EM_M32C_OLD:
 818     case EM_M32C:
 819     case EM_M32R:
 820     case EM_MCORE:
 821     case EM_CYGNUS_MEP:
 822     case EM_METAG:
 823     case EM_MMIX:
 824     case EM_MN10200:
 825     case EM_CYGNUS_MN10200:
 826     case EM_MN10300:
 827     case EM_CYGNUS_MN10300:
 828     case EM_MOXIE:
 829     case EM_MSP430:
 830     case EM_MSP430_OLD:
 831     case EM_MT:
 832     case EM_NDS32:
 833     case EM_NIOS32:
 834     case EM_OR1K:
 835     case EM_PPC64:
 836     case EM_PPC:
 837     case EM_TI_PRU:
 838     case EM_RISCV:
 839     case EM_RL78:
 840     case EM_RX:
 841     case EM_S390:
 842     case EM_S390_OLD:
 843     case EM_SH:
 844     case EM_SPARC:
 845     case EM_SPARC32PLUS:
 846     case EM_SPARCV9:
 847     case EM_SPU:
 848     case EM_TI_C6000:
 849     case EM_TILEGX:
 850     case EM_TILEPRO:
 851     case EM_V800:
 852     case EM_V850:
 853     case EM_CYGNUS_V850:
 854     case EM_VAX:
 855     case EM_VISIUM:
 856     case EM_X86_64:
 857     case EM_L1OM:
 858     case EM_K1OM:
 859     case EM_XSTORMY16:
 860     case EM_XTENSA:
 861     case EM_XTENSA_OLD:
 862     case EM_MICROBLAZE:
 863     case EM_MICROBLAZE_OLD:
 864     case EM_WEBASSEMBLY:
 865       return TRUE;
 866
 867     case EM_68HC05:
 868     case EM_68HC08:
 869     case EM_68HC11:
 870     case EM_68HC16:
 871     case EM_FX66:
 872     case EM_ME16:
 873     case EM_MMA:
 874     case EM_NCPU:
 875     case EM_NDR1:
 876     case EM_PCP:
 877     case EM_ST100:
 878     case EM_ST19:
 879     case EM_ST7:
 880     case EM_ST9PLUS:
 881     case EM_STARCORE:
 882     case EM_SVX:
 883     case EM_TINYJ:
 884     default:
 885       warn (_("Don't know about relocations on this machine architecture\n"));
 886       return FALSE;
 887     }
 888 }
 889
 890 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 891    Returns TRUE upon success, FALSE otherwise.  If successful then a
 892    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 893    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 894    responsibility to free the allocated buffer.  */
 895
 896 static bfd_boolean
 897 slurp_rela_relocs (Filedata *            filedata,
 898                    unsigned long         rel_offset,
 899                    unsigned long         rel_size,
 900                    Elf_Internal_Rela **  relasp,
 901                    unsigned long *       nrelasp)
 902 {
 903   Elf_Internal_Rela * relas;
 904   size_t nrelas;
 905   unsigned int i;
 906
 907   if (is_32bit_elf)
 908     {
 909       Elf32_External_Rela * erelas;
 910
 911       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 912                                                  rel_size, _("32-bit relocation data"));
 913       if (!erelas)
 914         return FALSE;
 915
 916       nrelas = rel_size / sizeof (Elf32_External_Rela);
 917
 918       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 919                                              sizeof (Elf_Internal_Rela));
 920
 921       if (relas == NULL)
 922         {
 923           free (erelas);
 924           error (_("out of memory parsing relocs\n"));
 925           return FALSE;
 926         }
 927
 928       for (i = 0; i < nrelas; i++)
 929         {
 930           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 931           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 932           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 933         }
 934
 935       free (erelas);
 936     }
 937   else
 938     {
 939       Elf64_External_Rela * erelas;
 940
 941       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 942                                                  rel_size, _("64-bit relocation data"));
 943       if (!erelas)
 944         return FALSE;
 945
 946       nrelas = rel_size / sizeof (Elf64_External_Rela);
 947
 948       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 949                                              sizeof (Elf_Internal_Rela));
 950
 951       if (relas == NULL)
 952         {
 953           free (erelas);
 954           error (_("out of memory parsing relocs\n"));
 955           return FALSE;
 956         }
 957
 958       for (i = 0; i < nrelas; i++)
 959         {
 960           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 961           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 962           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 963
 964           /* The #ifdef BFD64 below is to prevent a compile time
 965              warning.  We know that if we do not have a 64 bit data
 966              type that we will never execute this code anyway.  */
 967 #ifdef BFD64
 968           if (filedata->file_header.e_machine == EM_MIPS
 969               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 970             {
 971               /* In little-endian objects, r_info isn't really a
 972                  64-bit little-endian value: it has a 32-bit
 973                  little-endian symbol index followed by four
 974                  individual byte fields.  Reorder INFO
 975                  accordingly.  */
 976               bfd_vma inf = relas[i].r_info;
 977               inf = (((inf & 0xffffffff) << 32)
 978                       | ((inf >> 56) & 0xff)
 979                       | ((inf >> 40) & 0xff00)
 980                       | ((inf >> 24) & 0xff0000)
 981                       | ((inf >> 8) & 0xff000000));
 982               relas[i].r_info = inf;
 983             }
 984 #endif /* BFD64 */
 985         }
 986
 987       free (erelas);
 988     }
 989
 990   *relasp = relas;
 991   *nrelasp = nrelas;
 992   return TRUE;
 993 }
 994
 995 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 996    Returns TRUE upon success, FALSE otherwise.  If successful then a
 997    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 998    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 999    responsibility to free the allocated buffer.  */
1000
1001 static bfd_boolean
1002 slurp_rel_relocs (Filedata *            filedata,
1003                   unsigned long         rel_offset,
1004                   unsigned long         rel_size,
1005                   Elf_Internal_Rela **  relsp,
1006                   unsigned long *       nrelsp)
1007 {
1008   Elf_Internal_Rela * rels;
1009   size_t nrels;
1010   unsigned int i;
1011
1012   if (is_32bit_elf)
1013     {
1014       Elf32_External_Rel * erels;
1015
1016       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1017                                                rel_size, _("32-bit relocation data"));
1018       if (!erels)
1019         return FALSE;
1020
1021       nrels = rel_size / sizeof (Elf32_External_Rel);
1022
1023       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1024
1025       if (rels == NULL)
1026         {
1027           free (erels);
1028           error (_("out of memory parsing relocs\n"));
1029           return FALSE;
1030         }
1031
1032       for (i = 0; i < nrels; i++)
1033         {
1034           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1035           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1036           rels[i].r_addend = 0;
1037         }
1038
1039       free (erels);
1040     }
1041   else
1042     {
1043       Elf64_External_Rel * erels;
1044
1045       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1046                                                rel_size, _("64-bit relocation data"));
1047       if (!erels)
1048         return FALSE;
1049
1050       nrels = rel_size / sizeof (Elf64_External_Rel);
1051
1052       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1053
1054       if (rels == NULL)
1055         {
1056           free (erels);
1057           error (_("out of memory parsing relocs\n"));
1058           return FALSE;
1059         }
1060
1061       for (i = 0; i < nrels; i++)
1062         {
1063           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1064           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1065           rels[i].r_addend = 0;
1066
1067           /* The #ifdef BFD64 below is to prevent a compile time
1068              warning.  We know that if we do not have a 64 bit data
1069              type that we will never execute this code anyway.  */
1070 #ifdef BFD64
1071           if (filedata->file_header.e_machine == EM_MIPS
1072               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1073             {
1074               /* In little-endian objects, r_info isn't really a
1075                  64-bit little-endian value: it has a 32-bit
1076                  little-endian symbol index followed by four
1077                  individual byte fields.  Reorder INFO
1078                  accordingly.  */
1079               bfd_vma inf = rels[i].r_info;
1080               inf = (((inf & 0xffffffff) << 32)
1081                      | ((inf >> 56) & 0xff)
1082                      | ((inf >> 40) & 0xff00)
1083                      | ((inf >> 24) & 0xff0000)
1084                      | ((inf >> 8) & 0xff000000));
1085               rels[i].r_info = inf;
1086             }
1087 #endif /* BFD64 */
1088         }
1089
1090       free (erels);
1091     }
1092
1093   *relsp = rels;
1094   *nrelsp = nrels;
1095   return TRUE;
1096 }
1097
1098 /* Returns the reloc type extracted from the reloc info field.  */
1099
1100 static unsigned int
1101 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1102 {
1103   if (is_32bit_elf)
1104     return ELF32_R_TYPE (reloc_info);
1105
1106   switch (filedata->file_header.e_machine)
1107     {
1108     case EM_MIPS:
1109       /* Note: We assume that reloc_info has already been adjusted for us.  */
1110       return ELF64_MIPS_R_TYPE (reloc_info);
1111
1112     case EM_SPARCV9:
1113       return ELF64_R_TYPE_ID (reloc_info);
1114
1115     default:
1116       return ELF64_R_TYPE (reloc_info);
1117     }
1118 }
1119
1120 /* Return the symbol index extracted from the reloc info field.  */
1121
1122 static bfd_vma
1123 get_reloc_symindex (bfd_vma reloc_info)
1124 {
1125   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1126 }
1127
1128 static inline bfd_boolean
1129 uses_msp430x_relocs (Filedata * filedata)
1130 {
1131   return
1132     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1133     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1134     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1135         /* TI compiler uses ELFOSABI_NONE.  */
1136         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1137 }
1138
1139 /* Display the contents of the relocation data found at the specified
1140    offset.  */
1141
1142 static bfd_boolean
1143 dump_relocations (Filedata *          filedata,
1144                   unsigned long       rel_offset,
1145                   unsigned long       rel_size,
1146                   Elf_Internal_Sym *  symtab,
1147                   unsigned long       nsyms,
1148                   char *              strtab,
1149                   unsigned long       strtablen,
1150                   int                 is_rela,
1151                   bfd_boolean         is_dynsym)
1152 {
1153   unsigned long i;
1154   Elf_Internal_Rela * rels;
1155   bfd_boolean res = TRUE;
1156
1157   if (is_rela == UNKNOWN)
1158     is_rela = guess_is_rela (filedata->file_header.e_machine);
1159
1160   if (is_rela)
1161     {
1162       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1163         return FALSE;
1164     }
1165   else
1166     {
1167       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1168         return FALSE;
1169     }
1170
1171   if (is_32bit_elf)
1172     {
1173       if (is_rela)
1174         {
1175           if (do_wide)
1176             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1177           else
1178             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1179         }
1180       else
1181         {
1182           if (do_wide)
1183             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1184           else
1185             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1186         }
1187     }
1188   else
1189     {
1190       if (is_rela)
1191         {
1192           if (do_wide)
1193             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1194           else
1195             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1196         }
1197       else
1198         {
1199           if (do_wide)
1200             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1201           else
1202             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1203         }
1204     }
1205
1206   for (i = 0; i < rel_size; i++)
1207     {
1208       const char * rtype;
1209       bfd_vma offset;
1210       bfd_vma inf;
1211       bfd_vma symtab_index;
1212       bfd_vma type;
1213
1214       offset = rels[i].r_offset;
1215       inf    = rels[i].r_info;
1216
1217       type = get_reloc_type (filedata, inf);
1218       symtab_index = get_reloc_symindex  (inf);
1219
1220       if (is_32bit_elf)
1221         {
1222           printf ("%8.8lx  %8.8lx ",
1223                   (unsigned long) offset & 0xffffffff,
1224                   (unsigned long) inf & 0xffffffff);
1225         }
1226       else
1227         {
1228 #if BFD_HOST_64BIT_LONG
1229           printf (do_wide
1230                   ? "%16.16lx  %16.16lx "
1231                   : "%12.12lx  %12.12lx ",
1232                   offset, inf);
1233 #elif BFD_HOST_64BIT_LONG_LONG
1234 #ifndef __MSVCRT__
1235           printf (do_wide
1236                   ? "%16.16llx  %16.16llx "
1237                   : "%12.12llx  %12.12llx ",
1238                   offset, inf);
1239 #else
1240           printf (do_wide
1241                   ? "%16.16I64x  %16.16I64x "
1242                   : "%12.12I64x  %12.12I64x ",
1243                   offset, inf);
1244 #endif
1245 #else
1246           printf (do_wide
1247                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1248                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1249                   _bfd_int64_high (offset),
1250                   _bfd_int64_low (offset),
1251                   _bfd_int64_high (inf),
1252                   _bfd_int64_low (inf));
1253 #endif
1254         }
1255
1256       switch (filedata->file_header.e_machine)
1257         {
1258         default:
1259           rtype = NULL;
1260           break;
1261
1262         case EM_AARCH64:
1263           rtype = elf_aarch64_reloc_type (type);
1264           break;
1265
1266         case EM_M32R:
1267         case EM_CYGNUS_M32R:
1268           rtype = elf_m32r_reloc_type (type);
1269           break;
1270
1271         case EM_386:
1272         case EM_IAMCU:
1273           rtype = elf_i386_reloc_type (type);
1274           break;
1275
1276         case EM_68HC11:
1277         case EM_68HC12:
1278           rtype = elf_m68hc11_reloc_type (type);
1279           break;
1280
1281         case EM_S12Z:
1282           rtype = elf_s12z_reloc_type (type);
1283           break;
1284
1285         case EM_68K:
1286           rtype = elf_m68k_reloc_type (type);
1287           break;
1288
1289         case EM_960:
1290           rtype = elf_i960_reloc_type (type);
1291           break;
1292
1293         case EM_AVR:
1294         case EM_AVR_OLD:
1295           rtype = elf_avr_reloc_type (type);
1296           break;
1297
1298         case EM_OLD_SPARCV9:
1299         case EM_SPARC32PLUS:
1300         case EM_SPARCV9:
1301         case EM_SPARC:
1302           rtype = elf_sparc_reloc_type (type);
1303           break;
1304
1305         case EM_SPU:
1306           rtype = elf_spu_reloc_type (type);
1307           break;
1308
1309         case EM_V800:
1310           rtype = v800_reloc_type (type);
1311           break;
1312         case EM_V850:
1313         case EM_CYGNUS_V850:
1314           rtype = v850_reloc_type (type);
1315           break;
1316
1317         case EM_D10V:
1318         case EM_CYGNUS_D10V:
1319           rtype = elf_d10v_reloc_type (type);
1320           break;
1321
1322         case EM_D30V:
1323         case EM_CYGNUS_D30V:
1324           rtype = elf_d30v_reloc_type (type);
1325           break;
1326
1327         case EM_DLX:
1328           rtype = elf_dlx_reloc_type (type);
1329           break;
1330
1331         case EM_SH:
1332           rtype = elf_sh_reloc_type (type);
1333           break;
1334
1335         case EM_MN10300:
1336         case EM_CYGNUS_MN10300:
1337           rtype = elf_mn10300_reloc_type (type);
1338           break;
1339
1340         case EM_MN10200:
1341         case EM_CYGNUS_MN10200:
1342           rtype = elf_mn10200_reloc_type (type);
1343           break;
1344
1345         case EM_FR30:
1346         case EM_CYGNUS_FR30:
1347           rtype = elf_fr30_reloc_type (type);
1348           break;
1349
1350         case EM_CYGNUS_FRV:
1351           rtype = elf_frv_reloc_type (type);
1352           break;
1353
1354         case EM_CSKY:
1355           rtype = elf_csky_reloc_type (type);
1356           break;
1357
1358         case EM_FT32:
1359           rtype = elf_ft32_reloc_type (type);
1360           break;
1361
1362         case EM_MCORE:
1363           rtype = elf_mcore_reloc_type (type);
1364           break;
1365
1366         case EM_MMIX:
1367           rtype = elf_mmix_reloc_type (type);
1368           break;
1369
1370         case EM_MOXIE:
1371           rtype = elf_moxie_reloc_type (type);
1372           break;
1373
1374         case EM_MSP430:
1375           if (uses_msp430x_relocs (filedata))
1376             {
1377               rtype = elf_msp430x_reloc_type (type);
1378               break;
1379             }
1380           /* Fall through.  */
1381         case EM_MSP430_OLD:
1382           rtype = elf_msp430_reloc_type (type);
1383           break;
1384
1385         case EM_NDS32:
1386           rtype = elf_nds32_reloc_type (type);
1387           break;
1388
1389         case EM_PPC:
1390           rtype = elf_ppc_reloc_type (type);
1391           break;
1392
1393         case EM_PPC64:
1394           rtype = elf_ppc64_reloc_type (type);
1395           break;
1396
1397         case EM_MIPS:
1398         case EM_MIPS_RS3_LE:
1399           rtype = elf_mips_reloc_type (type);
1400           break;
1401
1402         case EM_RISCV:
1403           rtype = elf_riscv_reloc_type (type);
1404           break;
1405
1406         case EM_ALPHA:
1407           rtype = elf_alpha_reloc_type (type);
1408           break;
1409
1410         case EM_ARM:
1411           rtype = elf_arm_reloc_type (type);
1412           break;
1413
1414         case EM_ARC:
1415         case EM_ARC_COMPACT:
1416         case EM_ARC_COMPACT2:
1417           rtype = elf_arc_reloc_type (type);
1418           break;
1419
1420         case EM_PARISC:
1421           rtype = elf_hppa_reloc_type (type);
1422           break;
1423
1424         case EM_H8_300:
1425         case EM_H8_300H:
1426         case EM_H8S:
1427           rtype = elf_h8_reloc_type (type);
1428           break;
1429
1430         case EM_OR1K:
1431           rtype = elf_or1k_reloc_type (type);
1432           break;
1433
1434         case EM_PJ:
1435         case EM_PJ_OLD:
1436           rtype = elf_pj_reloc_type (type);
1437           break;
1438         case EM_IA_64:
1439           rtype = elf_ia64_reloc_type (type);
1440           break;
1441
1442         case EM_CRIS:
1443           rtype = elf_cris_reloc_type (type);
1444           break;
1445
1446         case EM_860:
1447           rtype = elf_i860_reloc_type (type);
1448           break;
1449
1450         case EM_X86_64:
1451         case EM_L1OM:
1452         case EM_K1OM:
1453           rtype = elf_x86_64_reloc_type (type);
1454           break;
1455
1456         case EM_S370:
1457           rtype = i370_reloc_type (type);
1458           break;
1459
1460         case EM_S390_OLD:
1461         case EM_S390:
1462           rtype = elf_s390_reloc_type (type);
1463           break;
1464
1465         case EM_SCORE:
1466           rtype = elf_score_reloc_type (type);
1467           break;
1468
1469         case EM_XSTORMY16:
1470           rtype = elf_xstormy16_reloc_type (type);
1471           break;
1472
1473         case EM_CRX:
1474           rtype = elf_crx_reloc_type (type);
1475           break;
1476
1477         case EM_VAX:
1478           rtype = elf_vax_reloc_type (type);
1479           break;
1480
1481         case EM_VISIUM:
1482           rtype = elf_visium_reloc_type (type);
1483           break;
1484
1485         case EM_ADAPTEVA_EPIPHANY:
1486           rtype = elf_epiphany_reloc_type (type);
1487           break;
1488
1489         case EM_IP2K:
1490         case EM_IP2K_OLD:
1491           rtype = elf_ip2k_reloc_type (type);
1492           break;
1493
1494         case EM_IQ2000:
1495           rtype = elf_iq2000_reloc_type (type);
1496           break;
1497
1498         case EM_XTENSA_OLD:
1499         case EM_XTENSA:
1500           rtype = elf_xtensa_reloc_type (type);
1501           break;
1502
1503         case EM_LATTICEMICO32:
1504           rtype = elf_lm32_reloc_type (type);
1505           break;
1506
1507         case EM_M32C_OLD:
1508         case EM_M32C:
1509           rtype = elf_m32c_reloc_type (type);
1510           break;
1511
1512         case EM_MT:
1513           rtype = elf_mt_reloc_type (type);
1514           break;
1515
1516         case EM_BLACKFIN:
1517           rtype = elf_bfin_reloc_type (type);
1518           break;
1519
1520         case EM_CYGNUS_MEP:
1521           rtype = elf_mep_reloc_type (type);
1522           break;
1523
1524         case EM_CR16:
1525           rtype = elf_cr16_reloc_type (type);
1526           break;
1527
1528         case EM_MICROBLAZE:
1529         case EM_MICROBLAZE_OLD:
1530           rtype = elf_microblaze_reloc_type (type);
1531           break;
1532
1533         case EM_RL78:
1534           rtype = elf_rl78_reloc_type (type);
1535           break;
1536
1537         case EM_RX:
1538           rtype = elf_rx_reloc_type (type);
1539           break;
1540
1541         case EM_METAG:
1542           rtype = elf_metag_reloc_type (type);
1543           break;
1544
1545         case EM_XC16X:
1546         case EM_C166:
1547           rtype = elf_xc16x_reloc_type (type);
1548           break;
1549
1550         case EM_TI_C6000:
1551           rtype = elf_tic6x_reloc_type (type);
1552           break;
1553
1554         case EM_TILEGX:
1555           rtype = elf_tilegx_reloc_type (type);
1556           break;
1557
1558         case EM_TILEPRO:
1559           rtype = elf_tilepro_reloc_type (type);
1560           break;
1561
1562         case EM_WEBASSEMBLY:
1563           rtype = elf_wasm32_reloc_type (type);
1564           break;
1565
1566         case EM_XGATE:
1567           rtype = elf_xgate_reloc_type (type);
1568           break;
1569
1570         case EM_ALTERA_NIOS2:
1571           rtype = elf_nios2_reloc_type (type);
1572           break;
1573
1574         case EM_TI_PRU:
1575           rtype = elf_pru_reloc_type (type);
1576           break;
1577
1578         case EM_NFP:
1579           if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1580             rtype = elf_nfp3200_reloc_type (type);
1581           else
1582             rtype = elf_nfp_reloc_type (type);
1583           break;
1584         }
1585
1586       if (rtype == NULL)
1587         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1588       else
1589         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1590
1591       if (filedata->file_header.e_machine == EM_ALPHA
1592           && rtype != NULL
1593           && streq (rtype, "R_ALPHA_LITUSE")
1594           && is_rela)
1595         {
1596           switch (rels[i].r_addend)
1597             {
1598             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1599             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1600             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1601             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1602             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1603             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1604             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1605             default: rtype = NULL;
1606             }
1607
1608           if (rtype)
1609             printf (" (%s)", rtype);
1610           else
1611             {
1612               putchar (' ');
1613               printf (_("<unknown addend: %lx>"),
1614                       (unsigned long) rels[i].r_addend);
1615               res = FALSE;
1616             }
1617         }
1618       else if (symtab_index)
1619         {
1620           if (symtab == NULL || symtab_index >= nsyms)
1621             {
1622               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1623               res = FALSE;
1624             }
1625           else
1626             {
1627               Elf_Internal_Sym * psym;
1628               const char * version_string;
1629               enum versioned_symbol_info sym_info;
1630               unsigned short vna_other;
1631
1632               psym = symtab + symtab_index;
1633
1634               version_string
1635                 = get_symbol_version_string (filedata, is_dynsym,
1636                                              strtab, strtablen,
1637                                              symtab_index,
1638                                              psym,
1639                                              &sym_info,
1640                                              &vna_other);
1641
1642               printf (" ");
1643
1644               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1645                 {
1646                   const char * name;
1647                   unsigned int len;
1648                   unsigned int width = is_32bit_elf ? 8 : 14;
1649
1650                   /* Relocations against GNU_IFUNC symbols do not use the value
1651                      of the symbol as the address to relocate against.  Instead
1652                      they invoke the function named by the symbol and use its
1653                      result as the address for relocation.
1654
1655                      To indicate this to the user, do not display the value of
1656                      the symbol in the "Symbols's Value" field.  Instead show
1657                      its name followed by () as a hint that the symbol is
1658                      invoked.  */
1659
1660                   if (strtab == NULL
1661                       || psym->st_name == 0
1662                       || psym->st_name >= strtablen)
1663                     name = "??";
1664                   else
1665                     name = strtab + psym->st_name;
1666
1667                   len = print_symbol (width, name);
1668                   if (version_string)
1669                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1670                             version_string);
1671                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1672                 }
1673               else
1674                 {
1675                   print_vma (psym->st_value, LONG_HEX);
1676
1677                   printf (is_32bit_elf ? "   " : " ");
1678                 }
1679
1680               if (psym->st_name == 0)
1681                 {
1682                   const char * sec_name = "<null>";
1683                   char name_buf[40];
1684
1685                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1686                     {
1687                       if (psym->st_shndx < filedata->file_header.e_shnum)
1688                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1689                       else if (psym->st_shndx == SHN_ABS)
1690                         sec_name = "ABS";
1691                       else if (psym->st_shndx == SHN_COMMON)
1692                         sec_name = "COMMON";
1693                       else if ((filedata->file_header.e_machine == EM_MIPS
1694                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1695                                || (filedata->file_header.e_machine == EM_TI_C6000
1696                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1697                         sec_name = "SCOMMON";
1698                       else if (filedata->file_header.e_machine == EM_MIPS
1699                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1700                         sec_name = "SUNDEF";
1701                       else if ((filedata->file_header.e_machine == EM_X86_64
1702                                 || filedata->file_header.e_machine == EM_L1OM
1703                                 || filedata->file_header.e_machine == EM_K1OM)
1704                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1705                         sec_name = "LARGE_COMMON";
1706                       else if (filedata->file_header.e_machine == EM_IA_64
1707                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1708                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1709                         sec_name = "ANSI_COM";
1710                       else if (is_ia64_vms (filedata)
1711                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1712                         sec_name = "VMS_SYMVEC";
1713                       else
1714                         {
1715                           sprintf (name_buf, "<section 0x%x>",
1716                                    (unsigned int) psym->st_shndx);
1717                           sec_name = name_buf;
1718                         }
1719                     }
1720                   print_symbol (22, sec_name);
1721                 }
1722               else if (strtab == NULL)
1723                 printf (_("<string table index: %3ld>"), psym->st_name);
1724               else if (psym->st_name >= strtablen)
1725                 {
1726                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1727                   res = FALSE;
1728                 }
1729               else
1730                 {
1731                   print_symbol (22, strtab + psym->st_name);
1732                   if (version_string)
1733                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1734                             version_string);
1735                 }
1736
1737               if (is_rela)
1738                 {
1739                   bfd_vma off = rels[i].r_addend;
1740
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         }
1748       else if (is_rela)
1749         {
1750           bfd_vma off = rels[i].r_addend;
1751
1752           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1753           if ((bfd_signed_vma) off < 0)
1754             printf ("-%" BFD_VMA_FMT "x", - off);
1755           else
1756             printf ("%" BFD_VMA_FMT "x", off);
1757         }
1758
1759       if (filedata->file_header.e_machine == EM_SPARCV9
1760           && rtype != NULL
1761           && streq (rtype, "R_SPARC_OLO10"))
1762         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1763
1764       putchar ('\n');
1765
1766 #ifdef BFD64
1767       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1768         {
1769           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1770           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1771           const char * rtype2 = elf_mips_reloc_type (type2);
1772           const char * rtype3 = elf_mips_reloc_type (type3);
1773
1774           printf ("                    Type2: ");
1775
1776           if (rtype2 == NULL)
1777             printf (_("unrecognized: %-7lx"),
1778                     (unsigned long) type2 & 0xffffffff);
1779           else
1780             printf ("%-17.17s", rtype2);
1781
1782           printf ("\n                    Type3: ");
1783
1784           if (rtype3 == NULL)
1785             printf (_("unrecognized: %-7lx"),
1786                     (unsigned long) type3 & 0xffffffff);
1787           else
1788             printf ("%-17.17s", rtype3);
1789
1790           putchar ('\n');
1791         }
1792 #endif /* BFD64 */
1793     }
1794
1795   free (rels);
1796
1797   return res;
1798 }
1799
1800 static const char *
1801 get_aarch64_dynamic_type (unsigned long type)
1802 {
1803   switch (type)
1804     {
1805     case DT_AARCH64_BTI_PLT:  return "AARCH64_BTI_PLT";
1806     default:
1807       return NULL;
1808     }
1809 }
1810
1811 static const char *
1812 get_mips_dynamic_type (unsigned long type)
1813 {
1814   switch (type)
1815     {
1816     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1817     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1818     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1819     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1820     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1821     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1822     case DT_MIPS_MSYM: return "MIPS_MSYM";
1823     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1824     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1825     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1826     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1827     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1828     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1829     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1830     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1831     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1832     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1833     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1834     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1835     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1836     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1837     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1838     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1839     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1840     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1841     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1842     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1843     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1844     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1845     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1846     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1847     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1848     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1849     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1850     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1851     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1852     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1853     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1854     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1855     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1856     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1857     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1858     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1859     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1860     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1861     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1862     default:
1863       return NULL;
1864     }
1865 }
1866
1867 static const char *
1868 get_sparc64_dynamic_type (unsigned long type)
1869 {
1870   switch (type)
1871     {
1872     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1873     default:
1874       return NULL;
1875     }
1876 }
1877
1878 static const char *
1879 get_ppc_dynamic_type (unsigned long type)
1880 {
1881   switch (type)
1882     {
1883     case DT_PPC_GOT:    return "PPC_GOT";
1884     case DT_PPC_OPT:    return "PPC_OPT";
1885     default:
1886       return NULL;
1887     }
1888 }
1889
1890 static const char *
1891 get_ppc64_dynamic_type (unsigned long type)
1892 {
1893   switch (type)
1894     {
1895     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1896     case DT_PPC64_OPD:    return "PPC64_OPD";
1897     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1898     case DT_PPC64_OPT:    return "PPC64_OPT";
1899     default:
1900       return NULL;
1901     }
1902 }
1903
1904 static const char *
1905 get_parisc_dynamic_type (unsigned long type)
1906 {
1907   switch (type)
1908     {
1909     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1910     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1911     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1912     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1913     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1914     case DT_HP_PREINIT:         return "HP_PREINIT";
1915     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1916     case DT_HP_NEEDED:          return "HP_NEEDED";
1917     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1918     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1919     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1920     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1921     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1922     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1923     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1924     case DT_HP_FILTERED:        return "HP_FILTERED";
1925     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1926     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1927     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1928     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1929     case DT_PLT:                return "PLT";
1930     case DT_PLT_SIZE:           return "PLT_SIZE";
1931     case DT_DLT:                return "DLT";
1932     case DT_DLT_SIZE:           return "DLT_SIZE";
1933     default:
1934       return NULL;
1935     }
1936 }
1937
1938 static const char *
1939 get_ia64_dynamic_type (unsigned long type)
1940 {
1941   switch (type)
1942     {
1943     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1944     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1945     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1946     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1947     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1948     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1949     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1950     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1951     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1952     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1953     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1954     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1955     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1956     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1957     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1958     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1959     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1960     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1961     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1962     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1963     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1964     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1965     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1966     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1967     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1968     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1969     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1970     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1971     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1972     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1973     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1974     default:
1975       return NULL;
1976     }
1977 }
1978
1979 static const char *
1980 get_solaris_section_type (unsigned long type)
1981 {
1982   switch (type)
1983     {
1984     case 0x6fffffee: return "SUNW_ancillary";
1985     case 0x6fffffef: return "SUNW_capchain";
1986     case 0x6ffffff0: return "SUNW_capinfo";
1987     case 0x6ffffff1: return "SUNW_symsort";
1988     case 0x6ffffff2: return "SUNW_tlssort";
1989     case 0x6ffffff3: return "SUNW_LDYNSYM";
1990     case 0x6ffffff4: return "SUNW_dof";
1991     case 0x6ffffff5: return "SUNW_cap";
1992     case 0x6ffffff6: return "SUNW_SIGNATURE";
1993     case 0x6ffffff7: return "SUNW_ANNOTATE";
1994     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1995     case 0x6ffffff9: return "SUNW_DEBUG";
1996     case 0x6ffffffa: return "SUNW_move";
1997     case 0x6ffffffb: return "SUNW_COMDAT";
1998     case 0x6ffffffc: return "SUNW_syminfo";
1999     case 0x6ffffffd: return "SUNW_verdef";
2000     case 0x6ffffffe: return "SUNW_verneed";
2001     case 0x6fffffff: return "SUNW_versym";
2002     case 0x70000000: return "SPARC_GOTDATA";
2003     default: return NULL;
2004     }
2005 }
2006
2007 static const char *
2008 get_alpha_dynamic_type (unsigned long type)
2009 {
2010   switch (type)
2011     {
2012     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2013     default: return NULL;
2014     }
2015 }
2016
2017 static const char *
2018 get_score_dynamic_type (unsigned long type)
2019 {
2020   switch (type)
2021     {
2022     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2023     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
2024     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
2025     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
2026     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
2027     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
2028     default:                    return NULL;
2029     }
2030 }
2031
2032 static const char *
2033 get_tic6x_dynamic_type (unsigned long type)
2034 {
2035   switch (type)
2036     {
2037     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2038     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2039     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2040     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2041     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2042     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2043     default:                   return NULL;
2044     }
2045 }
2046
2047 static const char *
2048 get_nios2_dynamic_type (unsigned long type)
2049 {
2050   switch (type)
2051     {
2052     case DT_NIOS2_GP: return "NIOS2_GP";
2053     default:          return NULL;
2054     }
2055 }
2056
2057 static const char *
2058 get_solaris_dynamic_type (unsigned long type)
2059 {
2060   switch (type)
2061     {
2062     case 0x6000000d: return "SUNW_AUXILIARY";
2063     case 0x6000000e: return "SUNW_RTLDINF";
2064     case 0x6000000f: return "SUNW_FILTER";
2065     case 0x60000010: return "SUNW_CAP";
2066     case 0x60000011: return "SUNW_SYMTAB";
2067     case 0x60000012: return "SUNW_SYMSZ";
2068     case 0x60000013: return "SUNW_SORTENT";
2069     case 0x60000014: return "SUNW_SYMSORT";
2070     case 0x60000015: return "SUNW_SYMSORTSZ";
2071     case 0x60000016: return "SUNW_TLSSORT";
2072     case 0x60000017: return "SUNW_TLSSORTSZ";
2073     case 0x60000018: return "SUNW_CAPINFO";
2074     case 0x60000019: return "SUNW_STRPAD";
2075     case 0x6000001a: return "SUNW_CAPCHAIN";
2076     case 0x6000001b: return "SUNW_LDMACH";
2077     case 0x6000001d: return "SUNW_CAPCHAINENT";
2078     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2079     case 0x60000021: return "SUNW_PARENT";
2080     case 0x60000023: return "SUNW_ASLR";
2081     case 0x60000025: return "SUNW_RELAX";
2082     case 0x60000029: return "SUNW_NXHEAP";
2083     case 0x6000002b: return "SUNW_NXSTACK";
2084
2085     case 0x70000001: return "SPARC_REGISTER";
2086     case 0x7ffffffd: return "AUXILIARY";
2087     case 0x7ffffffe: return "USED";
2088     case 0x7fffffff: return "FILTER";
2089
2090     default: return NULL;
2091     }
2092 }
2093
2094 static const char *
2095 get_dynamic_type (Filedata * filedata, unsigned long type)
2096 {
2097   static char buff[64];
2098
2099   switch (type)
2100     {
2101     case DT_NULL:       return "NULL";
2102     case DT_NEEDED:     return "NEEDED";
2103     case DT_PLTRELSZ:   return "PLTRELSZ";
2104     case DT_PLTGOT:     return "PLTGOT";
2105     case DT_HASH:       return "HASH";
2106     case DT_STRTAB:     return "STRTAB";
2107     case DT_SYMTAB:     return "SYMTAB";
2108     case DT_RELA:       return "RELA";
2109     case DT_RELASZ:     return "RELASZ";
2110     case DT_RELAENT:    return "RELAENT";
2111     case DT_STRSZ:      return "STRSZ";
2112     case DT_SYMENT:     return "SYMENT";
2113     case DT_INIT:       return "INIT";
2114     case DT_FINI:       return "FINI";
2115     case DT_SONAME:     return "SONAME";
2116     case DT_RPATH:      return "RPATH";
2117     case DT_SYMBOLIC:   return "SYMBOLIC";
2118     case DT_REL:        return "REL";
2119     case DT_RELSZ:      return "RELSZ";
2120     case DT_RELENT:     return "RELENT";
2121     case DT_PLTREL:     return "PLTREL";
2122     case DT_DEBUG:      return "DEBUG";
2123     case DT_TEXTREL:    return "TEXTREL";
2124     case DT_JMPREL:     return "JMPREL";
2125     case DT_BIND_NOW:   return "BIND_NOW";
2126     case DT_INIT_ARRAY: return "INIT_ARRAY";
2127     case DT_FINI_ARRAY: return "FINI_ARRAY";
2128     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2129     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2130     case DT_RUNPATH:    return "RUNPATH";
2131     case DT_FLAGS:      return "FLAGS";
2132
2133     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2134     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2135     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2136
2137     case DT_CHECKSUM:   return "CHECKSUM";
2138     case DT_PLTPADSZ:   return "PLTPADSZ";
2139     case DT_MOVEENT:    return "MOVEENT";
2140     case DT_MOVESZ:     return "MOVESZ";
2141     case DT_FEATURE:    return "FEATURE";
2142     case DT_POSFLAG_1:  return "POSFLAG_1";
2143     case DT_SYMINSZ:    return "SYMINSZ";
2144     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2145
2146     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2147     case DT_CONFIG:     return "CONFIG";
2148     case DT_DEPAUDIT:   return "DEPAUDIT";
2149     case DT_AUDIT:      return "AUDIT";
2150     case DT_PLTPAD:     return "PLTPAD";
2151     case DT_MOVETAB:    return "MOVETAB";
2152     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2153
2154     case DT_VERSYM:     return "VERSYM";
2155
2156     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2157     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2158     case DT_RELACOUNT:  return "RELACOUNT";
2159     case DT_RELCOUNT:   return "RELCOUNT";
2160     case DT_FLAGS_1:    return "FLAGS_1";
2161     case DT_VERDEF:     return "VERDEF";
2162     case DT_VERDEFNUM:  return "VERDEFNUM";
2163     case DT_VERNEED:    return "VERNEED";
2164     case DT_VERNEEDNUM: return "VERNEEDNUM";
2165
2166     case DT_AUXILIARY:  return "AUXILIARY";
2167     case DT_USED:       return "USED";
2168     case DT_FILTER:     return "FILTER";
2169
2170     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2171     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2172     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2173     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2174     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2175     case DT_GNU_HASH:   return "GNU_HASH";
2176
2177     default:
2178       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2179         {
2180           const char * result;
2181
2182           switch (filedata->file_header.e_machine)
2183             {
2184             case EM_AARCH64:
2185               result = get_aarch64_dynamic_type (type);
2186               break;
2187             case EM_MIPS:
2188             case EM_MIPS_RS3_LE:
2189               result = get_mips_dynamic_type (type);
2190               break;
2191             case EM_SPARCV9:
2192               result = get_sparc64_dynamic_type (type);
2193               break;
2194             case EM_PPC:
2195               result = get_ppc_dynamic_type (type);
2196               break;
2197             case EM_PPC64:
2198               result = get_ppc64_dynamic_type (type);
2199               break;
2200             case EM_IA_64:
2201               result = get_ia64_dynamic_type (type);
2202               break;
2203             case EM_ALPHA:
2204               result = get_alpha_dynamic_type (type);
2205               break;
2206             case EM_SCORE:
2207               result = get_score_dynamic_type (type);
2208               break;
2209             case EM_TI_C6000:
2210               result = get_tic6x_dynamic_type (type);
2211               break;
2212             case EM_ALTERA_NIOS2:
2213               result = get_nios2_dynamic_type (type);
2214               break;
2215             default:
2216               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2217                 result = get_solaris_dynamic_type (type);
2218               else
2219                 result = NULL;
2220               break;
2221             }
2222
2223           if (result != NULL)
2224             return result;
2225
2226           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2227         }
2228       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2229                || (filedata->file_header.e_machine == EM_PARISC
2230                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2231         {
2232           const char * result;
2233
2234           switch (filedata->file_header.e_machine)
2235             {
2236             case EM_PARISC:
2237               result = get_parisc_dynamic_type (type);
2238               break;
2239             case EM_IA_64:
2240               result = get_ia64_dynamic_type (type);
2241               break;
2242             default:
2243               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2244                 result = get_solaris_dynamic_type (type);
2245               else
2246                 result = NULL;
2247               break;
2248             }
2249
2250           if (result != NULL)
2251             return result;
2252
2253           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2254                     type);
2255         }
2256       else
2257         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2258
2259       return buff;
2260     }
2261 }
2262
2263 static char *
2264 get_file_type (unsigned e_type)
2265 {
2266   static char buff[32];
2267
2268   switch (e_type)
2269     {
2270     case ET_NONE: return _("NONE (None)");
2271     case ET_REL:  return _("REL (Relocatable file)");
2272     case ET_EXEC: return _("EXEC (Executable file)");
2273     case ET_DYN:  return _("DYN (Shared object file)");
2274     case ET_CORE: return _("CORE (Core file)");
2275
2276     default:
2277       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2278         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2279       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2280         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2281       else
2282         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2283       return buff;
2284     }
2285 }
2286
2287 static char *
2288 get_machine_name (unsigned e_machine)
2289 {
2290   static char buff[64]; /* XXX */
2291
2292   switch (e_machine)
2293     {
2294       /* Please keep this switch table sorted by increasing EM_ value.  */
2295       /* 0 */
2296     case EM_NONE:               return _("None");
2297     case EM_M32:                return "WE32100";
2298     case EM_SPARC:              return "Sparc";
2299     case EM_386:                return "Intel 80386";
2300     case EM_68K:                return "MC68000";
2301     case EM_88K:                return "MC88000";
2302     case EM_IAMCU:              return "Intel MCU";
2303     case EM_860:                return "Intel 80860";
2304     case EM_MIPS:               return "MIPS R3000";
2305     case EM_S370:               return "IBM System/370";
2306       /* 10 */
2307     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2308     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2309     case EM_PARISC:             return "HPPA";
2310     case EM_VPP550:             return "Fujitsu VPP500";
2311     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2312     case EM_960:                return "Intel 80960";
2313     case EM_PPC:                return "PowerPC";
2314       /* 20 */
2315     case EM_PPC64:              return "PowerPC64";
2316     case EM_S390_OLD:
2317     case EM_S390:               return "IBM S/390";
2318     case EM_SPU:                return "SPU";
2319       /* 30 */
2320     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2321     case EM_FR20:               return "Fujitsu FR20";
2322     case EM_RH32:               return "TRW RH32";
2323     case EM_MCORE:              return "MCORE";
2324       /* 40 */
2325     case EM_ARM:                return "ARM";
2326     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2327     case EM_SH:                 return "Renesas / SuperH SH";
2328     case EM_SPARCV9:            return "Sparc v9";
2329     case EM_TRICORE:            return "Siemens Tricore";
2330     case EM_ARC:                return "ARC";
2331     case EM_H8_300:             return "Renesas H8/300";
2332     case EM_H8_300H:            return "Renesas H8/300H";
2333     case EM_H8S:                return "Renesas H8S";
2334     case EM_H8_500:             return "Renesas H8/500";
2335       /* 50 */
2336     case EM_IA_64:              return "Intel IA-64";
2337     case EM_MIPS_X:             return "Stanford MIPS-X";
2338     case EM_COLDFIRE:           return "Motorola Coldfire";
2339     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2340     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2341     case EM_PCP:                return "Siemens PCP";
2342     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2343     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2344     case EM_STARCORE:           return "Motorola Star*Core processor";
2345     case EM_ME16:               return "Toyota ME16 processor";
2346       /* 60 */
2347     case EM_ST100:              return "STMicroelectronics ST100 processor";
2348     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2349     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2350     case EM_PDSP:               return "Sony DSP processor";
2351     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2352     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2353     case EM_FX66:               return "Siemens FX66 microcontroller";
2354     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2355     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2356     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2357       /* 70 */
2358     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2359     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2360     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2361     case EM_SVX:                return "Silicon Graphics SVx";
2362     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2363     case EM_VAX:                return "Digital VAX";
2364     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2365     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2366     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2367     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2368       /* 80 */
2369     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2370     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2371     case EM_PRISM:              return "Vitesse Prism";
2372     case EM_AVR_OLD:
2373     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2374     case EM_CYGNUS_FR30:
2375     case EM_FR30:               return "Fujitsu FR30";
2376     case EM_CYGNUS_D10V:
2377     case EM_D10V:               return "d10v";
2378     case EM_CYGNUS_D30V:
2379     case EM_D30V:               return "d30v";
2380     case EM_CYGNUS_V850:
2381     case EM_V850:               return "Renesas V850";
2382     case EM_CYGNUS_M32R:
2383     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2384     case EM_CYGNUS_MN10300:
2385     case EM_MN10300:            return "mn10300";
2386       /* 90 */
2387     case EM_CYGNUS_MN10200:
2388     case EM_MN10200:            return "mn10200";
2389     case EM_PJ:                 return "picoJava";
2390     case EM_OR1K:               return "OpenRISC 1000";
2391     case EM_ARC_COMPACT:        return "ARCompact";
2392     case EM_XTENSA_OLD:
2393     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2394     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2395     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2396     case EM_NS32K:              return "National Semiconductor 32000 series";
2397     case EM_TPC:                return "Tenor Network TPC processor";
2398     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2399       /* 100 */
2400     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2401     case EM_IP2K_OLD:
2402     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2403     case EM_MAX:                return "MAX Processor";
2404     case EM_CR:                 return "National Semiconductor CompactRISC";
2405     case EM_F2MC16:             return "Fujitsu F2MC16";
2406     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2407     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2408     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2409     case EM_SEP:                return "Sharp embedded microprocessor";
2410     case EM_ARCA:               return "Arca RISC microprocessor";
2411       /* 110 */
2412     case EM_UNICORE:            return "Unicore";
2413     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2414     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2415     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2416     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2417     case EM_XGATE:              return "Motorola XGATE embedded processor";
2418     case EM_C166:
2419     case EM_XC16X:              return "Infineon Technologies xc16x";
2420     case EM_M16C:               return "Renesas M16C series microprocessors";
2421     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2422     case EM_CE:                 return "Freescale Communication Engine RISC core";
2423       /* 120 */
2424     case EM_M32C:               return "Renesas M32c";
2425       /* 130 */
2426     case EM_TSK3000:            return "Altium TSK3000 core";
2427     case EM_RS08:               return "Freescale RS08 embedded processor";
2428     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2429     case EM_SCORE:              return "SUNPLUS S+Core";
2430     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2431     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2432     case EM_LATTICEMICO32:      return "Lattice Mico32";
2433     case EM_SE_C17:             return "Seiko Epson C17 family";
2434       /* 140 */
2435     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2436     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2437     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2438     case EM_TI_PRU:             return "TI PRU I/O processor";
2439       /* 160 */
2440     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2441     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2442     case EM_R32C:               return "Renesas R32C series microprocessors";
2443     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2444     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2445     case EM_8051:               return "Intel 8051 and variants";
2446     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2447     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2448     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2449     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2450       /* 170 */
2451     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2452     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2453     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2454     case EM_RX:                 return "Renesas RX";
2455     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2456     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2457     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2458     case EM_CR16:
2459     case EM_MICROBLAZE:
2460     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2461     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2462     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2463       /* 180 */
2464     case EM_L1OM:               return "Intel L1OM";
2465     case EM_K1OM:               return "Intel K1OM";
2466     case EM_INTEL182:           return "Intel (reserved)";
2467     case EM_AARCH64:            return "AArch64";
2468     case EM_ARM184:             return "ARM (reserved)";
2469     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2470     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2471     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2472     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2473       /* 190 */
2474     case EM_CUDA:               return "NVIDIA CUDA architecture";
2475     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2476     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2477     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2478     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2479     case EM_ARC_COMPACT2:       return "ARCv2";
2480     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2481     case EM_RL78:               return "Renesas RL78";
2482     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2483     case EM_78K0R:              return "Renesas 78K0R";
2484       /* 200 */
2485     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2486     case EM_BA1:                return "Beyond BA1 CPU architecture";
2487     case EM_BA2:                return "Beyond BA2 CPU architecture";
2488     case EM_XCORE:              return "XMOS xCORE processor family";
2489     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2490       /* 210 */
2491     case EM_KM32:               return "KM211 KM32 32-bit processor";
2492     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2493     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2494     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2495     case EM_KVARC:              return "KM211 KVARC processor";
2496     case EM_CDP:                return "Paneve CDP architecture family";
2497     case EM_COGE:               return "Cognitive Smart Memory Processor";
2498     case EM_COOL:               return "Bluechip Systems CoolEngine";
2499     case EM_NORC:               return "Nanoradio Optimized RISC";
2500     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2501       /* 220 */
2502     case EM_Z80:                return "Zilog Z80";
2503     case EM_VISIUM:             return "CDS VISIUMcore processor";
2504     case EM_FT32:               return "FTDI Chip FT32";
2505     case EM_MOXIE:              return "Moxie";
2506     case EM_AMDGPU:             return "AMD GPU";
2507     case EM_RISCV:              return "RISC-V";
2508     case EM_LANAI:              return "Lanai 32-bit processor";
2509     case EM_BPF:                return "Linux BPF";
2510     case EM_NFP:                return "Netronome Flow Processor";
2511
2512       /* Large numbers...  */
2513     case EM_MT:                 return "Morpho Techologies MT processor";
2514     case EM_ALPHA:              return "Alpha";
2515     case EM_WEBASSEMBLY:        return "Web Assembly";
2516     case EM_DLX:                return "OpenDLX";
2517     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2518     case EM_IQ2000:             return "Vitesse IQ2000";
2519     case EM_M32C_OLD:
2520     case EM_NIOS32:             return "Altera Nios";
2521     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2522     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2523     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2524     case EM_S12Z:               return "Freescale S12Z";
2525     case EM_CSKY:               return "C-SKY";
2526
2527     default:
2528       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2529       return buff;
2530     }
2531 }
2532
2533 static void
2534 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2535 {
2536   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2537      other compilers don't a specific architecture type in the e_flags, and
2538      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2539      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2540      architectures.
2541
2542      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2543      but also sets a specific architecture type in the e_flags field.
2544
2545      However, when decoding the flags we don't worry if we see an
2546      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2547      ARCEM architecture type.  */
2548
2549   switch (e_flags & EF_ARC_MACH_MSK)
2550     {
2551       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2552     case EF_ARC_CPU_ARCV2EM:
2553       strcat (buf, ", ARC EM");
2554       break;
2555     case EF_ARC_CPU_ARCV2HS:
2556       strcat (buf, ", ARC HS");
2557       break;
2558
2559       /* We only expect these to occur for EM_ARC_COMPACT.  */
2560     case E_ARC_MACH_ARC600:
2561       strcat (buf, ", ARC600");
2562       break;
2563     case E_ARC_MACH_ARC601:
2564       strcat (buf, ", ARC601");
2565       break;
2566     case E_ARC_MACH_ARC700:
2567       strcat (buf, ", ARC700");
2568       break;
2569
2570       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2571          new ELF with new architecture being read by an old version of
2572          readelf, or (c) An ELF built with non-GNU compiler that does not
2573          set the architecture in the e_flags.  */
2574     default:
2575       if (e_machine == EM_ARC_COMPACT)
2576         strcat (buf, ", Unknown ARCompact");
2577       else
2578         strcat (buf, ", Unknown ARC");
2579       break;
2580     }
2581
2582   switch (e_flags & EF_ARC_OSABI_MSK)
2583     {
2584     case E_ARC_OSABI_ORIG:
2585       strcat (buf, ", (ABI:legacy)");
2586       break;
2587     case E_ARC_OSABI_V2:
2588       strcat (buf, ", (ABI:v2)");
2589       break;
2590       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2591     case E_ARC_OSABI_V3:
2592       strcat (buf, ", v3 no-legacy-syscalls ABI");
2593       break;
2594     case E_ARC_OSABI_V4:
2595       strcat (buf, ", v4 ABI");
2596       break;
2597     default:
2598       strcat (buf, ", unrecognised ARC OSABI flag");
2599       break;
2600     }
2601 }
2602
2603 static void
2604 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2605 {
2606   unsigned eabi;
2607   bfd_boolean unknown = FALSE;
2608
2609   eabi = EF_ARM_EABI_VERSION (e_flags);
2610   e_flags &= ~ EF_ARM_EABIMASK;
2611
2612   /* Handle "generic" ARM flags.  */
2613   if (e_flags & EF_ARM_RELEXEC)
2614     {
2615       strcat (buf, ", relocatable executable");
2616       e_flags &= ~ EF_ARM_RELEXEC;
2617     }
2618
2619   if (e_flags & EF_ARM_PIC)
2620     {
2621       strcat (buf, ", position independent");
2622       e_flags &= ~ EF_ARM_PIC;
2623     }
2624
2625   /* Now handle EABI specific flags.  */
2626   switch (eabi)
2627     {
2628     default:
2629       strcat (buf, ", <unrecognized EABI>");
2630       if (e_flags)
2631         unknown = TRUE;
2632       break;
2633
2634     case EF_ARM_EABI_VER1:
2635       strcat (buf, ", Version1 EABI");
2636       while (e_flags)
2637         {
2638           unsigned flag;
2639
2640           /* Process flags one bit at a time.  */
2641           flag = e_flags & - e_flags;
2642           e_flags &= ~ flag;
2643
2644           switch (flag)
2645             {
2646             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2647               strcat (buf, ", sorted symbol tables");
2648               break;
2649
2650             default:
2651               unknown = TRUE;
2652               break;
2653             }
2654         }
2655       break;
2656
2657     case EF_ARM_EABI_VER2:
2658       strcat (buf, ", Version2 EABI");
2659       while (e_flags)
2660         {
2661           unsigned flag;
2662
2663           /* Process flags one bit at a time.  */
2664           flag = e_flags & - e_flags;
2665           e_flags &= ~ flag;
2666
2667           switch (flag)
2668             {
2669             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2670               strcat (buf, ", sorted symbol tables");
2671               break;
2672
2673             case EF_ARM_DYNSYMSUSESEGIDX:
2674               strcat (buf, ", dynamic symbols use segment index");
2675               break;
2676
2677             case EF_ARM_MAPSYMSFIRST:
2678               strcat (buf, ", mapping symbols precede others");
2679               break;
2680
2681             default:
2682               unknown = TRUE;
2683               break;
2684             }
2685         }
2686       break;
2687
2688     case EF_ARM_EABI_VER3:
2689       strcat (buf, ", Version3 EABI");
2690       break;
2691
2692     case EF_ARM_EABI_VER4:
2693       strcat (buf, ", Version4 EABI");
2694       while (e_flags)
2695         {
2696           unsigned flag;
2697
2698           /* Process flags one bit at a time.  */
2699           flag = e_flags & - e_flags;
2700           e_flags &= ~ flag;
2701
2702           switch (flag)
2703             {
2704             case EF_ARM_BE8:
2705               strcat (buf, ", BE8");
2706               break;
2707
2708             case EF_ARM_LE8:
2709               strcat (buf, ", LE8");
2710               break;
2711
2712             default:
2713               unknown = TRUE;
2714               break;
2715             }
2716         }
2717       break;
2718
2719     case EF_ARM_EABI_VER5:
2720       strcat (buf, ", Version5 EABI");
2721       while (e_flags)
2722         {
2723           unsigned flag;
2724
2725           /* Process flags one bit at a time.  */
2726           flag = e_flags & - e_flags;
2727           e_flags &= ~ flag;
2728
2729           switch (flag)
2730             {
2731             case EF_ARM_BE8:
2732               strcat (buf, ", BE8");
2733               break;
2734
2735             case EF_ARM_LE8:
2736               strcat (buf, ", LE8");
2737               break;
2738
2739             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2740               strcat (buf, ", soft-float ABI");
2741               break;
2742
2743             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2744               strcat (buf, ", hard-float ABI");
2745               break;
2746
2747             default:
2748               unknown = TRUE;
2749               break;
2750             }
2751         }
2752       break;
2753
2754     case EF_ARM_EABI_UNKNOWN:
2755       strcat (buf, ", GNU EABI");
2756       while (e_flags)
2757         {
2758           unsigned flag;
2759
2760           /* Process flags one bit at a time.  */
2761           flag = e_flags & - e_flags;
2762           e_flags &= ~ flag;
2763
2764           switch (flag)
2765             {
2766             case EF_ARM_INTERWORK:
2767               strcat (buf, ", interworking enabled");
2768               break;
2769
2770             case EF_ARM_APCS_26:
2771               strcat (buf, ", uses APCS/26");
2772               break;
2773
2774             case EF_ARM_APCS_FLOAT:
2775               strcat (buf, ", uses APCS/float");
2776               break;
2777
2778             case EF_ARM_PIC:
2779               strcat (buf, ", position independent");
2780               break;
2781
2782             case EF_ARM_ALIGN8:
2783               strcat (buf, ", 8 bit structure alignment");
2784               break;
2785
2786             case EF_ARM_NEW_ABI:
2787               strcat (buf, ", uses new ABI");
2788               break;
2789
2790             case EF_ARM_OLD_ABI:
2791               strcat (buf, ", uses old ABI");
2792               break;
2793
2794             case EF_ARM_SOFT_FLOAT:
2795               strcat (buf, ", software FP");
2796               break;
2797
2798             case EF_ARM_VFP_FLOAT:
2799               strcat (buf, ", VFP");
2800               break;
2801
2802             case EF_ARM_MAVERICK_FLOAT:
2803               strcat (buf, ", Maverick FP");
2804               break;
2805
2806             default:
2807               unknown = TRUE;
2808               break;
2809             }
2810         }
2811     }
2812
2813   if (unknown)
2814     strcat (buf,_(", <unknown>"));
2815 }
2816
2817 static void
2818 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2819 {
2820   --size; /* Leave space for null terminator.  */
2821
2822   switch (e_flags & EF_AVR_MACH)
2823     {
2824     case E_AVR_MACH_AVR1:
2825       strncat (buf, ", avr:1", size);
2826       break;
2827     case E_AVR_MACH_AVR2:
2828       strncat (buf, ", avr:2", size);
2829       break;
2830     case E_AVR_MACH_AVR25:
2831       strncat (buf, ", avr:25", size);
2832       break;
2833     case E_AVR_MACH_AVR3:
2834       strncat (buf, ", avr:3", size);
2835       break;
2836     case E_AVR_MACH_AVR31:
2837       strncat (buf, ", avr:31", size);
2838       break;
2839     case E_AVR_MACH_AVR35:
2840       strncat (buf, ", avr:35", size);
2841       break;
2842     case E_AVR_MACH_AVR4:
2843       strncat (buf, ", avr:4", size);
2844       break;
2845     case E_AVR_MACH_AVR5:
2846       strncat (buf, ", avr:5", size);
2847       break;
2848     case E_AVR_MACH_AVR51:
2849       strncat (buf, ", avr:51", size);
2850       break;
2851     case E_AVR_MACH_AVR6:
2852       strncat (buf, ", avr:6", size);
2853       break;
2854     case E_AVR_MACH_AVRTINY:
2855       strncat (buf, ", avr:100", size);
2856       break;
2857     case E_AVR_MACH_XMEGA1:
2858       strncat (buf, ", avr:101", size);
2859       break;
2860     case E_AVR_MACH_XMEGA2:
2861       strncat (buf, ", avr:102", size);
2862       break;
2863     case E_AVR_MACH_XMEGA3:
2864       strncat (buf, ", avr:103", size);
2865       break;
2866     case E_AVR_MACH_XMEGA4:
2867       strncat (buf, ", avr:104", size);
2868       break;
2869     case E_AVR_MACH_XMEGA5:
2870       strncat (buf, ", avr:105", size);
2871       break;
2872     case E_AVR_MACH_XMEGA6:
2873       strncat (buf, ", avr:106", size);
2874       break;
2875     case E_AVR_MACH_XMEGA7:
2876       strncat (buf, ", avr:107", size);
2877       break;
2878     default:
2879       strncat (buf, ", avr:<unknown>", size);
2880       break;
2881     }
2882
2883   size -= strlen (buf);
2884   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2885     strncat (buf, ", link-relax", size);
2886 }
2887
2888 static void
2889 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2890 {
2891   unsigned abi;
2892   unsigned arch;
2893   unsigned config;
2894   unsigned version;
2895   bfd_boolean has_fpu = FALSE;
2896   unsigned int r = 0;
2897
2898   static const char *ABI_STRINGS[] =
2899   {
2900     "ABI v0", /* use r5 as return register; only used in N1213HC */
2901     "ABI v1", /* use r0 as return register */
2902     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2903     "ABI v2fp", /* for FPU */
2904     "AABI",
2905     "ABI2 FP+"
2906   };
2907   static const char *VER_STRINGS[] =
2908   {
2909     "Andes ELF V1.3 or older",
2910     "Andes ELF V1.3.1",
2911     "Andes ELF V1.4"
2912   };
2913   static const char *ARCH_STRINGS[] =
2914   {
2915     "",
2916     "Andes Star v1.0",
2917     "Andes Star v2.0",
2918     "Andes Star v3.0",
2919     "Andes Star v3.0m"
2920   };
2921
2922   abi = EF_NDS_ABI & e_flags;
2923   arch = EF_NDS_ARCH & e_flags;
2924   config = EF_NDS_INST & e_flags;
2925   version = EF_NDS32_ELF_VERSION & e_flags;
2926
2927   memset (buf, 0, size);
2928
2929   switch (abi)
2930     {
2931     case E_NDS_ABI_V0:
2932     case E_NDS_ABI_V1:
2933     case E_NDS_ABI_V2:
2934     case E_NDS_ABI_V2FP:
2935     case E_NDS_ABI_AABI:
2936     case E_NDS_ABI_V2FP_PLUS:
2937       /* In case there are holes in the array.  */
2938       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2939       break;
2940
2941     default:
2942       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2943       break;
2944     }
2945
2946   switch (version)
2947     {
2948     case E_NDS32_ELF_VER_1_2:
2949     case E_NDS32_ELF_VER_1_3:
2950     case E_NDS32_ELF_VER_1_4:
2951       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2952       break;
2953
2954     default:
2955       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2956       break;
2957     }
2958
2959   if (E_NDS_ABI_V0 == abi)
2960     {
2961       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2962       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2963       if (arch == E_NDS_ARCH_STAR_V1_0)
2964         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2965       return;
2966     }
2967
2968   switch (arch)
2969     {
2970     case E_NDS_ARCH_STAR_V1_0:
2971     case E_NDS_ARCH_STAR_V2_0:
2972     case E_NDS_ARCH_STAR_V3_0:
2973     case E_NDS_ARCH_STAR_V3_M:
2974       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2975       break;
2976
2977     default:
2978       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2979       /* ARCH version determines how the e_flags are interpreted.
2980          If it is unknown, we cannot proceed.  */
2981       return;
2982     }
2983
2984   /* Newer ABI; Now handle architecture specific flags.  */
2985   if (arch == E_NDS_ARCH_STAR_V1_0)
2986     {
2987       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2988         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2989
2990       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2991         r += snprintf (buf + r, size -r, ", MAC");
2992
2993       if (config & E_NDS32_HAS_DIV_INST)
2994         r += snprintf (buf + r, size -r, ", DIV");
2995
2996       if (config & E_NDS32_HAS_16BIT_INST)
2997         r += snprintf (buf + r, size -r, ", 16b");
2998     }
2999   else
3000     {
3001       if (config & E_NDS32_HAS_MFUSR_PC_INST)
3002         {
3003           if (version <= E_NDS32_ELF_VER_1_3)
3004             r += snprintf (buf + r, size -r, ", [B8]");
3005           else
3006             r += snprintf (buf + r, size -r, ", EX9");
3007         }
3008
3009       if (config & E_NDS32_HAS_MAC_DX_INST)
3010         r += snprintf (buf + r, size -r, ", MAC_DX");
3011
3012       if (config & E_NDS32_HAS_DIV_DX_INST)
3013         r += snprintf (buf + r, size -r, ", DIV_DX");
3014
3015       if (config & E_NDS32_HAS_16BIT_INST)
3016         {
3017           if (version <= E_NDS32_ELF_VER_1_3)
3018             r += snprintf (buf + r, size -r, ", 16b");
3019           else
3020             r += snprintf (buf + r, size -r, ", IFC");
3021         }
3022     }
3023
3024   if (config & E_NDS32_HAS_EXT_INST)
3025     r += snprintf (buf + r, size -r, ", PERF1");
3026
3027   if (config & E_NDS32_HAS_EXT2_INST)
3028     r += snprintf (buf + r, size -r, ", PERF2");
3029
3030   if (config & E_NDS32_HAS_FPU_INST)
3031     {
3032       has_fpu = TRUE;
3033       r += snprintf (buf + r, size -r, ", FPU_SP");
3034     }
3035
3036   if (config & E_NDS32_HAS_FPU_DP_INST)
3037     {
3038       has_fpu = TRUE;
3039       r += snprintf (buf + r, size -r, ", FPU_DP");
3040     }
3041
3042   if (config & E_NDS32_HAS_FPU_MAC_INST)
3043     {
3044       has_fpu = TRUE;
3045       r += snprintf (buf + r, size -r, ", FPU_MAC");
3046     }
3047
3048   if (has_fpu)
3049     {
3050       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3051         {
3052         case E_NDS32_FPU_REG_8SP_4DP:
3053           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3054           break;
3055         case E_NDS32_FPU_REG_16SP_8DP:
3056           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3057           break;
3058         case E_NDS32_FPU_REG_32SP_16DP:
3059           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3060           break;
3061         case E_NDS32_FPU_REG_32SP_32DP:
3062           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3063           break;
3064         }
3065     }
3066
3067   if (config & E_NDS32_HAS_AUDIO_INST)
3068     r += snprintf (buf + r, size -r, ", AUDIO");
3069
3070   if (config & E_NDS32_HAS_STRING_INST)
3071     r += snprintf (buf + r, size -r, ", STR");
3072
3073   if (config & E_NDS32_HAS_REDUCED_REGS)
3074     r += snprintf (buf + r, size -r, ", 16REG");
3075
3076   if (config & E_NDS32_HAS_VIDEO_INST)
3077     {
3078       if (version <= E_NDS32_ELF_VER_1_3)
3079         r += snprintf (buf + r, size -r, ", VIDEO");
3080       else
3081         r += snprintf (buf + r, size -r, ", SATURATION");
3082     }
3083
3084   if (config & E_NDS32_HAS_ENCRIPT_INST)
3085     r += snprintf (buf + r, size -r, ", ENCRP");
3086
3087   if (config & E_NDS32_HAS_L2C_INST)
3088     r += snprintf (buf + r, size -r, ", L2C");
3089 }
3090
3091 static char *
3092 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3093 {
3094   static char buf[1024];
3095
3096   buf[0] = '\0';
3097
3098   if (e_flags)
3099     {
3100       switch (e_machine)
3101         {
3102         default:
3103           break;
3104
3105         case EM_ARC_COMPACT2:
3106         case EM_ARC_COMPACT:
3107           decode_ARC_machine_flags (e_flags, e_machine, buf);
3108           break;
3109
3110         case EM_ARM:
3111           decode_ARM_machine_flags (e_flags, buf);
3112           break;
3113
3114         case EM_AVR:
3115           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3116           break;
3117
3118         case EM_BLACKFIN:
3119           if (e_flags & EF_BFIN_PIC)
3120             strcat (buf, ", PIC");
3121
3122           if (e_flags & EF_BFIN_FDPIC)
3123             strcat (buf, ", FDPIC");
3124
3125           if (e_flags & EF_BFIN_CODE_IN_L1)
3126             strcat (buf, ", code in L1");
3127
3128           if (e_flags & EF_BFIN_DATA_IN_L1)
3129             strcat (buf, ", data in L1");
3130
3131           break;
3132
3133         case EM_CYGNUS_FRV:
3134           switch (e_flags & EF_FRV_CPU_MASK)
3135             {
3136             case EF_FRV_CPU_GENERIC:
3137               break;
3138
3139             default:
3140               strcat (buf, ", fr???");
3141               break;
3142
3143             case EF_FRV_CPU_FR300:
3144               strcat (buf, ", fr300");
3145               break;
3146
3147             case EF_FRV_CPU_FR400:
3148               strcat (buf, ", fr400");
3149               break;
3150             case EF_FRV_CPU_FR405:
3151               strcat (buf, ", fr405");
3152               break;
3153
3154             case EF_FRV_CPU_FR450:
3155               strcat (buf, ", fr450");
3156               break;
3157
3158             case EF_FRV_CPU_FR500:
3159               strcat (buf, ", fr500");
3160               break;
3161             case EF_FRV_CPU_FR550:
3162               strcat (buf, ", fr550");
3163               break;
3164
3165             case EF_FRV_CPU_SIMPLE:
3166               strcat (buf, ", simple");
3167               break;
3168             case EF_FRV_CPU_TOMCAT:
3169               strcat (buf, ", tomcat");
3170               break;
3171             }
3172           break;
3173
3174         case EM_68K:
3175           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3176             strcat (buf, ", m68000");
3177           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3178             strcat (buf, ", cpu32");
3179           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3180             strcat (buf, ", fido_a");
3181           else
3182             {
3183               char const * isa = _("unknown");
3184               char const * mac = _("unknown mac");
3185               char const * additional = NULL;
3186
3187               switch (e_flags & EF_M68K_CF_ISA_MASK)
3188                 {
3189                 case EF_M68K_CF_ISA_A_NODIV:
3190                   isa = "A";
3191                   additional = ", nodiv";
3192                   break;
3193                 case EF_M68K_CF_ISA_A:
3194                   isa = "A";
3195                   break;
3196                 case EF_M68K_CF_ISA_A_PLUS:
3197                   isa = "A+";
3198                   break;
3199                 case EF_M68K_CF_ISA_B_NOUSP:
3200                   isa = "B";
3201                   additional = ", nousp";
3202                   break;
3203                 case EF_M68K_CF_ISA_B:
3204                   isa = "B";
3205                   break;
3206                 case EF_M68K_CF_ISA_C:
3207                   isa = "C";
3208                   break;
3209                 case EF_M68K_CF_ISA_C_NODIV:
3210                   isa = "C";
3211                   additional = ", nodiv";
3212                   break;
3213                 }
3214               strcat (buf, ", cf, isa ");
3215               strcat (buf, isa);
3216               if (additional)
3217                 strcat (buf, additional);
3218               if (e_flags & EF_M68K_CF_FLOAT)
3219                 strcat (buf, ", float");
3220               switch (e_flags & EF_M68K_CF_MAC_MASK)
3221                 {
3222                 case 0:
3223                   mac = NULL;
3224                   break;
3225                 case EF_M68K_CF_MAC:
3226                   mac = "mac";
3227                   break;
3228                 case EF_M68K_CF_EMAC:
3229                   mac = "emac";
3230                   break;
3231                 case EF_M68K_CF_EMAC_B:
3232                   mac = "emac_b";
3233                   break;
3234                 }
3235               if (mac)
3236                 {
3237                   strcat (buf, ", ");
3238                   strcat (buf, mac);
3239                 }
3240             }
3241           break;
3242
3243         case EM_CYGNUS_MEP:
3244           switch (e_flags & EF_MEP_CPU_MASK)
3245             {
3246             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3247             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3248             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3249             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3250             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3251             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3252             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3253             }
3254
3255           switch (e_flags & EF_MEP_COP_MASK)
3256             {
3257             case EF_MEP_COP_NONE: break;
3258             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3259             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3260             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3261             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3262             default: strcat (buf, _("<unknown MeP copro type>")); break;
3263             }
3264
3265           if (e_flags & EF_MEP_LIBRARY)
3266             strcat (buf, ", Built for Library");
3267
3268           if (e_flags & EF_MEP_INDEX_MASK)
3269             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3270                      e_flags & EF_MEP_INDEX_MASK);
3271
3272           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3273             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3274                      e_flags & ~ EF_MEP_ALL_FLAGS);
3275           break;
3276
3277         case EM_PPC:
3278           if (e_flags & EF_PPC_EMB)
3279             strcat (buf, ", emb");
3280
3281           if (e_flags & EF_PPC_RELOCATABLE)
3282             strcat (buf, _(", relocatable"));
3283
3284           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3285             strcat (buf, _(", relocatable-lib"));
3286           break;
3287
3288         case EM_PPC64:
3289           if (e_flags & EF_PPC64_ABI)
3290             {
3291               char abi[] = ", abiv0";
3292
3293               abi[6] += e_flags & EF_PPC64_ABI;
3294               strcat (buf, abi);
3295             }
3296           break;
3297
3298         case EM_V800:
3299           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3300             strcat (buf, ", RH850 ABI");
3301
3302           if (e_flags & EF_V800_850E3)
3303             strcat (buf, ", V3 architecture");
3304
3305           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3306             strcat (buf, ", FPU not used");
3307
3308           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3309             strcat (buf, ", regmode: COMMON");
3310
3311           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3312             strcat (buf, ", r4 not used");
3313
3314           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3315             strcat (buf, ", r30 not used");
3316
3317           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3318             strcat (buf, ", r5 not used");
3319
3320           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3321             strcat (buf, ", r2 not used");
3322
3323           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3324             {
3325               switch (e_flags & - e_flags)
3326                 {
3327                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3328                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3329                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3330                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3331                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3332                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3333                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3334                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3335                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3336                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3337                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3338                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3339                 default: break;
3340                 }
3341             }
3342           break;
3343
3344         case EM_V850:
3345         case EM_CYGNUS_V850:
3346           switch (e_flags & EF_V850_ARCH)
3347             {
3348             case E_V850E3V5_ARCH:
3349               strcat (buf, ", v850e3v5");
3350               break;
3351             case E_V850E2V3_ARCH:
3352               strcat (buf, ", v850e2v3");
3353               break;
3354             case E_V850E2_ARCH:
3355               strcat (buf, ", v850e2");
3356               break;
3357             case E_V850E1_ARCH:
3358               strcat (buf, ", v850e1");
3359               break;
3360             case E_V850E_ARCH:
3361               strcat (buf, ", v850e");
3362               break;
3363             case E_V850_ARCH:
3364               strcat (buf, ", v850");
3365               break;
3366             default:
3367               strcat (buf, _(", unknown v850 architecture variant"));
3368               break;
3369             }
3370           break;
3371
3372         case EM_M32R:
3373         case EM_CYGNUS_M32R:
3374           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3375             strcat (buf, ", m32r");
3376           break;
3377
3378         case EM_MIPS:
3379         case EM_MIPS_RS3_LE:
3380           if (e_flags & EF_MIPS_NOREORDER)
3381             strcat (buf, ", noreorder");
3382
3383           if (e_flags & EF_MIPS_PIC)
3384             strcat (buf, ", pic");
3385
3386           if (e_flags & EF_MIPS_CPIC)
3387             strcat (buf, ", cpic");
3388
3389           if (e_flags & EF_MIPS_UCODE)
3390             strcat (buf, ", ugen_reserved");
3391
3392           if (e_flags & EF_MIPS_ABI2)
3393             strcat (buf, ", abi2");
3394
3395           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3396             strcat (buf, ", odk first");
3397
3398           if (e_flags & EF_MIPS_32BITMODE)
3399             strcat (buf, ", 32bitmode");
3400
3401           if (e_flags & EF_MIPS_NAN2008)
3402             strcat (buf, ", nan2008");
3403
3404           if (e_flags & EF_MIPS_FP64)
3405             strcat (buf, ", fp64");
3406
3407           switch ((e_flags & EF_MIPS_MACH))
3408             {
3409             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3410             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3411             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3412             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3413             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3414             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3415             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3416             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3417             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3418             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3419             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3420             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3421             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3422             case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3423             case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3424             case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3425             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3426             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3427             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3428             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3429             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3430             case 0:
3431             /* We simply ignore the field in this case to avoid confusion:
3432                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3433                extension.  */
3434               break;
3435             default: strcat (buf, _(", unknown CPU")); break;
3436             }
3437
3438           switch ((e_flags & EF_MIPS_ABI))
3439             {
3440             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3441             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3442             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3443             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3444             case 0:
3445             /* We simply ignore the field in this case to avoid confusion:
3446                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3447                This means it is likely to be an o32 file, but not for
3448                sure.  */
3449               break;
3450             default: strcat (buf, _(", unknown ABI")); break;
3451             }
3452
3453           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3454             strcat (buf, ", mdmx");
3455
3456           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3457             strcat (buf, ", mips16");
3458
3459           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3460             strcat (buf, ", micromips");
3461
3462           switch ((e_flags & EF_MIPS_ARCH))
3463             {
3464             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3465             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3466             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3467             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3468             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3469             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3470             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3471             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3472             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3473             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3474             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3475             default: strcat (buf, _(", unknown ISA")); break;
3476             }
3477           break;
3478
3479         case EM_NDS32:
3480           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3481           break;
3482
3483         case EM_NFP:
3484           switch (EF_NFP_MACH (e_flags))
3485             {
3486             case E_NFP_MACH_3200:
3487               strcat (buf, ", NFP-32xx");
3488               break;
3489             case E_NFP_MACH_6000:
3490               strcat (buf, ", NFP-6xxx");
3491               break;
3492             }
3493           break;
3494
3495         case EM_RISCV:
3496           if (e_flags & EF_RISCV_RVC)
3497             strcat (buf, ", RVC");
3498
3499           if (e_flags & EF_RISCV_RVE)
3500             strcat (buf, ", RVE");
3501
3502           switch (e_flags & EF_RISCV_FLOAT_ABI)
3503             {
3504             case EF_RISCV_FLOAT_ABI_SOFT:
3505               strcat (buf, ", soft-float ABI");
3506               break;
3507
3508             case EF_RISCV_FLOAT_ABI_SINGLE:
3509               strcat (buf, ", single-float ABI");
3510               break;
3511
3512             case EF_RISCV_FLOAT_ABI_DOUBLE:
3513               strcat (buf, ", double-float ABI");
3514               break;
3515
3516             case EF_RISCV_FLOAT_ABI_QUAD:
3517               strcat (buf, ", quad-float ABI");
3518               break;
3519             }
3520           break;
3521
3522         case EM_SH:
3523           switch ((e_flags & EF_SH_MACH_MASK))
3524             {
3525             case EF_SH1: strcat (buf, ", sh1"); break;
3526             case EF_SH2: strcat (buf, ", sh2"); break;
3527             case EF_SH3: strcat (buf, ", sh3"); break;
3528             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3529             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3530             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3531             case EF_SH3E: strcat (buf, ", sh3e"); break;
3532             case EF_SH4: strcat (buf, ", sh4"); break;
3533             case EF_SH5: strcat (buf, ", sh5"); break;
3534             case EF_SH2E: strcat (buf, ", sh2e"); break;
3535             case EF_SH4A: strcat (buf, ", sh4a"); break;
3536             case EF_SH2A: strcat (buf, ", sh2a"); break;
3537             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3538             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3539             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3540             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3541             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3542             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3543             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3544             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3545             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3546             default: strcat (buf, _(", unknown ISA")); break;
3547             }
3548
3549           if (e_flags & EF_SH_PIC)
3550             strcat (buf, ", pic");
3551
3552           if (e_flags & EF_SH_FDPIC)
3553             strcat (buf, ", fdpic");
3554           break;
3555
3556         case EM_OR1K:
3557           if (e_flags & EF_OR1K_NODELAY)
3558             strcat (buf, ", no delay");
3559           break;
3560
3561         case EM_SPARCV9:
3562           if (e_flags & EF_SPARC_32PLUS)
3563             strcat (buf, ", v8+");
3564
3565           if (e_flags & EF_SPARC_SUN_US1)
3566             strcat (buf, ", ultrasparcI");
3567
3568           if (e_flags & EF_SPARC_SUN_US3)
3569             strcat (buf, ", ultrasparcIII");
3570
3571           if (e_flags & EF_SPARC_HAL_R1)
3572             strcat (buf, ", halr1");
3573
3574           if (e_flags & EF_SPARC_LEDATA)
3575             strcat (buf, ", ledata");
3576
3577           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3578             strcat (buf, ", tso");
3579
3580           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3581             strcat (buf, ", pso");
3582
3583           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3584             strcat (buf, ", rmo");
3585           break;
3586
3587         case EM_PARISC:
3588           switch (e_flags & EF_PARISC_ARCH)
3589             {
3590             case EFA_PARISC_1_0:
3591               strcpy (buf, ", PA-RISC 1.0");
3592               break;
3593             case EFA_PARISC_1_1:
3594               strcpy (buf, ", PA-RISC 1.1");
3595               break;
3596             case EFA_PARISC_2_0:
3597               strcpy (buf, ", PA-RISC 2.0");
3598               break;
3599             default:
3600               break;
3601             }
3602           if (e_flags & EF_PARISC_TRAPNIL)
3603             strcat (buf, ", trapnil");
3604           if (e_flags & EF_PARISC_EXT)
3605             strcat (buf, ", ext");
3606           if (e_flags & EF_PARISC_LSB)
3607             strcat (buf, ", lsb");
3608           if (e_flags & EF_PARISC_WIDE)
3609             strcat (buf, ", wide");
3610           if (e_flags & EF_PARISC_NO_KABP)
3611             strcat (buf, ", no kabp");
3612           if (e_flags & EF_PARISC_LAZYSWAP)
3613             strcat (buf, ", lazyswap");
3614           break;
3615
3616         case EM_PJ:
3617         case EM_PJ_OLD:
3618           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3619             strcat (buf, ", new calling convention");
3620
3621           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3622             strcat (buf, ", gnu calling convention");
3623           break;
3624
3625         case EM_IA_64:
3626           if ((e_flags & EF_IA_64_ABI64))
3627             strcat (buf, ", 64-bit");
3628           else
3629             strcat (buf, ", 32-bit");
3630           if ((e_flags & EF_IA_64_REDUCEDFP))
3631             strcat (buf, ", reduced fp model");
3632           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3633             strcat (buf, ", no function descriptors, constant gp");
3634           else if ((e_flags & EF_IA_64_CONS_GP))
3635             strcat (buf, ", constant gp");
3636           if ((e_flags & EF_IA_64_ABSOLUTE))
3637             strcat (buf, ", absolute");
3638           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3639             {
3640               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3641                 strcat (buf, ", vms_linkages");
3642               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3643                 {
3644                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3645                   break;
3646                 case EF_IA_64_VMS_COMCOD_WARNING:
3647                   strcat (buf, ", warning");
3648                   break;
3649                 case EF_IA_64_VMS_COMCOD_ERROR:
3650                   strcat (buf, ", error");
3651                   break;
3652                 case EF_IA_64_VMS_COMCOD_ABORT:
3653                   strcat (buf, ", abort");
3654                   break;
3655                 default:
3656                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3657                         e_flags & EF_IA_64_VMS_COMCOD);
3658                   strcat (buf, ", <unknown>");
3659                 }
3660             }
3661           break;
3662
3663         case EM_VAX:
3664           if ((e_flags & EF_VAX_NONPIC))
3665             strcat (buf, ", non-PIC");
3666           if ((e_flags & EF_VAX_DFLOAT))
3667             strcat (buf, ", D-Float");
3668           if ((e_flags & EF_VAX_GFLOAT))
3669             strcat (buf, ", G-Float");
3670           break;
3671
3672         case EM_VISIUM:
3673           if (e_flags & EF_VISIUM_ARCH_MCM)
3674             strcat (buf, ", mcm");
3675           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3676             strcat (buf, ", mcm24");
3677           if (e_flags & EF_VISIUM_ARCH_GR6)
3678             strcat (buf, ", gr6");
3679           break;
3680
3681         case EM_RL78:
3682           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3683             {
3684             case E_FLAG_RL78_ANY_CPU: break;
3685             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3686             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3687             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3688             }
3689           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3690             strcat (buf, ", 64-bit doubles");
3691           break;
3692
3693         case EM_RX:
3694           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3695             strcat (buf, ", 64-bit doubles");
3696           if (e_flags & E_FLAG_RX_DSP)
3697             strcat (buf, ", dsp");
3698           if (e_flags & E_FLAG_RX_PID)
3699             strcat (buf, ", pid");
3700           if (e_flags & E_FLAG_RX_ABI)
3701             strcat (buf, ", RX ABI");
3702           if (e_flags & E_FLAG_RX_SINSNS_SET)
3703             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3704                     ? ", uses String instructions" : ", bans String instructions");
3705           if (e_flags & E_FLAG_RX_V2)
3706             strcat (buf, ", V2");
3707           if (e_flags & E_FLAG_RX_V3)
3708             strcat (buf, ", V3");
3709           break;
3710
3711         case EM_S390:
3712           if (e_flags & EF_S390_HIGH_GPRS)
3713             strcat (buf, ", highgprs");
3714           break;
3715
3716         case EM_TI_C6000:
3717           if ((e_flags & EF_C6000_REL))
3718             strcat (buf, ", relocatable module");
3719           break;
3720
3721         case EM_MSP430:
3722           strcat (buf, _(": architecture variant: "));
3723           switch (e_flags & EF_MSP430_MACH)
3724             {
3725             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3726             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3727             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3728             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3729             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3730             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3731             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3732             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3733             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3734             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3735             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3736             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3737             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3738             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3739             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3740             default:
3741               strcat (buf, _(": unknown")); break;
3742             }
3743
3744           if (e_flags & ~ EF_MSP430_MACH)
3745             strcat (buf, _(": unknown extra flag bits also present"));
3746         }
3747     }
3748
3749   return buf;
3750 }
3751
3752 static const char *
3753 get_osabi_name (Filedata * filedata, unsigned int osabi)
3754 {
3755   static char buff[32];
3756
3757   switch (osabi)
3758     {
3759     case ELFOSABI_NONE:         return "UNIX - System V";
3760     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3761     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3762     case ELFOSABI_GNU:          return "UNIX - GNU";
3763     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3764     case ELFOSABI_AIX:          return "UNIX - AIX";
3765     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3766     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3767     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3768     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3769     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3770     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3771     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3772     case ELFOSABI_AROS:         return "AROS";
3773     case ELFOSABI_FENIXOS:      return "FenixOS";
3774     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3775     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3776     default:
3777       if (osabi >= 64)
3778         switch (filedata->file_header.e_machine)
3779           {
3780           case EM_ARM:
3781             switch (osabi)
3782               {
3783               case ELFOSABI_ARM:        return "ARM";
3784               case ELFOSABI_ARM_FDPIC:  return "ARM FDPIC";
3785               default:
3786                 break;
3787               }
3788             break;
3789
3790           case EM_MSP430:
3791           case EM_MSP430_OLD:
3792           case EM_VISIUM:
3793             switch (osabi)
3794               {
3795               case ELFOSABI_STANDALONE: return _("Standalone App");
3796               default:
3797                 break;
3798               }
3799             break;
3800
3801           case EM_TI_C6000:
3802             switch (osabi)
3803               {
3804               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3805               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3806               default:
3807                 break;
3808               }
3809             break;
3810
3811           default:
3812             break;
3813           }
3814       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3815       return buff;
3816     }
3817 }
3818
3819 static const char *
3820 get_aarch64_segment_type (unsigned long type)
3821 {
3822   switch (type)
3823     {
3824     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3825     default:                  return NULL;
3826     }
3827 }
3828
3829 static const char *
3830 get_arm_segment_type (unsigned long type)
3831 {
3832   switch (type)
3833     {
3834     case PT_ARM_EXIDX: return "EXIDX";
3835     default:           return NULL;
3836     }
3837 }
3838
3839 static const char *
3840 get_s390_segment_type (unsigned long type)
3841 {
3842   switch (type)
3843     {
3844     case PT_S390_PGSTE: return "S390_PGSTE";
3845     default:            return NULL;
3846     }
3847 }
3848
3849 static const char *
3850 get_mips_segment_type (unsigned long type)
3851 {
3852   switch (type)
3853     {
3854     case PT_MIPS_REGINFO:   return "REGINFO";
3855     case PT_MIPS_RTPROC:    return "RTPROC";
3856     case PT_MIPS_OPTIONS:   return "OPTIONS";
3857     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3858     default:                return NULL;
3859     }
3860 }
3861
3862 static const char *
3863 get_parisc_segment_type (unsigned long type)
3864 {
3865   switch (type)
3866     {
3867     case PT_HP_TLS:             return "HP_TLS";
3868     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3869     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3870     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3871     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3872     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3873     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3874     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3875     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3876     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3877     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3878     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3879     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3880     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3881     case PT_HP_STACK:           return "HP_STACK";
3882     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3883     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3884     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3885     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3886     default:                    return NULL;
3887     }
3888 }
3889
3890 static const char *
3891 get_ia64_segment_type (unsigned long type)
3892 {
3893   switch (type)
3894     {
3895     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3896     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3897     case PT_HP_TLS:             return "HP_TLS";
3898     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3899     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3900     case PT_IA_64_HP_STACK:     return "HP_STACK";
3901     default:                    return NULL;
3902     }
3903 }
3904
3905 static const char *
3906 get_tic6x_segment_type (unsigned long type)
3907 {
3908   switch (type)
3909     {
3910     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3911     default:               return NULL;
3912     }
3913 }
3914
3915 static const char *
3916 get_solaris_segment_type (unsigned long type)
3917 {
3918   switch (type)
3919     {
3920     case 0x6464e550: return "PT_SUNW_UNWIND";
3921     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3922     case 0x6ffffff7: return "PT_LOSUNW";
3923     case 0x6ffffffa: return "PT_SUNWBSS";
3924     case 0x6ffffffb: return "PT_SUNWSTACK";
3925     case 0x6ffffffc: return "PT_SUNWDTRACE";
3926     case 0x6ffffffd: return "PT_SUNWCAP";
3927     case 0x6fffffff: return "PT_HISUNW";
3928     default:         return NULL;
3929     }
3930 }
3931
3932 static const char *
3933 get_segment_type (Filedata * filedata, unsigned long p_type)
3934 {
3935   static char buff[32];
3936
3937   switch (p_type)
3938     {
3939     case PT_NULL:       return "NULL";
3940     case PT_LOAD:       return "LOAD";
3941     case PT_DYNAMIC:    return "DYNAMIC";
3942     case PT_INTERP:     return "INTERP";
3943     case PT_NOTE:       return "NOTE";
3944     case PT_SHLIB:      return "SHLIB";
3945     case PT_PHDR:       return "PHDR";
3946     case PT_TLS:        return "TLS";
3947     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3948     case PT_GNU_STACK:  return "GNU_STACK";
3949     case PT_GNU_RELRO:  return "GNU_RELRO";
3950     case PT_GNU_PROPERTY: return "GNU_PROPERTY";
3951
3952     default:
3953       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3954         {
3955           sprintf (buff, "GNU_MBIND+%#lx",
3956                    p_type - PT_GNU_MBIND_LO);
3957         }
3958       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3959         {
3960           const char * result;
3961
3962           switch (filedata->file_header.e_machine)
3963             {
3964             case EM_AARCH64:
3965               result = get_aarch64_segment_type (p_type);
3966               break;
3967             case EM_ARM:
3968               result = get_arm_segment_type (p_type);
3969               break;
3970             case EM_MIPS:
3971             case EM_MIPS_RS3_LE:
3972               result = get_mips_segment_type (p_type);
3973               break;
3974             case EM_PARISC:
3975               result = get_parisc_segment_type (p_type);
3976               break;
3977             case EM_IA_64:
3978               result = get_ia64_segment_type (p_type);
3979               break;
3980             case EM_TI_C6000:
3981               result = get_tic6x_segment_type (p_type);
3982               break;
3983             case EM_S390:
3984             case EM_S390_OLD:
3985               result = get_s390_segment_type (p_type);
3986               break;
3987             default:
3988               result = NULL;
3989               break;
3990             }
3991
3992           if (result != NULL)
3993             return result;
3994
3995           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3996         }
3997       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3998         {
3999           const char * result;
4000
4001           switch (filedata->file_header.e_machine)
4002             {
4003             case EM_PARISC:
4004               result = get_parisc_segment_type (p_type);
4005               break;
4006             case EM_IA_64:
4007               result = get_ia64_segment_type (p_type);
4008               break;
4009             default:
4010               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4011                 result = get_solaris_segment_type (p_type);
4012               else
4013                 result = NULL;
4014               break;
4015             }
4016
4017           if (result != NULL)
4018             return result;
4019
4020           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4021         }
4022       else
4023         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4024
4025       return buff;
4026     }
4027 }
4028
4029 static const char *
4030 get_arc_section_type_name (unsigned int sh_type)
4031 {
4032   switch (sh_type)
4033     {
4034     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
4035     default:
4036       break;
4037     }
4038   return NULL;
4039 }
4040
4041 static const char *
4042 get_mips_section_type_name (unsigned int sh_type)
4043 {
4044   switch (sh_type)
4045     {
4046     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
4047     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
4048     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
4049     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
4050     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
4051     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
4052     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
4053     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
4054     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
4055     case SHT_MIPS_RELD:          return "MIPS_RELD";
4056     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
4057     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
4058     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
4059     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
4060     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
4061     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
4062     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
4063     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
4064     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
4065     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4066     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4067     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4068     case SHT_MIPS_LINE:          return "MIPS_LINE";
4069     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4070     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4071     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4072     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4073     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4074     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4075     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4076     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4077     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4078     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4079     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4080     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4081     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4082     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4083     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4084     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4085     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4086     default:
4087       break;
4088     }
4089   return NULL;
4090 }
4091
4092 static const char *
4093 get_parisc_section_type_name (unsigned int sh_type)
4094 {
4095   switch (sh_type)
4096     {
4097     case SHT_PARISC_EXT:        return "PARISC_EXT";
4098     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4099     case SHT_PARISC_DOC:        return "PARISC_DOC";
4100     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4101     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4102     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4103     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4104     default:                    return NULL;
4105     }
4106 }
4107
4108 static const char *
4109 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4110 {
4111   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4112   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4113     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4114
4115   switch (sh_type)
4116     {
4117     case SHT_IA_64_EXT:                return "IA_64_EXT";
4118     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4119     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4120     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4121     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4122     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4123     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4124     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4125     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4126     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4127     default:
4128       break;
4129     }
4130   return NULL;
4131 }
4132
4133 static const char *
4134 get_x86_64_section_type_name (unsigned int sh_type)
4135 {
4136   switch (sh_type)
4137     {
4138     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4139     default:                    return NULL;
4140     }
4141 }
4142
4143 static const char *
4144 get_aarch64_section_type_name (unsigned int sh_type)
4145 {
4146   switch (sh_type)
4147     {
4148     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4149     default:                     return NULL;
4150     }
4151 }
4152
4153 static const char *
4154 get_arm_section_type_name (unsigned int sh_type)
4155 {
4156   switch (sh_type)
4157     {
4158     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4159     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4160     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4161     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4162     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4163     default:                      return NULL;
4164     }
4165 }
4166
4167 static const char *
4168 get_tic6x_section_type_name (unsigned int sh_type)
4169 {
4170   switch (sh_type)
4171     {
4172     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4173     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4174     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4175     case SHT_TI_ICODE:          return "TI_ICODE";
4176     case SHT_TI_XREF:           return "TI_XREF";
4177     case SHT_TI_HANDLER:        return "TI_HANDLER";
4178     case SHT_TI_INITINFO:       return "TI_INITINFO";
4179     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4180     default:                    return NULL;
4181     }
4182 }
4183
4184 static const char *
4185 get_msp430x_section_type_name (unsigned int sh_type)
4186 {
4187   switch (sh_type)
4188     {
4189     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4190     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4191     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4192     default:                      return NULL;
4193     }
4194 }
4195
4196 static const char *
4197 get_nfp_section_type_name (unsigned int sh_type)
4198 {
4199   switch (sh_type)
4200     {
4201     case SHT_NFP_MECONFIG:      return "NFP_MECONFIG";
4202     case SHT_NFP_INITREG:       return "NFP_INITREG";
4203     case SHT_NFP_UDEBUG:        return "NFP_UDEBUG";
4204     default:                    return NULL;
4205     }
4206 }
4207
4208 static const char *
4209 get_v850_section_type_name (unsigned int sh_type)
4210 {
4211   switch (sh_type)
4212     {
4213     case SHT_V850_SCOMMON:  return "V850 Small Common";
4214     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4215     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4216     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4217     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4218     default:                return NULL;
4219     }
4220 }
4221
4222 static const char *
4223 get_riscv_section_type_name (unsigned int sh_type)
4224 {
4225   switch (sh_type)
4226     {
4227     case SHT_RISCV_ATTRIBUTES:  return "RISCV_ATTRIBUTES";
4228     default: return NULL;
4229     }
4230 }
4231
4232 static const char *
4233 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4234 {
4235   static char buff[32];
4236   const char * result;
4237
4238   switch (sh_type)
4239     {
4240     case SHT_NULL:              return "NULL";
4241     case SHT_PROGBITS:          return "PROGBITS";
4242     case SHT_SYMTAB:            return "SYMTAB";
4243     case SHT_STRTAB:            return "STRTAB";
4244     case SHT_RELA:              return "RELA";
4245     case SHT_HASH:              return "HASH";
4246     case SHT_DYNAMIC:           return "DYNAMIC";
4247     case SHT_NOTE:              return "NOTE";
4248     case SHT_NOBITS:            return "NOBITS";
4249     case SHT_REL:               return "REL";
4250     case SHT_SHLIB:             return "SHLIB";
4251     case SHT_DYNSYM:            return "DYNSYM";
4252     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4253     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4254     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4255     case SHT_GNU_HASH:          return "GNU_HASH";
4256     case SHT_GROUP:             return "GROUP";
4257     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICES";
4258     case SHT_GNU_verdef:        return "VERDEF";
4259     case SHT_GNU_verneed:       return "VERNEED";
4260     case SHT_GNU_versym:        return "VERSYM";
4261     case 0x6ffffff0:            return "VERSYM";
4262     case 0x6ffffffc:            return "VERDEF";
4263     case 0x7ffffffd:            return "AUXILIARY";
4264     case 0x7fffffff:            return "FILTER";
4265     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4266
4267     default:
4268       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4269         {
4270           switch (filedata->file_header.e_machine)
4271             {
4272             case EM_ARC:
4273             case EM_ARC_COMPACT:
4274             case EM_ARC_COMPACT2:
4275               result = get_arc_section_type_name (sh_type);
4276               break;
4277             case EM_MIPS:
4278             case EM_MIPS_RS3_LE:
4279               result = get_mips_section_type_name (sh_type);
4280               break;
4281             case EM_PARISC:
4282               result = get_parisc_section_type_name (sh_type);
4283               break;
4284             case EM_IA_64:
4285               result = get_ia64_section_type_name (filedata, sh_type);
4286               break;
4287             case EM_X86_64:
4288             case EM_L1OM:
4289             case EM_K1OM:
4290               result = get_x86_64_section_type_name (sh_type);
4291               break;
4292             case EM_AARCH64:
4293               result = get_aarch64_section_type_name (sh_type);
4294               break;
4295             case EM_ARM:
4296               result = get_arm_section_type_name (sh_type);
4297               break;
4298             case EM_TI_C6000:
4299               result = get_tic6x_section_type_name (sh_type);
4300               break;
4301             case EM_MSP430:
4302               result = get_msp430x_section_type_name (sh_type);
4303               break;
4304             case EM_NFP:
4305               result = get_nfp_section_type_name (sh_type);
4306               break;
4307             case EM_V800:
4308             case EM_V850:
4309             case EM_CYGNUS_V850:
4310               result = get_v850_section_type_name (sh_type);
4311               break;
4312             case EM_RISCV:
4313               result = get_riscv_section_type_name (sh_type);
4314               break;
4315             default:
4316               result = NULL;
4317               break;
4318             }
4319
4320           if (result != NULL)
4321             return result;
4322
4323           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4324         }
4325       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4326         {
4327           switch (filedata->file_header.e_machine)
4328             {
4329             case EM_IA_64:
4330               result = get_ia64_section_type_name (filedata, sh_type);
4331               break;
4332             default:
4333               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4334                 result = get_solaris_section_type (sh_type);
4335               else
4336                 {
4337                   switch (sh_type)
4338                     {
4339                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4340                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4341                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4342                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4343                     default:
4344                       result = NULL;
4345                       break;
4346                     }
4347                 }
4348               break;
4349             }
4350
4351           if (result != NULL)
4352             return result;
4353
4354           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4355         }
4356       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4357         {
4358           switch (filedata->file_header.e_machine)
4359             {
4360             case EM_V800:
4361             case EM_V850:
4362             case EM_CYGNUS_V850:
4363               result = get_v850_section_type_name (sh_type);
4364               break;
4365             default:
4366               result = NULL;
4367               break;
4368             }
4369
4370           if (result != NULL)
4371             return result;
4372
4373           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4374         }
4375       else
4376         /* This message is probably going to be displayed in a 15
4377            character wide field, so put the hex value first.  */
4378         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4379
4380       return buff;
4381     }
4382 }
4383
4384 #define OPTION_DEBUG_DUMP       512
4385 #define OPTION_DYN_SYMS         513
4386 #define OPTION_DWARF_DEPTH      514
4387 #define OPTION_DWARF_START      515
4388 #define OPTION_DWARF_CHECK      516
4389
4390 static struct option options[] =
4391 {
4392   {"all",              no_argument, 0, 'a'},
4393   {"file-header",      no_argument, 0, 'h'},
4394   {"program-headers",  no_argument, 0, 'l'},
4395   {"headers",          no_argument, 0, 'e'},
4396   {"histogram",        no_argument, 0, 'I'},
4397   {"segments",         no_argument, 0, 'l'},
4398   {"sections",         no_argument, 0, 'S'},
4399   {"section-headers",  no_argument, 0, 'S'},
4400   {"section-groups",   no_argument, 0, 'g'},
4401   {"section-details",  no_argument, 0, 't'},
4402   {"full-section-name",no_argument, 0, 'N'},
4403   {"symbols",          no_argument, 0, 's'},
4404   {"syms",             no_argument, 0, 's'},
4405   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4406   {"relocs",           no_argument, 0, 'r'},
4407   {"notes",            no_argument, 0, 'n'},
4408   {"dynamic",          no_argument, 0, 'd'},
4409   {"arch-specific",    no_argument, 0, 'A'},
4410   {"version-info",     no_argument, 0, 'V'},
4411   {"use-dynamic",      no_argument, 0, 'D'},
4412   {"unwind",           no_argument, 0, 'u'},
4413   {"archive-index",    no_argument, 0, 'c'},
4414   {"hex-dump",         required_argument, 0, 'x'},
4415   {"relocated-dump",   required_argument, 0, 'R'},
4416   {"string-dump",      required_argument, 0, 'p'},
4417   {"decompress",       no_argument, 0, 'z'},
4418 #ifdef SUPPORT_DISASSEMBLY
4419   {"instruction-dump", required_argument, 0, 'i'},
4420 #endif
4421   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4422
4423   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4424   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4425   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4426
4427   {"version",          no_argument, 0, 'v'},
4428   {"wide",             no_argument, 0, 'W'},
4429   {"help",             no_argument, 0, 'H'},
4430   {0,                  no_argument, 0, 0}
4431 };
4432
4433 static void
4434 usage (FILE * stream)
4435 {
4436   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4437   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4438   fprintf (stream, _(" Options are:\n\
4439   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4440   -h --file-header       Display the ELF file header\n\
4441   -l --program-headers   Display the program headers\n\
4442      --segments          An alias for --program-headers\n\
4443   -S --section-headers   Display the sections' header\n\
4444      --sections          An alias for --section-headers\n\
4445   -g --section-groups    Display the section groups\n\
4446   -t --section-details   Display the section details\n\
4447   -e --headers           Equivalent to: -h -l -S\n\
4448   -s --syms              Display the symbol table\n\
4449      --symbols           An alias for --syms\n\
4450   --dyn-syms             Display the dynamic symbol table\n\
4451   -n --notes             Display the core notes (if present)\n\
4452   -r --relocs            Display the relocations (if present)\n\
4453   -u --unwind            Display the unwind info (if present)\n\
4454   -d --dynamic           Display the dynamic section (if present)\n\
4455   -V --version-info      Display the version sections (if present)\n\
4456   -A --arch-specific     Display architecture specific information (if any)\n\
4457   -c --archive-index     Display the symbol/file index in an archive\n\
4458   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4459   -x --hex-dump=<number|name>\n\
4460                          Dump the contents of section <number|name> as bytes\n\
4461   -p --string-dump=<number|name>\n\
4462                          Dump the contents of section <number|name> as strings\n\
4463   -R --relocated-dump=<number|name>\n\
4464                          Dump the contents of section <number|name> as relocated bytes\n\
4465   -z --decompress        Decompress section before dumping it\n\
4466   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4467   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4468                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4469                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4470                =addr,=cu_index,=links,=follow-links]\n\
4471                          Display the contents of DWARF debug sections\n"));
4472   fprintf (stream, _("\
4473   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4474   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4475                          or deeper\n"));
4476 #ifdef SUPPORT_DISASSEMBLY
4477   fprintf (stream, _("\
4478   -i --instruction-dump=<number|name>\n\
4479                          Disassemble the contents of section <number|name>\n"));
4480 #endif
4481   fprintf (stream, _("\
4482   -I --histogram         Display histogram of bucket list lengths\n\
4483   -W --wide              Allow output width to exceed 80 characters\n\
4484   @<file>                Read options from <file>\n\
4485   -H --help              Display this information\n\
4486   -v --version           Display the version number of readelf\n"));
4487
4488   if (REPORT_BUGS_TO[0] && stream == stdout)
4489     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4490
4491   exit (stream == stdout ? 0 : 1);
4492 }
4493
4494 /* Record the fact that the user wants the contents of section number
4495    SECTION to be displayed using the method(s) encoded as flags bits
4496    in TYPE.  Note, TYPE can be zero if we are creating the array for
4497    the first time.  */
4498
4499 static void
4500 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4501 {
4502   if (section >= filedata->num_dump_sects)
4503     {
4504       dump_type * new_dump_sects;
4505
4506       new_dump_sects = (dump_type *) calloc (section + 1,
4507                                              sizeof (* new_dump_sects));
4508
4509       if (new_dump_sects == NULL)
4510         error (_("Out of memory allocating dump request table.\n"));
4511       else
4512         {
4513           if (filedata->dump_sects)
4514             {
4515               /* Copy current flag settings.  */
4516               memcpy (new_dump_sects, filedata->dump_sects,
4517                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4518
4519               free (filedata->dump_sects);
4520             }
4521
4522           filedata->dump_sects = new_dump_sects;
4523           filedata->num_dump_sects = section + 1;
4524         }
4525     }
4526
4527   if (filedata->dump_sects)
4528     filedata->dump_sects[section] |= type;
4529 }
4530
4531 /* Request a dump by section name.  */
4532
4533 static void
4534 request_dump_byname (const char * section, dump_type type)
4535 {
4536   struct dump_list_entry * new_request;
4537
4538   new_request = (struct dump_list_entry *)
4539       malloc (sizeof (struct dump_list_entry));
4540   if (!new_request)
4541     error (_("Out of memory allocating dump request table.\n"));
4542
4543   new_request->name = strdup (section);
4544   if (!new_request->name)
4545     error (_("Out of memory allocating dump request table.\n"));
4546
4547   new_request->type = type;
4548
4549   new_request->next = dump_sects_byname;
4550   dump_sects_byname = new_request;
4551 }
4552
4553 static inline void
4554 request_dump (Filedata * filedata, dump_type type)
4555 {
4556   int section;
4557   char * cp;
4558
4559   do_dump++;
4560   section = strtoul (optarg, & cp, 0);
4561
4562   if (! *cp && section >= 0)
4563     request_dump_bynumber (filedata, section, type);
4564   else
4565     request_dump_byname (optarg, type);
4566 }
4567
4568 static void
4569 parse_args (Filedata * filedata, int argc, char ** argv)
4570 {
4571   int c;
4572
4573   if (argc < 2)
4574     usage (stderr);
4575
4576   while ((c = getopt_long
4577           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4578     {
4579       switch (c)
4580         {
4581         case 0:
4582           /* Long options.  */
4583           break;
4584         case 'H':
4585           usage (stdout);
4586           break;
4587
4588         case 'a':
4589           do_syms = TRUE;
4590           do_reloc = TRUE;
4591           do_unwind = TRUE;
4592           do_dynamic = TRUE;
4593           do_header = TRUE;
4594           do_sections = TRUE;
4595           do_section_groups = TRUE;
4596           do_segments = TRUE;
4597           do_version = TRUE;
4598           do_histogram = TRUE;
4599           do_arch = TRUE;
4600           do_notes = TRUE;
4601           break;
4602         case 'g':
4603           do_section_groups = TRUE;
4604           break;
4605         case 't':
4606         case 'N':
4607           do_sections = TRUE;
4608           do_section_details = TRUE;
4609           break;
4610         case 'e':
4611           do_header = TRUE;
4612           do_sections = TRUE;
4613           do_segments = TRUE;
4614           break;
4615         case 'A':
4616           do_arch = TRUE;
4617           break;
4618         case 'D':
4619           do_using_dynamic = TRUE;
4620           break;
4621         case 'r':
4622           do_reloc = TRUE;
4623           break;
4624         case 'u':
4625           do_unwind = TRUE;
4626           break;
4627         case 'h':
4628           do_header = TRUE;
4629           break;
4630         case 'l':
4631           do_segments = TRUE;
4632           break;
4633         case 's':
4634           do_syms = TRUE;
4635           break;
4636         case 'S':
4637           do_sections = TRUE;
4638           break;
4639         case 'd':
4640           do_dynamic = TRUE;
4641           break;
4642         case 'I':
4643           do_histogram = TRUE;
4644           break;
4645         case 'n':
4646           do_notes = TRUE;
4647           break;
4648         case 'c':
4649           do_archive_index = TRUE;
4650           break;
4651         case 'x':
4652           request_dump (filedata, HEX_DUMP);
4653           break;
4654         case 'p':
4655           request_dump (filedata, STRING_DUMP);
4656           break;
4657         case 'R':
4658           request_dump (filedata, RELOC_DUMP);
4659           break;
4660         case 'z':
4661           decompress_dumps = TRUE;
4662           break;
4663         case 'w':
4664           do_dump = TRUE;
4665           if (optarg == 0)
4666             {
4667               do_debugging = TRUE;
4668               dwarf_select_sections_all ();
4669             }
4670           else
4671             {
4672               do_debugging = FALSE;
4673               dwarf_select_sections_by_letters (optarg);
4674             }
4675           break;
4676         case OPTION_DEBUG_DUMP:
4677           do_dump = TRUE;
4678           if (optarg == 0)
4679             do_debugging = TRUE;
4680           else
4681             {
4682               do_debugging = FALSE;
4683               dwarf_select_sections_by_names (optarg);
4684             }
4685           break;
4686         case OPTION_DWARF_DEPTH:
4687           {
4688             char *cp;
4689
4690             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4691           }
4692           break;
4693         case OPTION_DWARF_START:
4694           {
4695             char *cp;
4696
4697             dwarf_start_die = strtoul (optarg, & cp, 0);
4698           }
4699           break;
4700         case OPTION_DWARF_CHECK:
4701           dwarf_check = TRUE;
4702           break;
4703         case OPTION_DYN_SYMS:
4704           do_dyn_syms = TRUE;
4705           break;
4706 #ifdef SUPPORT_DISASSEMBLY
4707         case 'i':
4708           request_dump (filedata, DISASS_DUMP);
4709           break;
4710 #endif
4711         case 'v':
4712           print_version (program_name);
4713           break;
4714         case 'V':
4715           do_version = TRUE;
4716           break;
4717         case 'W':
4718           do_wide = TRUE;
4719           break;
4720         default:
4721           /* xgettext:c-format */
4722           error (_("Invalid option '-%c'\n"), c);
4723           /* Fall through.  */
4724         case '?':
4725           usage (stderr);
4726         }
4727     }
4728
4729   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4730       && !do_segments && !do_header && !do_dump && !do_version
4731       && !do_histogram && !do_debugging && !do_arch && !do_notes
4732       && !do_section_groups && !do_archive_index
4733       && !do_dyn_syms)
4734     usage (stderr);
4735 }
4736
4737 static const char *
4738 get_elf_class (unsigned int elf_class)
4739 {
4740   static char buff[32];
4741
4742   switch (elf_class)
4743     {
4744     case ELFCLASSNONE: return _("none");
4745     case ELFCLASS32:   return "ELF32";
4746     case ELFCLASS64:   return "ELF64";
4747     default:
4748       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4749       return buff;
4750     }
4751 }
4752
4753 static const char *
4754 get_data_encoding (unsigned int encoding)
4755 {
4756   static char buff[32];
4757
4758   switch (encoding)
4759     {
4760     case ELFDATANONE: return _("none");
4761     case ELFDATA2LSB: return _("2's complement, little endian");
4762     case ELFDATA2MSB: return _("2's complement, big endian");
4763     default:
4764       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4765       return buff;
4766     }
4767 }
4768
4769 /* Decode the data held in 'filedata->file_header'.  */
4770
4771 static bfd_boolean
4772 process_file_header (Filedata * filedata)
4773 {
4774   Elf_Internal_Ehdr * header = & filedata->file_header;
4775
4776   if (   header->e_ident[EI_MAG0] != ELFMAG0
4777       || header->e_ident[EI_MAG1] != ELFMAG1
4778       || header->e_ident[EI_MAG2] != ELFMAG2
4779       || header->e_ident[EI_MAG3] != ELFMAG3)
4780     {
4781       error
4782         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4783       return FALSE;
4784     }
4785
4786   init_dwarf_regnames (header->e_machine);
4787
4788   if (do_header)
4789     {
4790       unsigned i;
4791
4792       printf (_("ELF Header:\n"));
4793       printf (_("  Magic:   "));
4794       for (i = 0; i < EI_NIDENT; i++)
4795         printf ("%2.2x ", header->e_ident[i]);
4796       printf ("\n");
4797       printf (_("  Class:                             %s\n"),
4798               get_elf_class (header->e_ident[EI_CLASS]));
4799       printf (_("  Data:                              %s\n"),
4800               get_data_encoding (header->e_ident[EI_DATA]));
4801       printf (_("  Version:                           %d%s\n"),
4802               header->e_ident[EI_VERSION],
4803               (header->e_ident[EI_VERSION] == EV_CURRENT
4804                ? _(" (current)")
4805                : (header->e_ident[EI_VERSION] != EV_NONE
4806                   ? _(" <unknown>")
4807                   : "")));
4808       printf (_("  OS/ABI:                            %s\n"),
4809               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4810       printf (_("  ABI Version:                       %d\n"),
4811               header->e_ident[EI_ABIVERSION]);
4812       printf (_("  Type:                              %s\n"),
4813               get_file_type (header->e_type));
4814       printf (_("  Machine:                           %s\n"),
4815               get_machine_name (header->e_machine));
4816       printf (_("  Version:                           0x%lx\n"),
4817               header->e_version);
4818
4819       printf (_("  Entry point address:               "));
4820       print_vma (header->e_entry, PREFIX_HEX);
4821       printf (_("\n  Start of program headers:          "));
4822       print_vma (header->e_phoff, DEC);
4823       printf (_(" (bytes into file)\n  Start of section headers:          "));
4824       print_vma (header->e_shoff, DEC);
4825       printf (_(" (bytes into file)\n"));
4826
4827       printf (_("  Flags:                             0x%lx%s\n"),
4828               header->e_flags,
4829               get_machine_flags (filedata, header->e_flags, header->e_machine));
4830       printf (_("  Size of this header:               %u (bytes)\n"),
4831               header->e_ehsize);
4832       printf (_("  Size of program headers:           %u (bytes)\n"),
4833               header->e_phentsize);
4834       printf (_("  Number of program headers:         %u"),
4835               header->e_phnum);
4836       if (filedata->section_headers != NULL
4837           && header->e_phnum == PN_XNUM
4838           && filedata->section_headers[0].sh_info != 0)
4839         {
4840           header->e_phnum = filedata->section_headers[0].sh_info;
4841           printf (" (%u)", header->e_phnum);
4842         }
4843       putc ('\n', stdout);
4844       printf (_("  Size of section headers:           %u (bytes)\n"),
4845               header->e_shentsize);
4846       printf (_("  Number of section headers:         %u"),
4847               header->e_shnum);
4848       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4849         {
4850           header->e_shnum = filedata->section_headers[0].sh_size;
4851           printf (" (%u)", header->e_shnum);
4852         }
4853       putc ('\n', stdout);
4854       printf (_("  Section header string table index: %u"),
4855               header->e_shstrndx);
4856       if (filedata->section_headers != NULL
4857           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4858         {
4859           header->e_shstrndx = filedata->section_headers[0].sh_link;
4860           printf (" (%u)", header->e_shstrndx);
4861         }
4862       if (header->e_shstrndx != SHN_UNDEF
4863           && header->e_shstrndx >= header->e_shnum)
4864         {
4865           header->e_shstrndx = SHN_UNDEF;
4866           printf (_(" <corrupt: out of range>"));
4867         }
4868       putc ('\n', stdout);
4869     }
4870
4871   if (filedata->section_headers != NULL)
4872     {
4873       if (header->e_phnum == PN_XNUM
4874           && filedata->section_headers[0].sh_info != 0)
4875         header->e_phnum = filedata->section_headers[0].sh_info;
4876       if (header->e_shnum == SHN_UNDEF)
4877         header->e_shnum = filedata->section_headers[0].sh_size;
4878       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4879         header->e_shstrndx = filedata->section_headers[0].sh_link;
4880       if (header->e_shstrndx >= header->e_shnum)
4881         header->e_shstrndx = SHN_UNDEF;
4882       free (filedata->section_headers);
4883       filedata->section_headers = NULL;
4884     }
4885
4886   return TRUE;
4887 }
4888
4889 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4890    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4891
4892 static bfd_boolean
4893 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4894 {
4895   Elf32_External_Phdr * phdrs;
4896   Elf32_External_Phdr * external;
4897   Elf_Internal_Phdr *   internal;
4898   unsigned int i;
4899   unsigned int size = filedata->file_header.e_phentsize;
4900   unsigned int num  = filedata->file_header.e_phnum;
4901
4902   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4903   if (size == 0 || num == 0)
4904     return FALSE;
4905   if (size < sizeof * phdrs)
4906     {
4907       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4908       return FALSE;
4909     }
4910   if (size > sizeof * phdrs)
4911     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4912
4913   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4914                                             size, num, _("program headers"));
4915   if (phdrs == NULL)
4916     return FALSE;
4917
4918   for (i = 0, internal = pheaders, external = phdrs;
4919        i < filedata->file_header.e_phnum;
4920        i++, internal++, external++)
4921     {
4922       internal->p_type   = BYTE_GET (external->p_type);
4923       internal->p_offset = BYTE_GET (external->p_offset);
4924       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4925       internal->p_paddr  = BYTE_GET (external->p_paddr);
4926       internal->p_filesz = BYTE_GET (external->p_filesz);
4927       internal->p_memsz  = BYTE_GET (external->p_memsz);
4928       internal->p_flags  = BYTE_GET (external->p_flags);
4929       internal->p_align  = BYTE_GET (external->p_align);
4930     }
4931
4932   free (phdrs);
4933   return TRUE;
4934 }
4935
4936 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4937    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4938
4939 static bfd_boolean
4940 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4941 {
4942   Elf64_External_Phdr * phdrs;
4943   Elf64_External_Phdr * external;
4944   Elf_Internal_Phdr *   internal;
4945   unsigned int i;
4946   unsigned int size = filedata->file_header.e_phentsize;
4947   unsigned int num  = filedata->file_header.e_phnum;
4948
4949   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4950   if (size == 0 || num == 0)
4951     return FALSE;
4952   if (size < sizeof * phdrs)
4953     {
4954       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4955       return FALSE;
4956     }
4957   if (size > sizeof * phdrs)
4958     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4959
4960   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4961                                             size, num, _("program headers"));
4962   if (!phdrs)
4963     return FALSE;
4964
4965   for (i = 0, internal = pheaders, external = phdrs;
4966        i < filedata->file_header.e_phnum;
4967        i++, internal++, external++)
4968     {
4969       internal->p_type   = BYTE_GET (external->p_type);
4970       internal->p_flags  = BYTE_GET (external->p_flags);
4971       internal->p_offset = BYTE_GET (external->p_offset);
4972       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4973       internal->p_paddr  = BYTE_GET (external->p_paddr);
4974       internal->p_filesz = BYTE_GET (external->p_filesz);
4975       internal->p_memsz  = BYTE_GET (external->p_memsz);
4976       internal->p_align  = BYTE_GET (external->p_align);
4977     }
4978
4979   free (phdrs);
4980   return TRUE;
4981 }
4982
4983 /* Returns TRUE if the program headers were read into `program_headers'.  */
4984
4985 static bfd_boolean
4986 get_program_headers (Filedata * filedata)
4987 {
4988   Elf_Internal_Phdr * phdrs;
4989
4990   /* Check cache of prior read.  */
4991   if (filedata->program_headers != NULL)
4992     return TRUE;
4993
4994   /* Be kind to memory checkers by looking for
4995      e_phnum values which we know must be invalid.  */
4996   if (filedata->file_header.e_phnum
4997       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4998       >= filedata->file_size)
4999     {
5000       error (_("Too many program headers - %#x - the file is not that big\n"),
5001              filedata->file_header.e_phnum);
5002       return FALSE;
5003     }
5004
5005   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
5006                                          sizeof (Elf_Internal_Phdr));
5007   if (phdrs == NULL)
5008     {
5009       error (_("Out of memory reading %u program headers\n"),
5010              filedata->file_header.e_phnum);
5011       return FALSE;
5012     }
5013
5014   if (is_32bit_elf
5015       ? get_32bit_program_headers (filedata, phdrs)
5016       : get_64bit_program_headers (filedata, phdrs))
5017     {
5018       filedata->program_headers = phdrs;
5019       return TRUE;
5020     }
5021
5022   free (phdrs);
5023   return FALSE;
5024 }
5025
5026 /* Returns TRUE if the program headers were loaded.  */
5027
5028 static bfd_boolean
5029 process_program_headers (Filedata * filedata)
5030 {
5031   Elf_Internal_Phdr * segment;
5032   unsigned int i;
5033   Elf_Internal_Phdr * previous_load = NULL;
5034
5035   if (filedata->file_header.e_phnum == 0)
5036     {
5037       /* PR binutils/12467.  */
5038       if (filedata->file_header.e_phoff != 0)
5039         {
5040           warn (_("possibly corrupt ELF header - it has a non-zero program"
5041                   " header offset, but no program headers\n"));
5042           return FALSE;
5043         }
5044       else if (do_segments)
5045         printf (_("\nThere are no program headers in this file.\n"));
5046       return TRUE;
5047     }
5048
5049   if (do_segments && !do_header)
5050     {
5051       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5052       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5053       printf (ngettext ("There is %d program header, starting at offset %s\n",
5054                         "There are %d program headers, starting at offset %s\n",
5055                         filedata->file_header.e_phnum),
5056               filedata->file_header.e_phnum,
5057               bfd_vmatoa ("u", filedata->file_header.e_phoff));
5058     }
5059
5060   if (! get_program_headers (filedata))
5061     return TRUE;
5062
5063   if (do_segments)
5064     {
5065       if (filedata->file_header.e_phnum > 1)
5066         printf (_("\nProgram Headers:\n"));
5067       else
5068         printf (_("\nProgram Headers:\n"));
5069
5070       if (is_32bit_elf)
5071         printf
5072           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
5073       else if (do_wide)
5074         printf
5075           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
5076       else
5077         {
5078           printf
5079             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
5080           printf
5081             (_("                 FileSiz            MemSiz              Flags  Align\n"));
5082         }
5083     }
5084
5085   dynamic_addr = 0;
5086   dynamic_size = 0;
5087
5088   for (i = 0, segment = filedata->program_headers;
5089        i < filedata->file_header.e_phnum;
5090        i++, segment++)
5091     {
5092       if (do_segments)
5093         {
5094           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
5095
5096           if (is_32bit_elf)
5097             {
5098               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5099               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5100               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5101               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5102               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5103               printf ("%c%c%c ",
5104                       (segment->p_flags & PF_R ? 'R' : ' '),
5105                       (segment->p_flags & PF_W ? 'W' : ' '),
5106                       (segment->p_flags & PF_X ? 'E' : ' '));
5107               printf ("%#lx", (unsigned long) segment->p_align);
5108             }
5109           else if (do_wide)
5110             {
5111               if ((unsigned long) segment->p_offset == segment->p_offset)
5112                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5113               else
5114                 {
5115                   print_vma (segment->p_offset, FULL_HEX);
5116                   putchar (' ');
5117                 }
5118
5119               print_vma (segment->p_vaddr, FULL_HEX);
5120               putchar (' ');
5121               print_vma (segment->p_paddr, FULL_HEX);
5122               putchar (' ');
5123
5124               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5125                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5126               else
5127                 {
5128                   print_vma (segment->p_filesz, FULL_HEX);
5129                   putchar (' ');
5130                 }
5131
5132               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5133                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5134               else
5135                 {
5136                   print_vma (segment->p_memsz, FULL_HEX);
5137                 }
5138
5139               printf (" %c%c%c ",
5140                       (segment->p_flags & PF_R ? 'R' : ' '),
5141                       (segment->p_flags & PF_W ? 'W' : ' '),
5142                       (segment->p_flags & PF_X ? 'E' : ' '));
5143
5144               if ((unsigned long) segment->p_align == segment->p_align)
5145                 printf ("%#lx", (unsigned long) segment->p_align);
5146               else
5147                 {
5148                   print_vma (segment->p_align, PREFIX_HEX);
5149                 }
5150             }
5151           else
5152             {
5153               print_vma (segment->p_offset, FULL_HEX);
5154               putchar (' ');
5155               print_vma (segment->p_vaddr, FULL_HEX);
5156               putchar (' ');
5157               print_vma (segment->p_paddr, FULL_HEX);
5158               printf ("\n                 ");
5159               print_vma (segment->p_filesz, FULL_HEX);
5160               putchar (' ');
5161               print_vma (segment->p_memsz, FULL_HEX);
5162               printf ("  %c%c%c    ",
5163                       (segment->p_flags & PF_R ? 'R' : ' '),
5164                       (segment->p_flags & PF_W ? 'W' : ' '),
5165                       (segment->p_flags & PF_X ? 'E' : ' '));
5166               print_vma (segment->p_align, PREFIX_HEX);
5167             }
5168
5169           putc ('\n', stdout);
5170         }
5171
5172       switch (segment->p_type)
5173         {
5174         case PT_LOAD:
5175 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5176          required by the ELF standard, several programs, including the Linux
5177          kernel, make use of non-ordered segments.  */
5178           if (previous_load
5179               && previous_load->p_vaddr > segment->p_vaddr)
5180             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5181 #endif
5182           if (segment->p_memsz < segment->p_filesz)
5183             error (_("the segment's file size is larger than its memory size\n"));
5184           previous_load = segment;
5185           break;
5186
5187         case PT_PHDR:
5188           /* PR 20815 - Verify that the program header is loaded into memory.  */
5189           if (i > 0 && previous_load != NULL)
5190             error (_("the PHDR segment must occur before any LOAD segment\n"));
5191           if (filedata->file_header.e_machine != EM_PARISC)
5192             {
5193               unsigned int j;
5194
5195               for (j = 1; j < filedata->file_header.e_phnum; j++)
5196                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5197                     && (filedata->program_headers[j].p_vaddr
5198                         + filedata->program_headers[j].p_memsz)
5199                     >= (segment->p_vaddr + segment->p_filesz))
5200                   break;
5201               if (j == filedata->file_header.e_phnum)
5202                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5203             }
5204           break;
5205
5206         case PT_DYNAMIC:
5207           if (dynamic_addr)
5208             error (_("more than one dynamic segment\n"));
5209
5210           /* By default, assume that the .dynamic section is the first
5211              section in the DYNAMIC segment.  */
5212           dynamic_addr = segment->p_offset;
5213           dynamic_size = segment->p_filesz;
5214
5215           /* Try to locate the .dynamic section. If there is
5216              a section header table, we can easily locate it.  */
5217           if (filedata->section_headers != NULL)
5218             {
5219               Elf_Internal_Shdr * sec;
5220
5221               sec = find_section (filedata, ".dynamic");
5222               if (sec == NULL || sec->sh_size == 0)
5223                 {
5224                   /* A corresponding .dynamic section is expected, but on
5225                      IA-64/OpenVMS it is OK for it to be missing.  */
5226                   if (!is_ia64_vms (filedata))
5227                     error (_("no .dynamic section in the dynamic segment\n"));
5228                   break;
5229                 }
5230
5231               if (sec->sh_type == SHT_NOBITS)
5232                 {
5233                   dynamic_size = 0;
5234                   break;
5235                 }
5236
5237               dynamic_addr = sec->sh_offset;
5238               dynamic_size = sec->sh_size;
5239
5240               if (dynamic_addr < segment->p_offset
5241                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5242                 warn (_("the .dynamic section is not contained"
5243                         " within the dynamic segment\n"));
5244               else if (dynamic_addr > segment->p_offset)
5245                 warn (_("the .dynamic section is not the first section"
5246                         " in the dynamic segment.\n"));
5247             }
5248
5249           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5250              segment.  Check this after matching against the section headers
5251              so we don't warn on debuginfo file (which have NOBITS .dynamic
5252              sections).  */
5253           if (dynamic_addr > filedata->file_size
5254               || dynamic_size > filedata->file_size - dynamic_addr)
5255             {
5256               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5257               dynamic_addr = dynamic_size = 0;
5258             }
5259           break;
5260
5261         case PT_INTERP:
5262           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5263                      SEEK_SET))
5264             error (_("Unable to find program interpreter name\n"));
5265           else
5266             {
5267               char fmt [32];
5268               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5269
5270               if (ret >= (int) sizeof (fmt) || ret < 0)
5271                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5272
5273               program_interpreter[0] = 0;
5274               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5275                 error (_("Unable to read program interpreter name\n"));
5276
5277               if (do_segments)
5278                 printf (_("      [Requesting program interpreter: %s]\n"),
5279                     program_interpreter);
5280             }
5281           break;
5282         }
5283     }
5284
5285   if (do_segments
5286       && filedata->section_headers != NULL
5287       && filedata->string_table != NULL)
5288     {
5289       printf (_("\n Section to Segment mapping:\n"));
5290       printf (_("  Segment Sections...\n"));
5291
5292       for (i = 0; i < filedata->file_header.e_phnum; i++)
5293         {
5294           unsigned int j;
5295           Elf_Internal_Shdr * section;
5296
5297           segment = filedata->program_headers + i;
5298           section = filedata->section_headers + 1;
5299
5300           printf ("   %2.2d     ", i);
5301
5302           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5303             {
5304               if (!ELF_TBSS_SPECIAL (section, segment)
5305                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5306                 printf ("%s ", printable_section_name (filedata, section));
5307             }
5308
5309           putc ('\n',stdout);
5310         }
5311     }
5312
5313   return TRUE;
5314 }
5315
5316
5317 /* Find the file offset corresponding to VMA by using the program headers.  */
5318
5319 static long
5320 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5321 {
5322   Elf_Internal_Phdr * seg;
5323
5324   if (! get_program_headers (filedata))
5325     {
5326       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5327       return (long) vma;
5328     }
5329
5330   for (seg = filedata->program_headers;
5331        seg < filedata->program_headers + filedata->file_header.e_phnum;
5332        ++seg)
5333     {
5334       if (seg->p_type != PT_LOAD)
5335         continue;
5336
5337       if (vma >= (seg->p_vaddr & -seg->p_align)
5338           && vma + size <= seg->p_vaddr + seg->p_filesz)
5339         return vma - seg->p_vaddr + seg->p_offset;
5340     }
5341
5342   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5343         (unsigned long) vma);
5344   return (long) vma;
5345 }
5346
5347
5348 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5349    If PROBE is true, this is just a probe and we do not generate any error
5350    messages if the load fails.  */
5351
5352 static bfd_boolean
5353 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5354 {
5355   Elf32_External_Shdr * shdrs;
5356   Elf_Internal_Shdr *   internal;
5357   unsigned int          i;
5358   unsigned int          size = filedata->file_header.e_shentsize;
5359   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5360
5361   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5362   if (size == 0 || num == 0)
5363     return FALSE;
5364   if (size < sizeof * shdrs)
5365     {
5366       if (! probe)
5367         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5368       return FALSE;
5369     }
5370   if (!probe && size > sizeof * shdrs)
5371     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5372
5373   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5374                                             size, num,
5375                                             probe ? NULL : _("section headers"));
5376   if (shdrs == NULL)
5377     return FALSE;
5378
5379   free (filedata->section_headers);
5380   filedata->section_headers = (Elf_Internal_Shdr *)
5381     cmalloc (num, sizeof (Elf_Internal_Shdr));
5382   if (filedata->section_headers == NULL)
5383     {
5384       if (!probe)
5385         error (_("Out of memory reading %u section headers\n"), num);
5386       free (shdrs);
5387       return FALSE;
5388     }
5389
5390   for (i = 0, internal = filedata->section_headers;
5391        i < num;
5392        i++, internal++)
5393     {
5394       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5395       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5396       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5397       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5398       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5399       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5400       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5401       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5402       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5403       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5404       if (!probe && internal->sh_link > num)
5405         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5406       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5407         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5408     }
5409
5410   free (shdrs);
5411   return TRUE;
5412 }
5413
5414 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5415
5416 static bfd_boolean
5417 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5418 {
5419   Elf64_External_Shdr *  shdrs;
5420   Elf_Internal_Shdr *    internal;
5421   unsigned int           i;
5422   unsigned int           size = filedata->file_header.e_shentsize;
5423   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5424
5425   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5426   if (size == 0 || num == 0)
5427     return FALSE;
5428
5429   if (size < sizeof * shdrs)
5430     {
5431       if (! probe)
5432         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5433       return FALSE;
5434     }
5435
5436   if (! probe && size > sizeof * shdrs)
5437     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5438
5439   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5440                                             filedata->file_header.e_shoff,
5441                                             size, num,
5442                                             probe ? NULL : _("section headers"));
5443   if (shdrs == NULL)
5444     return FALSE;
5445
5446   free (filedata->section_headers);
5447   filedata->section_headers = (Elf_Internal_Shdr *)
5448     cmalloc (num, sizeof (Elf_Internal_Shdr));
5449   if (filedata->section_headers == NULL)
5450     {
5451       if (! probe)
5452         error (_("Out of memory reading %u section headers\n"), num);
5453       free (shdrs);
5454       return FALSE;
5455     }
5456
5457   for (i = 0, internal = filedata->section_headers;
5458        i < num;
5459        i++, internal++)
5460     {
5461       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5462       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5463       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5464       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5465       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5466       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5467       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5468       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5469       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5470       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5471       if (!probe && internal->sh_link > num)
5472         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5473       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5474         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5475     }
5476
5477   free (shdrs);
5478   return TRUE;
5479 }
5480
5481 static Elf_Internal_Sym *
5482 get_32bit_elf_symbols (Filedata *           filedata,
5483                        Elf_Internal_Shdr *  section,
5484                        unsigned long *      num_syms_return)
5485 {
5486   unsigned long number = 0;
5487   Elf32_External_Sym * esyms = NULL;
5488   Elf_External_Sym_Shndx * shndx = NULL;
5489   Elf_Internal_Sym * isyms = NULL;
5490   Elf_Internal_Sym * psym;
5491   unsigned int j;
5492   elf_section_list * entry;
5493
5494   if (section->sh_size == 0)
5495     {
5496       if (num_syms_return != NULL)
5497         * num_syms_return = 0;
5498       return NULL;
5499     }
5500
5501   /* Run some sanity checks first.  */
5502   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5503     {
5504       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5505              printable_section_name (filedata, section),
5506              (unsigned long) section->sh_entsize);
5507       goto exit_point;
5508     }
5509
5510   if (section->sh_size > filedata->file_size)
5511     {
5512       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5513              printable_section_name (filedata, section),
5514              (unsigned long) section->sh_size);
5515       goto exit_point;
5516     }
5517
5518   number = section->sh_size / section->sh_entsize;
5519
5520   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5521     {
5522       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5523              (unsigned long) section->sh_size,
5524              printable_section_name (filedata, section),
5525              (unsigned long) section->sh_entsize);
5526       goto exit_point;
5527     }
5528
5529   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5530                                            section->sh_size, _("symbols"));
5531   if (esyms == NULL)
5532     goto exit_point;
5533
5534   shndx = NULL;
5535   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5536     {
5537       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5538         continue;
5539
5540       if (shndx != NULL)
5541         {
5542           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5543           free (shndx);
5544         }
5545
5546       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5547                                                    entry->hdr->sh_offset,
5548                                                    1, entry->hdr->sh_size,
5549                                                    _("symbol table section indices"));
5550       if (shndx == NULL)
5551         goto exit_point;
5552
5553       /* PR17531: file: heap-buffer-overflow */
5554       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5555         {
5556           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5557                  printable_section_name (filedata, entry->hdr),
5558                  (unsigned long) entry->hdr->sh_size,
5559                  (unsigned long) section->sh_size);
5560           goto exit_point;
5561         }
5562     }
5563
5564   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5565
5566   if (isyms == NULL)
5567     {
5568       error (_("Out of memory reading %lu symbols\n"),
5569              (unsigned long) number);
5570       goto exit_point;
5571     }
5572
5573   for (j = 0, psym = isyms; j < number; j++, psym++)
5574     {
5575       psym->st_name  = BYTE_GET (esyms[j].st_name);
5576       psym->st_value = BYTE_GET (esyms[j].st_value);
5577       psym->st_size  = BYTE_GET (esyms[j].st_size);
5578       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5579       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5580         psym->st_shndx
5581           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5582       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5583         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5584       psym->st_info  = BYTE_GET (esyms[j].st_info);
5585       psym->st_other = BYTE_GET (esyms[j].st_other);
5586     }
5587
5588  exit_point:
5589   free (shndx);
5590   free (esyms);
5591
5592   if (num_syms_return != NULL)
5593     * num_syms_return = isyms == NULL ? 0 : number;
5594
5595   return isyms;
5596 }
5597
5598 static Elf_Internal_Sym *
5599 get_64bit_elf_symbols (Filedata *           filedata,
5600                        Elf_Internal_Shdr *  section,
5601                        unsigned long *      num_syms_return)
5602 {
5603   unsigned long number = 0;
5604   Elf64_External_Sym * esyms = NULL;
5605   Elf_External_Sym_Shndx * shndx = NULL;
5606   Elf_Internal_Sym * isyms = NULL;
5607   Elf_Internal_Sym * psym;
5608   unsigned int j;
5609   elf_section_list * entry;
5610
5611   if (section->sh_size == 0)
5612     {
5613       if (num_syms_return != NULL)
5614         * num_syms_return = 0;
5615       return NULL;
5616     }
5617
5618   /* Run some sanity checks first.  */
5619   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5620     {
5621       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5622              printable_section_name (filedata, section),
5623              (unsigned long) section->sh_entsize);
5624       goto exit_point;
5625     }
5626
5627   if (section->sh_size > filedata->file_size)
5628     {
5629       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5630              printable_section_name (filedata, section),
5631              (unsigned long) section->sh_size);
5632       goto exit_point;
5633     }
5634
5635   number = section->sh_size / section->sh_entsize;
5636
5637   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5638     {
5639       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5640              (unsigned long) section->sh_size,
5641              printable_section_name (filedata, section),
5642              (unsigned long) section->sh_entsize);
5643       goto exit_point;
5644     }
5645
5646   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5647                                            section->sh_size, _("symbols"));
5648   if (!esyms)
5649     goto exit_point;
5650
5651   shndx = NULL;
5652   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5653     {
5654       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5655         continue;
5656
5657       if (shndx != NULL)
5658         {
5659           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5660           free (shndx);
5661         }
5662
5663       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5664                                                    entry->hdr->sh_offset,
5665                                                    1, entry->hdr->sh_size,
5666                                                    _("symbol table section indices"));
5667       if (shndx == NULL)
5668         goto exit_point;
5669
5670       /* PR17531: file: heap-buffer-overflow */
5671       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5672         {
5673           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5674                  printable_section_name (filedata, entry->hdr),
5675                  (unsigned long) entry->hdr->sh_size,
5676                  (unsigned long) section->sh_size);
5677           goto exit_point;
5678         }
5679     }
5680
5681   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5682
5683   if (isyms == NULL)
5684     {
5685       error (_("Out of memory reading %lu symbols\n"),
5686              (unsigned long) number);
5687       goto exit_point;
5688     }
5689
5690   for (j = 0, psym = isyms; j < number; j++, psym++)
5691     {
5692       psym->st_name  = BYTE_GET (esyms[j].st_name);
5693       psym->st_info  = BYTE_GET (esyms[j].st_info);
5694       psym->st_other = BYTE_GET (esyms[j].st_other);
5695       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5696
5697       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5698         psym->st_shndx
5699           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5700       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5701         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5702
5703       psym->st_value = BYTE_GET (esyms[j].st_value);
5704       psym->st_size  = BYTE_GET (esyms[j].st_size);
5705     }
5706
5707  exit_point:
5708   free (shndx);
5709   free (esyms);
5710
5711   if (num_syms_return != NULL)
5712     * num_syms_return = isyms == NULL ? 0 : number;
5713
5714   return isyms;
5715 }
5716
5717 static const char *
5718 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5719 {
5720   static char buff[1024];
5721   char * p = buff;
5722   unsigned int field_size = is_32bit_elf ? 8 : 16;
5723   signed int sindex;
5724   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5725   bfd_vma os_flags = 0;
5726   bfd_vma proc_flags = 0;
5727   bfd_vma unknown_flags = 0;
5728   static const struct
5729     {
5730       const char * str;
5731       unsigned int len;
5732     }
5733   flags [] =
5734     {
5735       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5736       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5737       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5738       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5739       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5740       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5741       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5742       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5743       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5744       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5745       /* IA-64 specific.  */
5746       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5747       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5748       /* IA-64 OpenVMS specific.  */
5749       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5750       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5751       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5752       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5753       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5754       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5755       /* Generic.  */
5756       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5757       /* SPARC specific.  */
5758       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5759       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5760       /* ARM specific.  */
5761       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5762       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5763       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5764       /* GNU specific.  */
5765       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5766       /* VLE specific.  */
5767       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5768     };
5769
5770   if (do_section_details)
5771     {
5772       sprintf (buff, "[%*.*lx]: ",
5773                field_size, field_size, (unsigned long) sh_flags);
5774       p += field_size + 4;
5775     }
5776
5777   while (sh_flags)
5778     {
5779       bfd_vma flag;
5780
5781       flag = sh_flags & - sh_flags;
5782       sh_flags &= ~ flag;
5783
5784       if (do_section_details)
5785         {
5786           switch (flag)
5787             {
5788             case SHF_WRITE:             sindex = 0; break;
5789             case SHF_ALLOC:             sindex = 1; break;
5790             case SHF_EXECINSTR:         sindex = 2; break;
5791             case SHF_MERGE:             sindex = 3; break;
5792             case SHF_STRINGS:           sindex = 4; break;
5793             case SHF_INFO_LINK:         sindex = 5; break;
5794             case SHF_LINK_ORDER:        sindex = 6; break;
5795             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5796             case SHF_GROUP:             sindex = 8; break;
5797             case SHF_TLS:               sindex = 9; break;
5798             case SHF_EXCLUDE:           sindex = 18; break;
5799             case SHF_COMPRESSED:        sindex = 20; break;
5800             case SHF_GNU_MBIND:         sindex = 24; break;
5801
5802             default:
5803               sindex = -1;
5804               switch (filedata->file_header.e_machine)
5805                 {
5806                 case EM_IA_64:
5807                   if (flag == SHF_IA_64_SHORT)
5808                     sindex = 10;
5809                   else if (flag == SHF_IA_64_NORECOV)
5810                     sindex = 11;
5811 #ifdef BFD64
5812                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5813                     switch (flag)
5814                       {
5815                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5816                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5817                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5818                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5819                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5820                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5821                       default:                        break;
5822                       }
5823 #endif
5824                   break;
5825
5826                 case EM_386:
5827                 case EM_IAMCU:
5828                 case EM_X86_64:
5829                 case EM_L1OM:
5830                 case EM_K1OM:
5831                 case EM_OLD_SPARCV9:
5832                 case EM_SPARC32PLUS:
5833                 case EM_SPARCV9:
5834                 case EM_SPARC:
5835                   if (flag == SHF_ORDERED)
5836                     sindex = 19;
5837                   break;
5838
5839                 case EM_ARM:
5840                   switch (flag)
5841                     {
5842                     case SHF_ENTRYSECT: sindex = 21; break;
5843                     case SHF_ARM_PURECODE: sindex = 22; break;
5844                     case SHF_COMDEF: sindex = 23; break;
5845                     default: break;
5846                     }
5847                   break;
5848                 case EM_PPC:
5849                   if (flag == SHF_PPC_VLE)
5850                     sindex = 25;
5851                   break;
5852
5853                 default:
5854                   break;
5855                 }
5856             }
5857
5858           if (sindex != -1)
5859             {
5860               if (p != buff + field_size + 4)
5861                 {
5862                   if (size < (10 + 2))
5863                     {
5864                       warn (_("Internal error: not enough buffer room for section flag info"));
5865                       return _("<unknown>");
5866                     }
5867                   size -= 2;
5868                   *p++ = ',';
5869                   *p++ = ' ';
5870                 }
5871
5872               size -= flags [sindex].len;
5873               p = stpcpy (p, flags [sindex].str);
5874             }
5875           else if (flag & SHF_MASKOS)
5876             os_flags |= flag;
5877           else if (flag & SHF_MASKPROC)
5878             proc_flags |= flag;
5879           else
5880             unknown_flags |= flag;
5881         }
5882       else
5883         {
5884           switch (flag)
5885             {
5886             case SHF_WRITE:             *p = 'W'; break;
5887             case SHF_ALLOC:             *p = 'A'; break;
5888             case SHF_EXECINSTR:         *p = 'X'; break;
5889             case SHF_MERGE:             *p = 'M'; break;
5890             case SHF_STRINGS:           *p = 'S'; break;
5891             case SHF_INFO_LINK:         *p = 'I'; break;
5892             case SHF_LINK_ORDER:        *p = 'L'; break;
5893             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5894             case SHF_GROUP:             *p = 'G'; break;
5895             case SHF_TLS:               *p = 'T'; break;
5896             case SHF_EXCLUDE:           *p = 'E'; break;
5897             case SHF_COMPRESSED:        *p = 'C'; break;
5898             case SHF_GNU_MBIND:         *p = 'D'; break;
5899
5900             default:
5901               if ((filedata->file_header.e_machine == EM_X86_64
5902                    || filedata->file_header.e_machine == EM_L1OM
5903                    || filedata->file_header.e_machine == EM_K1OM)
5904                   && flag == SHF_X86_64_LARGE)
5905                 *p = 'l';
5906               else if (filedata->file_header.e_machine == EM_ARM
5907                        && flag == SHF_ARM_PURECODE)
5908                   *p = 'y';
5909               else if (filedata->file_header.e_machine == EM_PPC
5910                        && flag == SHF_PPC_VLE)
5911                   *p = 'v';
5912               else if (flag & SHF_MASKOS)
5913                 {
5914                   *p = 'o';
5915                   sh_flags &= ~ SHF_MASKOS;
5916                 }
5917               else if (flag & SHF_MASKPROC)
5918                 {
5919                   *p = 'p';
5920                   sh_flags &= ~ SHF_MASKPROC;
5921                 }
5922               else
5923                 *p = 'x';
5924               break;
5925             }
5926           p++;
5927         }
5928     }
5929
5930   if (do_section_details)
5931     {
5932       if (os_flags)
5933         {
5934           size -= 5 + field_size;
5935           if (p != buff + field_size + 4)
5936             {
5937               if (size < (2 + 1))
5938                 {
5939                   warn (_("Internal error: not enough buffer room for section flag info"));
5940                   return _("<unknown>");
5941                 }
5942               size -= 2;
5943               *p++ = ',';
5944               *p++ = ' ';
5945             }
5946           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5947                    (unsigned long) os_flags);
5948           p += 5 + field_size;
5949         }
5950       if (proc_flags)
5951         {
5952           size -= 7 + field_size;
5953           if (p != buff + field_size + 4)
5954             {
5955               if (size < (2 + 1))
5956                 {
5957                   warn (_("Internal error: not enough buffer room for section flag info"));
5958                   return _("<unknown>");
5959                 }
5960               size -= 2;
5961               *p++ = ',';
5962               *p++ = ' ';
5963             }
5964           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5965                    (unsigned long) proc_flags);
5966           p += 7 + field_size;
5967         }
5968       if (unknown_flags)
5969         {
5970           size -= 10 + field_size;
5971           if (p != buff + field_size + 4)
5972             {
5973               if (size < (2 + 1))
5974                 {
5975                   warn (_("Internal error: not enough buffer room for section flag info"));
5976                   return _("<unknown>");
5977                 }
5978               size -= 2;
5979               *p++ = ',';
5980               *p++ = ' ';
5981             }
5982           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5983                    (unsigned long) unknown_flags);
5984           p += 10 + field_size;
5985         }
5986     }
5987
5988   *p = '\0';
5989   return buff;
5990 }
5991
5992 static unsigned int
5993 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5994 {
5995   if (is_32bit_elf)
5996     {
5997       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5998
5999       if (size < sizeof (* echdr))
6000         {
6001           error (_("Compressed section is too small even for a compression header\n"));
6002           return 0;
6003         }
6004
6005       chdr->ch_type = BYTE_GET (echdr->ch_type);
6006       chdr->ch_size = BYTE_GET (echdr->ch_size);
6007       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6008       return sizeof (*echdr);
6009     }
6010   else
6011     {
6012       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
6013
6014       if (size < sizeof (* echdr))
6015         {
6016           error (_("Compressed section is too small even for a compression header\n"));
6017           return 0;
6018         }
6019
6020       chdr->ch_type = BYTE_GET (echdr->ch_type);
6021       chdr->ch_size = BYTE_GET (echdr->ch_size);
6022       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6023       return sizeof (*echdr);
6024     }
6025 }
6026
6027 static bfd_boolean
6028 process_section_headers (Filedata * filedata)
6029 {
6030   Elf_Internal_Shdr * section;
6031   unsigned int i;
6032
6033   filedata->section_headers = NULL;
6034
6035   if (filedata->file_header.e_shnum == 0)
6036     {
6037       /* PR binutils/12467.  */
6038       if (filedata->file_header.e_shoff != 0)
6039         {
6040           warn (_("possibly corrupt ELF file header - it has a non-zero"
6041                   " section header offset, but no section headers\n"));
6042           return FALSE;
6043         }
6044       else if (do_sections)
6045         printf (_("\nThere are no sections in this file.\n"));
6046
6047       return TRUE;
6048     }
6049
6050   if (do_sections && !do_header)
6051     printf (ngettext ("There is %d section header, "
6052                       "starting at offset 0x%lx:\n",
6053                       "There are %d section headers, "
6054                       "starting at offset 0x%lx:\n",
6055                       filedata->file_header.e_shnum),
6056             filedata->file_header.e_shnum,
6057             (unsigned long) filedata->file_header.e_shoff);
6058
6059   if (is_32bit_elf)
6060     {
6061       if (! get_32bit_section_headers (filedata, FALSE))
6062         return FALSE;
6063     }
6064   else
6065     {
6066       if (! get_64bit_section_headers (filedata, FALSE))
6067         return FALSE;
6068     }
6069
6070   /* Read in the string table, so that we have names to display.  */
6071   if (filedata->file_header.e_shstrndx != SHN_UNDEF
6072        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6073     {
6074       section = filedata->section_headers + filedata->file_header.e_shstrndx;
6075
6076       if (section->sh_size != 0)
6077         {
6078           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6079                                                       1, section->sh_size,
6080                                                       _("string table"));
6081
6082           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6083         }
6084     }
6085
6086   /* Scan the sections for the dynamic symbol table
6087      and dynamic string table and debug sections.  */
6088   dynamic_symbols = NULL;
6089   dynamic_strings = NULL;
6090   dynamic_syminfo = NULL;
6091   symtab_shndx_list = NULL;
6092
6093   eh_addr_size = is_32bit_elf ? 4 : 8;
6094   switch (filedata->file_header.e_machine)
6095     {
6096     case EM_MIPS:
6097     case EM_MIPS_RS3_LE:
6098       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6099          FDE addresses.  However, the ABI also has a semi-official ILP32
6100          variant for which the normal FDE address size rules apply.
6101
6102          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6103          section, where XX is the size of longs in bits.  Unfortunately,
6104          earlier compilers provided no way of distinguishing ILP32 objects
6105          from LP64 objects, so if there's any doubt, we should assume that
6106          the official LP64 form is being used.  */
6107       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6108           && find_section (filedata, ".gcc_compiled_long32") == NULL)
6109         eh_addr_size = 8;
6110       break;
6111
6112     case EM_H8_300:
6113     case EM_H8_300H:
6114       switch (filedata->file_header.e_flags & EF_H8_MACH)
6115         {
6116         case E_H8_MACH_H8300:
6117         case E_H8_MACH_H8300HN:
6118         case E_H8_MACH_H8300SN:
6119         case E_H8_MACH_H8300SXN:
6120           eh_addr_size = 2;
6121           break;
6122         case E_H8_MACH_H8300H:
6123         case E_H8_MACH_H8300S:
6124         case E_H8_MACH_H8300SX:
6125           eh_addr_size = 4;
6126           break;
6127         }
6128       break;
6129
6130     case EM_M32C_OLD:
6131     case EM_M32C:
6132       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6133         {
6134         case EF_M32C_CPU_M16C:
6135           eh_addr_size = 2;
6136           break;
6137         }
6138       break;
6139     }
6140
6141 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6142   do                                                                    \
6143     {                                                                   \
6144       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6145       if (section->sh_entsize != expected_entsize)                      \
6146         {                                                               \
6147           char buf[40];                                                 \
6148           sprintf_vma (buf, section->sh_entsize);                       \
6149           /* Note: coded this way so that there is a single string for  \
6150              translation.  */ \
6151           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6152           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6153                    (unsigned) expected_entsize);                        \
6154           section->sh_entsize = expected_entsize;                       \
6155         }                                                               \
6156     }                                                                   \
6157   while (0)
6158
6159 #define CHECK_ENTSIZE(section, i, type)                                 \
6160   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6161                         sizeof (Elf64_External_##type))
6162
6163   for (i = 0, section = filedata->section_headers;
6164        i < filedata->file_header.e_shnum;
6165        i++, section++)
6166     {
6167       char * name = SECTION_NAME (section);
6168
6169       if (section->sh_type == SHT_DYNSYM)
6170         {
6171           if (dynamic_symbols != NULL)
6172             {
6173               error (_("File contains multiple dynamic symbol tables\n"));
6174               continue;
6175             }
6176
6177           CHECK_ENTSIZE (section, i, Sym);
6178           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6179         }
6180       else if (section->sh_type == SHT_STRTAB
6181                && streq (name, ".dynstr"))
6182         {
6183           if (dynamic_strings != NULL)
6184             {
6185               error (_("File contains multiple dynamic string tables\n"));
6186               continue;
6187             }
6188
6189           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6190                                                1, section->sh_size,
6191                                                _("dynamic strings"));
6192           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6193         }
6194       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6195         {
6196           elf_section_list * entry = xmalloc (sizeof * entry);
6197
6198           entry->hdr = section;
6199           entry->next = symtab_shndx_list;
6200           symtab_shndx_list = entry;
6201         }
6202       else if (section->sh_type == SHT_SYMTAB)
6203         CHECK_ENTSIZE (section, i, Sym);
6204       else if (section->sh_type == SHT_GROUP)
6205         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6206       else if (section->sh_type == SHT_REL)
6207         CHECK_ENTSIZE (section, i, Rel);
6208       else if (section->sh_type == SHT_RELA)
6209         CHECK_ENTSIZE (section, i, Rela);
6210       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6211                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6212                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6213                 || do_debug_str || do_debug_loc || do_debug_ranges
6214                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6215                && (const_strneq (name, ".debug_")
6216                    || const_strneq (name, ".zdebug_")))
6217         {
6218           if (name[1] == 'z')
6219             name += sizeof (".zdebug_") - 1;
6220           else
6221             name += sizeof (".debug_") - 1;
6222
6223           if (do_debugging
6224               || (do_debug_info     && const_strneq (name, "info"))
6225               || (do_debug_info     && const_strneq (name, "types"))
6226               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6227               || (do_debug_lines    && strcmp (name, "line") == 0)
6228               || (do_debug_lines    && const_strneq (name, "line."))
6229               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6230               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6231               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6232               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6233               || (do_debug_aranges  && const_strneq (name, "aranges"))
6234               || (do_debug_ranges   && const_strneq (name, "ranges"))
6235               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6236               || (do_debug_frames   && const_strneq (name, "frame"))
6237               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6238               || (do_debug_macinfo  && const_strneq (name, "macro"))
6239               || (do_debug_str      && const_strneq (name, "str"))
6240               || (do_debug_loc      && const_strneq (name, "loc"))
6241               || (do_debug_loc      && const_strneq (name, "loclists"))
6242               || (do_debug_addr     && const_strneq (name, "addr"))
6243               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6244               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6245               )
6246             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6247         }
6248       /* Linkonce section to be combined with .debug_info at link time.  */
6249       else if ((do_debugging || do_debug_info)
6250                && const_strneq (name, ".gnu.linkonce.wi."))
6251         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6252       else if (do_debug_frames && streq (name, ".eh_frame"))
6253         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6254       else if (do_gdb_index && (streq (name, ".gdb_index")
6255                                 || streq (name, ".debug_names")))
6256         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6257       /* Trace sections for Itanium VMS.  */
6258       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6259                 || do_trace_aranges)
6260                && const_strneq (name, ".trace_"))
6261         {
6262           name += sizeof (".trace_") - 1;
6263
6264           if (do_debugging
6265               || (do_trace_info     && streq (name, "info"))
6266               || (do_trace_abbrevs  && streq (name, "abbrev"))
6267               || (do_trace_aranges  && streq (name, "aranges"))
6268               )
6269             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6270         }
6271       else if ((do_debugging || do_debug_links)
6272                && (const_strneq (name, ".gnu_debuglink")
6273                    || const_strneq (name, ".gnu_debugaltlink")))
6274         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6275     }
6276
6277   if (! do_sections)
6278     return TRUE;
6279
6280   if (filedata->file_header.e_shnum > 1)
6281     printf (_("\nSection Headers:\n"));
6282   else
6283     printf (_("\nSection Header:\n"));
6284
6285   if (is_32bit_elf)
6286     {
6287       if (do_section_details)
6288         {
6289           printf (_("  [Nr] Name\n"));
6290           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6291         }
6292       else
6293         printf
6294           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6295     }
6296   else if (do_wide)
6297     {
6298       if (do_section_details)
6299         {
6300           printf (_("  [Nr] Name\n"));
6301           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6302         }
6303       else
6304         printf
6305           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6306     }
6307   else
6308     {
6309       if (do_section_details)
6310         {
6311           printf (_("  [Nr] Name\n"));
6312           printf (_("       Type              Address          Offset            Link\n"));
6313           printf (_("       Size              EntSize          Info              Align\n"));
6314         }
6315       else
6316         {
6317           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6318           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6319         }
6320     }
6321
6322   if (do_section_details)
6323     printf (_("       Flags\n"));
6324
6325   for (i = 0, section = filedata->section_headers;
6326        i < filedata->file_header.e_shnum;
6327        i++, section++)
6328     {
6329       /* Run some sanity checks on the section header.  */
6330
6331       /* Check the sh_link field.  */
6332       switch (section->sh_type)
6333         {
6334         case SHT_REL:
6335         case SHT_RELA:
6336           if (section->sh_link == 0
6337               && (filedata->file_header.e_type == ET_EXEC
6338                   || filedata->file_header.e_type == ET_DYN))
6339             /* A dynamic relocation section where all entries use a
6340                zero symbol index need not specify a symtab section.  */
6341             break;
6342           /* Fall through.  */
6343         case SHT_SYMTAB_SHNDX:
6344         case SHT_GROUP:
6345         case SHT_HASH:
6346         case SHT_GNU_HASH:
6347         case SHT_GNU_versym:
6348           if (section->sh_link == 0
6349               || section->sh_link >= filedata->file_header.e_shnum
6350               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6351                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6352             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6353                   i, section->sh_link);
6354           break;
6355
6356         case SHT_DYNAMIC:
6357         case SHT_SYMTAB:
6358         case SHT_DYNSYM:
6359         case SHT_GNU_verneed:
6360         case SHT_GNU_verdef:
6361         case SHT_GNU_LIBLIST:
6362           if (section->sh_link == 0
6363               || section->sh_link >= filedata->file_header.e_shnum
6364               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6365             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6366                   i, section->sh_link);
6367           break;
6368
6369         case SHT_INIT_ARRAY:
6370         case SHT_FINI_ARRAY:
6371         case SHT_PREINIT_ARRAY:
6372           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6373             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6374                   i, section->sh_link);
6375           break;
6376
6377         default:
6378           /* FIXME: Add support for target specific section types.  */
6379 #if 0     /* Currently we do not check other section types as there are too
6380              many special cases.  Stab sections for example have a type
6381              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6382              section.  */
6383           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6384             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6385                   i, section->sh_link);
6386 #endif
6387           break;
6388         }
6389
6390       /* Check the sh_info field.  */
6391       switch (section->sh_type)
6392         {
6393         case SHT_REL:
6394         case SHT_RELA:
6395           if (section->sh_info == 0
6396               && (filedata->file_header.e_type == ET_EXEC
6397                   || filedata->file_header.e_type == ET_DYN))
6398             /* Dynamic relocations apply to segments, so they do not
6399                need to specify the section they relocate.  */
6400             break;
6401           if (section->sh_info == 0
6402               || section->sh_info >= filedata->file_header.e_shnum
6403               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6404                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6405                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6406                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6407                   && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6408                   && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6409                   /* FIXME: Are other section types valid ?  */
6410                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6411             warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6412                   i, section->sh_info);
6413           break;
6414
6415         case SHT_DYNAMIC:
6416         case SHT_HASH:
6417         case SHT_SYMTAB_SHNDX:
6418         case SHT_INIT_ARRAY:
6419         case SHT_FINI_ARRAY:
6420         case SHT_PREINIT_ARRAY:
6421           if (section->sh_info != 0)
6422             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6423                   i, section->sh_info);
6424           break;
6425
6426         case SHT_GROUP:
6427         case SHT_SYMTAB:
6428         case SHT_DYNSYM:
6429           /* A symbol index - we assume that it is valid.  */
6430           break;
6431
6432         default:
6433           /* FIXME: Add support for target specific section types.  */
6434           if (section->sh_type == SHT_NOBITS)
6435             /* NOBITS section headers with non-zero sh_info fields can be
6436                created when a binary is stripped of everything but its debug
6437                information.  The stripped sections have their headers
6438                preserved but their types set to SHT_NOBITS.  So do not check
6439                this type of section.  */
6440             ;
6441           else if (section->sh_flags & SHF_INFO_LINK)
6442             {
6443               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6444                 warn (_("[%2u]: Expected link to another section in info field"), i);
6445             }
6446           else if (section->sh_type < SHT_LOOS
6447                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6448                    && section->sh_info != 0)
6449             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6450                   i, section->sh_info);
6451           break;
6452         }
6453
6454       /* Check the sh_size field.  */
6455       if (section->sh_size > filedata->file_size
6456           && section->sh_type != SHT_NOBITS
6457           && section->sh_type != SHT_NULL
6458           && section->sh_type < SHT_LOOS)
6459         warn (_("Size of section %u is larger than the entire file!\n"), i);
6460
6461       printf ("  [%2u] ", i);
6462       if (do_section_details)
6463         printf ("%s\n      ", printable_section_name (filedata, section));
6464       else
6465         print_symbol (-17, SECTION_NAME (section));
6466
6467       printf (do_wide ? " %-15s " : " %-15.15s ",
6468               get_section_type_name (filedata, section->sh_type));
6469
6470       if (is_32bit_elf)
6471         {
6472           const char * link_too_big = NULL;
6473
6474           print_vma (section->sh_addr, LONG_HEX);
6475
6476           printf ( " %6.6lx %6.6lx %2.2lx",
6477                    (unsigned long) section->sh_offset,
6478                    (unsigned long) section->sh_size,
6479                    (unsigned long) section->sh_entsize);
6480
6481           if (do_section_details)
6482             fputs ("  ", stdout);
6483           else
6484             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6485
6486           if (section->sh_link >= filedata->file_header.e_shnum)
6487             {
6488               link_too_big = "";
6489               /* The sh_link value is out of range.  Normally this indicates
6490                  an error but it can have special values in Solaris binaries.  */
6491               switch (filedata->file_header.e_machine)
6492                 {
6493                 case EM_386:
6494                 case EM_IAMCU:
6495                 case EM_X86_64:
6496                 case EM_L1OM:
6497                 case EM_K1OM:
6498                 case EM_OLD_SPARCV9:
6499                 case EM_SPARC32PLUS:
6500                 case EM_SPARCV9:
6501                 case EM_SPARC:
6502                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6503                     link_too_big = "BEFORE";
6504                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6505                     link_too_big = "AFTER";
6506                   break;
6507                 default:
6508                   break;
6509                 }
6510             }
6511
6512           if (do_section_details)
6513             {
6514               if (link_too_big != NULL && * link_too_big)
6515                 printf ("<%s> ", link_too_big);
6516               else
6517                 printf ("%2u ", section->sh_link);
6518               printf ("%3u %2lu\n", section->sh_info,
6519                       (unsigned long) section->sh_addralign);
6520             }
6521           else
6522             printf ("%2u %3u %2lu\n",
6523                     section->sh_link,
6524                     section->sh_info,
6525                     (unsigned long) section->sh_addralign);
6526
6527           if (link_too_big && ! * link_too_big)
6528             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6529                   i, section->sh_link);
6530         }
6531       else if (do_wide)
6532         {
6533           print_vma (section->sh_addr, LONG_HEX);
6534
6535           if ((long) section->sh_offset == section->sh_offset)
6536             printf (" %6.6lx", (unsigned long) section->sh_offset);
6537           else
6538             {
6539               putchar (' ');
6540               print_vma (section->sh_offset, LONG_HEX);
6541             }
6542
6543           if ((unsigned long) section->sh_size == section->sh_size)
6544             printf (" %6.6lx", (unsigned long) section->sh_size);
6545           else
6546             {
6547               putchar (' ');
6548               print_vma (section->sh_size, LONG_HEX);
6549             }
6550
6551           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6552             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6553           else
6554             {
6555               putchar (' ');
6556               print_vma (section->sh_entsize, LONG_HEX);
6557             }
6558
6559           if (do_section_details)
6560             fputs ("  ", stdout);
6561           else
6562             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6563
6564           printf ("%2u %3u ", section->sh_link, section->sh_info);
6565
6566           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6567             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6568           else
6569             {
6570               print_vma (section->sh_addralign, DEC);
6571               putchar ('\n');
6572             }
6573         }
6574       else if (do_section_details)
6575         {
6576           putchar (' ');
6577           print_vma (section->sh_addr, LONG_HEX);
6578           if ((long) section->sh_offset == section->sh_offset)
6579             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6580           else
6581             {
6582               printf ("  ");
6583               print_vma (section->sh_offset, LONG_HEX);
6584             }
6585           printf ("  %u\n       ", section->sh_link);
6586           print_vma (section->sh_size, LONG_HEX);
6587           putchar (' ');
6588           print_vma (section->sh_entsize, LONG_HEX);
6589
6590           printf ("  %-16u  %lu\n",
6591                   section->sh_info,
6592                   (unsigned long) section->sh_addralign);
6593         }
6594       else
6595         {
6596           putchar (' ');
6597           print_vma (section->sh_addr, LONG_HEX);
6598           if ((long) section->sh_offset == section->sh_offset)
6599             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6600           else
6601             {
6602               printf ("  ");
6603               print_vma (section->sh_offset, LONG_HEX);
6604             }
6605           printf ("\n       ");
6606           print_vma (section->sh_size, LONG_HEX);
6607           printf ("  ");
6608           print_vma (section->sh_entsize, LONG_HEX);
6609
6610           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6611
6612           printf ("     %2u   %3u     %lu\n",
6613                   section->sh_link,
6614                   section->sh_info,
6615                   (unsigned long) section->sh_addralign);
6616         }
6617
6618       if (do_section_details)
6619         {
6620           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6621           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6622             {
6623               /* Minimum section size is 12 bytes for 32-bit compression
6624                  header + 12 bytes for compressed data header.  */
6625               unsigned char buf[24];
6626
6627               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6628               if (get_data (&buf, filedata, section->sh_offset, 1,
6629                             sizeof (buf), _("compression header")))
6630                 {
6631                   Elf_Internal_Chdr chdr;
6632
6633                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6634
6635                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6636                     printf ("       ZLIB, ");
6637                   else
6638                     printf (_("       [<unknown>: 0x%x], "),
6639                             chdr.ch_type);
6640                   print_vma (chdr.ch_size, LONG_HEX);
6641                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6642                 }
6643             }
6644         }
6645     }
6646
6647   if (!do_section_details)
6648     {
6649       /* The ordering of the letters shown here matches the ordering of the
6650          corresponding SHF_xxx values, and hence the order in which these
6651          letters will be displayed to the user.  */
6652       printf (_("Key to Flags:\n\
6653   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6654   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6655   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6656       if (filedata->file_header.e_machine == EM_X86_64
6657           || filedata->file_header.e_machine == EM_L1OM
6658           || filedata->file_header.e_machine == EM_K1OM)
6659         printf (_("l (large), "));
6660       else if (filedata->file_header.e_machine == EM_ARM)
6661         printf (_("y (purecode), "));
6662       else if (filedata->file_header.e_machine == EM_PPC)
6663         printf (_("v (VLE), "));
6664       printf ("p (processor specific)\n");
6665     }
6666
6667   return TRUE;
6668 }
6669
6670 static const char *
6671 get_group_flags (unsigned int flags)
6672 {
6673   static char buff[128];
6674
6675   if (flags == 0)
6676     return "";
6677   else if (flags == GRP_COMDAT)
6678     return "COMDAT ";
6679
6680   snprintf (buff, 14, _("[0x%x: "), flags);
6681
6682   flags &= ~ GRP_COMDAT;
6683   if (flags & GRP_MASKOS)
6684     {
6685       strcat (buff, "<OS specific>");
6686       flags &= ~ GRP_MASKOS;
6687     }
6688
6689   if (flags & GRP_MASKPROC)
6690     {
6691       strcat (buff, "<PROC specific>");
6692       flags &= ~ GRP_MASKPROC;
6693     }
6694
6695   if (flags)
6696     strcat (buff, "<unknown>");
6697
6698   strcat (buff, "]");
6699   return buff;
6700 }
6701
6702 static bfd_boolean
6703 process_section_groups (Filedata * filedata)
6704 {
6705   Elf_Internal_Shdr * section;
6706   unsigned int i;
6707   struct group * group;
6708   Elf_Internal_Shdr * symtab_sec;
6709   Elf_Internal_Shdr * strtab_sec;
6710   Elf_Internal_Sym * symtab;
6711   unsigned long num_syms;
6712   char * strtab;
6713   size_t strtab_size;
6714
6715   /* Don't process section groups unless needed.  */
6716   if (!do_unwind && !do_section_groups)
6717     return TRUE;
6718
6719   if (filedata->file_header.e_shnum == 0)
6720     {
6721       if (do_section_groups)
6722         printf (_("\nThere are no sections to group in this file.\n"));
6723
6724       return TRUE;
6725     }
6726
6727   if (filedata->section_headers == NULL)
6728     {
6729       error (_("Section headers are not available!\n"));
6730       /* PR 13622: This can happen with a corrupt ELF header.  */
6731       return FALSE;
6732     }
6733
6734   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6735                                                      sizeof (struct group *));
6736
6737   if (section_headers_groups == NULL)
6738     {
6739       error (_("Out of memory reading %u section group headers\n"),
6740              filedata->file_header.e_shnum);
6741       return FALSE;
6742     }
6743
6744   /* Scan the sections for the group section.  */
6745   group_count = 0;
6746   for (i = 0, section = filedata->section_headers;
6747        i < filedata->file_header.e_shnum;
6748        i++, section++)
6749     if (section->sh_type == SHT_GROUP)
6750       group_count++;
6751
6752   if (group_count == 0)
6753     {
6754       if (do_section_groups)
6755         printf (_("\nThere are no section groups in this file.\n"));
6756
6757       return TRUE;
6758     }
6759
6760   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6761
6762   if (section_groups == NULL)
6763     {
6764       error (_("Out of memory reading %lu groups\n"),
6765              (unsigned long) group_count);
6766       return FALSE;
6767     }
6768
6769   symtab_sec = NULL;
6770   strtab_sec = NULL;
6771   symtab = NULL;
6772   num_syms = 0;
6773   strtab = NULL;
6774   strtab_size = 0;
6775   for (i = 0, section = filedata->section_headers, group = section_groups;
6776        i < filedata->file_header.e_shnum;
6777        i++, section++)
6778     {
6779       if (section->sh_type == SHT_GROUP)
6780         {
6781           const char * name = printable_section_name (filedata, section);
6782           const char * group_name;
6783           unsigned char * start;
6784           unsigned char * indices;
6785           unsigned int entry, j, size;
6786           Elf_Internal_Shdr * sec;
6787           Elf_Internal_Sym * sym;
6788
6789           /* Get the symbol table.  */
6790           if (section->sh_link >= filedata->file_header.e_shnum
6791               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6792                   != SHT_SYMTAB))
6793             {
6794               error (_("Bad sh_link in group section `%s'\n"), name);
6795               continue;
6796             }
6797
6798           if (symtab_sec != sec)
6799             {
6800               symtab_sec = sec;
6801               if (symtab)
6802                 free (symtab);
6803               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6804             }
6805
6806           if (symtab == NULL)
6807             {
6808               error (_("Corrupt header in group section `%s'\n"), name);
6809               continue;
6810             }
6811
6812           if (section->sh_info >= num_syms)
6813             {
6814               error (_("Bad sh_info in group section `%s'\n"), name);
6815               continue;
6816             }
6817
6818           sym = symtab + section->sh_info;
6819
6820           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6821             {
6822               if (sym->st_shndx == 0
6823                   || sym->st_shndx >= filedata->file_header.e_shnum)
6824                 {
6825                   error (_("Bad sh_info in group section `%s'\n"), name);
6826                   continue;
6827                 }
6828
6829               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6830               strtab_sec = NULL;
6831               if (strtab)
6832                 free (strtab);
6833               strtab = NULL;
6834               strtab_size = 0;
6835             }
6836           else
6837             {
6838               /* Get the string table.  */
6839               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6840                 {
6841                   strtab_sec = NULL;
6842                   if (strtab)
6843                     free (strtab);
6844                   strtab = NULL;
6845                   strtab_size = 0;
6846                 }
6847               else if (strtab_sec
6848                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6849                 {
6850                   strtab_sec = sec;
6851                   if (strtab)
6852                     free (strtab);
6853
6854                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6855                                               1, strtab_sec->sh_size,
6856                                               _("string table"));
6857                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6858                 }
6859               group_name = sym->st_name < strtab_size
6860                 ? strtab + sym->st_name : _("<corrupt>");
6861             }
6862
6863           /* PR 17531: file: loop.  */
6864           if (section->sh_entsize > section->sh_size)
6865             {
6866               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6867                      printable_section_name (filedata, section),
6868                      (unsigned long) section->sh_entsize,
6869                      (unsigned long) section->sh_size);
6870               break;
6871             }
6872
6873           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6874                                               1, section->sh_size,
6875                                               _("section data"));
6876           if (start == NULL)
6877             continue;
6878
6879           indices = start;
6880           size = (section->sh_size / section->sh_entsize) - 1;
6881           entry = byte_get (indices, 4);
6882           indices += 4;
6883
6884           if (do_section_groups)
6885             {
6886               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6887                       get_group_flags (entry), i, name, group_name, size);
6888
6889               printf (_("   [Index]    Name\n"));
6890             }
6891
6892           group->group_index = i;
6893
6894           for (j = 0; j < size; j++)
6895             {
6896               struct group_list * g;
6897
6898               entry = byte_get (indices, 4);
6899               indices += 4;
6900
6901               if (entry >= filedata->file_header.e_shnum)
6902                 {
6903                   static unsigned num_group_errors = 0;
6904
6905                   if (num_group_errors ++ < 10)
6906                     {
6907                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6908                              entry, i, filedata->file_header.e_shnum - 1);
6909                       if (num_group_errors == 10)
6910                         warn (_("Further error messages about overlarge group section indices suppressed\n"));
6911                     }
6912                   continue;
6913                 }
6914
6915               if (section_headers_groups [entry] != NULL)
6916                 {
6917                   if (entry)
6918                     {
6919                       static unsigned num_errs = 0;
6920
6921                       if (num_errs ++ < 10)
6922                         {
6923                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6924                                  entry, i,
6925                                  section_headers_groups [entry]->group_index);
6926                           if (num_errs == 10)
6927                             warn (_("Further error messages about already contained group sections suppressed\n"));
6928                         }
6929                       continue;
6930                     }
6931                   else
6932                     {
6933                       /* Intel C/C++ compiler may put section 0 in a
6934                          section group.  We just warn it the first time
6935                          and ignore it afterwards.  */
6936                       static bfd_boolean warned = FALSE;
6937                       if (!warned)
6938                         {
6939                           error (_("section 0 in group section [%5u]\n"),
6940                                  section_headers_groups [entry]->group_index);
6941                           warned = TRUE;
6942                         }
6943                     }
6944                 }
6945
6946               section_headers_groups [entry] = group;
6947
6948               if (do_section_groups)
6949                 {
6950                   sec = filedata->section_headers + entry;
6951                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6952                 }
6953
6954               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6955               g->section_index = entry;
6956               g->next = group->root;
6957               group->root = g;
6958             }
6959
6960           if (start)
6961             free (start);
6962
6963           group++;
6964         }
6965     }
6966
6967   if (symtab)
6968     free (symtab);
6969   if (strtab)
6970     free (strtab);
6971   return TRUE;
6972 }
6973
6974 /* Data used to display dynamic fixups.  */
6975
6976 struct ia64_vms_dynfixup
6977 {
6978   bfd_vma needed_ident;         /* Library ident number.  */
6979   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6980   bfd_vma fixup_needed;         /* Index of the library.  */
6981   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6982   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6983 };
6984
6985 /* Data used to display dynamic relocations.  */
6986
6987 struct ia64_vms_dynimgrela
6988 {
6989   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6990   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6991 };
6992
6993 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6994    library).  */
6995
6996 static bfd_boolean
6997 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6998                               struct ia64_vms_dynfixup *  fixup,
6999                               const char *                strtab,
7000                               unsigned int                strtab_sz)
7001 {
7002   Elf64_External_VMS_IMAGE_FIXUP * imfs;
7003   long i;
7004   const char * lib_name;
7005
7006   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
7007                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
7008                    _("dynamic section image fixups"));
7009   if (!imfs)
7010     return FALSE;
7011
7012   if (fixup->needed < strtab_sz)
7013     lib_name = strtab + fixup->needed;
7014   else
7015     {
7016       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7017             (unsigned long) fixup->needed);
7018       lib_name = "???";
7019     }
7020   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7021           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
7022   printf
7023     (_("Seg Offset           Type                             SymVec DataType\n"));
7024
7025   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
7026     {
7027       unsigned int type;
7028       const char *rtype;
7029
7030       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
7031       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7032       type = BYTE_GET (imfs [i].type);
7033       rtype = elf_ia64_reloc_type (type);
7034       if (rtype == NULL)
7035         printf (" 0x%08x                       ", type);
7036       else
7037         printf (" %-32s ", rtype);
7038       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7039       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7040     }
7041
7042   free (imfs);
7043   return TRUE;
7044 }
7045
7046 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
7047
7048 static bfd_boolean
7049 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7050 {
7051   Elf64_External_VMS_IMAGE_RELA *imrs;
7052   long i;
7053
7054   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7055                    1, imgrela->img_rela_cnt * sizeof (*imrs),
7056                    _("dynamic section image relocations"));
7057   if (!imrs)
7058     return FALSE;
7059
7060   printf (_("\nImage relocs\n"));
7061   printf
7062     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
7063
7064   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7065     {
7066       unsigned int type;
7067       const char *rtype;
7068
7069       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7070       printf ("%08" BFD_VMA_FMT "x ",
7071               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7072       type = BYTE_GET (imrs [i].type);
7073       rtype = elf_ia64_reloc_type (type);
7074       if (rtype == NULL)
7075         printf ("0x%08x                      ", type);
7076       else
7077         printf ("%-31s ", rtype);
7078       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7079       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7080       printf ("%08" BFD_VMA_FMT "x\n",
7081               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7082     }
7083
7084   free (imrs);
7085   return TRUE;
7086 }
7087
7088 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
7089
7090 static bfd_boolean
7091 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7092 {
7093   struct ia64_vms_dynfixup fixup;
7094   struct ia64_vms_dynimgrela imgrela;
7095   Elf_Internal_Dyn *entry;
7096   bfd_vma strtab_off = 0;
7097   bfd_vma strtab_sz = 0;
7098   char *strtab = NULL;
7099   bfd_boolean res = TRUE;
7100
7101   memset (&fixup, 0, sizeof (fixup));
7102   memset (&imgrela, 0, sizeof (imgrela));
7103
7104   /* Note: the order of the entries is specified by the OpenVMS specs.  */
7105   for (entry = dynamic_section;
7106        entry < dynamic_section + dynamic_nent;
7107        entry++)
7108     {
7109       switch (entry->d_tag)
7110         {
7111         case DT_IA_64_VMS_STRTAB_OFFSET:
7112           strtab_off = entry->d_un.d_val;
7113           break;
7114         case DT_STRSZ:
7115           strtab_sz = entry->d_un.d_val;
7116           if (strtab == NULL)
7117             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7118                                1, strtab_sz, _("dynamic string section"));
7119           break;
7120
7121         case DT_IA_64_VMS_NEEDED_IDENT:
7122           fixup.needed_ident = entry->d_un.d_val;
7123           break;
7124         case DT_NEEDED:
7125           fixup.needed = entry->d_un.d_val;
7126           break;
7127         case DT_IA_64_VMS_FIXUP_NEEDED:
7128           fixup.fixup_needed = entry->d_un.d_val;
7129           break;
7130         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7131           fixup.fixup_rela_cnt = entry->d_un.d_val;
7132           break;
7133         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7134           fixup.fixup_rela_off = entry->d_un.d_val;
7135           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7136             res = FALSE;
7137           break;
7138         case DT_IA_64_VMS_IMG_RELA_CNT:
7139           imgrela.img_rela_cnt = entry->d_un.d_val;
7140           break;
7141         case DT_IA_64_VMS_IMG_RELA_OFF:
7142           imgrela.img_rela_off = entry->d_un.d_val;
7143           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7144             res = FALSE;
7145           break;
7146
7147         default:
7148           break;
7149         }
7150     }
7151
7152   if (strtab != NULL)
7153     free (strtab);
7154
7155   return res;
7156 }
7157
7158 static struct
7159 {
7160   const char * name;
7161   int reloc;
7162   int size;
7163   int rela;
7164 }
7165   dynamic_relocations [] =
7166 {
7167   { "REL", DT_REL, DT_RELSZ, FALSE },
7168   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7169   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7170 };
7171
7172 /* Process the reloc section.  */
7173
7174 static bfd_boolean
7175 process_relocs (Filedata * filedata)
7176 {
7177   unsigned long rel_size;
7178   unsigned long rel_offset;
7179
7180   if (!do_reloc)
7181     return TRUE;
7182
7183   if (do_using_dynamic)
7184     {
7185       int          is_rela;
7186       const char * name;
7187       bfd_boolean  has_dynamic_reloc;
7188       unsigned int i;
7189
7190       has_dynamic_reloc = FALSE;
7191
7192       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7193         {
7194           is_rela = dynamic_relocations [i].rela;
7195           name = dynamic_relocations [i].name;
7196           rel_size = dynamic_info [dynamic_relocations [i].size];
7197           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7198
7199           if (rel_size)
7200             has_dynamic_reloc = TRUE;
7201
7202           if (is_rela == UNKNOWN)
7203             {
7204               if (dynamic_relocations [i].reloc == DT_JMPREL)
7205                 switch (dynamic_info[DT_PLTREL])
7206                   {
7207                   case DT_REL:
7208                     is_rela = FALSE;
7209                     break;
7210                   case DT_RELA:
7211                     is_rela = TRUE;
7212                     break;
7213                   }
7214             }
7215
7216           if (rel_size)
7217             {
7218               printf
7219                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7220                  name, rel_offset, rel_size);
7221
7222               dump_relocations (filedata,
7223                                 offset_from_vma (filedata, rel_offset, rel_size),
7224                                 rel_size,
7225                                 dynamic_symbols, num_dynamic_syms,
7226                                 dynamic_strings, dynamic_strings_length,
7227                                 is_rela, TRUE /* is_dynamic */);
7228             }
7229         }
7230
7231       if (is_ia64_vms (filedata))
7232         if (process_ia64_vms_dynamic_relocs (filedata))
7233           has_dynamic_reloc = TRUE;
7234
7235       if (! has_dynamic_reloc)
7236         printf (_("\nThere are no dynamic relocations in this file.\n"));
7237     }
7238   else
7239     {
7240       Elf_Internal_Shdr * section;
7241       unsigned long i;
7242       bfd_boolean found = FALSE;
7243
7244       for (i = 0, section = filedata->section_headers;
7245            i < filedata->file_header.e_shnum;
7246            i++, section++)
7247         {
7248           if (   section->sh_type != SHT_RELA
7249               && section->sh_type != SHT_REL)
7250             continue;
7251
7252           rel_offset = section->sh_offset;
7253           rel_size   = section->sh_size;
7254
7255           if (rel_size)
7256             {
7257               Elf_Internal_Shdr * strsec;
7258               int is_rela;
7259               unsigned long num_rela;
7260
7261               printf (_("\nRelocation section "));
7262
7263               if (filedata->string_table == NULL)
7264                 printf ("%d", section->sh_name);
7265               else
7266                 printf ("'%s'", printable_section_name (filedata, section));
7267
7268               num_rela = rel_size / section->sh_entsize;
7269               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7270                                 " at offset 0x%lx contains %lu entries:\n",
7271                                 num_rela),
7272                       rel_offset, num_rela);
7273
7274               is_rela = section->sh_type == SHT_RELA;
7275
7276               if (section->sh_link != 0
7277                   && section->sh_link < filedata->file_header.e_shnum)
7278                 {
7279                   Elf_Internal_Shdr * symsec;
7280                   Elf_Internal_Sym *  symtab;
7281                   unsigned long nsyms;
7282                   unsigned long strtablen = 0;
7283                   char * strtab = NULL;
7284
7285                   symsec = filedata->section_headers + section->sh_link;
7286                   if (symsec->sh_type != SHT_SYMTAB
7287                       && symsec->sh_type != SHT_DYNSYM)
7288                     continue;
7289
7290                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7291
7292                   if (symtab == NULL)
7293                     continue;
7294
7295                   if (symsec->sh_link != 0
7296                       && symsec->sh_link < filedata->file_header.e_shnum)
7297                     {
7298                       strsec = filedata->section_headers + symsec->sh_link;
7299
7300                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7301                                                   1, strsec->sh_size,
7302                                                   _("string table"));
7303                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7304                     }
7305
7306                   dump_relocations (filedata, rel_offset, rel_size,
7307                                     symtab, nsyms, strtab, strtablen,
7308                                     is_rela,
7309                                     symsec->sh_type == SHT_DYNSYM);
7310                   if (strtab)
7311                     free (strtab);
7312                   free (symtab);
7313                 }
7314               else
7315                 dump_relocations (filedata, rel_offset, rel_size,
7316                                   NULL, 0, NULL, 0, is_rela,
7317                                   FALSE /* is_dynamic */);
7318
7319               found = TRUE;
7320             }
7321         }
7322
7323       if (! found)
7324         {
7325           /* Users sometimes forget the -D option, so try to be helpful.  */
7326           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7327             {
7328               if (dynamic_info [dynamic_relocations [i].size])
7329                 {
7330                   printf (_("\nThere are no static relocations in this file."));
7331                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7332
7333                   break;
7334                 }
7335             }
7336           if (i == ARRAY_SIZE (dynamic_relocations))
7337             printf (_("\nThere are no relocations in this file.\n"));
7338         }
7339     }
7340
7341   return TRUE;
7342 }
7343
7344 /* An absolute address consists of a section and an offset.  If the
7345    section is NULL, the offset itself is the address, otherwise, the
7346    address equals to LOAD_ADDRESS(section) + offset.  */
7347
7348 struct absaddr
7349 {
7350   unsigned short section;
7351   bfd_vma offset;
7352 };
7353
7354 #define ABSADDR(a) \
7355   ((a).section \
7356    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7357    : (a).offset)
7358
7359 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7360    name, if found, and the offset from the symbol to ADDR.  */
7361
7362 static void
7363 find_symbol_for_address (Filedata *          filedata,
7364                          Elf_Internal_Sym *  symtab,
7365                          unsigned long       nsyms,
7366                          const char *        strtab,
7367                          unsigned long       strtab_size,
7368                          struct absaddr      addr,
7369                          const char **       symname,
7370                          bfd_vma *           offset)
7371 {
7372   bfd_vma dist = 0x100000;
7373   Elf_Internal_Sym * sym;
7374   Elf_Internal_Sym * beg;
7375   Elf_Internal_Sym * end;
7376   Elf_Internal_Sym * best = NULL;
7377
7378   REMOVE_ARCH_BITS (addr.offset);
7379   beg = symtab;
7380   end = symtab + nsyms;
7381
7382   while (beg < end)
7383     {
7384       bfd_vma value;
7385
7386       sym = beg + (end - beg) / 2;
7387
7388       value = sym->st_value;
7389       REMOVE_ARCH_BITS (value);
7390
7391       if (sym->st_name != 0
7392           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7393           && addr.offset >= value
7394           && addr.offset - value < dist)
7395         {
7396           best = sym;
7397           dist = addr.offset - value;
7398           if (!dist)
7399             break;
7400         }
7401
7402       if (addr.offset < value)
7403         end = sym;
7404       else
7405         beg = sym + 1;
7406     }
7407
7408   if (best)
7409     {
7410       *symname = (best->st_name >= strtab_size
7411                   ? _("<corrupt>") : strtab + best->st_name);
7412       *offset = dist;
7413       return;
7414     }
7415
7416   *symname = NULL;
7417   *offset = addr.offset;
7418 }
7419
7420 static /* signed */ int
7421 symcmp (const void *p, const void *q)
7422 {
7423   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7424   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7425
7426   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7427 }
7428
7429 /* Process the unwind section.  */
7430
7431 #include "unwind-ia64.h"
7432
7433 struct ia64_unw_table_entry
7434 {
7435   struct absaddr start;
7436   struct absaddr end;
7437   struct absaddr info;
7438 };
7439
7440 struct ia64_unw_aux_info
7441 {
7442   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7443   unsigned long                 table_len;      /* Length of unwind table.  */
7444   unsigned char *               info;           /* Unwind info.  */
7445   unsigned long                 info_size;      /* Size of unwind info.  */
7446   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7447   bfd_vma                       seg_base;       /* Starting address of segment.  */
7448   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7449   unsigned long                 nsyms;          /* Number of symbols.  */
7450   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7451   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7452   char *                        strtab;         /* The string table.  */
7453   unsigned long                 strtab_size;    /* Size of string table.  */
7454 };
7455
7456 static bfd_boolean
7457 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7458 {
7459   struct ia64_unw_table_entry * tp;
7460   unsigned long j, nfuns;
7461   int in_body;
7462   bfd_boolean res = TRUE;
7463
7464   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7465   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7466     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7467       aux->funtab[nfuns++] = aux->symtab[j];
7468   aux->nfuns = nfuns;
7469   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7470
7471   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7472     {
7473       bfd_vma stamp;
7474       bfd_vma offset;
7475       const unsigned char * dp;
7476       const unsigned char * head;
7477       const unsigned char * end;
7478       const char * procname;
7479
7480       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7481                                aux->strtab_size, tp->start, &procname, &offset);
7482
7483       fputs ("\n<", stdout);
7484
7485       if (procname)
7486         {
7487           fputs (procname, stdout);
7488
7489           if (offset)
7490             printf ("+%lx", (unsigned long) offset);
7491         }
7492
7493       fputs (">: [", stdout);
7494       print_vma (tp->start.offset, PREFIX_HEX);
7495       fputc ('-', stdout);
7496       print_vma (tp->end.offset, PREFIX_HEX);
7497       printf ("], info at +0x%lx\n",
7498               (unsigned long) (tp->info.offset - aux->seg_base));
7499
7500       /* PR 17531: file: 86232b32.  */
7501       if (aux->info == NULL)
7502         continue;
7503
7504       /* PR 17531: file: 0997b4d1.  */
7505       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7506         {
7507           warn (_("Invalid offset %lx in table entry %ld\n"),
7508                 (long) tp->info.offset, (long) (tp - aux->table));
7509           res = FALSE;
7510           continue;
7511         }
7512
7513       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7514       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7515
7516       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7517               (unsigned) UNW_VER (stamp),
7518               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7519               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7520               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7521               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7522
7523       if (UNW_VER (stamp) != 1)
7524         {
7525           printf (_("\tUnknown version.\n"));
7526           continue;
7527         }
7528
7529       in_body = 0;
7530       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7531       /* PR 17531: file: 16ceda89.  */
7532       if (end > aux->info + aux->info_size)
7533         end = aux->info + aux->info_size;
7534       for (dp = head + 8; dp < end;)
7535         dp = unw_decode (dp, in_body, & in_body, end);
7536     }
7537
7538   free (aux->funtab);
7539
7540   return res;
7541 }
7542
7543 static bfd_boolean
7544 slurp_ia64_unwind_table (Filedata *                  filedata,
7545                          struct ia64_unw_aux_info *  aux,
7546                          Elf_Internal_Shdr *         sec)
7547 {
7548   unsigned long size, nrelas, i;
7549   Elf_Internal_Phdr * seg;
7550   struct ia64_unw_table_entry * tep;
7551   Elf_Internal_Shdr * relsec;
7552   Elf_Internal_Rela * rela;
7553   Elf_Internal_Rela * rp;
7554   unsigned char * table;
7555   unsigned char * tp;
7556   Elf_Internal_Sym * sym;
7557   const char * relname;
7558
7559   aux->table_len = 0;
7560
7561   /* First, find the starting address of the segment that includes
7562      this section: */
7563
7564   if (filedata->file_header.e_phnum)
7565     {
7566       if (! get_program_headers (filedata))
7567           return FALSE;
7568
7569       for (seg = filedata->program_headers;
7570            seg < filedata->program_headers + filedata->file_header.e_phnum;
7571            ++seg)
7572         {
7573           if (seg->p_type != PT_LOAD)
7574             continue;
7575
7576           if (sec->sh_addr >= seg->p_vaddr
7577               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7578             {
7579               aux->seg_base = seg->p_vaddr;
7580               break;
7581             }
7582         }
7583     }
7584
7585   /* Second, build the unwind table from the contents of the unwind section:  */
7586   size = sec->sh_size;
7587   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7588                                       _("unwind table"));
7589   if (!table)
7590     return FALSE;
7591
7592   aux->table_len = size / (3 * eh_addr_size);
7593   aux->table = (struct ia64_unw_table_entry *)
7594     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7595   tep = aux->table;
7596
7597   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7598     {
7599       tep->start.section = SHN_UNDEF;
7600       tep->end.section   = SHN_UNDEF;
7601       tep->info.section  = SHN_UNDEF;
7602       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7603       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7604       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7605       tep->start.offset += aux->seg_base;
7606       tep->end.offset   += aux->seg_base;
7607       tep->info.offset  += aux->seg_base;
7608     }
7609   free (table);
7610
7611   /* Third, apply any relocations to the unwind table:  */
7612   for (relsec = filedata->section_headers;
7613        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7614        ++relsec)
7615     {
7616       if (relsec->sh_type != SHT_RELA
7617           || relsec->sh_info >= filedata->file_header.e_shnum
7618           || filedata->section_headers + relsec->sh_info != sec)
7619         continue;
7620
7621       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7622                               & rela, & nrelas))
7623         {
7624           free (aux->table);
7625           aux->table = NULL;
7626           aux->table_len = 0;
7627           return FALSE;
7628         }
7629
7630       for (rp = rela; rp < rela + nrelas; ++rp)
7631         {
7632           unsigned int sym_ndx;
7633           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7634           relname = elf_ia64_reloc_type (r_type);
7635
7636           /* PR 17531: file: 9fa67536.  */
7637           if (relname == NULL)
7638             {
7639               warn (_("Skipping unknown relocation type: %u\n"), r_type);
7640               continue;
7641             }
7642
7643           if (! const_strneq (relname, "R_IA64_SEGREL"))
7644             {
7645               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7646               continue;
7647             }
7648
7649           i = rp->r_offset / (3 * eh_addr_size);
7650
7651           /* PR 17531: file: 5bc8d9bf.  */
7652           if (i >= aux->table_len)
7653             {
7654               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7655               continue;
7656             }
7657
7658           sym_ndx = get_reloc_symindex (rp->r_info);
7659           if (sym_ndx >= aux->nsyms)
7660             {
7661               warn (_("Skipping reloc with invalid symbol index: %u\n"),
7662                     sym_ndx);
7663               continue;
7664             }
7665           sym = aux->symtab + sym_ndx;
7666
7667           switch (rp->r_offset / eh_addr_size % 3)
7668             {
7669             case 0:
7670               aux->table[i].start.section = sym->st_shndx;
7671               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7672               break;
7673             case 1:
7674               aux->table[i].end.section   = sym->st_shndx;
7675               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7676               break;
7677             case 2:
7678               aux->table[i].info.section  = sym->st_shndx;
7679               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7680               break;
7681             default:
7682               break;
7683             }
7684         }
7685
7686       free (rela);
7687     }
7688
7689   return TRUE;
7690 }
7691
7692 static bfd_boolean
7693 ia64_process_unwind (Filedata * filedata)
7694 {
7695   Elf_Internal_Shdr * sec;
7696   Elf_Internal_Shdr * unwsec = NULL;
7697   Elf_Internal_Shdr * strsec;
7698   unsigned long i, unwcount = 0, unwstart = 0;
7699   struct ia64_unw_aux_info aux;
7700   bfd_boolean res = TRUE;
7701
7702   memset (& aux, 0, sizeof (aux));
7703
7704   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7705     {
7706       if (sec->sh_type == SHT_SYMTAB
7707           && sec->sh_link < filedata->file_header.e_shnum)
7708         {
7709           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7710
7711           strsec = filedata->section_headers + sec->sh_link;
7712           if (aux.strtab != NULL)
7713             {
7714               error (_("Multiple auxillary string tables encountered\n"));
7715               free (aux.strtab);
7716               res = FALSE;
7717             }
7718           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7719                                           1, strsec->sh_size,
7720                                           _("string table"));
7721           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7722         }
7723       else if (sec->sh_type == SHT_IA_64_UNWIND)
7724         unwcount++;
7725     }
7726
7727   if (!unwcount)
7728     printf (_("\nThere are no unwind sections in this file.\n"));
7729
7730   while (unwcount-- > 0)
7731     {
7732       char * suffix;
7733       size_t len, len2;
7734
7735       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7736            i < filedata->file_header.e_shnum; ++i, ++sec)
7737         if (sec->sh_type == SHT_IA_64_UNWIND)
7738           {
7739             unwsec = sec;
7740             break;
7741           }
7742       /* We have already counted the number of SHT_IA64_UNWIND
7743          sections so the loop above should never fail.  */
7744       assert (unwsec != NULL);
7745
7746       unwstart = i + 1;
7747       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7748
7749       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7750         {
7751           /* We need to find which section group it is in.  */
7752           struct group_list * g;
7753
7754           if (section_headers_groups == NULL
7755               || section_headers_groups [i] == NULL)
7756             i = filedata->file_header.e_shnum;
7757           else
7758             {
7759               g = section_headers_groups [i]->root;
7760
7761               for (; g != NULL; g = g->next)
7762                 {
7763                   sec = filedata->section_headers + g->section_index;
7764
7765                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7766                     break;
7767                 }
7768
7769               if (g == NULL)
7770                 i = filedata->file_header.e_shnum;
7771             }
7772         }
7773       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7774         {
7775           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7776           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7777           suffix = SECTION_NAME (unwsec) + len;
7778           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7779                ++i, ++sec)
7780             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7781                 && streq (SECTION_NAME (sec) + len2, suffix))
7782               break;
7783         }
7784       else
7785         {
7786           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7787              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7788           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7789           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7790           suffix = "";
7791           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7792             suffix = SECTION_NAME (unwsec) + len;
7793           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7794                ++i, ++sec)
7795             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7796                 && streq (SECTION_NAME (sec) + len2, suffix))
7797               break;
7798         }
7799
7800       if (i == filedata->file_header.e_shnum)
7801         {
7802           printf (_("\nCould not find unwind info section for "));
7803
7804           if (filedata->string_table == NULL)
7805             printf ("%d", unwsec->sh_name);
7806           else
7807             printf ("'%s'", printable_section_name (filedata, unwsec));
7808         }
7809       else
7810         {
7811           aux.info_addr = sec->sh_addr;
7812           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7813                                                  sec->sh_size,
7814                                                  _("unwind info"));
7815           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7816
7817           printf (_("\nUnwind section "));
7818
7819           if (filedata->string_table == NULL)
7820             printf ("%d", unwsec->sh_name);
7821           else
7822             printf ("'%s'", printable_section_name (filedata, unwsec));
7823
7824           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7825                   (unsigned long) unwsec->sh_offset,
7826                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7827
7828           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7829               && aux.table_len > 0)
7830             dump_ia64_unwind (filedata, & aux);
7831
7832           if (aux.table)
7833             free ((char *) aux.table);
7834           if (aux.info)
7835             free ((char *) aux.info);
7836           aux.table = NULL;
7837           aux.info = NULL;
7838         }
7839     }
7840
7841   if (aux.symtab)
7842     free (aux.symtab);
7843   if (aux.strtab)
7844     free ((char *) aux.strtab);
7845
7846   return res;
7847 }
7848
7849 struct hppa_unw_table_entry
7850 {
7851   struct absaddr start;
7852   struct absaddr end;
7853   unsigned int Cannot_unwind:1;                 /* 0 */
7854   unsigned int Millicode:1;                     /* 1 */
7855   unsigned int Millicode_save_sr0:1;            /* 2 */
7856   unsigned int Region_description:2;            /* 3..4 */
7857   unsigned int reserved1:1;                     /* 5 */
7858   unsigned int Entry_SR:1;                      /* 6 */
7859   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7860   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7861   unsigned int Args_stored:1;                   /* 16 */
7862   unsigned int Variable_Frame:1;                /* 17 */
7863   unsigned int Separate_Package_Body:1;         /* 18 */
7864   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7865   unsigned int Stack_Overflow_Check:1;          /* 20 */
7866   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7867   unsigned int Ada_Region:1;                    /* 22 */
7868   unsigned int cxx_info:1;                      /* 23 */
7869   unsigned int cxx_try_catch:1;                 /* 24 */
7870   unsigned int sched_entry_seq:1;               /* 25 */
7871   unsigned int reserved2:1;                     /* 26 */
7872   unsigned int Save_SP:1;                       /* 27 */
7873   unsigned int Save_RP:1;                       /* 28 */
7874   unsigned int Save_MRP_in_frame:1;             /* 29 */
7875   unsigned int extn_ptr_defined:1;              /* 30 */
7876   unsigned int Cleanup_defined:1;               /* 31 */
7877
7878   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7879   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7880   unsigned int Large_frame:1;                   /* 2 */
7881   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7882   unsigned int reserved4:1;                     /* 4 */
7883   unsigned int Total_frame_size:27;             /* 5..31 */
7884 };
7885
7886 struct hppa_unw_aux_info
7887 {
7888   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7889   unsigned long                  table_len;     /* Length of unwind table.  */
7890   bfd_vma                        seg_base;      /* Starting address of segment.  */
7891   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7892   unsigned long                  nsyms;         /* Number of symbols.  */
7893   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7894   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7895   char *                         strtab;        /* The string table.  */
7896   unsigned long                  strtab_size;   /* Size of string table.  */
7897 };
7898
7899 static bfd_boolean
7900 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7901 {
7902   struct hppa_unw_table_entry * tp;
7903   unsigned long j, nfuns;
7904   bfd_boolean res = TRUE;
7905
7906   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7907   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7908     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7909       aux->funtab[nfuns++] = aux->symtab[j];
7910   aux->nfuns = nfuns;
7911   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7912
7913   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7914     {
7915       bfd_vma offset;
7916       const char * procname;
7917
7918       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7919                                aux->strtab_size, tp->start, &procname,
7920                                &offset);
7921
7922       fputs ("\n<", stdout);
7923
7924       if (procname)
7925         {
7926           fputs (procname, stdout);
7927
7928           if (offset)
7929             printf ("+%lx", (unsigned long) offset);
7930         }
7931
7932       fputs (">: [", stdout);
7933       print_vma (tp->start.offset, PREFIX_HEX);
7934       fputc ('-', stdout);
7935       print_vma (tp->end.offset, PREFIX_HEX);
7936       printf ("]\n\t");
7937
7938 #define PF(_m) if (tp->_m) printf (#_m " ");
7939 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7940       PF(Cannot_unwind);
7941       PF(Millicode);
7942       PF(Millicode_save_sr0);
7943       /* PV(Region_description);  */
7944       PF(Entry_SR);
7945       PV(Entry_FR);
7946       PV(Entry_GR);
7947       PF(Args_stored);
7948       PF(Variable_Frame);
7949       PF(Separate_Package_Body);
7950       PF(Frame_Extension_Millicode);
7951       PF(Stack_Overflow_Check);
7952       PF(Two_Instruction_SP_Increment);
7953       PF(Ada_Region);
7954       PF(cxx_info);
7955       PF(cxx_try_catch);
7956       PF(sched_entry_seq);
7957       PF(Save_SP);
7958       PF(Save_RP);
7959       PF(Save_MRP_in_frame);
7960       PF(extn_ptr_defined);
7961       PF(Cleanup_defined);
7962       PF(MPE_XL_interrupt_marker);
7963       PF(HP_UX_interrupt_marker);
7964       PF(Large_frame);
7965       PF(Pseudo_SP_Set);
7966       PV(Total_frame_size);
7967 #undef PF
7968 #undef PV
7969     }
7970
7971   printf ("\n");
7972
7973   free (aux->funtab);
7974
7975   return res;
7976 }
7977
7978 static bfd_boolean
7979 slurp_hppa_unwind_table (Filedata *                  filedata,
7980                          struct hppa_unw_aux_info *  aux,
7981                          Elf_Internal_Shdr *         sec)
7982 {
7983   unsigned long size, unw_ent_size, nentries, nrelas, i;
7984   Elf_Internal_Phdr * seg;
7985   struct hppa_unw_table_entry * tep;
7986   Elf_Internal_Shdr * relsec;
7987   Elf_Internal_Rela * rela;
7988   Elf_Internal_Rela * rp;
7989   unsigned char * table;
7990   unsigned char * tp;
7991   Elf_Internal_Sym * sym;
7992   const char * relname;
7993
7994   /* First, find the starting address of the segment that includes
7995      this section.  */
7996   if (filedata->file_header.e_phnum)
7997     {
7998       if (! get_program_headers (filedata))
7999         return FALSE;
8000
8001       for (seg = filedata->program_headers;
8002            seg < filedata->program_headers + filedata->file_header.e_phnum;
8003            ++seg)
8004         {
8005           if (seg->p_type != PT_LOAD)
8006             continue;
8007
8008           if (sec->sh_addr >= seg->p_vaddr
8009               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
8010             {
8011               aux->seg_base = seg->p_vaddr;
8012               break;
8013             }
8014         }
8015     }
8016
8017   /* Second, build the unwind table from the contents of the unwind
8018      section.  */
8019   size = sec->sh_size;
8020   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
8021                                       _("unwind table"));
8022   if (!table)
8023     return FALSE;
8024
8025   unw_ent_size = 16;
8026   nentries = size / unw_ent_size;
8027   size = unw_ent_size * nentries;
8028
8029   tep = aux->table = (struct hppa_unw_table_entry *)
8030       xcmalloc (nentries, sizeof (aux->table[0]));
8031
8032   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8033     {
8034       unsigned int tmp1, tmp2;
8035
8036       tep->start.section = SHN_UNDEF;
8037       tep->end.section   = SHN_UNDEF;
8038
8039       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8040       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8041       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8042       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8043
8044       tep->start.offset += aux->seg_base;
8045       tep->end.offset   += aux->seg_base;
8046
8047       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8048       tep->Millicode = (tmp1 >> 30) & 0x1;
8049       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8050       tep->Region_description = (tmp1 >> 27) & 0x3;
8051       tep->reserved1 = (tmp1 >> 26) & 0x1;
8052       tep->Entry_SR = (tmp1 >> 25) & 0x1;
8053       tep->Entry_FR = (tmp1 >> 21) & 0xf;
8054       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8055       tep->Args_stored = (tmp1 >> 15) & 0x1;
8056       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8057       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8058       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8059       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8060       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8061       tep->Ada_Region = (tmp1 >> 9) & 0x1;
8062       tep->cxx_info = (tmp1 >> 8) & 0x1;
8063       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8064       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8065       tep->reserved2 = (tmp1 >> 5) & 0x1;
8066       tep->Save_SP = (tmp1 >> 4) & 0x1;
8067       tep->Save_RP = (tmp1 >> 3) & 0x1;
8068       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8069       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8070       tep->Cleanup_defined = tmp1 & 0x1;
8071
8072       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8073       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8074       tep->Large_frame = (tmp2 >> 29) & 0x1;
8075       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8076       tep->reserved4 = (tmp2 >> 27) & 0x1;
8077       tep->Total_frame_size = tmp2 & 0x7ffffff;
8078     }
8079   free (table);
8080
8081   /* Third, apply any relocations to the unwind table.  */
8082   for (relsec = filedata->section_headers;
8083        relsec < filedata->section_headers + filedata->file_header.e_shnum;
8084        ++relsec)
8085     {
8086       if (relsec->sh_type != SHT_RELA
8087           || relsec->sh_info >= filedata->file_header.e_shnum
8088           || filedata->section_headers + relsec->sh_info != sec)
8089         continue;
8090
8091       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8092                               & rela, & nrelas))
8093         return FALSE;
8094
8095       for (rp = rela; rp < rela + nrelas; ++rp)
8096         {
8097           unsigned int sym_ndx;
8098           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8099           relname = elf_hppa_reloc_type (r_type);
8100
8101           if (relname == NULL)
8102             {
8103               warn (_("Skipping unknown relocation type: %u\n"), r_type);
8104               continue;
8105             }
8106
8107           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
8108           if (! const_strneq (relname, "R_PARISC_SEGREL"))
8109             {
8110               warn (_("Skipping unexpected relocation type: %s\n"), relname);
8111               continue;
8112             }
8113
8114           i = rp->r_offset / unw_ent_size;
8115           if (i >= aux->table_len)
8116             {
8117               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8118               continue;
8119             }
8120
8121           sym_ndx = get_reloc_symindex (rp->r_info);
8122           if (sym_ndx >= aux->nsyms)
8123             {
8124               warn (_("Skipping reloc with invalid symbol index: %u\n"),
8125                     sym_ndx);
8126               continue;
8127             }
8128           sym = aux->symtab + sym_ndx;
8129
8130           switch ((rp->r_offset % unw_ent_size) / 4)
8131             {
8132             case 0:
8133               aux->table[i].start.section = sym->st_shndx;
8134               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
8135               break;
8136             case 1:
8137               aux->table[i].end.section   = sym->st_shndx;
8138               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
8139               break;
8140             default:
8141               break;
8142             }
8143         }
8144
8145       free (rela);
8146     }
8147
8148   aux->table_len = nentries;
8149
8150   return TRUE;
8151 }
8152
8153 static bfd_boolean
8154 hppa_process_unwind (Filedata * filedata)
8155 {
8156   struct hppa_unw_aux_info aux;
8157   Elf_Internal_Shdr * unwsec = NULL;
8158   Elf_Internal_Shdr * strsec;
8159   Elf_Internal_Shdr * sec;
8160   unsigned long i;
8161   bfd_boolean res = TRUE;
8162
8163   if (filedata->string_table == NULL)
8164     return FALSE;
8165
8166   memset (& aux, 0, sizeof (aux));
8167
8168   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8169     {
8170       if (sec->sh_type == SHT_SYMTAB
8171           && sec->sh_link < filedata->file_header.e_shnum)
8172         {
8173           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8174
8175           strsec = filedata->section_headers + sec->sh_link;
8176           if (aux.strtab != NULL)
8177             {
8178               error (_("Multiple auxillary string tables encountered\n"));
8179               free (aux.strtab);
8180               res = FALSE;
8181             }
8182           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8183                                           1, strsec->sh_size,
8184                                           _("string table"));
8185           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8186         }
8187       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8188         unwsec = sec;
8189     }
8190
8191   if (!unwsec)
8192     printf (_("\nThere are no unwind sections in this file.\n"));
8193
8194   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8195     {
8196       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8197         {
8198           unsigned long num_unwind = sec->sh_size / 16;
8199
8200           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8201                             "contains %lu entry:\n",
8202                             "\nUnwind section '%s' at offset 0x%lx "
8203                             "contains %lu entries:\n",
8204                             num_unwind),
8205                   printable_section_name (filedata, sec),
8206                   (unsigned long) sec->sh_offset,
8207                   num_unwind);
8208
8209           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8210             res = FALSE;
8211
8212           if (res && aux.table_len > 0)
8213             {
8214               if (! dump_hppa_unwind (filedata, &aux))
8215                 res = FALSE;
8216             }
8217
8218           if (aux.table)
8219             free ((char *) aux.table);
8220           aux.table = NULL;
8221         }
8222     }
8223
8224   if (aux.symtab)
8225     free (aux.symtab);
8226   if (aux.strtab)
8227     free ((char *) aux.strtab);
8228
8229   return res;
8230 }
8231
8232 struct arm_section
8233 {
8234   unsigned char *      data;            /* The unwind data.  */
8235   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8236   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8237   unsigned long        nrelas;          /* The number of relocations.  */
8238   unsigned int         rel_type;        /* REL or RELA ?  */
8239   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8240 };
8241
8242 struct arm_unw_aux_info
8243 {
8244   Filedata *          filedata;         /* The file containing the unwind sections.  */
8245   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8246   unsigned long       nsyms;            /* Number of symbols.  */
8247   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8248   unsigned long       nfuns;            /* Number of these symbols.  */
8249   char *              strtab;           /* The file's string table.  */
8250   unsigned long       strtab_size;      /* Size of string table.  */
8251 };
8252
8253 static const char *
8254 arm_print_vma_and_name (Filedata *                 filedata,
8255                         struct arm_unw_aux_info *  aux,
8256                         bfd_vma                    fn,
8257                         struct absaddr             addr)
8258 {
8259   const char *procname;
8260   bfd_vma sym_offset;
8261
8262   if (addr.section == SHN_UNDEF)
8263     addr.offset = fn;
8264
8265   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8266                            aux->strtab_size, addr, &procname,
8267                            &sym_offset);
8268
8269   print_vma (fn, PREFIX_HEX);
8270
8271   if (procname)
8272     {
8273       fputs (" <", stdout);
8274       fputs (procname, stdout);
8275
8276       if (sym_offset)
8277         printf ("+0x%lx", (unsigned long) sym_offset);
8278       fputc ('>', stdout);
8279     }
8280
8281   return procname;
8282 }
8283
8284 static void
8285 arm_free_section (struct arm_section *arm_sec)
8286 {
8287   if (arm_sec->data != NULL)
8288     free (arm_sec->data);
8289
8290   if (arm_sec->rela != NULL)
8291     free (arm_sec->rela);
8292 }
8293
8294 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8295       cached section and install SEC instead.
8296    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8297       and return its valued in * WORDP, relocating if necessary.
8298    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8299       relocation's offset in ADDR.
8300    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8301       into the string table of the symbol associated with the reloc.  If no
8302       reloc was applied store -1 there.
8303    5) Return TRUE upon success, FALSE otherwise.  */
8304
8305 static bfd_boolean
8306 get_unwind_section_word (Filedata *                 filedata,
8307                          struct arm_unw_aux_info *  aux,
8308                          struct arm_section *       arm_sec,
8309                          Elf_Internal_Shdr *        sec,
8310                          bfd_vma                    word_offset,
8311                          unsigned int *             wordp,
8312                          struct absaddr *           addr,
8313                          bfd_vma *                  sym_name)
8314 {
8315   Elf_Internal_Rela *rp;
8316   Elf_Internal_Sym *sym;
8317   const char * relname;
8318   unsigned int word;
8319   bfd_boolean wrapped;
8320
8321   if (sec == NULL || arm_sec == NULL)
8322     return FALSE;
8323
8324   addr->section = SHN_UNDEF;
8325   addr->offset = 0;
8326
8327   if (sym_name != NULL)
8328     *sym_name = (bfd_vma) -1;
8329
8330   /* If necessary, update the section cache.  */
8331   if (sec != arm_sec->sec)
8332     {
8333       Elf_Internal_Shdr *relsec;
8334
8335       arm_free_section (arm_sec);
8336
8337       arm_sec->sec = sec;
8338       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8339                                 sec->sh_size, _("unwind data"));
8340       arm_sec->rela = NULL;
8341       arm_sec->nrelas = 0;
8342
8343       for (relsec = filedata->section_headers;
8344            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8345            ++relsec)
8346         {
8347           if (relsec->sh_info >= filedata->file_header.e_shnum
8348               || filedata->section_headers + relsec->sh_info != sec
8349               /* PR 15745: Check the section type as well.  */
8350               || (relsec->sh_type != SHT_REL
8351                   && relsec->sh_type != SHT_RELA))
8352             continue;
8353
8354           arm_sec->rel_type = relsec->sh_type;
8355           if (relsec->sh_type == SHT_REL)
8356             {
8357               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8358                                      relsec->sh_size,
8359                                      & arm_sec->rela, & arm_sec->nrelas))
8360                 return FALSE;
8361             }
8362           else /* relsec->sh_type == SHT_RELA */
8363             {
8364               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8365                                       relsec->sh_size,
8366                                       & arm_sec->rela, & arm_sec->nrelas))
8367                 return FALSE;
8368             }
8369           break;
8370         }
8371
8372       arm_sec->next_rela = arm_sec->rela;
8373     }
8374
8375   /* If there is no unwind data we can do nothing.  */
8376   if (arm_sec->data == NULL)
8377     return FALSE;
8378
8379   /* If the offset is invalid then fail.  */
8380   if (/* PR 21343 *//* PR 18879 */
8381       sec->sh_size < 4
8382       || word_offset > (sec->sh_size - 4)
8383       || ((bfd_signed_vma) word_offset) < 0)
8384     return FALSE;
8385
8386   /* Get the word at the required offset.  */
8387   word = byte_get (arm_sec->data + word_offset, 4);
8388
8389   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8390   if (arm_sec->rela == NULL)
8391     {
8392       * wordp = word;
8393       return TRUE;
8394     }
8395
8396   /* Look through the relocs to find the one that applies to the provided offset.  */
8397   wrapped = FALSE;
8398   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8399     {
8400       bfd_vma prelval, offset;
8401
8402       if (rp->r_offset > word_offset && !wrapped)
8403         {
8404           rp = arm_sec->rela;
8405           wrapped = TRUE;
8406         }
8407       if (rp->r_offset > word_offset)
8408         break;
8409
8410       if (rp->r_offset & 3)
8411         {
8412           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8413                 (unsigned long) rp->r_offset);
8414           continue;
8415         }
8416
8417       if (rp->r_offset < word_offset)
8418         continue;
8419
8420       /* PR 17531: file: 027-161405-0.004  */
8421       if (aux->symtab == NULL)
8422         continue;
8423
8424       if (arm_sec->rel_type == SHT_REL)
8425         {
8426           offset = word & 0x7fffffff;
8427           if (offset & 0x40000000)
8428             offset |= ~ (bfd_vma) 0x7fffffff;
8429         }
8430       else if (arm_sec->rel_type == SHT_RELA)
8431         offset = rp->r_addend;
8432       else
8433         {
8434           error (_("Unknown section relocation type %d encountered\n"),
8435                  arm_sec->rel_type);
8436           break;
8437         }
8438
8439       /* PR 17531 file: 027-1241568-0.004.  */
8440       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8441         {
8442           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8443                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8444           break;
8445         }
8446
8447       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8448       offset += sym->st_value;
8449       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8450
8451       /* Check that we are processing the expected reloc type.  */
8452       if (filedata->file_header.e_machine == EM_ARM)
8453         {
8454           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8455           if (relname == NULL)
8456             {
8457               warn (_("Skipping unknown ARM relocation type: %d\n"),
8458                     (int) ELF32_R_TYPE (rp->r_info));
8459               continue;
8460             }
8461
8462           if (streq (relname, "R_ARM_NONE"))
8463               continue;
8464
8465           if (! streq (relname, "R_ARM_PREL31"))
8466             {
8467               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8468               continue;
8469             }
8470         }
8471       else if (filedata->file_header.e_machine == EM_TI_C6000)
8472         {
8473           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8474           if (relname == NULL)
8475             {
8476               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8477                     (int) ELF32_R_TYPE (rp->r_info));
8478               continue;
8479             }
8480
8481           if (streq (relname, "R_C6000_NONE"))
8482             continue;
8483
8484           if (! streq (relname, "R_C6000_PREL31"))
8485             {
8486               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8487               continue;
8488             }
8489
8490           prelval >>= 1;
8491         }
8492       else
8493         {
8494           /* This function currently only supports ARM and TI unwinders.  */
8495           warn (_("Only TI and ARM unwinders are currently supported\n"));
8496           break;
8497         }
8498
8499       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8500       addr->section = sym->st_shndx;
8501       addr->offset = offset;
8502
8503       if (sym_name)
8504         * sym_name = sym->st_name;
8505       break;
8506     }
8507
8508   *wordp = word;
8509   arm_sec->next_rela = rp;
8510
8511   return TRUE;
8512 }
8513
8514 static const char *tic6x_unwind_regnames[16] =
8515 {
8516   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8517   "A14", "A13", "A12", "A11", "A10",
8518   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8519 };
8520
8521 static void
8522 decode_tic6x_unwind_regmask (unsigned int mask)
8523 {
8524   int i;
8525
8526   for (i = 12; mask; mask >>= 1, i--)
8527     {
8528       if (mask & 1)
8529         {
8530           fputs (tic6x_unwind_regnames[i], stdout);
8531           if (mask > 1)
8532             fputs (", ", stdout);
8533         }
8534     }
8535 }
8536
8537 #define ADVANCE                                                 \
8538   if (remaining == 0 && more_words)                             \
8539     {                                                           \
8540       data_offset += 4;                                         \
8541       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8542                                      data_offset, & word, & addr, NULL))        \
8543         return FALSE;                                           \
8544       remaining = 4;                                            \
8545       more_words--;                                             \
8546     }                                                           \
8547
8548 #define GET_OP(OP)                      \
8549   ADVANCE;                              \
8550   if (remaining)                        \
8551     {                                   \
8552       remaining--;                      \
8553       (OP) = word >> 24;                \
8554       word <<= 8;                       \
8555     }                                   \
8556   else                                  \
8557     {                                   \
8558       printf (_("[Truncated opcode]\n"));       \
8559       return FALSE;                     \
8560     }                                   \
8561   printf ("0x%02x ", OP)
8562
8563 static bfd_boolean
8564 decode_arm_unwind_bytecode (Filedata *                 filedata,
8565                             struct arm_unw_aux_info *  aux,
8566                             unsigned int               word,
8567                             unsigned int               remaining,
8568                             unsigned int               more_words,
8569                             bfd_vma                    data_offset,
8570                             Elf_Internal_Shdr *        data_sec,
8571                             struct arm_section *       data_arm_sec)
8572 {
8573   struct absaddr addr;
8574   bfd_boolean res = TRUE;
8575
8576   /* Decode the unwinding instructions.  */
8577   while (1)
8578     {
8579       unsigned int op, op2;
8580
8581       ADVANCE;
8582       if (remaining == 0)
8583         break;
8584       remaining--;
8585       op = word >> 24;
8586       word <<= 8;
8587
8588       printf ("  0x%02x ", op);
8589
8590       if ((op & 0xc0) == 0x00)
8591         {
8592           int offset = ((op & 0x3f) << 2) + 4;
8593
8594           printf ("     vsp = vsp + %d", offset);
8595         }
8596       else if ((op & 0xc0) == 0x40)
8597         {
8598           int offset = ((op & 0x3f) << 2) + 4;
8599
8600           printf ("     vsp = vsp - %d", offset);
8601         }
8602       else if ((op & 0xf0) == 0x80)
8603         {
8604           GET_OP (op2);
8605           if (op == 0x80 && op2 == 0)
8606             printf (_("Refuse to unwind"));
8607           else
8608             {
8609               unsigned int mask = ((op & 0x0f) << 8) | op2;
8610               bfd_boolean first = TRUE;
8611               int i;
8612
8613               printf ("pop {");
8614               for (i = 0; i < 12; i++)
8615                 if (mask & (1 << i))
8616                   {
8617                     if (first)
8618                       first = FALSE;
8619                     else
8620                       printf (", ");
8621                     printf ("r%d", 4 + i);
8622                   }
8623               printf ("}");
8624             }
8625         }
8626       else if ((op & 0xf0) == 0x90)
8627         {
8628           if (op == 0x9d || op == 0x9f)
8629             printf (_("     [Reserved]"));
8630           else
8631             printf ("     vsp = r%d", op & 0x0f);
8632         }
8633       else if ((op & 0xf0) == 0xa0)
8634         {
8635           int end = 4 + (op & 0x07);
8636           bfd_boolean first = TRUE;
8637           int i;
8638
8639           printf ("     pop {");
8640           for (i = 4; i <= end; i++)
8641             {
8642               if (first)
8643                 first = FALSE;
8644               else
8645                 printf (", ");
8646               printf ("r%d", i);
8647             }
8648           if (op & 0x08)
8649             {
8650               if (!first)
8651                 printf (", ");
8652               printf ("r14");
8653             }
8654           printf ("}");
8655         }
8656       else if (op == 0xb0)
8657         printf (_("     finish"));
8658       else if (op == 0xb1)
8659         {
8660           GET_OP (op2);
8661           if (op2 == 0 || (op2 & 0xf0) != 0)
8662             printf (_("[Spare]"));
8663           else
8664             {
8665               unsigned int mask = op2 & 0x0f;
8666               bfd_boolean first = TRUE;
8667               int i;
8668
8669               printf ("pop {");
8670               for (i = 0; i < 12; i++)
8671                 if (mask & (1 << i))
8672                   {
8673                     if (first)
8674                       first = FALSE;
8675                     else
8676                       printf (", ");
8677                     printf ("r%d", i);
8678                   }
8679               printf ("}");
8680             }
8681         }
8682       else if (op == 0xb2)
8683         {
8684           unsigned char buf[9];
8685           unsigned int i, len;
8686           unsigned long offset;
8687
8688           for (i = 0; i < sizeof (buf); i++)
8689             {
8690               GET_OP (buf[i]);
8691               if ((buf[i] & 0x80) == 0)
8692                 break;
8693             }
8694           if (i == sizeof (buf))
8695             {
8696               error (_("corrupt change to vsp"));
8697               res = FALSE;
8698             }
8699           else
8700             {
8701               offset = read_uleb128 (buf, &len, buf + i + 1);
8702               assert (len == i + 1);
8703               offset = offset * 4 + 0x204;
8704               printf ("vsp = vsp + %ld", offset);
8705             }
8706         }
8707       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8708         {
8709           unsigned int first, last;
8710
8711           GET_OP (op2);
8712           first = op2 >> 4;
8713           last = op2 & 0x0f;
8714           if (op == 0xc8)
8715             first = first + 16;
8716           printf ("pop {D%d", first);
8717           if (last)
8718             printf ("-D%d", first + last);
8719           printf ("}");
8720         }
8721       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8722         {
8723           unsigned int count = op & 0x07;
8724
8725           printf ("pop {D8");
8726           if (count)
8727             printf ("-D%d", 8 + count);
8728           printf ("}");
8729         }
8730       else if (op >= 0xc0 && op <= 0xc5)
8731         {
8732           unsigned int count = op & 0x07;
8733
8734           printf ("     pop {wR10");
8735           if (count)
8736             printf ("-wR%d", 10 + count);
8737           printf ("}");
8738         }
8739       else if (op == 0xc6)
8740         {
8741           unsigned int first, last;
8742
8743           GET_OP (op2);
8744           first = op2 >> 4;
8745           last = op2 & 0x0f;
8746           printf ("pop {wR%d", first);
8747           if (last)
8748             printf ("-wR%d", first + last);
8749           printf ("}");
8750         }
8751       else if (op == 0xc7)
8752         {
8753           GET_OP (op2);
8754           if (op2 == 0 || (op2 & 0xf0) != 0)
8755             printf (_("[Spare]"));
8756           else
8757             {
8758               unsigned int mask = op2 & 0x0f;
8759               bfd_boolean first = TRUE;
8760               int i;
8761
8762               printf ("pop {");
8763               for (i = 0; i < 4; i++)
8764                 if (mask & (1 << i))
8765                   {
8766                     if (first)
8767                       first = FALSE;
8768                     else
8769                       printf (", ");
8770                     printf ("wCGR%d", i);
8771                   }
8772               printf ("}");
8773             }
8774         }
8775       else
8776         {
8777           printf (_("     [unsupported opcode]"));
8778           res = FALSE;
8779         }
8780
8781       printf ("\n");
8782     }
8783
8784   return res;
8785 }
8786
8787 static bfd_boolean
8788 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8789                               struct arm_unw_aux_info *  aux,
8790                               unsigned int               word,
8791                               unsigned int               remaining,
8792                               unsigned int               more_words,
8793                               bfd_vma                    data_offset,
8794                               Elf_Internal_Shdr *        data_sec,
8795                               struct arm_section *       data_arm_sec)
8796 {
8797   struct absaddr addr;
8798
8799   /* Decode the unwinding instructions.  */
8800   while (1)
8801     {
8802       unsigned int op, op2;
8803
8804       ADVANCE;
8805       if (remaining == 0)
8806         break;
8807       remaining--;
8808       op = word >> 24;
8809       word <<= 8;
8810
8811       printf ("  0x%02x ", op);
8812
8813       if ((op & 0xc0) == 0x00)
8814         {
8815           int offset = ((op & 0x3f) << 3) + 8;
8816           printf ("     sp = sp + %d", offset);
8817         }
8818       else if ((op & 0xc0) == 0x80)
8819         {
8820           GET_OP (op2);
8821           if (op == 0x80 && op2 == 0)
8822             printf (_("Refuse to unwind"));
8823           else
8824             {
8825               unsigned int mask = ((op & 0x1f) << 8) | op2;
8826               if (op & 0x20)
8827                 printf ("pop compact {");
8828               else
8829                 printf ("pop {");
8830
8831               decode_tic6x_unwind_regmask (mask);
8832               printf("}");
8833             }
8834         }
8835       else if ((op & 0xf0) == 0xc0)
8836         {
8837           unsigned int reg;
8838           unsigned int nregs;
8839           unsigned int i;
8840           const char *name;
8841           struct
8842           {
8843             unsigned int offset;
8844             unsigned int reg;
8845           } regpos[16];
8846
8847           /* Scan entire instruction first so that GET_OP output is not
8848              interleaved with disassembly.  */
8849           nregs = 0;
8850           for (i = 0; nregs < (op & 0xf); i++)
8851             {
8852               GET_OP (op2);
8853               reg = op2 >> 4;
8854               if (reg != 0xf)
8855                 {
8856                   regpos[nregs].offset = i * 2;
8857                   regpos[nregs].reg = reg;
8858                   nregs++;
8859                 }
8860
8861               reg = op2 & 0xf;
8862               if (reg != 0xf)
8863                 {
8864                   regpos[nregs].offset = i * 2 + 1;
8865                   regpos[nregs].reg = reg;
8866                   nregs++;
8867                 }
8868             }
8869
8870           printf (_("pop frame {"));
8871           if (nregs == 0)
8872             {
8873               printf (_("*corrupt* - no registers specified"));
8874             }
8875           else
8876             {
8877               reg = nregs - 1;
8878               for (i = i * 2; i > 0; i--)
8879                 {
8880                   if (regpos[reg].offset == i - 1)
8881                     {
8882                       name = tic6x_unwind_regnames[regpos[reg].reg];
8883                       if (reg > 0)
8884                         reg--;
8885                     }
8886                   else
8887                     name = _("[pad]");
8888
8889                   fputs (name, stdout);
8890                   if (i > 1)
8891                     printf (", ");
8892                 }
8893             }
8894
8895           printf ("}");
8896         }
8897       else if (op == 0xd0)
8898         printf ("     MOV FP, SP");
8899       else if (op == 0xd1)
8900         printf ("     __c6xabi_pop_rts");
8901       else if (op == 0xd2)
8902         {
8903           unsigned char buf[9];
8904           unsigned int i, len;
8905           unsigned long offset;
8906
8907           for (i = 0; i < sizeof (buf); i++)
8908             {
8909               GET_OP (buf[i]);
8910               if ((buf[i] & 0x80) == 0)
8911                 break;
8912             }
8913           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8914           if (i == sizeof (buf))
8915             {
8916               warn (_("Corrupt stack pointer adjustment detected\n"));
8917               return FALSE;
8918             }
8919
8920           offset = read_uleb128 (buf, &len, buf + i + 1);
8921           assert (len == i + 1);
8922           offset = offset * 8 + 0x408;
8923           printf (_("sp = sp + %ld"), offset);
8924         }
8925       else if ((op & 0xf0) == 0xe0)
8926         {
8927           if ((op & 0x0f) == 7)
8928             printf ("     RETURN");
8929           else
8930             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8931         }
8932       else
8933         {
8934           printf (_("     [unsupported opcode]"));
8935         }
8936       putchar ('\n');
8937     }
8938
8939   return TRUE;
8940 }
8941
8942 static bfd_vma
8943 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8944 {
8945   bfd_vma offset;
8946
8947   offset = word & 0x7fffffff;
8948   if (offset & 0x40000000)
8949     offset |= ~ (bfd_vma) 0x7fffffff;
8950
8951   if (filedata->file_header.e_machine == EM_TI_C6000)
8952     offset <<= 1;
8953
8954   return offset + where;
8955 }
8956
8957 static bfd_boolean
8958 decode_arm_unwind (Filedata *                 filedata,
8959                    struct arm_unw_aux_info *  aux,
8960                    unsigned int               word,
8961                    unsigned int               remaining,
8962                    bfd_vma                    data_offset,
8963                    Elf_Internal_Shdr *        data_sec,
8964                    struct arm_section *       data_arm_sec)
8965 {
8966   int per_index;
8967   unsigned int more_words = 0;
8968   struct absaddr addr;
8969   bfd_vma sym_name = (bfd_vma) -1;
8970   bfd_boolean res = TRUE;
8971
8972   if (remaining == 0)
8973     {
8974       /* Fetch the first word.
8975          Note - when decoding an object file the address extracted
8976          here will always be 0.  So we also pass in the sym_name
8977          parameter so that we can find the symbol associated with
8978          the personality routine.  */
8979       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8980                                      & word, & addr, & sym_name))
8981         return FALSE;
8982
8983       remaining = 4;
8984     }
8985
8986   if ((word & 0x80000000) == 0)
8987     {
8988       /* Expand prel31 for personality routine.  */
8989       bfd_vma fn;
8990       const char *procname;
8991
8992       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8993       printf (_("  Personality routine: "));
8994       if (fn == 0
8995           && addr.section == SHN_UNDEF && addr.offset == 0
8996           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8997         {
8998           procname = aux->strtab + sym_name;
8999           print_vma (fn, PREFIX_HEX);
9000           if (procname)
9001             {
9002               fputs (" <", stdout);
9003               fputs (procname, stdout);
9004               fputc ('>', stdout);
9005             }
9006         }
9007       else
9008         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
9009       fputc ('\n', stdout);
9010
9011       /* The GCC personality routines use the standard compact
9012          encoding, starting with one byte giving the number of
9013          words.  */
9014       if (procname != NULL
9015           && (const_strneq (procname, "__gcc_personality_v0")
9016               || const_strneq (procname, "__gxx_personality_v0")
9017               || const_strneq (procname, "__gcj_personality_v0")
9018               || const_strneq (procname, "__gnu_objc_personality_v0")))
9019         {
9020           remaining = 0;
9021           more_words = 1;
9022           ADVANCE;
9023           if (!remaining)
9024             {
9025               printf (_("  [Truncated data]\n"));
9026               return FALSE;
9027             }
9028           more_words = word >> 24;
9029           word <<= 8;
9030           remaining--;
9031           per_index = -1;
9032         }
9033       else
9034         return TRUE;
9035     }
9036   else
9037     {
9038       /* ARM EHABI Section 6.3:
9039
9040          An exception-handling table entry for the compact model looks like:
9041
9042            31 30-28 27-24 23-0
9043            -- ----- ----- ----
9044             1   0   index Data for personalityRoutine[index]    */
9045
9046       if (filedata->file_header.e_machine == EM_ARM
9047           && (word & 0x70000000))
9048         {
9049           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9050           res = FALSE;
9051         }
9052
9053       per_index = (word >> 24) & 0x7f;
9054       printf (_("  Compact model index: %d\n"), per_index);
9055       if (per_index == 0)
9056         {
9057           more_words = 0;
9058           word <<= 8;
9059           remaining--;
9060         }
9061       else if (per_index < 3)
9062         {
9063           more_words = (word >> 16) & 0xff;
9064           word <<= 16;
9065           remaining -= 2;
9066         }
9067     }
9068
9069   switch (filedata->file_header.e_machine)
9070     {
9071     case EM_ARM:
9072       if (per_index < 3)
9073         {
9074           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9075                                             data_offset, data_sec, data_arm_sec))
9076             res = FALSE;
9077         }
9078       else
9079         {
9080           warn (_("Unknown ARM compact model index encountered\n"));
9081           printf (_("  [reserved]\n"));
9082           res = FALSE;
9083         }
9084       break;
9085
9086     case EM_TI_C6000:
9087       if (per_index < 3)
9088         {
9089           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9090                                               data_offset, data_sec, data_arm_sec))
9091             res = FALSE;
9092         }
9093       else if (per_index < 5)
9094         {
9095           if (((word >> 17) & 0x7f) == 0x7f)
9096             printf (_("  Restore stack from frame pointer\n"));
9097           else
9098             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
9099           printf (_("  Registers restored: "));
9100           if (per_index == 4)
9101             printf (" (compact) ");
9102           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9103           putchar ('\n');
9104           printf (_("  Return register: %s\n"),
9105                   tic6x_unwind_regnames[word & 0xf]);
9106         }
9107       else
9108         printf (_("  [reserved (%d)]\n"), per_index);
9109       break;
9110
9111     default:
9112       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9113              filedata->file_header.e_machine);
9114       res = FALSE;
9115     }
9116
9117   /* Decode the descriptors.  Not implemented.  */
9118
9119   return res;
9120 }
9121
9122 static bfd_boolean
9123 dump_arm_unwind (Filedata *                 filedata,
9124                  struct arm_unw_aux_info *  aux,
9125                  Elf_Internal_Shdr *        exidx_sec)
9126 {
9127   struct arm_section exidx_arm_sec, extab_arm_sec;
9128   unsigned int i, exidx_len;
9129   unsigned long j, nfuns;
9130   bfd_boolean res = TRUE;
9131
9132   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9133   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9134   exidx_len = exidx_sec->sh_size / 8;
9135
9136   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9137   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9138     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9139       aux->funtab[nfuns++] = aux->symtab[j];
9140   aux->nfuns = nfuns;
9141   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9142
9143   for (i = 0; i < exidx_len; i++)
9144     {
9145       unsigned int exidx_fn, exidx_entry;
9146       struct absaddr fn_addr, entry_addr;
9147       bfd_vma fn;
9148
9149       fputc ('\n', stdout);
9150
9151       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9152                                      8 * i, & exidx_fn, & fn_addr, NULL)
9153           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9154                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9155         {
9156           free (aux->funtab);
9157           arm_free_section (& exidx_arm_sec);
9158           arm_free_section (& extab_arm_sec);
9159           return FALSE;
9160         }
9161
9162       /* ARM EHABI, Section 5:
9163          An index table entry consists of 2 words.
9164          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9165       if (exidx_fn & 0x80000000)
9166         {
9167           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9168           res = FALSE;
9169         }
9170
9171       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9172
9173       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9174       fputs (": ", stdout);
9175
9176       if (exidx_entry == 1)
9177         {
9178           print_vma (exidx_entry, PREFIX_HEX);
9179           fputs (" [cantunwind]\n", stdout);
9180         }
9181       else if (exidx_entry & 0x80000000)
9182         {
9183           print_vma (exidx_entry, PREFIX_HEX);
9184           fputc ('\n', stdout);
9185           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9186         }
9187       else
9188         {
9189           bfd_vma table, table_offset = 0;
9190           Elf_Internal_Shdr *table_sec;
9191
9192           fputs ("@", stdout);
9193           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9194           print_vma (table, PREFIX_HEX);
9195           printf ("\n");
9196
9197           /* Locate the matching .ARM.extab.  */
9198           if (entry_addr.section != SHN_UNDEF
9199               && entry_addr.section < filedata->file_header.e_shnum)
9200             {
9201               table_sec = filedata->section_headers + entry_addr.section;
9202               table_offset = entry_addr.offset;
9203               /* PR 18879 */
9204               if (table_offset > table_sec->sh_size
9205                   || ((bfd_signed_vma) table_offset) < 0)
9206                 {
9207                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9208                         (unsigned long) table_offset,
9209                         printable_section_name (filedata, table_sec));
9210                   res = FALSE;
9211                   continue;
9212                 }
9213             }
9214           else
9215             {
9216               table_sec = find_section_by_address (filedata, table);
9217               if (table_sec != NULL)
9218                 table_offset = table - table_sec->sh_addr;
9219             }
9220
9221           if (table_sec == NULL)
9222             {
9223               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9224                     (unsigned long) table);
9225               res = FALSE;
9226               continue;
9227             }
9228
9229           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9230                                    &extab_arm_sec))
9231             res = FALSE;
9232         }
9233     }
9234
9235   printf ("\n");
9236
9237   free (aux->funtab);
9238   arm_free_section (&exidx_arm_sec);
9239   arm_free_section (&extab_arm_sec);
9240
9241   return res;
9242 }
9243
9244 /* Used for both ARM and C6X unwinding tables.  */
9245
9246 static bfd_boolean
9247 arm_process_unwind (Filedata * filedata)
9248 {
9249   struct arm_unw_aux_info aux;
9250   Elf_Internal_Shdr *unwsec = NULL;
9251   Elf_Internal_Shdr *strsec;
9252   Elf_Internal_Shdr *sec;
9253   unsigned long i;
9254   unsigned int sec_type;
9255   bfd_boolean res = TRUE;
9256
9257   switch (filedata->file_header.e_machine)
9258     {
9259     case EM_ARM:
9260       sec_type = SHT_ARM_EXIDX;
9261       break;
9262
9263     case EM_TI_C6000:
9264       sec_type = SHT_C6000_UNWIND;
9265       break;
9266
9267     default:
9268       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9269              filedata->file_header.e_machine);
9270       return FALSE;
9271     }
9272
9273   if (filedata->string_table == NULL)
9274     return FALSE;
9275
9276   memset (& aux, 0, sizeof (aux));
9277   aux.filedata = filedata;
9278
9279   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9280     {
9281       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9282         {
9283           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9284
9285           strsec = filedata->section_headers + sec->sh_link;
9286
9287           /* PR binutils/17531 file: 011-12666-0.004.  */
9288           if (aux.strtab != NULL)
9289             {
9290               error (_("Multiple string tables found in file.\n"));
9291               free (aux.strtab);
9292               res = FALSE;
9293             }
9294           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9295                                  1, strsec->sh_size, _("string table"));
9296           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9297         }
9298       else if (sec->sh_type == sec_type)
9299         unwsec = sec;
9300     }
9301
9302   if (unwsec == NULL)
9303     printf (_("\nThere are no unwind sections in this file.\n"));
9304   else
9305     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9306       {
9307         if (sec->sh_type == sec_type)
9308           {
9309             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9310             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9311                               "contains %lu entry:\n",
9312                               "\nUnwind section '%s' at offset 0x%lx "
9313                               "contains %lu entries:\n",
9314                               num_unwind),
9315                     printable_section_name (filedata, sec),
9316                     (unsigned long) sec->sh_offset,
9317                     num_unwind);
9318
9319             if (! dump_arm_unwind (filedata, &aux, sec))
9320               res = FALSE;
9321           }
9322       }
9323
9324   if (aux.symtab)
9325     free (aux.symtab);
9326   if (aux.strtab)
9327     free ((char *) aux.strtab);
9328
9329   return res;
9330 }
9331
9332 static bfd_boolean
9333 process_unwind (Filedata * filedata)
9334 {
9335   struct unwind_handler
9336   {
9337     unsigned int machtype;
9338     bfd_boolean (* handler)(Filedata *);
9339   } handlers[] =
9340   {
9341     { EM_ARM, arm_process_unwind },
9342     { EM_IA_64, ia64_process_unwind },
9343     { EM_PARISC, hppa_process_unwind },
9344     { EM_TI_C6000, arm_process_unwind },
9345     { 0, NULL }
9346   };
9347   int i;
9348
9349   if (!do_unwind)
9350     return TRUE;
9351
9352   for (i = 0; handlers[i].handler != NULL; i++)
9353     if (filedata->file_header.e_machine == handlers[i].machtype)
9354       return handlers[i].handler (filedata);
9355
9356   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9357           get_machine_name (filedata->file_header.e_machine));
9358   return TRUE;
9359 }
9360
9361 static void
9362 dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
9363 {
9364   switch (entry->d_tag)
9365     {
9366     case DT_AARCH64_BTI_PLT:
9367       break;
9368     default:
9369       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9370       break;
9371     }
9372   putchar ('\n');
9373 }
9374
9375 static void
9376 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9377 {
9378   switch (entry->d_tag)
9379     {
9380     case DT_MIPS_FLAGS:
9381       if (entry->d_un.d_val == 0)
9382         printf (_("NONE"));
9383       else
9384         {
9385           static const char * opts[] =
9386           {
9387             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9388             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9389             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9390             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9391             "RLD_ORDER_SAFE"
9392           };
9393           unsigned int cnt;
9394           bfd_boolean first = TRUE;
9395
9396           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9397             if (entry->d_un.d_val & (1 << cnt))
9398               {
9399                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9400                 first = FALSE;
9401               }
9402         }
9403       break;
9404
9405     case DT_MIPS_IVERSION:
9406       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9407         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9408       else
9409         {
9410           char buf[40];
9411           sprintf_vma (buf, entry->d_un.d_ptr);
9412           /* Note: coded this way so that there is a single string for translation.  */
9413           printf (_("<corrupt: %s>"), buf);
9414         }
9415       break;
9416
9417     case DT_MIPS_TIME_STAMP:
9418       {
9419         char timebuf[128];
9420         struct tm * tmp;
9421         time_t atime = entry->d_un.d_val;
9422
9423         tmp = gmtime (&atime);
9424         /* PR 17531: file: 6accc532.  */
9425         if (tmp == NULL)
9426           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9427         else
9428           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9429                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9430                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9431         printf (_("Time Stamp: %s"), timebuf);
9432       }
9433       break;
9434
9435     case DT_MIPS_RLD_VERSION:
9436     case DT_MIPS_LOCAL_GOTNO:
9437     case DT_MIPS_CONFLICTNO:
9438     case DT_MIPS_LIBLISTNO:
9439     case DT_MIPS_SYMTABNO:
9440     case DT_MIPS_UNREFEXTNO:
9441     case DT_MIPS_HIPAGENO:
9442     case DT_MIPS_DELTA_CLASS_NO:
9443     case DT_MIPS_DELTA_INSTANCE_NO:
9444     case DT_MIPS_DELTA_RELOC_NO:
9445     case DT_MIPS_DELTA_SYM_NO:
9446     case DT_MIPS_DELTA_CLASSSYM_NO:
9447     case DT_MIPS_COMPACT_SIZE:
9448       print_vma (entry->d_un.d_val, DEC);
9449       break;
9450
9451     default:
9452       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9453     }
9454     putchar ('\n');
9455 }
9456
9457 static void
9458 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9459 {
9460   switch (entry->d_tag)
9461     {
9462     case DT_HP_DLD_FLAGS:
9463       {
9464         static struct
9465         {
9466           long int bit;
9467           const char * str;
9468         }
9469         flags[] =
9470         {
9471           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9472           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9473           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9474           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9475           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9476           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9477           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9478           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9479           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9480           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9481           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9482           { DT_HP_GST, "HP_GST" },
9483           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9484           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9485           { DT_HP_NODELETE, "HP_NODELETE" },
9486           { DT_HP_GROUP, "HP_GROUP" },
9487           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9488         };
9489         bfd_boolean first = TRUE;
9490         size_t cnt;
9491         bfd_vma val = entry->d_un.d_val;
9492
9493         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9494           if (val & flags[cnt].bit)
9495             {
9496               if (! first)
9497                 putchar (' ');
9498               fputs (flags[cnt].str, stdout);
9499               first = FALSE;
9500               val ^= flags[cnt].bit;
9501             }
9502
9503         if (val != 0 || first)
9504           {
9505             if (! first)
9506               putchar (' ');
9507             print_vma (val, HEX);
9508           }
9509       }
9510       break;
9511
9512     default:
9513       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9514       break;
9515     }
9516   putchar ('\n');
9517 }
9518
9519 #ifdef BFD64
9520
9521 /* VMS vs Unix time offset and factor.  */
9522
9523 #define VMS_EPOCH_OFFSET 35067168000000000LL
9524 #define VMS_GRANULARITY_FACTOR 10000000
9525
9526 /* Display a VMS time in a human readable format.  */
9527
9528 static void
9529 print_vms_time (bfd_int64_t vmstime)
9530 {
9531   struct tm *tm;
9532   time_t unxtime;
9533
9534   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9535   tm = gmtime (&unxtime);
9536   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9537           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9538           tm->tm_hour, tm->tm_min, tm->tm_sec);
9539 }
9540 #endif /* BFD64 */
9541
9542 static void
9543 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9544 {
9545   switch (entry->d_tag)
9546     {
9547     case DT_IA_64_PLT_RESERVE:
9548       /* First 3 slots reserved.  */
9549       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9550       printf (" -- ");
9551       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9552       break;
9553
9554     case DT_IA_64_VMS_LINKTIME:
9555 #ifdef BFD64
9556       print_vms_time (entry->d_un.d_val);
9557 #endif
9558       break;
9559
9560     case DT_IA_64_VMS_LNKFLAGS:
9561       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9562       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9563         printf (" CALL_DEBUG");
9564       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9565         printf (" NOP0BUFS");
9566       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9567         printf (" P0IMAGE");
9568       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9569         printf (" MKTHREADS");
9570       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9571         printf (" UPCALLS");
9572       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9573         printf (" IMGSTA");
9574       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9575         printf (" INITIALIZE");
9576       if (entry->d_un.d_val & VMS_LF_MAIN)
9577         printf (" MAIN");
9578       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9579         printf (" EXE_INIT");
9580       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9581         printf (" TBK_IN_IMG");
9582       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9583         printf (" DBG_IN_IMG");
9584       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9585         printf (" TBK_IN_DSF");
9586       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9587         printf (" DBG_IN_DSF");
9588       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9589         printf (" SIGNATURES");
9590       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9591         printf (" REL_SEG_OFF");
9592       break;
9593
9594     default:
9595       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9596       break;
9597     }
9598   putchar ('\n');
9599 }
9600
9601 static bfd_boolean
9602 get_32bit_dynamic_section (Filedata * filedata)
9603 {
9604   Elf32_External_Dyn * edyn;
9605   Elf32_External_Dyn * ext;
9606   Elf_Internal_Dyn * entry;
9607
9608   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9609                                           dynamic_size, _("dynamic section"));
9610   if (!edyn)
9611     return FALSE;
9612
9613   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9614      might not have the luxury of section headers.  Look for the DT_NULL
9615      terminator to determine the number of entries.  */
9616   for (ext = edyn, dynamic_nent = 0;
9617        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9618        ext++)
9619     {
9620       dynamic_nent++;
9621       if (BYTE_GET (ext->d_tag) == DT_NULL)
9622         break;
9623     }
9624
9625   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9626                                                   sizeof (* entry));
9627   if (dynamic_section == NULL)
9628     {
9629       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9630              (unsigned long) dynamic_nent);
9631       free (edyn);
9632       return FALSE;
9633     }
9634
9635   for (ext = edyn, entry = dynamic_section;
9636        entry < dynamic_section + dynamic_nent;
9637        ext++, entry++)
9638     {
9639       entry->d_tag      = BYTE_GET (ext->d_tag);
9640       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9641     }
9642
9643   free (edyn);
9644
9645   return TRUE;
9646 }
9647
9648 static bfd_boolean
9649 get_64bit_dynamic_section (Filedata * filedata)
9650 {
9651   Elf64_External_Dyn * edyn;
9652   Elf64_External_Dyn * ext;
9653   Elf_Internal_Dyn * entry;
9654
9655   /* Read in the data.  */
9656   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9657                                           dynamic_size, _("dynamic section"));
9658   if (!edyn)
9659     return FALSE;
9660
9661   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9662      might not have the luxury of section headers.  Look for the DT_NULL
9663      terminator to determine the number of entries.  */
9664   for (ext = edyn, dynamic_nent = 0;
9665        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9666        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9667        ext++)
9668     {
9669       dynamic_nent++;
9670       if (BYTE_GET (ext->d_tag) == DT_NULL)
9671         break;
9672     }
9673
9674   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9675                                                   sizeof (* entry));
9676   if (dynamic_section == NULL)
9677     {
9678       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9679              (unsigned long) dynamic_nent);
9680       free (edyn);
9681       return FALSE;
9682     }
9683
9684   /* Convert from external to internal formats.  */
9685   for (ext = edyn, entry = dynamic_section;
9686        entry < dynamic_section + dynamic_nent;
9687        ext++, entry++)
9688     {
9689       entry->d_tag      = BYTE_GET (ext->d_tag);
9690       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9691     }
9692
9693   free (edyn);
9694
9695   return TRUE;
9696 }
9697
9698 static void
9699 print_dynamic_flags (bfd_vma flags)
9700 {
9701   bfd_boolean first = TRUE;
9702
9703   while (flags)
9704     {
9705       bfd_vma flag;
9706
9707       flag = flags & - flags;
9708       flags &= ~ flag;
9709
9710       if (first)
9711         first = FALSE;
9712       else
9713         putc (' ', stdout);
9714
9715       switch (flag)
9716         {
9717         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9718         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9719         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9720         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9721         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9722         default:                fputs (_("unknown"), stdout); break;
9723         }
9724     }
9725   puts ("");
9726 }
9727
9728 /* Parse and display the contents of the dynamic section.  */
9729
9730 static bfd_boolean
9731 process_dynamic_section (Filedata * filedata)
9732 {
9733   Elf_Internal_Dyn * entry;
9734
9735   if (dynamic_size == 0)
9736     {
9737       if (do_dynamic)
9738         printf (_("\nThere is no dynamic section in this file.\n"));
9739
9740       return TRUE;
9741     }
9742
9743   if (is_32bit_elf)
9744     {
9745       if (! get_32bit_dynamic_section (filedata))
9746         return FALSE;
9747     }
9748   else
9749     {
9750       if (! get_64bit_dynamic_section (filedata))
9751         return FALSE;
9752     }
9753
9754   /* Find the appropriate symbol table.  */
9755   if (dynamic_symbols == NULL)
9756     {
9757       for (entry = dynamic_section;
9758            entry < dynamic_section + dynamic_nent;
9759            ++entry)
9760         {
9761           Elf_Internal_Shdr section;
9762
9763           if (entry->d_tag != DT_SYMTAB)
9764             continue;
9765
9766           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9767
9768           /* Since we do not know how big the symbol table is,
9769              we default to reading in the entire file (!) and
9770              processing that.  This is overkill, I know, but it
9771              should work.  */
9772           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9773           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9774             {
9775               /* See PR 21379 for a reproducer.  */
9776               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9777               return FALSE;
9778             }
9779
9780           if (archive_file_offset != 0)
9781             section.sh_size = archive_file_size - section.sh_offset;
9782           else
9783             section.sh_size = filedata->file_size - section.sh_offset;
9784
9785           if (is_32bit_elf)
9786             section.sh_entsize = sizeof (Elf32_External_Sym);
9787           else
9788             section.sh_entsize = sizeof (Elf64_External_Sym);
9789           section.sh_name = filedata->string_table_length;
9790
9791           if (dynamic_symbols != NULL)
9792             {
9793               error (_("Multiple dynamic symbol table sections found\n"));
9794               free (dynamic_symbols);
9795             }
9796           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9797           if (num_dynamic_syms < 1)
9798             {
9799               error (_("Unable to determine the number of symbols to load\n"));
9800               continue;
9801             }
9802         }
9803     }
9804
9805   /* Similarly find a string table.  */
9806   if (dynamic_strings == NULL)
9807     {
9808       for (entry = dynamic_section;
9809            entry < dynamic_section + dynamic_nent;
9810            ++entry)
9811         {
9812           unsigned long offset;
9813           long str_tab_len;
9814
9815           if (entry->d_tag != DT_STRTAB)
9816             continue;
9817
9818           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9819
9820           /* Since we do not know how big the string table is,
9821              we default to reading in the entire file (!) and
9822              processing that.  This is overkill, I know, but it
9823              should work.  */
9824
9825           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9826
9827           if (archive_file_offset != 0)
9828             str_tab_len = archive_file_size - offset;
9829           else
9830             str_tab_len = filedata->file_size - offset;
9831
9832           if (str_tab_len < 1)
9833             {
9834               error
9835                 (_("Unable to determine the length of the dynamic string table\n"));
9836               continue;
9837             }
9838
9839           if (dynamic_strings != NULL)
9840             {
9841               error (_("Multiple dynamic string tables found\n"));
9842               free (dynamic_strings);
9843             }
9844
9845           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9846                                                str_tab_len,
9847                                                _("dynamic string table"));
9848           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9849         }
9850     }
9851
9852   /* And find the syminfo section if available.  */
9853   if (dynamic_syminfo == NULL)
9854     {
9855       unsigned long syminsz = 0;
9856
9857       for (entry = dynamic_section;
9858            entry < dynamic_section + dynamic_nent;
9859            ++entry)
9860         {
9861           if (entry->d_tag == DT_SYMINENT)
9862             {
9863               /* Note: these braces are necessary to avoid a syntax
9864                  error from the SunOS4 C compiler.  */
9865               /* PR binutils/17531: A corrupt file can trigger this test.
9866                  So do not use an assert, instead generate an error message.  */
9867               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9868                 error (_("Bad value (%d) for SYMINENT entry\n"),
9869                        (int) entry->d_un.d_val);
9870             }
9871           else if (entry->d_tag == DT_SYMINSZ)
9872             syminsz = entry->d_un.d_val;
9873           else if (entry->d_tag == DT_SYMINFO)
9874             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9875                                                       syminsz);
9876         }
9877
9878       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9879         {
9880           Elf_External_Syminfo * extsyminfo;
9881           Elf_External_Syminfo * extsym;
9882           Elf_Internal_Syminfo * syminfo;
9883
9884           /* There is a syminfo section.  Read the data.  */
9885           extsyminfo = (Elf_External_Syminfo *)
9886               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9887                         _("symbol information"));
9888           if (!extsyminfo)
9889             return FALSE;
9890
9891           if (dynamic_syminfo != NULL)
9892             {
9893               error (_("Multiple dynamic symbol information sections found\n"));
9894               free (dynamic_syminfo);
9895             }
9896           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9897           if (dynamic_syminfo == NULL)
9898             {
9899               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9900                      (unsigned long) syminsz);
9901               return FALSE;
9902             }
9903
9904           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9905           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9906                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9907                ++syminfo, ++extsym)
9908             {
9909               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9910               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9911             }
9912
9913           free (extsyminfo);
9914         }
9915     }
9916
9917   if (do_dynamic && dynamic_addr)
9918     printf (ngettext ("\nDynamic section at offset 0x%lx "
9919                       "contains %lu entry:\n",
9920                       "\nDynamic section at offset 0x%lx "
9921                       "contains %lu entries:\n",
9922                       dynamic_nent),
9923             dynamic_addr, (unsigned long) dynamic_nent);
9924   if (do_dynamic)
9925     printf (_("  Tag        Type                         Name/Value\n"));
9926
9927   for (entry = dynamic_section;
9928        entry < dynamic_section + dynamic_nent;
9929        entry++)
9930     {
9931       if (do_dynamic)
9932         {
9933           const char * dtype;
9934
9935           putchar (' ');
9936           print_vma (entry->d_tag, FULL_HEX);
9937           dtype = get_dynamic_type (filedata, entry->d_tag);
9938           printf (" (%s)%*s", dtype,
9939                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9940         }
9941
9942       switch (entry->d_tag)
9943         {
9944         case DT_FLAGS:
9945           if (do_dynamic)
9946             print_dynamic_flags (entry->d_un.d_val);
9947           break;
9948
9949         case DT_AUXILIARY:
9950         case DT_FILTER:
9951         case DT_CONFIG:
9952         case DT_DEPAUDIT:
9953         case DT_AUDIT:
9954           if (do_dynamic)
9955             {
9956               switch (entry->d_tag)
9957                 {
9958                 case DT_AUXILIARY:
9959                   printf (_("Auxiliary library"));
9960                   break;
9961
9962                 case DT_FILTER:
9963                   printf (_("Filter library"));
9964                   break;
9965
9966                 case DT_CONFIG:
9967                   printf (_("Configuration file"));
9968                   break;
9969
9970                 case DT_DEPAUDIT:
9971                   printf (_("Dependency audit library"));
9972                   break;
9973
9974                 case DT_AUDIT:
9975                   printf (_("Audit library"));
9976                   break;
9977                 }
9978
9979               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9980                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9981               else
9982                 {
9983                   printf (": ");
9984                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9985                   putchar ('\n');
9986                 }
9987             }
9988           break;
9989
9990         case DT_FEATURE:
9991           if (do_dynamic)
9992             {
9993               printf (_("Flags:"));
9994
9995               if (entry->d_un.d_val == 0)
9996                 printf (_(" None\n"));
9997               else
9998                 {
9999                   unsigned long int val = entry->d_un.d_val;
10000
10001                   if (val & DTF_1_PARINIT)
10002                     {
10003                       printf (" PARINIT");
10004                       val ^= DTF_1_PARINIT;
10005                     }
10006                   if (val & DTF_1_CONFEXP)
10007                     {
10008                       printf (" CONFEXP");
10009                       val ^= DTF_1_CONFEXP;
10010                     }
10011                   if (val != 0)
10012                     printf (" %lx", val);
10013                   puts ("");
10014                 }
10015             }
10016           break;
10017
10018         case DT_POSFLAG_1:
10019           if (do_dynamic)
10020             {
10021               printf (_("Flags:"));
10022
10023               if (entry->d_un.d_val == 0)
10024                 printf (_(" None\n"));
10025               else
10026                 {
10027                   unsigned long int val = entry->d_un.d_val;
10028
10029                   if (val & DF_P1_LAZYLOAD)
10030                     {
10031                       printf (" LAZYLOAD");
10032                       val ^= DF_P1_LAZYLOAD;
10033                     }
10034                   if (val & DF_P1_GROUPPERM)
10035                     {
10036                       printf (" GROUPPERM");
10037                       val ^= DF_P1_GROUPPERM;
10038                     }
10039                   if (val != 0)
10040                     printf (" %lx", val);
10041                   puts ("");
10042                 }
10043             }
10044           break;
10045
10046         case DT_FLAGS_1:
10047           if (do_dynamic)
10048             {
10049               printf (_("Flags:"));
10050               if (entry->d_un.d_val == 0)
10051                 printf (_(" None\n"));
10052               else
10053                 {
10054                   unsigned long int val = entry->d_un.d_val;
10055
10056                   if (val & DF_1_NOW)
10057                     {
10058                       printf (" NOW");
10059                       val ^= DF_1_NOW;
10060                     }
10061                   if (val & DF_1_GLOBAL)
10062                     {
10063                       printf (" GLOBAL");
10064                       val ^= DF_1_GLOBAL;
10065                     }
10066                   if (val & DF_1_GROUP)
10067                     {
10068                       printf (" GROUP");
10069                       val ^= DF_1_GROUP;
10070                     }
10071                   if (val & DF_1_NODELETE)
10072                     {
10073                       printf (" NODELETE");
10074                       val ^= DF_1_NODELETE;
10075                     }
10076                   if (val & DF_1_LOADFLTR)
10077                     {
10078                       printf (" LOADFLTR");
10079                       val ^= DF_1_LOADFLTR;
10080                     }
10081                   if (val & DF_1_INITFIRST)
10082                     {
10083                       printf (" INITFIRST");
10084                       val ^= DF_1_INITFIRST;
10085                     }
10086                   if (val & DF_1_NOOPEN)
10087                     {
10088                       printf (" NOOPEN");
10089                       val ^= DF_1_NOOPEN;
10090                     }
10091                   if (val & DF_1_ORIGIN)
10092                     {
10093                       printf (" ORIGIN");
10094                       val ^= DF_1_ORIGIN;
10095                     }
10096                   if (val & DF_1_DIRECT)
10097                     {
10098                       printf (" DIRECT");
10099                       val ^= DF_1_DIRECT;
10100                     }
10101                   if (val & DF_1_TRANS)
10102                     {
10103                       printf (" TRANS");
10104                       val ^= DF_1_TRANS;
10105                     }
10106                   if (val & DF_1_INTERPOSE)
10107                     {
10108                       printf (" INTERPOSE");
10109                       val ^= DF_1_INTERPOSE;
10110                     }
10111                   if (val & DF_1_NODEFLIB)
10112                     {
10113                       printf (" NODEFLIB");
10114                       val ^= DF_1_NODEFLIB;
10115                     }
10116                   if (val & DF_1_NODUMP)
10117                     {
10118                       printf (" NODUMP");
10119                       val ^= DF_1_NODUMP;
10120                     }
10121                   if (val & DF_1_CONFALT)
10122                     {
10123                       printf (" CONFALT");
10124                       val ^= DF_1_CONFALT;
10125                     }
10126                   if (val & DF_1_ENDFILTEE)
10127                     {
10128                       printf (" ENDFILTEE");
10129                       val ^= DF_1_ENDFILTEE;
10130                     }
10131                   if (val & DF_1_DISPRELDNE)
10132                     {
10133                       printf (" DISPRELDNE");
10134                       val ^= DF_1_DISPRELDNE;
10135                     }
10136                   if (val & DF_1_DISPRELPND)
10137                     {
10138                       printf (" DISPRELPND");
10139                       val ^= DF_1_DISPRELPND;
10140                     }
10141                   if (val & DF_1_NODIRECT)
10142                     {
10143                       printf (" NODIRECT");
10144                       val ^= DF_1_NODIRECT;
10145                     }
10146                   if (val & DF_1_IGNMULDEF)
10147                     {
10148                       printf (" IGNMULDEF");
10149                       val ^= DF_1_IGNMULDEF;
10150                     }
10151                   if (val & DF_1_NOKSYMS)
10152                     {
10153                       printf (" NOKSYMS");
10154                       val ^= DF_1_NOKSYMS;
10155                     }
10156                   if (val & DF_1_NOHDR)
10157                     {
10158                       printf (" NOHDR");
10159                       val ^= DF_1_NOHDR;
10160                     }
10161                   if (val & DF_1_EDITED)
10162                     {
10163                       printf (" EDITED");
10164                       val ^= DF_1_EDITED;
10165                     }
10166                   if (val & DF_1_NORELOC)
10167                     {
10168                       printf (" NORELOC");
10169                       val ^= DF_1_NORELOC;
10170                     }
10171                   if (val & DF_1_SYMINTPOSE)
10172                     {
10173                       printf (" SYMINTPOSE");
10174                       val ^= DF_1_SYMINTPOSE;
10175                     }
10176                   if (val & DF_1_GLOBAUDIT)
10177                     {
10178                       printf (" GLOBAUDIT");
10179                       val ^= DF_1_GLOBAUDIT;
10180                     }
10181                   if (val & DF_1_SINGLETON)
10182                     {
10183                       printf (" SINGLETON");
10184                       val ^= DF_1_SINGLETON;
10185                     }
10186                   if (val & DF_1_STUB)
10187                     {
10188                       printf (" STUB");
10189                       val ^= DF_1_STUB;
10190                     }
10191                   if (val & DF_1_PIE)
10192                     {
10193                       printf (" PIE");
10194                       val ^= DF_1_PIE;
10195                     }
10196                   if (val & DF_1_KMOD)
10197                     {
10198                       printf (" KMOD");
10199                       val ^= DF_1_KMOD;
10200                     }
10201                   if (val & DF_1_WEAKFILTER)
10202                     {
10203                       printf (" WEAKFILTER");
10204                       val ^= DF_1_WEAKFILTER;
10205                     }
10206                   if (val & DF_1_NOCOMMON)
10207                     {
10208                       printf (" NOCOMMON");
10209                       val ^= DF_1_NOCOMMON;
10210                     }
10211                   if (val != 0)
10212                     printf (" %lx", val);
10213                   puts ("");
10214                 }
10215             }
10216           break;
10217
10218         case DT_PLTREL:
10219           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10220           if (do_dynamic)
10221             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10222           break;
10223
10224         case DT_NULL    :
10225         case DT_NEEDED  :
10226         case DT_PLTGOT  :
10227         case DT_HASH    :
10228         case DT_STRTAB  :
10229         case DT_SYMTAB  :
10230         case DT_RELA    :
10231         case DT_INIT    :
10232         case DT_FINI    :
10233         case DT_SONAME  :
10234         case DT_RPATH   :
10235         case DT_SYMBOLIC:
10236         case DT_REL     :
10237         case DT_DEBUG   :
10238         case DT_TEXTREL :
10239         case DT_JMPREL  :
10240         case DT_RUNPATH :
10241           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10242
10243           if (do_dynamic)
10244             {
10245               char * name;
10246
10247               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10248                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10249               else
10250                 name = NULL;
10251
10252               if (name)
10253                 {
10254                   switch (entry->d_tag)
10255                     {
10256                     case DT_NEEDED:
10257                       printf (_("Shared library: [%s]"), name);
10258
10259                       if (streq (name, program_interpreter))
10260                         printf (_(" program interpreter"));
10261                       break;
10262
10263                     case DT_SONAME:
10264                       printf (_("Library soname: [%s]"), name);
10265                       break;
10266
10267                     case DT_RPATH:
10268                       printf (_("Library rpath: [%s]"), name);
10269                       break;
10270
10271                     case DT_RUNPATH:
10272                       printf (_("Library runpath: [%s]"), name);
10273                       break;
10274
10275                     default:
10276                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10277                       break;
10278                     }
10279                 }
10280               else
10281                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10282
10283               putchar ('\n');
10284             }
10285           break;
10286
10287         case DT_PLTRELSZ:
10288         case DT_RELASZ  :
10289         case DT_STRSZ   :
10290         case DT_RELSZ   :
10291         case DT_RELAENT :
10292         case DT_SYMENT  :
10293         case DT_RELENT  :
10294           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10295           /* Fall through.  */
10296         case DT_PLTPADSZ:
10297         case DT_MOVEENT :
10298         case DT_MOVESZ  :
10299         case DT_INIT_ARRAYSZ:
10300         case DT_FINI_ARRAYSZ:
10301         case DT_GNU_CONFLICTSZ:
10302         case DT_GNU_LIBLISTSZ:
10303           if (do_dynamic)
10304             {
10305               print_vma (entry->d_un.d_val, UNSIGNED);
10306               printf (_(" (bytes)\n"));
10307             }
10308           break;
10309
10310         case DT_VERDEFNUM:
10311         case DT_VERNEEDNUM:
10312         case DT_RELACOUNT:
10313         case DT_RELCOUNT:
10314           if (do_dynamic)
10315             {
10316               print_vma (entry->d_un.d_val, UNSIGNED);
10317               putchar ('\n');
10318             }
10319           break;
10320
10321         case DT_SYMINSZ:
10322         case DT_SYMINENT:
10323         case DT_SYMINFO:
10324         case DT_USED:
10325         case DT_INIT_ARRAY:
10326         case DT_FINI_ARRAY:
10327           if (do_dynamic)
10328             {
10329               if (entry->d_tag == DT_USED
10330                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10331                 {
10332                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10333
10334                   if (*name)
10335                     {
10336                       printf (_("Not needed object: [%s]\n"), name);
10337                       break;
10338                     }
10339                 }
10340
10341               print_vma (entry->d_un.d_val, PREFIX_HEX);
10342               putchar ('\n');
10343             }
10344           break;
10345
10346         case DT_BIND_NOW:
10347           /* The value of this entry is ignored.  */
10348           if (do_dynamic)
10349             putchar ('\n');
10350           break;
10351
10352         case DT_GNU_PRELINKED:
10353           if (do_dynamic)
10354             {
10355               struct tm * tmp;
10356               time_t atime = entry->d_un.d_val;
10357
10358               tmp = gmtime (&atime);
10359               /* PR 17533 file: 041-1244816-0.004.  */
10360               if (tmp == NULL)
10361                 printf (_("<corrupt time val: %lx"),
10362                         (unsigned long) atime);
10363               else
10364                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10365                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10366                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10367
10368             }
10369           break;
10370
10371         case DT_GNU_HASH:
10372           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10373           if (do_dynamic)
10374             {
10375               print_vma (entry->d_un.d_val, PREFIX_HEX);
10376               putchar ('\n');
10377             }
10378           break;
10379
10380         default:
10381           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10382             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10383               entry->d_un.d_val;
10384
10385           if (do_dynamic)
10386             {
10387               switch (filedata->file_header.e_machine)
10388                 {
10389                 case EM_AARCH64:
10390                   dynamic_section_aarch64_val (entry);
10391                   break;
10392                 case EM_MIPS:
10393                 case EM_MIPS_RS3_LE:
10394                   dynamic_section_mips_val (entry);
10395                   break;
10396                 case EM_PARISC:
10397                   dynamic_section_parisc_val (entry);
10398                   break;
10399                 case EM_IA_64:
10400                   dynamic_section_ia64_val (entry);
10401                   break;
10402                 default:
10403                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10404                   putchar ('\n');
10405                 }
10406             }
10407           break;
10408         }
10409     }
10410
10411   return TRUE;
10412 }
10413
10414 static char *
10415 get_ver_flags (unsigned int flags)
10416 {
10417   static char buff[128];
10418
10419   buff[0] = 0;
10420
10421   if (flags == 0)
10422     return _("none");
10423
10424   if (flags & VER_FLG_BASE)
10425     strcat (buff, "BASE");
10426
10427   if (flags & VER_FLG_WEAK)
10428     {
10429       if (flags & VER_FLG_BASE)
10430         strcat (buff, " | ");
10431
10432       strcat (buff, "WEAK");
10433     }
10434
10435   if (flags & VER_FLG_INFO)
10436     {
10437       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10438         strcat (buff, " | ");
10439
10440       strcat (buff, "INFO");
10441     }
10442
10443   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10444     {
10445       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10446         strcat (buff, " | ");
10447
10448       strcat (buff, _("<unknown>"));
10449     }
10450
10451   return buff;
10452 }
10453
10454 /* Display the contents of the version sections.  */
10455
10456 static bfd_boolean
10457 process_version_sections (Filedata * filedata)
10458 {
10459   Elf_Internal_Shdr * section;
10460   unsigned i;
10461   bfd_boolean found = FALSE;
10462
10463   if (! do_version)
10464     return TRUE;
10465
10466   for (i = 0, section = filedata->section_headers;
10467        i < filedata->file_header.e_shnum;
10468        i++, section++)
10469     {
10470       switch (section->sh_type)
10471         {
10472         case SHT_GNU_verdef:
10473           {
10474             Elf_External_Verdef * edefs;
10475             unsigned long idx;
10476             unsigned long cnt;
10477             char * endbuf;
10478
10479             found = TRUE;
10480
10481             printf (ngettext ("\nVersion definition section '%s' "
10482                               "contains %u entry:\n",
10483                               "\nVersion definition section '%s' "
10484                               "contains %u entries:\n",
10485                               section->sh_info),
10486                     printable_section_name (filedata, section),
10487                     section->sh_info);
10488
10489             printf (_("  Addr: 0x"));
10490             printf_vma (section->sh_addr);
10491             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10492                     (unsigned long) section->sh_offset, section->sh_link,
10493                     printable_section_name_from_index (filedata, section->sh_link));
10494
10495             edefs = (Elf_External_Verdef *)
10496                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10497                           _("version definition section"));
10498             if (!edefs)
10499               break;
10500             endbuf = (char *) edefs + section->sh_size;
10501
10502             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10503               {
10504                 char * vstart;
10505                 Elf_External_Verdef * edef;
10506                 Elf_Internal_Verdef ent;
10507                 Elf_External_Verdaux * eaux;
10508                 Elf_Internal_Verdaux aux;
10509                 unsigned long isum;
10510                 int j;
10511
10512                 vstart = ((char *) edefs) + idx;
10513                 if (vstart + sizeof (*edef) > endbuf)
10514                   break;
10515
10516                 edef = (Elf_External_Verdef *) vstart;
10517
10518                 ent.vd_version = BYTE_GET (edef->vd_version);
10519                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10520                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10521                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10522                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10523                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10524                 ent.vd_next    = BYTE_GET (edef->vd_next);
10525
10526                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10527                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10528
10529                 printf (_("  Index: %d  Cnt: %d  "),
10530                         ent.vd_ndx, ent.vd_cnt);
10531
10532                 /* Check for overflow.  */
10533                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10534                   break;
10535
10536                 vstart += ent.vd_aux;
10537
10538                 if (vstart + sizeof (*eaux) > endbuf)
10539                   break;
10540                 eaux = (Elf_External_Verdaux *) vstart;
10541
10542                 aux.vda_name = BYTE_GET (eaux->vda_name);
10543                 aux.vda_next = BYTE_GET (eaux->vda_next);
10544
10545                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10546                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10547                 else
10548                   printf (_("Name index: %ld\n"), aux.vda_name);
10549
10550                 isum = idx + ent.vd_aux;
10551
10552                 for (j = 1; j < ent.vd_cnt; j++)
10553                   {
10554                     if (aux.vda_next < sizeof (*eaux)
10555                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10556                       {
10557                         warn (_("Invalid vda_next field of %lx\n"),
10558                               aux.vda_next);
10559                         j = ent.vd_cnt;
10560                         break;
10561                       }
10562                     /* Check for overflow.  */
10563                     if (aux.vda_next > (size_t) (endbuf - vstart))
10564                       break;
10565
10566                     isum   += aux.vda_next;
10567                     vstart += aux.vda_next;
10568
10569                     if (vstart + sizeof (*eaux) > endbuf)
10570                       break;
10571                     eaux = (Elf_External_Verdaux *) vstart;
10572
10573                     aux.vda_name = BYTE_GET (eaux->vda_name);
10574                     aux.vda_next = BYTE_GET (eaux->vda_next);
10575
10576                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10577                       printf (_("  %#06lx: Parent %d: %s\n"),
10578                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10579                     else
10580                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10581                               isum, j, aux.vda_name);
10582                   }
10583
10584                 if (j < ent.vd_cnt)
10585                   printf (_("  Version def aux past end of section\n"));
10586
10587                 /* PR 17531:
10588                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10589                 if (ent.vd_next < sizeof (*edef)
10590                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10591                   {
10592                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10593                     cnt = section->sh_info;
10594                     break;
10595                   }
10596                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10597                   break;
10598
10599                 idx += ent.vd_next;
10600               }
10601
10602             if (cnt < section->sh_info)
10603               printf (_("  Version definition past end of section\n"));
10604
10605             free (edefs);
10606           }
10607           break;
10608
10609         case SHT_GNU_verneed:
10610           {
10611             Elf_External_Verneed * eneed;
10612             unsigned long idx;
10613             unsigned long cnt;
10614             char * endbuf;
10615
10616             found = TRUE;
10617
10618             printf (ngettext ("\nVersion needs section '%s' "
10619                               "contains %u entry:\n",
10620                               "\nVersion needs section '%s' "
10621                               "contains %u entries:\n",
10622                               section->sh_info),
10623                     printable_section_name (filedata, section), section->sh_info);
10624
10625             printf (_(" Addr: 0x"));
10626             printf_vma (section->sh_addr);
10627             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10628                     (unsigned long) section->sh_offset, section->sh_link,
10629                     printable_section_name_from_index (filedata, section->sh_link));
10630
10631             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10632                                                        section->sh_offset, 1,
10633                                                        section->sh_size,
10634                                                        _("Version Needs section"));
10635             if (!eneed)
10636               break;
10637             endbuf = (char *) eneed + section->sh_size;
10638
10639             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10640               {
10641                 Elf_External_Verneed * entry;
10642                 Elf_Internal_Verneed ent;
10643                 unsigned long isum;
10644                 int j;
10645                 char * vstart;
10646
10647                 vstart = ((char *) eneed) + idx;
10648                 if (vstart + sizeof (*entry) > endbuf)
10649                   break;
10650
10651                 entry = (Elf_External_Verneed *) vstart;
10652
10653                 ent.vn_version = BYTE_GET (entry->vn_version);
10654                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10655                 ent.vn_file    = BYTE_GET (entry->vn_file);
10656                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10657                 ent.vn_next    = BYTE_GET (entry->vn_next);
10658
10659                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10660
10661                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10662                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10663                 else
10664                   printf (_("  File: %lx"), ent.vn_file);
10665
10666                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10667
10668                 /* Check for overflow.  */
10669                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10670                   break;
10671                 vstart += ent.vn_aux;
10672
10673                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10674                   {
10675                     Elf_External_Vernaux * eaux;
10676                     Elf_Internal_Vernaux aux;
10677
10678                     if (vstart + sizeof (*eaux) > endbuf)
10679                       break;
10680                     eaux = (Elf_External_Vernaux *) vstart;
10681
10682                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10683                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10684                     aux.vna_other = BYTE_GET (eaux->vna_other);
10685                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10686                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10687
10688                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10689                       printf (_("  %#06lx:   Name: %s"),
10690                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10691                     else
10692                       printf (_("  %#06lx:   Name index: %lx"),
10693                               isum, aux.vna_name);
10694
10695                     printf (_("  Flags: %s  Version: %d\n"),
10696                             get_ver_flags (aux.vna_flags), aux.vna_other);
10697
10698                     if (aux.vna_next < sizeof (*eaux)
10699                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10700                       {
10701                         warn (_("Invalid vna_next field of %lx\n"),
10702                               aux.vna_next);
10703                         j = ent.vn_cnt;
10704                         break;
10705                       }
10706                     /* Check for overflow.  */
10707                     if (aux.vna_next > (size_t) (endbuf - vstart))
10708                       break;
10709                     isum   += aux.vna_next;
10710                     vstart += aux.vna_next;
10711                   }
10712
10713                 if (j < ent.vn_cnt)
10714                   warn (_("Missing Version Needs auxillary information\n"));
10715
10716                 if (ent.vn_next < sizeof (*entry)
10717                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10718                   {
10719                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10720                     cnt = section->sh_info;
10721                     break;
10722                   }
10723                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10724                   break;
10725                 idx += ent.vn_next;
10726               }
10727
10728             if (cnt < section->sh_info)
10729               warn (_("Missing Version Needs information\n"));
10730
10731             free (eneed);
10732           }
10733           break;
10734
10735         case SHT_GNU_versym:
10736           {
10737             Elf_Internal_Shdr * link_section;
10738             size_t total;
10739             unsigned int cnt;
10740             unsigned char * edata;
10741             unsigned short * data;
10742             char * strtab;
10743             Elf_Internal_Sym * symbols;
10744             Elf_Internal_Shdr * string_sec;
10745             unsigned long num_syms;
10746             long off;
10747
10748             if (section->sh_link >= filedata->file_header.e_shnum)
10749               break;
10750
10751             link_section = filedata->section_headers + section->sh_link;
10752             total = section->sh_size / sizeof (Elf_External_Versym);
10753
10754             if (link_section->sh_link >= filedata->file_header.e_shnum)
10755               break;
10756
10757             found = TRUE;
10758
10759             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10760             if (symbols == NULL)
10761               break;
10762
10763             string_sec = filedata->section_headers + link_section->sh_link;
10764
10765             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10766                                         string_sec->sh_size,
10767                                         _("version string table"));
10768             if (!strtab)
10769               {
10770                 free (symbols);
10771                 break;
10772               }
10773
10774             printf (ngettext ("\nVersion symbols section '%s' "
10775                               "contains %lu entry:\n",
10776                               "\nVersion symbols section '%s' "
10777                               "contains %lu entries:\n",
10778                               total),
10779                     printable_section_name (filedata, section), (unsigned long) total);
10780
10781             printf (_(" Addr: "));
10782             printf_vma (section->sh_addr);
10783             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10784                     (unsigned long) section->sh_offset, section->sh_link,
10785                     printable_section_name (filedata, link_section));
10786
10787             off = offset_from_vma (filedata,
10788                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10789                                    total * sizeof (short));
10790             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10791                                                 sizeof (short),
10792                                                 _("version symbol data"));
10793             if (!edata)
10794               {
10795                 free (strtab);
10796                 free (symbols);
10797                 break;
10798               }
10799
10800             data = (short unsigned int *) cmalloc (total, sizeof (short));
10801
10802             for (cnt = total; cnt --;)
10803               data[cnt] = byte_get (edata + cnt * sizeof (short),
10804                                     sizeof (short));
10805
10806             free (edata);
10807
10808             for (cnt = 0; cnt < total; cnt += 4)
10809               {
10810                 int j, nn;
10811                 char *name;
10812                 char *invalid = _("*invalid*");
10813
10814                 printf ("  %03x:", cnt);
10815
10816                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10817                   switch (data[cnt + j])
10818                     {
10819                     case 0:
10820                       fputs (_("   0 (*local*)    "), stdout);
10821                       break;
10822
10823                     case 1:
10824                       fputs (_("   1 (*global*)   "), stdout);
10825                       break;
10826
10827                     default:
10828                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10829                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10830
10831                       /* If this index value is greater than the size of the symbols
10832                          array, break to avoid an out-of-bounds read.  */
10833                       if ((unsigned long)(cnt + j) >= num_syms)
10834                         {
10835                           warn (_("invalid index into symbol array\n"));
10836                           break;
10837                         }
10838
10839                       name = NULL;
10840                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10841                         {
10842                           Elf_Internal_Verneed ivn;
10843                           unsigned long offset;
10844
10845                           offset = offset_from_vma
10846                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10847                              sizeof (Elf_External_Verneed));
10848
10849                           do
10850                             {
10851                               Elf_Internal_Vernaux ivna;
10852                               Elf_External_Verneed evn;
10853                               Elf_External_Vernaux evna;
10854                               unsigned long a_off;
10855
10856                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10857                                             _("version need")) == NULL)
10858                                 break;
10859
10860                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10861                               ivn.vn_next = BYTE_GET (evn.vn_next);
10862
10863                               a_off = offset + ivn.vn_aux;
10864
10865                               do
10866                                 {
10867                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10868                                                 1, _("version need aux (2)")) == NULL)
10869                                     {
10870                                       ivna.vna_next  = 0;
10871                                       ivna.vna_other = 0;
10872                                     }
10873                                   else
10874                                     {
10875                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10876                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10877                                     }
10878
10879                                   a_off += ivna.vna_next;
10880                                 }
10881                               while (ivna.vna_other != data[cnt + j]
10882                                      && ivna.vna_next != 0);
10883
10884                               if (ivna.vna_other == data[cnt + j])
10885                                 {
10886                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10887
10888                                   if (ivna.vna_name >= string_sec->sh_size)
10889                                     name = invalid;
10890                                   else
10891                                     name = strtab + ivna.vna_name;
10892                                   break;
10893                                 }
10894
10895                               offset += ivn.vn_next;
10896                             }
10897                           while (ivn.vn_next);
10898                         }
10899
10900                       if (data[cnt + j] != 0x8001
10901                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10902                         {
10903                           Elf_Internal_Verdef ivd;
10904                           Elf_External_Verdef evd;
10905                           unsigned long offset;
10906
10907                           offset = offset_from_vma
10908                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10909                              sizeof evd);
10910
10911                           do
10912                             {
10913                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10914                                             _("version def")) == NULL)
10915                                 {
10916                                   ivd.vd_next = 0;
10917                                   /* PR 17531: file: 046-1082287-0.004.  */
10918                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10919                                   break;
10920                                 }
10921                               else
10922                                 {
10923                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10924                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10925                                 }
10926
10927                               offset += ivd.vd_next;
10928                             }
10929                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10930                                  && ivd.vd_next != 0);
10931
10932                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10933                             {
10934                               Elf_External_Verdaux evda;
10935                               Elf_Internal_Verdaux ivda;
10936
10937                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10938
10939                               if (get_data (&evda, filedata,
10940                                             offset - ivd.vd_next + ivd.vd_aux,
10941                                             sizeof (evda), 1,
10942                                             _("version def aux")) == NULL)
10943                                 break;
10944
10945                               ivda.vda_name = BYTE_GET (evda.vda_name);
10946
10947                               if (ivda.vda_name >= string_sec->sh_size)
10948                                 name = invalid;
10949                               else if (name != NULL && name != invalid)
10950                                 name = _("*both*");
10951                               else
10952                                 name = strtab + ivda.vda_name;
10953                             }
10954                         }
10955                       if (name != NULL)
10956                         nn += printf ("(%s%-*s",
10957                                       name,
10958                                       12 - (int) strlen (name),
10959                                       ")");
10960
10961                       if (nn < 18)
10962                         printf ("%*c", 18 - nn, ' ');
10963                     }
10964
10965                 putchar ('\n');
10966               }
10967
10968             free (data);
10969             free (strtab);
10970             free (symbols);
10971           }
10972           break;
10973
10974         default:
10975           break;
10976         }
10977     }
10978
10979   if (! found)
10980     printf (_("\nNo version information found in this file.\n"));
10981
10982   return TRUE;
10983 }
10984
10985 static const char *
10986 get_symbol_binding (Filedata * filedata, unsigned int binding)
10987 {
10988   static char buff[32];
10989
10990   switch (binding)
10991     {
10992     case STB_LOCAL:     return "LOCAL";
10993     case STB_GLOBAL:    return "GLOBAL";
10994     case STB_WEAK:      return "WEAK";
10995     default:
10996       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10997         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10998                   binding);
10999       else if (binding >= STB_LOOS && binding <= STB_HIOS)
11000         {
11001           if (binding == STB_GNU_UNIQUE
11002               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11003                   /* GNU is still using the default value 0.  */
11004                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
11005             return "UNIQUE";
11006           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
11007         }
11008       else
11009         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
11010       return buff;
11011     }
11012 }
11013
11014 static const char *
11015 get_symbol_type (Filedata * filedata, unsigned int type)
11016 {
11017   static char buff[32];
11018
11019   switch (type)
11020     {
11021     case STT_NOTYPE:    return "NOTYPE";
11022     case STT_OBJECT:    return "OBJECT";
11023     case STT_FUNC:      return "FUNC";
11024     case STT_SECTION:   return "SECTION";
11025     case STT_FILE:      return "FILE";
11026     case STT_COMMON:    return "COMMON";
11027     case STT_TLS:       return "TLS";
11028     case STT_RELC:      return "RELC";
11029     case STT_SRELC:     return "SRELC";
11030     default:
11031       if (type >= STT_LOPROC && type <= STT_HIPROC)
11032         {
11033           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
11034             return "THUMB_FUNC";
11035
11036           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
11037             return "REGISTER";
11038
11039           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
11040             return "PARISC_MILLI";
11041
11042           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
11043         }
11044       else if (type >= STT_LOOS && type <= STT_HIOS)
11045         {
11046           if (filedata->file_header.e_machine == EM_PARISC)
11047             {
11048               if (type == STT_HP_OPAQUE)
11049                 return "HP_OPAQUE";
11050               if (type == STT_HP_STUB)
11051                 return "HP_STUB";
11052             }
11053
11054           if (type == STT_GNU_IFUNC
11055               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11056                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
11057                   /* GNU is still using the default value 0.  */
11058                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
11059             return "IFUNC";
11060
11061           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11062         }
11063       else
11064         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11065       return buff;
11066     }
11067 }
11068
11069 static const char *
11070 get_symbol_visibility (unsigned int visibility)
11071 {
11072   switch (visibility)
11073     {
11074     case STV_DEFAULT:   return "DEFAULT";
11075     case STV_INTERNAL:  return "INTERNAL";
11076     case STV_HIDDEN:    return "HIDDEN";
11077     case STV_PROTECTED: return "PROTECTED";
11078     default:
11079       error (_("Unrecognized visibility value: %u"), visibility);
11080       return _("<unknown>");
11081     }
11082 }
11083
11084 static const char *
11085 get_solaris_symbol_visibility (unsigned int visibility)
11086 {
11087   switch (visibility)
11088     {
11089     case 4: return "EXPORTED";
11090     case 5: return "SINGLETON";
11091     case 6: return "ELIMINATE";
11092     default: return get_symbol_visibility (visibility);
11093     }
11094 }
11095
11096 static const char *
11097 get_mips_symbol_other (unsigned int other)
11098 {
11099   switch (other)
11100     {
11101     case STO_OPTIONAL:      return "OPTIONAL";
11102     case STO_MIPS_PLT:      return "MIPS PLT";
11103     case STO_MIPS_PIC:      return "MIPS PIC";
11104     case STO_MICROMIPS:     return "MICROMIPS";
11105     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
11106     case STO_MIPS16:        return "MIPS16";
11107     default:                return NULL;
11108     }
11109 }
11110
11111 static const char *
11112 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11113 {
11114   if (is_ia64_vms (filedata))
11115     {
11116       static char res[32];
11117
11118       res[0] = 0;
11119
11120       /* Function types is for images and .STB files only.  */
11121       switch (filedata->file_header.e_type)
11122         {
11123         case ET_DYN:
11124         case ET_EXEC:
11125           switch (VMS_ST_FUNC_TYPE (other))
11126             {
11127             case VMS_SFT_CODE_ADDR:
11128               strcat (res, " CA");
11129               break;
11130             case VMS_SFT_SYMV_IDX:
11131               strcat (res, " VEC");
11132               break;
11133             case VMS_SFT_FD:
11134               strcat (res, " FD");
11135               break;
11136             case VMS_SFT_RESERVE:
11137               strcat (res, " RSV");
11138               break;
11139             default:
11140               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11141                     VMS_ST_FUNC_TYPE (other));
11142               strcat (res, " <unknown>");
11143               break;
11144             }
11145           break;
11146         default:
11147           break;
11148         }
11149       switch (VMS_ST_LINKAGE (other))
11150         {
11151         case VMS_STL_IGNORE:
11152           strcat (res, " IGN");
11153           break;
11154         case VMS_STL_RESERVE:
11155           strcat (res, " RSV");
11156           break;
11157         case VMS_STL_STD:
11158           strcat (res, " STD");
11159           break;
11160         case VMS_STL_LNK:
11161           strcat (res, " LNK");
11162           break;
11163         default:
11164           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11165                 VMS_ST_LINKAGE (other));
11166           strcat (res, " <unknown>");
11167           break;
11168         }
11169
11170       if (res[0] != 0)
11171         return res + 1;
11172       else
11173         return res;
11174     }
11175   return NULL;
11176 }
11177
11178 static const char *
11179 get_ppc64_symbol_other (unsigned int other)
11180 {
11181   if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11182     return NULL;
11183
11184   other >>= STO_PPC64_LOCAL_BIT;
11185   if (other <= 6)
11186     {
11187       static char buf[32];
11188       if (other >= 2)
11189         other = ppc64_decode_local_entry (other);
11190       snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11191       return buf;
11192     }
11193   return NULL;
11194 }
11195
11196 static const char *
11197 get_symbol_other (Filedata * filedata, unsigned int other)
11198 {
11199   const char * result = NULL;
11200   static char buff [32];
11201
11202   if (other == 0)
11203     return "";
11204
11205   switch (filedata->file_header.e_machine)
11206     {
11207     case EM_MIPS:
11208       result = get_mips_symbol_other (other);
11209       break;
11210     case EM_IA_64:
11211       result = get_ia64_symbol_other (filedata, other);
11212       break;
11213     case EM_PPC64:
11214       result = get_ppc64_symbol_other (other);
11215       break;
11216     default:
11217       result = NULL;
11218       break;
11219     }
11220
11221   if (result)
11222     return result;
11223
11224   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11225   return buff;
11226 }
11227
11228 static const char *
11229 get_symbol_index_type (Filedata * filedata, unsigned int type)
11230 {
11231   static char buff[32];
11232
11233   switch (type)
11234     {
11235     case SHN_UNDEF:     return "UND";
11236     case SHN_ABS:       return "ABS";
11237     case SHN_COMMON:    return "COM";
11238     default:
11239       if (type == SHN_IA_64_ANSI_COMMON
11240           && filedata->file_header.e_machine == EM_IA_64
11241           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11242         return "ANSI_COM";
11243       else if ((filedata->file_header.e_machine == EM_X86_64
11244                 || filedata->file_header.e_machine == EM_L1OM
11245                 || filedata->file_header.e_machine == EM_K1OM)
11246                && type == SHN_X86_64_LCOMMON)
11247         return "LARGE_COM";
11248       else if ((type == SHN_MIPS_SCOMMON
11249                 && filedata->file_header.e_machine == EM_MIPS)
11250                || (type == SHN_TIC6X_SCOMMON
11251                    && filedata->file_header.e_machine == EM_TI_C6000))
11252         return "SCOM";
11253       else if (type == SHN_MIPS_SUNDEFINED
11254                && filedata->file_header.e_machine == EM_MIPS)
11255         return "SUND";
11256       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11257         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11258       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11259         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11260       else if (type >= SHN_LORESERVE)
11261         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11262       else if (type >= filedata->file_header.e_shnum)
11263         sprintf (buff, _("bad section index[%3d]"), type);
11264       else
11265         sprintf (buff, "%3d", type);
11266       break;
11267     }
11268
11269   return buff;
11270 }
11271
11272 static bfd_vma *
11273 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11274 {
11275   unsigned char * e_data;
11276   bfd_vma * i_data;
11277
11278   /* If the size_t type is smaller than the bfd_size_type, eg because
11279      you are building a 32-bit tool on a 64-bit host, then make sure
11280      that when (number) is cast to (size_t) no information is lost.  */
11281   if (sizeof (size_t) < sizeof (bfd_size_type)
11282       && (bfd_size_type) ((size_t) number) != number)
11283     {
11284       error (_("Size truncation prevents reading %s elements of size %u\n"),
11285              bfd_vmatoa ("u", number), ent_size);
11286       return NULL;
11287     }
11288
11289   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11290      attempting to allocate memory when the read is bound to fail.  */
11291   if (ent_size * number > filedata->file_size)
11292     {
11293       error (_("Invalid number of dynamic entries: %s\n"),
11294              bfd_vmatoa ("u", number));
11295       return NULL;
11296     }
11297
11298   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11299   if (e_data == NULL)
11300     {
11301       error (_("Out of memory reading %s dynamic entries\n"),
11302              bfd_vmatoa ("u", number));
11303       return NULL;
11304     }
11305
11306   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11307     {
11308       error (_("Unable to read in %s bytes of dynamic data\n"),
11309              bfd_vmatoa ("u", number * ent_size));
11310       free (e_data);
11311       return NULL;
11312     }
11313
11314   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11315   if (i_data == NULL)
11316     {
11317       error (_("Out of memory allocating space for %s dynamic entries\n"),
11318              bfd_vmatoa ("u", number));
11319       free (e_data);
11320       return NULL;
11321     }
11322
11323   while (number--)
11324     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11325
11326   free (e_data);
11327
11328   return i_data;
11329 }
11330
11331 static void
11332 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11333 {
11334   Elf_Internal_Sym * psym;
11335   int n;
11336
11337   n = print_vma (si, DEC_5);
11338   if (n < 5)
11339     fputs (&"     "[n], stdout);
11340   printf (" %3lu: ", hn);
11341
11342   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11343     {
11344       printf (_("<No info available for dynamic symbol number %lu>\n"),
11345               (unsigned long) si);
11346       return;
11347     }
11348
11349   psym = dynamic_symbols + si;
11350   print_vma (psym->st_value, LONG_HEX);
11351   putchar (' ');
11352   print_vma (psym->st_size, DEC_5);
11353
11354   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11355   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11356
11357   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11358     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11359   else
11360     {
11361       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11362
11363       printf (" %-7s",  get_symbol_visibility (vis));
11364       /* Check to see if any other bits in the st_other field are set.
11365          Note - displaying this information disrupts the layout of the
11366          table being generated, but for the moment this case is very
11367          rare.  */
11368       if (psym->st_other ^ vis)
11369         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11370     }
11371
11372   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11373   if (VALID_DYNAMIC_NAME (psym->st_name))
11374     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11375   else
11376     printf (_(" <corrupt: %14ld>"), psym->st_name);
11377   putchar ('\n');
11378 }
11379
11380 static const char *
11381 get_symbol_version_string (Filedata *                   filedata,
11382                            bfd_boolean                  is_dynsym,
11383                            const char *                 strtab,
11384                            unsigned long int            strtab_size,
11385                            unsigned int                 si,
11386                            Elf_Internal_Sym *           psym,
11387                            enum versioned_symbol_info * sym_info,
11388                            unsigned short *             vna_other)
11389 {
11390   unsigned char data[2];
11391   unsigned short vers_data;
11392   unsigned long offset;
11393   unsigned short max_vd_ndx;
11394
11395   if (!is_dynsym
11396       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11397     return NULL;
11398
11399   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11400                             sizeof data + si * sizeof (vers_data));
11401
11402   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11403                 sizeof (data), 1, _("version data")) == NULL)
11404     return NULL;
11405
11406   vers_data = byte_get (data, 2);
11407
11408   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11409     return NULL;
11410
11411   max_vd_ndx = 0;
11412
11413   /* Usually we'd only see verdef for defined symbols, and verneed for
11414      undefined symbols.  However, symbols defined by the linker in
11415      .dynbss for variables copied from a shared library in order to
11416      avoid text relocations are defined yet have verneed.  We could
11417      use a heuristic to detect the special case, for example, check
11418      for verneed first on symbols defined in SHT_NOBITS sections, but
11419      it is simpler and more reliable to just look for both verdef and
11420      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11421
11422   if (psym->st_shndx != SHN_UNDEF
11423       && vers_data != 0x8001
11424       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11425     {
11426       Elf_Internal_Verdef ivd;
11427       Elf_Internal_Verdaux ivda;
11428       Elf_External_Verdaux evda;
11429       unsigned long off;
11430
11431       off = offset_from_vma (filedata,
11432                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11433                              sizeof (Elf_External_Verdef));
11434
11435       do
11436         {
11437           Elf_External_Verdef evd;
11438
11439           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11440                         _("version def")) == NULL)
11441             {
11442               ivd.vd_ndx = 0;
11443               ivd.vd_aux = 0;
11444               ivd.vd_next = 0;
11445               ivd.vd_flags = 0;
11446             }
11447           else
11448             {
11449               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11450               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11451               ivd.vd_next = BYTE_GET (evd.vd_next);
11452               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11453             }
11454
11455           if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11456             max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11457
11458           off += ivd.vd_next;
11459         }
11460       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11461
11462       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11463         {
11464           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11465             return NULL;
11466
11467           off -= ivd.vd_next;
11468           off += ivd.vd_aux;
11469
11470           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11471                         _("version def aux")) != NULL)
11472             {
11473               ivda.vda_name = BYTE_GET (evda.vda_name);
11474
11475               if (psym->st_name != ivda.vda_name)
11476                 {
11477                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11478                                ? symbol_hidden : symbol_public);
11479                   return (ivda.vda_name < strtab_size
11480                           ? strtab + ivda.vda_name : _("<corrupt>"));
11481                 }
11482             }
11483         }
11484     }
11485
11486   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11487     {
11488       Elf_External_Verneed evn;
11489       Elf_Internal_Verneed ivn;
11490       Elf_Internal_Vernaux ivna;
11491
11492       offset = offset_from_vma (filedata,
11493                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11494                                 sizeof evn);
11495       do
11496         {
11497           unsigned long vna_off;
11498
11499           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11500                         _("version need")) == NULL)
11501             {
11502               ivna.vna_next = 0;
11503               ivna.vna_other = 0;
11504               ivna.vna_name = 0;
11505               break;
11506             }
11507
11508           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11509           ivn.vn_next = BYTE_GET (evn.vn_next);
11510
11511           vna_off = offset + ivn.vn_aux;
11512
11513           do
11514             {
11515               Elf_External_Vernaux evna;
11516
11517               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11518                             _("version need aux (3)")) == NULL)
11519                 {
11520                   ivna.vna_next = 0;
11521                   ivna.vna_other = 0;
11522                   ivna.vna_name = 0;
11523                 }
11524               else
11525                 {
11526                   ivna.vna_other = BYTE_GET (evna.vna_other);
11527                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11528                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11529                 }
11530
11531               vna_off += ivna.vna_next;
11532             }
11533           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11534
11535           if (ivna.vna_other == vers_data)
11536             break;
11537
11538           offset += ivn.vn_next;
11539         }
11540       while (ivn.vn_next != 0);
11541
11542       if (ivna.vna_other == vers_data)
11543         {
11544           *sym_info = symbol_undefined;
11545           *vna_other = ivna.vna_other;
11546           return (ivna.vna_name < strtab_size
11547                   ? strtab + ivna.vna_name : _("<corrupt>"));
11548         }
11549       else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11550                && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11551         return _("<corrupt>");
11552     }
11553   return NULL;
11554 }
11555
11556 /* Dump the symbol table.  */
11557 static bfd_boolean
11558 process_symbol_table (Filedata * filedata)
11559 {
11560   Elf_Internal_Shdr * section;
11561   bfd_size_type nbuckets = 0;
11562   bfd_size_type nchains = 0;
11563   bfd_vma * buckets = NULL;
11564   bfd_vma * chains = NULL;
11565   bfd_vma ngnubuckets = 0;
11566   bfd_vma * gnubuckets = NULL;
11567   bfd_vma * gnuchains = NULL;
11568   bfd_vma gnusymidx = 0;
11569   bfd_size_type ngnuchains = 0;
11570
11571   if (!do_syms && !do_dyn_syms && !do_histogram)
11572     return TRUE;
11573
11574   if (dynamic_info[DT_HASH]
11575       && (do_histogram
11576           || (do_using_dynamic
11577               && !do_dyn_syms
11578               && dynamic_strings != NULL)))
11579     {
11580       unsigned char nb[8];
11581       unsigned char nc[8];
11582       unsigned int hash_ent_size = 4;
11583
11584       if ((filedata->file_header.e_machine == EM_ALPHA
11585            || filedata->file_header.e_machine == EM_S390
11586            || filedata->file_header.e_machine == EM_S390_OLD)
11587           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11588         hash_ent_size = 8;
11589
11590       if (fseek (filedata->handle,
11591                  (archive_file_offset
11592                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11593                                      sizeof nb + sizeof nc)),
11594                  SEEK_SET))
11595         {
11596           error (_("Unable to seek to start of dynamic information\n"));
11597           goto no_hash;
11598         }
11599
11600       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11601         {
11602           error (_("Failed to read in number of buckets\n"));
11603           goto no_hash;
11604         }
11605
11606       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11607         {
11608           error (_("Failed to read in number of chains\n"));
11609           goto no_hash;
11610         }
11611
11612       nbuckets = byte_get (nb, hash_ent_size);
11613       nchains  = byte_get (nc, hash_ent_size);
11614
11615       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11616       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11617
11618     no_hash:
11619       if (buckets == NULL || chains == NULL)
11620         {
11621           if (do_using_dynamic)
11622             return FALSE;
11623           free (buckets);
11624           free (chains);
11625           buckets = NULL;
11626           chains = NULL;
11627           nbuckets = 0;
11628           nchains = 0;
11629         }
11630     }
11631
11632   if (dynamic_info_DT_GNU_HASH
11633       && (do_histogram
11634           || (do_using_dynamic
11635               && !do_dyn_syms
11636               && dynamic_strings != NULL)))
11637     {
11638       unsigned char nb[16];
11639       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11640       bfd_vma buckets_vma;
11641
11642       if (fseek (filedata->handle,
11643                  (archive_file_offset
11644                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11645                                      sizeof nb)),
11646                  SEEK_SET))
11647         {
11648           error (_("Unable to seek to start of dynamic information\n"));
11649           goto no_gnu_hash;
11650         }
11651
11652       if (fread (nb, 16, 1, filedata->handle) != 1)
11653         {
11654           error (_("Failed to read in number of buckets\n"));
11655           goto no_gnu_hash;
11656         }
11657
11658       ngnubuckets = byte_get (nb, 4);
11659       gnusymidx = byte_get (nb + 4, 4);
11660       bitmaskwords = byte_get (nb + 8, 4);
11661       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11662       if (is_32bit_elf)
11663         buckets_vma += bitmaskwords * 4;
11664       else
11665         buckets_vma += bitmaskwords * 8;
11666
11667       if (fseek (filedata->handle,
11668                  (archive_file_offset
11669                   + offset_from_vma (filedata, buckets_vma, 4)),
11670                  SEEK_SET))
11671         {
11672           error (_("Unable to seek to start of dynamic information\n"));
11673           goto no_gnu_hash;
11674         }
11675
11676       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11677
11678       if (gnubuckets == NULL)
11679         goto no_gnu_hash;
11680
11681       for (i = 0; i < ngnubuckets; i++)
11682         if (gnubuckets[i] != 0)
11683           {
11684             if (gnubuckets[i] < gnusymidx)
11685               return FALSE;
11686
11687             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11688               maxchain = gnubuckets[i];
11689           }
11690
11691       if (maxchain == 0xffffffff)
11692         goto no_gnu_hash;
11693
11694       maxchain -= gnusymidx;
11695
11696       if (fseek (filedata->handle,
11697                  (archive_file_offset
11698                   + offset_from_vma (filedata, buckets_vma
11699                                            + 4 * (ngnubuckets + maxchain), 4)),
11700                  SEEK_SET))
11701         {
11702           error (_("Unable to seek to start of dynamic information\n"));
11703           goto no_gnu_hash;
11704         }
11705
11706       do
11707         {
11708           if (fread (nb, 4, 1, filedata->handle) != 1)
11709             {
11710               error (_("Failed to determine last chain length\n"));
11711               goto no_gnu_hash;
11712             }
11713
11714           if (maxchain + 1 == 0)
11715             goto no_gnu_hash;
11716
11717           ++maxchain;
11718         }
11719       while ((byte_get (nb, 4) & 1) == 0);
11720
11721       if (fseek (filedata->handle,
11722                  (archive_file_offset
11723                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11724                  SEEK_SET))
11725         {
11726           error (_("Unable to seek to start of dynamic information\n"));
11727           goto no_gnu_hash;
11728         }
11729
11730       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11731       ngnuchains = maxchain;
11732
11733     no_gnu_hash:
11734       if (gnuchains == NULL)
11735         {
11736           free (gnubuckets);
11737           gnubuckets = NULL;
11738           ngnubuckets = 0;
11739           if (do_using_dynamic)
11740             return FALSE;
11741         }
11742     }
11743
11744   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11745       && do_syms
11746       && do_using_dynamic
11747       && dynamic_strings != NULL
11748       && dynamic_symbols != NULL)
11749     {
11750       unsigned long hn;
11751
11752       if (dynamic_info[DT_HASH])
11753         {
11754           bfd_vma si;
11755           char *visited;
11756
11757           printf (_("\nSymbol table for image:\n"));
11758           if (is_32bit_elf)
11759             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11760           else
11761             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11762
11763           visited = xcmalloc (nchains, 1);
11764           memset (visited, 0, nchains);
11765           for (hn = 0; hn < nbuckets; hn++)
11766             {
11767               for (si = buckets[hn]; si > 0; si = chains[si])
11768                 {
11769                   print_dynamic_symbol (filedata, si, hn);
11770                   if (si >= nchains || visited[si])
11771                     {
11772                       error (_("histogram chain is corrupt\n"));
11773                       break;
11774                     }
11775                   visited[si] = 1;
11776                 }
11777             }
11778           free (visited);
11779         }
11780
11781       if (dynamic_info_DT_GNU_HASH)
11782         {
11783           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11784           if (is_32bit_elf)
11785             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11786           else
11787             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11788
11789           for (hn = 0; hn < ngnubuckets; ++hn)
11790             if (gnubuckets[hn] != 0)
11791               {
11792                 bfd_vma si = gnubuckets[hn];
11793                 bfd_vma off = si - gnusymidx;
11794
11795                 do
11796                   {
11797                     print_dynamic_symbol (filedata, si, hn);
11798                     si++;
11799                   }
11800                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11801               }
11802         }
11803     }
11804   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11805            && filedata->section_headers != NULL)
11806     {
11807       unsigned int i;
11808
11809       for (i = 0, section = filedata->section_headers;
11810            i < filedata->file_header.e_shnum;
11811            i++, section++)
11812         {
11813           unsigned int si;
11814           char * strtab = NULL;
11815           unsigned long int strtab_size = 0;
11816           Elf_Internal_Sym * symtab;
11817           Elf_Internal_Sym * psym;
11818           unsigned long num_syms;
11819
11820           if ((section->sh_type != SHT_SYMTAB
11821                && section->sh_type != SHT_DYNSYM)
11822               || (!do_syms
11823                   && section->sh_type == SHT_SYMTAB))
11824             continue;
11825
11826           if (section->sh_entsize == 0)
11827             {
11828               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11829                       printable_section_name (filedata, section));
11830               continue;
11831             }
11832
11833           num_syms = section->sh_size / section->sh_entsize;
11834           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11835                             "\nSymbol table '%s' contains %lu entries:\n",
11836                             num_syms),
11837                   printable_section_name (filedata, section),
11838                   num_syms);
11839
11840           if (is_32bit_elf)
11841             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11842           else
11843             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11844
11845           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11846           if (symtab == NULL)
11847             continue;
11848
11849           if (section->sh_link == filedata->file_header.e_shstrndx)
11850             {
11851               strtab = filedata->string_table;
11852               strtab_size = filedata->string_table_length;
11853             }
11854           else if (section->sh_link < filedata->file_header.e_shnum)
11855             {
11856               Elf_Internal_Shdr * string_sec;
11857
11858               string_sec = filedata->section_headers + section->sh_link;
11859
11860               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11861                                           1, string_sec->sh_size,
11862                                           _("string table"));
11863               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11864             }
11865
11866           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11867             {
11868               const char *version_string;
11869               enum versioned_symbol_info sym_info;
11870               unsigned short vna_other;
11871
11872               printf ("%6d: ", si);
11873               print_vma (psym->st_value, LONG_HEX);
11874               putchar (' ');
11875               print_vma (psym->st_size, DEC_5);
11876               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11877               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11878               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11879                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11880               else
11881                 {
11882                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11883
11884                   printf (" %-7s", get_symbol_visibility (vis));
11885                   /* Check to see if any other bits in the st_other field are set.
11886                      Note - displaying this information disrupts the layout of the
11887                      table being generated, but for the moment this case is very rare.  */
11888                   if (psym->st_other ^ vis)
11889                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11890                 }
11891               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11892               print_symbol (25, psym->st_name < strtab_size
11893                             ? strtab + psym->st_name : _("<corrupt>"));
11894
11895               version_string
11896                 = get_symbol_version_string (filedata,
11897                                              section->sh_type == SHT_DYNSYM,
11898                                              strtab, strtab_size, si,
11899                                              psym, &sym_info, &vna_other);
11900               if (version_string)
11901                 {
11902                   if (sym_info == symbol_undefined)
11903                     printf ("@%s (%d)", version_string, vna_other);
11904                   else
11905                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11906                             version_string);
11907                 }
11908
11909               putchar ('\n');
11910
11911               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11912                   && si >= section->sh_info
11913                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11914                   && filedata->file_header.e_machine != EM_MIPS
11915                   /* Solaris binaries have been found to violate this requirement as
11916                      well.  Not sure if this is a bug or an ABI requirement.  */
11917                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11918                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11919                       si, printable_section_name (filedata, section), section->sh_info);
11920             }
11921
11922           free (symtab);
11923           if (strtab != filedata->string_table)
11924             free (strtab);
11925         }
11926     }
11927   else if (do_syms)
11928     printf
11929       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11930
11931   if (do_histogram && buckets != NULL)
11932     {
11933       unsigned long * lengths;
11934       unsigned long * counts;
11935       unsigned long hn;
11936       bfd_vma si;
11937       unsigned long maxlength = 0;
11938       unsigned long nzero_counts = 0;
11939       unsigned long nsyms = 0;
11940       char *visited;
11941
11942       printf (ngettext ("\nHistogram for bucket list length "
11943                         "(total of %lu bucket):\n",
11944                         "\nHistogram for bucket list length "
11945                         "(total of %lu buckets):\n",
11946                         (unsigned long) nbuckets),
11947               (unsigned long) nbuckets);
11948
11949       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11950       if (lengths == NULL)
11951         {
11952           error (_("Out of memory allocating space for histogram buckets\n"));
11953           return FALSE;
11954         }
11955       visited = xcmalloc (nchains, 1);
11956       memset (visited, 0, nchains);
11957
11958       printf (_(" Length  Number     %% of total  Coverage\n"));
11959       for (hn = 0; hn < nbuckets; ++hn)
11960         {
11961           for (si = buckets[hn]; si > 0; si = chains[si])
11962             {
11963               ++nsyms;
11964               if (maxlength < ++lengths[hn])
11965                 ++maxlength;
11966               if (si >= nchains || visited[si])
11967                 {
11968                   error (_("histogram chain is corrupt\n"));
11969                   break;
11970                 }
11971               visited[si] = 1;
11972             }
11973         }
11974       free (visited);
11975
11976       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11977       if (counts == NULL)
11978         {
11979           free (lengths);
11980           error (_("Out of memory allocating space for histogram counts\n"));
11981           return FALSE;
11982         }
11983
11984       for (hn = 0; hn < nbuckets; ++hn)
11985         ++counts[lengths[hn]];
11986
11987       if (nbuckets > 0)
11988         {
11989           unsigned long i;
11990           printf ("      0  %-10lu (%5.1f%%)\n",
11991                   counts[0], (counts[0] * 100.0) / nbuckets);
11992           for (i = 1; i <= maxlength; ++i)
11993             {
11994               nzero_counts += counts[i] * i;
11995               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11996                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11997                       (nzero_counts * 100.0) / nsyms);
11998             }
11999         }
12000
12001       free (counts);
12002       free (lengths);
12003     }
12004
12005   if (buckets != NULL)
12006     {
12007       free (buckets);
12008       free (chains);
12009     }
12010
12011   if (do_histogram && gnubuckets != NULL)
12012     {
12013       unsigned long * lengths;
12014       unsigned long * counts;
12015       unsigned long hn;
12016       unsigned long maxlength = 0;
12017       unsigned long nzero_counts = 0;
12018       unsigned long nsyms = 0;
12019
12020       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
12021                         "(total of %lu bucket):\n",
12022                         "\nHistogram for `.gnu.hash' bucket list length "
12023                         "(total of %lu buckets):\n",
12024                         (unsigned long) ngnubuckets),
12025               (unsigned long) ngnubuckets);
12026
12027       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
12028       if (lengths == NULL)
12029         {
12030           error (_("Out of memory allocating space for gnu histogram buckets\n"));
12031           return FALSE;
12032         }
12033
12034       printf (_(" Length  Number     %% of total  Coverage\n"));
12035
12036       for (hn = 0; hn < ngnubuckets; ++hn)
12037         if (gnubuckets[hn] != 0)
12038           {
12039             bfd_vma off, length = 1;
12040
12041             for (off = gnubuckets[hn] - gnusymidx;
12042                  /* PR 17531 file: 010-77222-0.004.  */
12043                  off < ngnuchains && (gnuchains[off] & 1) == 0;
12044                  ++off)
12045               ++length;
12046             lengths[hn] = length;
12047             if (length > maxlength)
12048               maxlength = length;
12049             nsyms += length;
12050           }
12051
12052       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12053       if (counts == NULL)
12054         {
12055           free (lengths);
12056           error (_("Out of memory allocating space for gnu histogram counts\n"));
12057           return FALSE;
12058         }
12059
12060       for (hn = 0; hn < ngnubuckets; ++hn)
12061         ++counts[lengths[hn]];
12062
12063       if (ngnubuckets > 0)
12064         {
12065           unsigned long j;
12066           printf ("      0  %-10lu (%5.1f%%)\n",
12067                   counts[0], (counts[0] * 100.0) / ngnubuckets);
12068           for (j = 1; j <= maxlength; ++j)
12069             {
12070               nzero_counts += counts[j] * j;
12071               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
12072                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
12073                       (nzero_counts * 100.0) / nsyms);
12074             }
12075         }
12076
12077       free (counts);
12078       free (lengths);
12079       free (gnubuckets);
12080       free (gnuchains);
12081     }
12082
12083   return TRUE;
12084 }
12085
12086 static bfd_boolean
12087 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12088 {
12089   unsigned int i;
12090
12091   if (dynamic_syminfo == NULL
12092       || !do_dynamic)
12093     /* No syminfo, this is ok.  */
12094     return TRUE;
12095
12096   /* There better should be a dynamic symbol section.  */
12097   if (dynamic_symbols == NULL || dynamic_strings == NULL)
12098     return FALSE;
12099
12100   if (dynamic_addr)
12101     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12102                       "contains %d entry:\n",
12103                       "\nDynamic info segment at offset 0x%lx "
12104                       "contains %d entries:\n",
12105                       dynamic_syminfo_nent),
12106             dynamic_syminfo_offset, dynamic_syminfo_nent);
12107
12108   printf (_(" Num: Name                           BoundTo     Flags\n"));
12109   for (i = 0; i < dynamic_syminfo_nent; ++i)
12110     {
12111       unsigned short int flags = dynamic_syminfo[i].si_flags;
12112
12113       printf ("%4d: ", i);
12114       if (i >= num_dynamic_syms)
12115         printf (_("<corrupt index>"));
12116       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12117         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12118       else
12119         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12120       putchar (' ');
12121
12122       switch (dynamic_syminfo[i].si_boundto)
12123         {
12124         case SYMINFO_BT_SELF:
12125           fputs ("SELF       ", stdout);
12126           break;
12127         case SYMINFO_BT_PARENT:
12128           fputs ("PARENT     ", stdout);
12129           break;
12130         default:
12131           if (dynamic_syminfo[i].si_boundto > 0
12132               && dynamic_syminfo[i].si_boundto < dynamic_nent
12133               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12134             {
12135               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12136               putchar (' ' );
12137             }
12138           else
12139             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12140           break;
12141         }
12142
12143       if (flags & SYMINFO_FLG_DIRECT)
12144         printf (" DIRECT");
12145       if (flags & SYMINFO_FLG_PASSTHRU)
12146         printf (" PASSTHRU");
12147       if (flags & SYMINFO_FLG_COPY)
12148         printf (" COPY");
12149       if (flags & SYMINFO_FLG_LAZYLOAD)
12150         printf (" LAZYLOAD");
12151
12152       puts ("");
12153     }
12154
12155   return TRUE;
12156 }
12157
12158 #define IN_RANGE(START,END,ADDR,OFF)            \
12159   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12160
12161 /* Check to see if the given reloc needs to be handled in a target specific
12162    manner.  If so then process the reloc and return TRUE otherwise return
12163    FALSE.
12164
12165    If called with reloc == NULL, then this is a signal that reloc processing
12166    for the current section has finished, and any saved state should be
12167    discarded.  */
12168
12169 static bfd_boolean
12170 target_specific_reloc_handling (Filedata *           filedata,
12171                                 Elf_Internal_Rela *  reloc,
12172                                 unsigned char *      start,
12173                                 unsigned char *      end,
12174                                 Elf_Internal_Sym *   symtab,
12175                                 unsigned long        num_syms)
12176 {
12177   unsigned int reloc_type = 0;
12178   unsigned long sym_index = 0;
12179
12180   if (reloc)
12181     {
12182       reloc_type = get_reloc_type (filedata, reloc->r_info);
12183       sym_index = get_reloc_symindex (reloc->r_info);
12184     }
12185
12186   switch (filedata->file_header.e_machine)
12187     {
12188     case EM_MSP430:
12189     case EM_MSP430_OLD:
12190       {
12191         static Elf_Internal_Sym * saved_sym = NULL;
12192
12193         if (reloc == NULL)
12194           {
12195             saved_sym = NULL;
12196             return TRUE;
12197           }
12198
12199         switch (reloc_type)
12200           {
12201           case 10: /* R_MSP430_SYM_DIFF */
12202             if (uses_msp430x_relocs (filedata))
12203               break;
12204             /* Fall through.  */
12205           case 21: /* R_MSP430X_SYM_DIFF */
12206             /* PR 21139.  */
12207             if (sym_index >= num_syms)
12208               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12209                      sym_index);
12210             else
12211               saved_sym = symtab + sym_index;
12212             return TRUE;
12213
12214           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12215           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12216             goto handle_sym_diff;
12217
12218           case 5: /* R_MSP430_16_BYTE */
12219           case 9: /* R_MSP430_8 */
12220             if (uses_msp430x_relocs (filedata))
12221               break;
12222             goto handle_sym_diff;
12223
12224           case 2: /* R_MSP430_ABS16 */
12225           case 15: /* R_MSP430X_ABS16 */
12226             if (! uses_msp430x_relocs (filedata))
12227               break;
12228             goto handle_sym_diff;
12229
12230           handle_sym_diff:
12231             if (saved_sym != NULL)
12232               {
12233                 int reloc_size = reloc_type == 1 ? 4 : 2;
12234                 bfd_vma value;
12235
12236                 if (sym_index >= num_syms)
12237                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12238                          sym_index);
12239                 else
12240                   {
12241                     value = reloc->r_addend + (symtab[sym_index].st_value
12242                                                - saved_sym->st_value);
12243
12244                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12245                       byte_put (start + reloc->r_offset, value, reloc_size);
12246                     else
12247                       /* PR 21137 */
12248                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12249                              (long) reloc->r_offset);
12250                   }
12251
12252                 saved_sym = NULL;
12253                 return TRUE;
12254               }
12255             break;
12256
12257           default:
12258             if (saved_sym != NULL)
12259               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12260             break;
12261           }
12262         break;
12263       }
12264
12265     case EM_MN10300:
12266     case EM_CYGNUS_MN10300:
12267       {
12268         static Elf_Internal_Sym * saved_sym = NULL;
12269
12270         if (reloc == NULL)
12271           {
12272             saved_sym = NULL;
12273             return TRUE;
12274           }
12275
12276         switch (reloc_type)
12277           {
12278           case 34: /* R_MN10300_ALIGN */
12279             return TRUE;
12280           case 33: /* R_MN10300_SYM_DIFF */
12281             if (sym_index >= num_syms)
12282               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12283                      sym_index);
12284             else
12285               saved_sym = symtab + sym_index;
12286             return TRUE;
12287
12288           case 1: /* R_MN10300_32 */
12289           case 2: /* R_MN10300_16 */
12290             if (saved_sym != NULL)
12291               {
12292                 int reloc_size = reloc_type == 1 ? 4 : 2;
12293                 bfd_vma value;
12294
12295                 if (sym_index >= num_syms)
12296                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12297                          sym_index);
12298                 else
12299                   {
12300                     value = reloc->r_addend + (symtab[sym_index].st_value
12301                                                - saved_sym->st_value);
12302
12303                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12304                       byte_put (start + reloc->r_offset, value, reloc_size);
12305                     else
12306                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12307                              (long) reloc->r_offset);
12308                   }
12309
12310                 saved_sym = NULL;
12311                 return TRUE;
12312               }
12313             break;
12314           default:
12315             if (saved_sym != NULL)
12316               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12317             break;
12318           }
12319         break;
12320       }
12321
12322     case EM_RL78:
12323       {
12324         static bfd_vma saved_sym1 = 0;
12325         static bfd_vma saved_sym2 = 0;
12326         static bfd_vma value;
12327
12328         if (reloc == NULL)
12329           {
12330             saved_sym1 = saved_sym2 = 0;
12331             return TRUE;
12332           }
12333
12334         switch (reloc_type)
12335           {
12336           case 0x80: /* R_RL78_SYM.  */
12337             saved_sym1 = saved_sym2;
12338             if (sym_index >= num_syms)
12339               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12340                      sym_index);
12341             else
12342               {
12343                 saved_sym2 = symtab[sym_index].st_value;
12344                 saved_sym2 += reloc->r_addend;
12345               }
12346             return TRUE;
12347
12348           case 0x83: /* R_RL78_OPsub.  */
12349             value = saved_sym1 - saved_sym2;
12350             saved_sym2 = saved_sym1 = 0;
12351             return TRUE;
12352             break;
12353
12354           case 0x41: /* R_RL78_ABS32.  */
12355             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12356               byte_put (start + reloc->r_offset, value, 4);
12357             else
12358               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12359                      (long) reloc->r_offset);
12360             value = 0;
12361             return TRUE;
12362
12363           case 0x43: /* R_RL78_ABS16.  */
12364             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12365               byte_put (start + reloc->r_offset, value, 2);
12366             else
12367               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12368                      (long) reloc->r_offset);
12369             value = 0;
12370             return TRUE;
12371
12372           default:
12373             break;
12374           }
12375         break;
12376       }
12377     }
12378
12379   return FALSE;
12380 }
12381
12382 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12383    DWARF debug sections.  This is a target specific test.  Note - we do not
12384    go through the whole including-target-headers-multiple-times route, (as
12385    we have already done with <elf/h8.h>) because this would become very
12386    messy and even then this function would have to contain target specific
12387    information (the names of the relocs instead of their numeric values).
12388    FIXME: This is not the correct way to solve this problem.  The proper way
12389    is to have target specific reloc sizing and typing functions created by
12390    the reloc-macros.h header, in the same way that it already creates the
12391    reloc naming functions.  */
12392
12393 static bfd_boolean
12394 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12395 {
12396   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12397   switch (filedata->file_header.e_machine)
12398     {
12399     case EM_386:
12400     case EM_IAMCU:
12401       return reloc_type == 1; /* R_386_32.  */
12402     case EM_68K:
12403       return reloc_type == 1; /* R_68K_32.  */
12404     case EM_860:
12405       return reloc_type == 1; /* R_860_32.  */
12406     case EM_960:
12407       return reloc_type == 2; /* R_960_32.  */
12408     case EM_AARCH64:
12409       return (reloc_type == 258
12410               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12411     case EM_ADAPTEVA_EPIPHANY:
12412       return reloc_type == 3;
12413     case EM_ALPHA:
12414       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12415     case EM_ARC:
12416       return reloc_type == 1; /* R_ARC_32.  */
12417     case EM_ARC_COMPACT:
12418     case EM_ARC_COMPACT2:
12419       return reloc_type == 4; /* R_ARC_32.  */
12420     case EM_ARM:
12421       return reloc_type == 2; /* R_ARM_ABS32 */
12422     case EM_AVR_OLD:
12423     case EM_AVR:
12424       return reloc_type == 1;
12425     case EM_BLACKFIN:
12426       return reloc_type == 0x12; /* R_byte4_data.  */
12427     case EM_CRIS:
12428       return reloc_type == 3; /* R_CRIS_32.  */
12429     case EM_CR16:
12430       return reloc_type == 3; /* R_CR16_NUM32.  */
12431     case EM_CRX:
12432       return reloc_type == 15; /* R_CRX_NUM32.  */
12433     case EM_CSKY:
12434       return reloc_type == 1; /* R_CKCORE_ADDR32.  */
12435     case EM_CYGNUS_FRV:
12436       return reloc_type == 1;
12437     case EM_CYGNUS_D10V:
12438     case EM_D10V:
12439       return reloc_type == 6; /* R_D10V_32.  */
12440     case EM_CYGNUS_D30V:
12441     case EM_D30V:
12442       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12443     case EM_DLX:
12444       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12445     case EM_CYGNUS_FR30:
12446     case EM_FR30:
12447       return reloc_type == 3; /* R_FR30_32.  */
12448     case EM_FT32:
12449       return reloc_type == 1; /* R_FT32_32.  */
12450     case EM_H8S:
12451     case EM_H8_300:
12452     case EM_H8_300H:
12453       return reloc_type == 1; /* R_H8_DIR32.  */
12454     case EM_IA_64:
12455       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12456               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12457               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12458               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12459     case EM_IP2K_OLD:
12460     case EM_IP2K:
12461       return reloc_type == 2; /* R_IP2K_32.  */
12462     case EM_IQ2000:
12463       return reloc_type == 2; /* R_IQ2000_32.  */
12464     case EM_LATTICEMICO32:
12465       return reloc_type == 3; /* R_LM32_32.  */
12466     case EM_M32C_OLD:
12467     case EM_M32C:
12468       return reloc_type == 3; /* R_M32C_32.  */
12469     case EM_M32R:
12470       return reloc_type == 34; /* R_M32R_32_RELA.  */
12471     case EM_68HC11:
12472     case EM_68HC12:
12473       return reloc_type == 6; /* R_M68HC11_32.  */
12474     case EM_S12Z:
12475       return reloc_type == 7 || /* R_S12Z_EXT32 */
12476         reloc_type == 6;        /* R_S12Z_CW32.  */
12477     case EM_MCORE:
12478       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12479     case EM_CYGNUS_MEP:
12480       return reloc_type == 4; /* R_MEP_32.  */
12481     case EM_METAG:
12482       return reloc_type == 2; /* R_METAG_ADDR32.  */
12483     case EM_MICROBLAZE:
12484       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12485     case EM_MIPS:
12486       return reloc_type == 2; /* R_MIPS_32.  */
12487     case EM_MMIX:
12488       return reloc_type == 4; /* R_MMIX_32.  */
12489     case EM_CYGNUS_MN10200:
12490     case EM_MN10200:
12491       return reloc_type == 1; /* R_MN10200_32.  */
12492     case EM_CYGNUS_MN10300:
12493     case EM_MN10300:
12494       return reloc_type == 1; /* R_MN10300_32.  */
12495     case EM_MOXIE:
12496       return reloc_type == 1; /* R_MOXIE_32.  */
12497     case EM_MSP430_OLD:
12498     case EM_MSP430:
12499       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12500     case EM_MT:
12501       return reloc_type == 2; /* R_MT_32.  */
12502     case EM_NDS32:
12503       return reloc_type == 20; /* R_NDS32_RELA.  */
12504     case EM_ALTERA_NIOS2:
12505       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12506     case EM_NIOS32:
12507       return reloc_type == 1; /* R_NIOS_32.  */
12508     case EM_OR1K:
12509       return reloc_type == 1; /* R_OR1K_32.  */
12510     case EM_PARISC:
12511       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12512               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12513               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12514     case EM_PJ:
12515     case EM_PJ_OLD:
12516       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12517     case EM_PPC64:
12518       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12519     case EM_PPC:
12520       return reloc_type == 1; /* R_PPC_ADDR32.  */
12521     case EM_TI_PRU:
12522       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12523     case EM_RISCV:
12524       return reloc_type == 1; /* R_RISCV_32.  */
12525     case EM_RL78:
12526       return reloc_type == 1; /* R_RL78_DIR32.  */
12527     case EM_RX:
12528       return reloc_type == 1; /* R_RX_DIR32.  */
12529     case EM_S370:
12530       return reloc_type == 1; /* R_I370_ADDR31.  */
12531     case EM_S390_OLD:
12532     case EM_S390:
12533       return reloc_type == 4; /* R_S390_32.  */
12534     case EM_SCORE:
12535       return reloc_type == 8; /* R_SCORE_ABS32.  */
12536     case EM_SH:
12537       return reloc_type == 1; /* R_SH_DIR32.  */
12538     case EM_SPARC32PLUS:
12539     case EM_SPARCV9:
12540     case EM_SPARC:
12541       return reloc_type == 3 /* R_SPARC_32.  */
12542         || reloc_type == 23; /* R_SPARC_UA32.  */
12543     case EM_SPU:
12544       return reloc_type == 6; /* R_SPU_ADDR32 */
12545     case EM_TI_C6000:
12546       return reloc_type == 1; /* R_C6000_ABS32.  */
12547     case EM_TILEGX:
12548       return reloc_type == 2; /* R_TILEGX_32.  */
12549     case EM_TILEPRO:
12550       return reloc_type == 1; /* R_TILEPRO_32.  */
12551     case EM_CYGNUS_V850:
12552     case EM_V850:
12553       return reloc_type == 6; /* R_V850_ABS32.  */
12554     case EM_V800:
12555       return reloc_type == 0x33; /* R_V810_WORD.  */
12556     case EM_VAX:
12557       return reloc_type == 1; /* R_VAX_32.  */
12558     case EM_VISIUM:
12559       return reloc_type == 3;  /* R_VISIUM_32. */
12560     case EM_WEBASSEMBLY:
12561       return reloc_type == 1;  /* R_WASM32_32.  */
12562     case EM_X86_64:
12563     case EM_L1OM:
12564     case EM_K1OM:
12565       return reloc_type == 10; /* R_X86_64_32.  */
12566     case EM_XC16X:
12567     case EM_C166:
12568       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12569     case EM_XGATE:
12570       return reloc_type == 4; /* R_XGATE_32.  */
12571     case EM_XSTORMY16:
12572       return reloc_type == 1; /* R_XSTROMY16_32.  */
12573     case EM_XTENSA_OLD:
12574     case EM_XTENSA:
12575       return reloc_type == 1; /* R_XTENSA_32.  */
12576     default:
12577       {
12578         static unsigned int prev_warn = 0;
12579
12580         /* Avoid repeating the same warning multiple times.  */
12581         if (prev_warn != filedata->file_header.e_machine)
12582           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12583                  filedata->file_header.e_machine);
12584         prev_warn = filedata->file_header.e_machine;
12585         return FALSE;
12586       }
12587     }
12588 }
12589
12590 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12591    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12592
12593 static bfd_boolean
12594 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12595 {
12596   switch (filedata->file_header.e_machine)
12597   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12598     {
12599     case EM_386:
12600     case EM_IAMCU:
12601       return reloc_type == 2;  /* R_386_PC32.  */
12602     case EM_68K:
12603       return reloc_type == 4;  /* R_68K_PC32.  */
12604     case EM_AARCH64:
12605       return reloc_type == 261; /* R_AARCH64_PREL32 */
12606     case EM_ADAPTEVA_EPIPHANY:
12607       return reloc_type == 6;
12608     case EM_ALPHA:
12609       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12610     case EM_ARC_COMPACT:
12611     case EM_ARC_COMPACT2:
12612       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12613     case EM_ARM:
12614       return reloc_type == 3;  /* R_ARM_REL32 */
12615     case EM_AVR_OLD:
12616     case EM_AVR:
12617       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12618     case EM_MICROBLAZE:
12619       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12620     case EM_OR1K:
12621       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12622     case EM_PARISC:
12623       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12624     case EM_PPC:
12625       return reloc_type == 26; /* R_PPC_REL32.  */
12626     case EM_PPC64:
12627       return reloc_type == 26; /* R_PPC64_REL32.  */
12628     case EM_RISCV:
12629       return reloc_type == 57;  /* R_RISCV_32_PCREL.  */
12630     case EM_S390_OLD:
12631     case EM_S390:
12632       return reloc_type == 5;  /* R_390_PC32.  */
12633     case EM_SH:
12634       return reloc_type == 2;  /* R_SH_REL32.  */
12635     case EM_SPARC32PLUS:
12636     case EM_SPARCV9:
12637     case EM_SPARC:
12638       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12639     case EM_SPU:
12640       return reloc_type == 13; /* R_SPU_REL32.  */
12641     case EM_TILEGX:
12642       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12643     case EM_TILEPRO:
12644       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12645     case EM_VISIUM:
12646       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12647     case EM_X86_64:
12648     case EM_L1OM:
12649     case EM_K1OM:
12650       return reloc_type == 2;  /* R_X86_64_PC32.  */
12651     case EM_XTENSA_OLD:
12652     case EM_XTENSA:
12653       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12654     default:
12655       /* Do not abort or issue an error message here.  Not all targets use
12656          pc-relative 32-bit relocs in their DWARF debug information and we
12657          have already tested for target coverage in is_32bit_abs_reloc.  A
12658          more helpful warning message will be generated by apply_relocations
12659          anyway, so just return.  */
12660       return FALSE;
12661     }
12662 }
12663
12664 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12665    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12666
12667 static bfd_boolean
12668 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12669 {
12670   switch (filedata->file_header.e_machine)
12671     {
12672     case EM_AARCH64:
12673       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12674     case EM_ALPHA:
12675       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12676     case EM_IA_64:
12677       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12678               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12679     case EM_PARISC:
12680       return reloc_type == 80; /* R_PARISC_DIR64.  */
12681     case EM_PPC64:
12682       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12683     case EM_RISCV:
12684       return reloc_type == 2; /* R_RISCV_64.  */
12685     case EM_SPARC32PLUS:
12686     case EM_SPARCV9:
12687     case EM_SPARC:
12688       return reloc_type == 32 /* R_SPARC_64.  */
12689         || reloc_type == 54; /* R_SPARC_UA64.  */
12690     case EM_X86_64:
12691     case EM_L1OM:
12692     case EM_K1OM:
12693       return reloc_type == 1; /* R_X86_64_64.  */
12694     case EM_S390_OLD:
12695     case EM_S390:
12696       return reloc_type == 22;  /* R_S390_64.  */
12697     case EM_TILEGX:
12698       return reloc_type == 1; /* R_TILEGX_64.  */
12699     case EM_MIPS:
12700       return reloc_type == 18;  /* R_MIPS_64.  */
12701     default:
12702       return FALSE;
12703     }
12704 }
12705
12706 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12707    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12708
12709 static bfd_boolean
12710 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12711 {
12712   switch (filedata->file_header.e_machine)
12713     {
12714     case EM_AARCH64:
12715       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12716     case EM_ALPHA:
12717       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12718     case EM_IA_64:
12719       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12720               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12721     case EM_PARISC:
12722       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12723     case EM_PPC64:
12724       return reloc_type == 44; /* R_PPC64_REL64.  */
12725     case EM_SPARC32PLUS:
12726     case EM_SPARCV9:
12727     case EM_SPARC:
12728       return reloc_type == 46; /* R_SPARC_DISP64.  */
12729     case EM_X86_64:
12730     case EM_L1OM:
12731     case EM_K1OM:
12732       return reloc_type == 24; /* R_X86_64_PC64.  */
12733     case EM_S390_OLD:
12734     case EM_S390:
12735       return reloc_type == 23;  /* R_S390_PC64.  */
12736     case EM_TILEGX:
12737       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12738     default:
12739       return FALSE;
12740     }
12741 }
12742
12743 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12744    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12745
12746 static bfd_boolean
12747 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12748 {
12749   switch (filedata->file_header.e_machine)
12750     {
12751     case EM_CYGNUS_MN10200:
12752     case EM_MN10200:
12753       return reloc_type == 4; /* R_MN10200_24.  */
12754     case EM_FT32:
12755       return reloc_type == 5; /* R_FT32_20.  */
12756     default:
12757       return FALSE;
12758     }
12759 }
12760
12761 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12762    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12763
12764 static bfd_boolean
12765 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12766 {
12767   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12768   switch (filedata->file_header.e_machine)
12769     {
12770     case EM_ARC:
12771     case EM_ARC_COMPACT:
12772     case EM_ARC_COMPACT2:
12773       return reloc_type == 2; /* R_ARC_16.  */
12774     case EM_ADAPTEVA_EPIPHANY:
12775       return reloc_type == 5;
12776     case EM_AVR_OLD:
12777     case EM_AVR:
12778       return reloc_type == 4; /* R_AVR_16.  */
12779     case EM_CYGNUS_D10V:
12780     case EM_D10V:
12781       return reloc_type == 3; /* R_D10V_16.  */
12782     case EM_FT32:
12783       return reloc_type == 2; /* R_FT32_16.  */
12784     case EM_H8S:
12785     case EM_H8_300:
12786     case EM_H8_300H:
12787       return reloc_type == R_H8_DIR16;
12788     case EM_IP2K_OLD:
12789     case EM_IP2K:
12790       return reloc_type == 1; /* R_IP2K_16.  */
12791     case EM_M32C_OLD:
12792     case EM_M32C:
12793       return reloc_type == 1; /* R_M32C_16 */
12794     case EM_CYGNUS_MN10200:
12795     case EM_MN10200:
12796       return reloc_type == 2; /* R_MN10200_16.  */
12797     case EM_CYGNUS_MN10300:
12798     case EM_MN10300:
12799       return reloc_type == 2; /* R_MN10300_16.  */
12800     case EM_MSP430:
12801       if (uses_msp430x_relocs (filedata))
12802         return reloc_type == 2; /* R_MSP430_ABS16.  */
12803       /* Fall through.  */
12804     case EM_MSP430_OLD:
12805       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12806     case EM_NDS32:
12807       return reloc_type == 19; /* R_NDS32_RELA.  */
12808     case EM_ALTERA_NIOS2:
12809       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12810     case EM_NIOS32:
12811       return reloc_type == 9; /* R_NIOS_16.  */
12812     case EM_OR1K:
12813       return reloc_type == 2; /* R_OR1K_16.  */
12814     case EM_RISCV:
12815       return reloc_type == 55; /* R_RISCV_SET16.  */
12816     case EM_TI_PRU:
12817       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12818     case EM_TI_C6000:
12819       return reloc_type == 2; /* R_C6000_ABS16.  */
12820     case EM_VISIUM:
12821       return reloc_type == 2; /* R_VISIUM_16. */
12822     case EM_XC16X:
12823     case EM_C166:
12824       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12825     case EM_XGATE:
12826       return reloc_type == 3; /* R_XGATE_16.  */
12827     default:
12828       return FALSE;
12829     }
12830 }
12831
12832 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12833    a 8-bit absolute RELA relocation used in DWARF debug sections.  */
12834
12835 static bfd_boolean
12836 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12837 {
12838   switch (filedata->file_header.e_machine)
12839     {
12840     case EM_RISCV:
12841       return reloc_type == 54; /* R_RISCV_SET8.  */
12842     default:
12843       return FALSE;
12844     }
12845 }
12846
12847 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12848    a 6-bit absolute RELA relocation used in DWARF debug sections.  */
12849
12850 static bfd_boolean
12851 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12852 {
12853   switch (filedata->file_header.e_machine)
12854     {
12855     case EM_RISCV:
12856       return reloc_type == 53; /* R_RISCV_SET6.  */
12857     default:
12858       return FALSE;
12859     }
12860 }
12861
12862 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12863    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12864
12865 static bfd_boolean
12866 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12867 {
12868   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12869   switch (filedata->file_header.e_machine)
12870     {
12871     case EM_RISCV:
12872       return reloc_type == 35; /* R_RISCV_ADD32.  */
12873     default:
12874       return FALSE;
12875     }
12876 }
12877
12878 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12879    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12880
12881 static bfd_boolean
12882 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12883 {
12884   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12885   switch (filedata->file_header.e_machine)
12886     {
12887     case EM_RISCV:
12888       return reloc_type == 39; /* R_RISCV_SUB32.  */
12889     default:
12890       return FALSE;
12891     }
12892 }
12893
12894 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12895    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12896
12897 static bfd_boolean
12898 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12899 {
12900   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12901   switch (filedata->file_header.e_machine)
12902     {
12903     case EM_RISCV:
12904       return reloc_type == 36; /* R_RISCV_ADD64.  */
12905     default:
12906       return FALSE;
12907     }
12908 }
12909
12910 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12911    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12912
12913 static bfd_boolean
12914 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12915 {
12916   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12917   switch (filedata->file_header.e_machine)
12918     {
12919     case EM_RISCV:
12920       return reloc_type == 40; /* R_RISCV_SUB64.  */
12921     default:
12922       return FALSE;
12923     }
12924 }
12925
12926 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12927    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12928
12929 static bfd_boolean
12930 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12931 {
12932   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12933   switch (filedata->file_header.e_machine)
12934     {
12935     case EM_RISCV:
12936       return reloc_type == 34; /* R_RISCV_ADD16.  */
12937     default:
12938       return FALSE;
12939     }
12940 }
12941
12942 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12943    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12944
12945 static bfd_boolean
12946 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12947 {
12948   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12949   switch (filedata->file_header.e_machine)
12950     {
12951     case EM_RISCV:
12952       return reloc_type == 38; /* R_RISCV_SUB16.  */
12953     default:
12954       return FALSE;
12955     }
12956 }
12957
12958 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12959    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12960
12961 static bfd_boolean
12962 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12963 {
12964   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12965   switch (filedata->file_header.e_machine)
12966     {
12967     case EM_RISCV:
12968       return reloc_type == 33; /* R_RISCV_ADD8.  */
12969     default:
12970       return FALSE;
12971     }
12972 }
12973
12974 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12975    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12976
12977 static bfd_boolean
12978 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12979 {
12980   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12981   switch (filedata->file_header.e_machine)
12982     {
12983     case EM_RISCV:
12984       return reloc_type == 37; /* R_RISCV_SUB8.  */
12985     default:
12986       return FALSE;
12987     }
12988 }
12989
12990 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12991    a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
12992
12993 static bfd_boolean
12994 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12995 {
12996   switch (filedata->file_header.e_machine)
12997     {
12998     case EM_RISCV:
12999       return reloc_type == 52; /* R_RISCV_SUB6.  */
13000     default:
13001       return FALSE;
13002     }
13003 }
13004
13005 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13006    relocation entries (possibly formerly used for SHT_GROUP sections).  */
13007
13008 static bfd_boolean
13009 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
13010 {
13011   switch (filedata->file_header.e_machine)
13012     {
13013     case EM_386:     /* R_386_NONE.  */
13014     case EM_68K:     /* R_68K_NONE.  */
13015     case EM_ADAPTEVA_EPIPHANY:
13016     case EM_ALPHA:   /* R_ALPHA_NONE.  */
13017     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
13018     case EM_ARC:     /* R_ARC_NONE.  */
13019     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
13020     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
13021     case EM_ARM:     /* R_ARM_NONE.  */
13022     case EM_C166:    /* R_XC16X_NONE.  */
13023     case EM_CRIS:    /* R_CRIS_NONE.  */
13024     case EM_FT32:    /* R_FT32_NONE.  */
13025     case EM_IA_64:   /* R_IA64_NONE.  */
13026     case EM_K1OM:    /* R_X86_64_NONE.  */
13027     case EM_L1OM:    /* R_X86_64_NONE.  */
13028     case EM_M32R:    /* R_M32R_NONE.  */
13029     case EM_MIPS:    /* R_MIPS_NONE.  */
13030     case EM_MN10300: /* R_MN10300_NONE.  */
13031     case EM_MOXIE:   /* R_MOXIE_NONE.  */
13032     case EM_NIOS32:  /* R_NIOS_NONE.  */
13033     case EM_OR1K:    /* R_OR1K_NONE. */
13034     case EM_PARISC:  /* R_PARISC_NONE.  */
13035     case EM_PPC64:   /* R_PPC64_NONE.  */
13036     case EM_PPC:     /* R_PPC_NONE.  */
13037     case EM_RISCV:   /* R_RISCV_NONE.  */
13038     case EM_S390:    /* R_390_NONE.  */
13039     case EM_S390_OLD:
13040     case EM_SH:      /* R_SH_NONE.  */
13041     case EM_SPARC32PLUS:
13042     case EM_SPARC:   /* R_SPARC_NONE.  */
13043     case EM_SPARCV9:
13044     case EM_TILEGX:  /* R_TILEGX_NONE.  */
13045     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
13046     case EM_TI_C6000:/* R_C6000_NONE.  */
13047     case EM_X86_64:  /* R_X86_64_NONE.  */
13048     case EM_XC16X:
13049     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
13050       return reloc_type == 0;
13051
13052     case EM_AARCH64:
13053       return reloc_type == 0 || reloc_type == 256;
13054     case EM_AVR_OLD:
13055     case EM_AVR:
13056       return (reloc_type == 0 /* R_AVR_NONE.  */
13057               || reloc_type == 30 /* R_AVR_DIFF8.  */
13058               || reloc_type == 31 /* R_AVR_DIFF16.  */
13059               || reloc_type == 32 /* R_AVR_DIFF32.  */);
13060     case EM_METAG:
13061       return reloc_type == 3; /* R_METAG_NONE.  */
13062     case EM_NDS32:
13063       return (reloc_type == 0       /* R_XTENSA_NONE.  */
13064               || reloc_type == 204  /* R_NDS32_DIFF8.  */
13065               || reloc_type == 205  /* R_NDS32_DIFF16.  */
13066               || reloc_type == 206  /* R_NDS32_DIFF32.  */
13067               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
13068     case EM_TI_PRU:
13069       return (reloc_type == 0       /* R_PRU_NONE.  */
13070               || reloc_type == 65   /* R_PRU_DIFF8.  */
13071               || reloc_type == 66   /* R_PRU_DIFF16.  */
13072               || reloc_type == 67   /* R_PRU_DIFF32.  */);
13073     case EM_XTENSA_OLD:
13074     case EM_XTENSA:
13075       return (reloc_type == 0      /* R_XTENSA_NONE.  */
13076               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
13077               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
13078               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
13079     }
13080   return FALSE;
13081 }
13082
13083 /* Returns TRUE if there is a relocation against
13084    section NAME at OFFSET bytes.  */
13085
13086 bfd_boolean
13087 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13088 {
13089   Elf_Internal_Rela * relocs;
13090   Elf_Internal_Rela * rp;
13091
13092   if (dsec == NULL || dsec->reloc_info == NULL)
13093     return FALSE;
13094
13095   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13096
13097   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13098     if (rp->r_offset == offset)
13099       return TRUE;
13100
13101    return FALSE;
13102 }
13103
13104 /* Apply relocations to a section.
13105    Returns TRUE upon success, FALSE otherwise.
13106    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13107    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
13108    will be set to the number of relocs loaded.
13109
13110    Note: So far support has been added only for those relocations
13111    which can be found in debug sections. FIXME: Add support for
13112    more relocations ?  */
13113
13114 static bfd_boolean
13115 apply_relocations (Filedata *                 filedata,
13116                    const Elf_Internal_Shdr *  section,
13117                    unsigned char *            start,
13118                    bfd_size_type              size,
13119                    void **                    relocs_return,
13120                    unsigned long *            num_relocs_return)
13121 {
13122   Elf_Internal_Shdr * relsec;
13123   unsigned char * end = start + size;
13124
13125   if (relocs_return != NULL)
13126     {
13127       * (Elf_Internal_Rela **) relocs_return = NULL;
13128       * num_relocs_return = 0;
13129     }
13130
13131   if (filedata->file_header.e_type != ET_REL)
13132     /* No relocs to apply.  */
13133     return TRUE;
13134
13135   /* Find the reloc section associated with the section.  */
13136   for (relsec = filedata->section_headers;
13137        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13138        ++relsec)
13139     {
13140       bfd_boolean is_rela;
13141       unsigned long num_relocs;
13142       Elf_Internal_Rela * relocs;
13143       Elf_Internal_Rela * rp;
13144       Elf_Internal_Shdr * symsec;
13145       Elf_Internal_Sym * symtab;
13146       unsigned long num_syms;
13147       Elf_Internal_Sym * sym;
13148
13149       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13150           || relsec->sh_info >= filedata->file_header.e_shnum
13151           || filedata->section_headers + relsec->sh_info != section
13152           || relsec->sh_size == 0
13153           || relsec->sh_link >= filedata->file_header.e_shnum)
13154         continue;
13155
13156       is_rela = relsec->sh_type == SHT_RELA;
13157
13158       if (is_rela)
13159         {
13160           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13161                                   relsec->sh_size, & relocs, & num_relocs))
13162             return FALSE;
13163         }
13164       else
13165         {
13166           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13167                                  relsec->sh_size, & relocs, & num_relocs))
13168             return FALSE;
13169         }
13170
13171       /* SH uses RELA but uses in place value instead of the addend field.  */
13172       if (filedata->file_header.e_machine == EM_SH)
13173         is_rela = FALSE;
13174
13175       symsec = filedata->section_headers + relsec->sh_link;
13176       if (symsec->sh_type != SHT_SYMTAB
13177           && symsec->sh_type != SHT_DYNSYM)
13178         return FALSE;
13179       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13180
13181       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13182         {
13183           bfd_vma         addend;
13184           unsigned int    reloc_type;
13185           unsigned int    reloc_size;
13186           bfd_boolean     reloc_inplace = FALSE;
13187           bfd_boolean     reloc_subtract = FALSE;
13188           unsigned char * rloc;
13189           unsigned long   sym_index;
13190
13191           reloc_type = get_reloc_type (filedata, rp->r_info);
13192
13193           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13194             continue;
13195           else if (is_none_reloc (filedata, reloc_type))
13196             continue;
13197           else if (is_32bit_abs_reloc (filedata, reloc_type)
13198                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13199             reloc_size = 4;
13200           else if (is_64bit_abs_reloc (filedata, reloc_type)
13201                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13202             reloc_size = 8;
13203           else if (is_24bit_abs_reloc (filedata, reloc_type))
13204             reloc_size = 3;
13205           else if (is_16bit_abs_reloc (filedata, reloc_type))
13206             reloc_size = 2;
13207           else if (is_8bit_abs_reloc (filedata, reloc_type)
13208                    || is_6bit_abs_reloc (filedata, reloc_type))
13209             reloc_size = 1;
13210           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13211                                                                  reloc_type))
13212                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13213             {
13214               reloc_size = 4;
13215               reloc_inplace = TRUE;
13216             }
13217           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13218                                                                  reloc_type))
13219                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13220             {
13221               reloc_size = 8;
13222               reloc_inplace = TRUE;
13223             }
13224           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13225                                                                  reloc_type))
13226                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13227             {
13228               reloc_size = 2;
13229               reloc_inplace = TRUE;
13230             }
13231           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13232                                                                 reloc_type))
13233                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13234             {
13235               reloc_size = 1;
13236               reloc_inplace = TRUE;
13237             }
13238           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13239                                                                 reloc_type)))
13240             {
13241               reloc_size = 1;
13242               reloc_inplace = TRUE;
13243             }
13244           else
13245             {
13246               static unsigned int prev_reloc = 0;
13247
13248               if (reloc_type != prev_reloc)
13249                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13250                       reloc_type, printable_section_name (filedata, section));
13251               prev_reloc = reloc_type;
13252               continue;
13253             }
13254
13255           rloc = start + rp->r_offset;
13256           if ((rloc + reloc_size) > end || (rloc < start))
13257             {
13258               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13259                     (unsigned long) rp->r_offset,
13260                     printable_section_name (filedata, section));
13261               continue;
13262             }
13263
13264           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13265           if (sym_index >= num_syms)
13266             {
13267               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13268                     sym_index, printable_section_name (filedata, section));
13269               continue;
13270             }
13271           sym = symtab + sym_index;
13272
13273           /* If the reloc has a symbol associated with it,
13274              make sure that it is of an appropriate type.
13275
13276              Relocations against symbols without type can happen.
13277              Gcc -feliminate-dwarf2-dups may generate symbols
13278              without type for debug info.
13279
13280              Icc generates relocations against function symbols
13281              instead of local labels.
13282
13283              Relocations against object symbols can happen, eg when
13284              referencing a global array.  For an example of this see
13285              the _clz.o binary in libgcc.a.  */
13286           if (sym != symtab
13287               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13288               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13289             {
13290               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13291                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13292                     printable_section_name (filedata, relsec),
13293                     (long int)(rp - relocs));
13294               continue;
13295             }
13296
13297           addend = 0;
13298           if (is_rela)
13299             addend += rp->r_addend;
13300           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13301              partial_inplace.  */
13302           if (!is_rela
13303               || (filedata->file_header.e_machine == EM_XTENSA
13304                   && reloc_type == 1)
13305               || ((filedata->file_header.e_machine == EM_PJ
13306                    || filedata->file_header.e_machine == EM_PJ_OLD)
13307                   && reloc_type == 1)
13308               || ((filedata->file_header.e_machine == EM_D30V
13309                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13310                   && reloc_type == 12)
13311               || reloc_inplace)
13312             {
13313               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13314                 addend += byte_get (rloc, reloc_size) & 0x3f;
13315               else
13316                 addend += byte_get (rloc, reloc_size);
13317             }
13318
13319           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13320               || is_64bit_pcrel_reloc (filedata, reloc_type))
13321             {
13322               /* On HPPA, all pc-relative relocations are biased by 8.  */
13323               if (filedata->file_header.e_machine == EM_PARISC)
13324                 addend -= 8;
13325               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13326                         reloc_size);
13327             }
13328           else if (is_6bit_abs_reloc (filedata, reloc_type)
13329                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13330             {
13331               if (reloc_subtract)
13332                 addend -= sym->st_value;
13333               else
13334                 addend += sym->st_value;
13335               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13336               byte_put (rloc, addend, reloc_size);
13337             }
13338           else if (reloc_subtract)
13339             byte_put (rloc, addend - sym->st_value, reloc_size);
13340           else
13341             byte_put (rloc, addend + sym->st_value, reloc_size);
13342         }
13343
13344       free (symtab);
13345       /* Let the target specific reloc processing code know that
13346          we have finished with these relocs.  */
13347       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13348
13349       if (relocs_return)
13350         {
13351           * (Elf_Internal_Rela **) relocs_return = relocs;
13352           * num_relocs_return = num_relocs;
13353         }
13354       else
13355         free (relocs);
13356
13357       break;
13358     }
13359
13360   return TRUE;
13361 }
13362
13363 #ifdef SUPPORT_DISASSEMBLY
13364 static bfd_boolean
13365 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13366 {
13367   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13368
13369   /* FIXME: XXX -- to be done --- XXX */
13370
13371   return TRUE;
13372 }
13373 #endif
13374
13375 /* Reads in the contents of SECTION from FILE, returning a pointer
13376    to a malloc'ed buffer or NULL if something went wrong.  */
13377
13378 static char *
13379 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13380 {
13381   bfd_size_type num_bytes = section->sh_size;
13382
13383   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13384     {
13385       printf (_("Section '%s' has no data to dump.\n"),
13386               printable_section_name (filedata, section));
13387       return NULL;
13388     }
13389
13390   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13391                              _("section contents"));
13392 }
13393
13394 /* Uncompresses a section that was compressed using zlib, in place.  */
13395
13396 static bfd_boolean
13397 uncompress_section_contents (unsigned char **   buffer,
13398                              dwarf_size_type    uncompressed_size,
13399                              dwarf_size_type *  size)
13400 {
13401   dwarf_size_type compressed_size = *size;
13402   unsigned char * compressed_buffer = *buffer;
13403   unsigned char * uncompressed_buffer;
13404   z_stream strm;
13405   int rc;
13406
13407   /* It is possible the section consists of several compressed
13408      buffers concatenated together, so we uncompress in a loop.  */
13409   /* PR 18313: The state field in the z_stream structure is supposed
13410      to be invisible to the user (ie us), but some compilers will
13411      still complain about it being used without initialisation.  So
13412      we first zero the entire z_stream structure and then set the fields
13413      that we need.  */
13414   memset (& strm, 0, sizeof strm);
13415   strm.avail_in = compressed_size;
13416   strm.next_in = (Bytef *) compressed_buffer;
13417   strm.avail_out = uncompressed_size;
13418   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13419
13420   rc = inflateInit (& strm);
13421   while (strm.avail_in > 0)
13422     {
13423       if (rc != Z_OK)
13424         goto fail;
13425       strm.next_out = ((Bytef *) uncompressed_buffer
13426                        + (uncompressed_size - strm.avail_out));
13427       rc = inflate (&strm, Z_FINISH);
13428       if (rc != Z_STREAM_END)
13429         goto fail;
13430       rc = inflateReset (& strm);
13431     }
13432   rc = inflateEnd (& strm);
13433   if (rc != Z_OK
13434       || strm.avail_out != 0)
13435     goto fail;
13436
13437   *buffer = uncompressed_buffer;
13438   *size = uncompressed_size;
13439   return TRUE;
13440
13441  fail:
13442   free (uncompressed_buffer);
13443   /* Indicate decompression failure.  */
13444   *buffer = NULL;
13445   return FALSE;
13446 }
13447
13448 static bfd_boolean
13449 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13450 {
13451   Elf_Internal_Shdr *  relsec;
13452   bfd_size_type        num_bytes;
13453   unsigned char *      data;
13454   unsigned char *      end;
13455   unsigned char *      real_start;
13456   unsigned char *      start;
13457   bfd_boolean          some_strings_shown;
13458
13459   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13460   if (start == NULL)
13461     /* PR 21820: Do not fail if the section was empty.  */
13462     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13463
13464   num_bytes = section->sh_size;
13465
13466   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13467
13468   if (decompress_dumps)
13469     {
13470       dwarf_size_type new_size = num_bytes;
13471       dwarf_size_type uncompressed_size = 0;
13472
13473       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13474         {
13475           Elf_Internal_Chdr chdr;
13476           unsigned int compression_header_size
13477             = get_compression_header (& chdr, (unsigned char *) start,
13478                                       num_bytes);
13479
13480           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13481             {
13482               warn (_("section '%s' has unsupported compress type: %d\n"),
13483                     printable_section_name (filedata, section), chdr.ch_type);
13484               return FALSE;
13485             }
13486           uncompressed_size = chdr.ch_size;
13487           start += compression_header_size;
13488           new_size -= compression_header_size;
13489         }
13490       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13491         {
13492           /* Read the zlib header.  In this case, it should be "ZLIB"
13493              followed by the uncompressed section size, 8 bytes in
13494              big-endian order.  */
13495           uncompressed_size = start[4]; uncompressed_size <<= 8;
13496           uncompressed_size += start[5]; uncompressed_size <<= 8;
13497           uncompressed_size += start[6]; uncompressed_size <<= 8;
13498           uncompressed_size += start[7]; uncompressed_size <<= 8;
13499           uncompressed_size += start[8]; uncompressed_size <<= 8;
13500           uncompressed_size += start[9]; uncompressed_size <<= 8;
13501           uncompressed_size += start[10]; uncompressed_size <<= 8;
13502           uncompressed_size += start[11];
13503           start += 12;
13504           new_size -= 12;
13505         }
13506
13507       if (uncompressed_size)
13508         {
13509           if (uncompress_section_contents (& start,
13510                                            uncompressed_size, & new_size))
13511             num_bytes = new_size;
13512           else
13513             {
13514               error (_("Unable to decompress section %s\n"),
13515                      printable_section_name (filedata, section));
13516               return FALSE;
13517             }
13518         }
13519       else
13520         start = real_start;
13521     }
13522
13523   /* If the section being dumped has relocations against it the user might
13524      be expecting these relocations to have been applied.  Check for this
13525      case and issue a warning message in order to avoid confusion.
13526      FIXME: Maybe we ought to have an option that dumps a section with
13527      relocs applied ?  */
13528   for (relsec = filedata->section_headers;
13529        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13530        ++relsec)
13531     {
13532       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13533           || relsec->sh_info >= filedata->file_header.e_shnum
13534           || filedata->section_headers + relsec->sh_info != section
13535           || relsec->sh_size == 0
13536           || relsec->sh_link >= filedata->file_header.e_shnum)
13537         continue;
13538
13539       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13540       break;
13541     }
13542
13543   data = start;
13544   end  = start + num_bytes;
13545   some_strings_shown = FALSE;
13546
13547   while (data < end)
13548     {
13549       while (!ISPRINT (* data))
13550         if (++ data >= end)
13551           break;
13552
13553       if (data < end)
13554         {
13555           size_t maxlen = end - data;
13556
13557 #ifndef __MSVCRT__
13558           /* PR 11128: Use two separate invocations in order to work
13559              around bugs in the Solaris 8 implementation of printf.  */
13560           printf ("  [%6tx]  ", data - start);
13561 #else
13562           printf ("  [%6Ix]  ", (size_t) (data - start));
13563 #endif
13564           if (maxlen > 0)
13565             {
13566               print_symbol ((int) maxlen, (const char *) data);
13567               putchar ('\n');
13568               data += strnlen ((const char *) data, maxlen);
13569             }
13570           else
13571             {
13572               printf (_("<corrupt>\n"));
13573               data = end;
13574             }
13575           some_strings_shown = TRUE;
13576         }
13577     }
13578
13579   if (! some_strings_shown)
13580     printf (_("  No strings found in this section."));
13581
13582   free (real_start);
13583
13584   putchar ('\n');
13585   return TRUE;
13586 }
13587
13588 static bfd_boolean
13589 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13590                        Filedata *           filedata,
13591                        bfd_boolean          relocate)
13592 {
13593   Elf_Internal_Shdr * relsec;
13594   bfd_size_type       bytes;
13595   bfd_size_type       section_size;
13596   bfd_vma             addr;
13597   unsigned char *     data;
13598   unsigned char *     real_start;
13599   unsigned char *     start;
13600
13601   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13602   if (start == NULL)
13603     /* PR 21820: Do not fail if the section was empty.  */
13604     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13605
13606   section_size = section->sh_size;
13607
13608   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13609
13610   if (decompress_dumps)
13611     {
13612       dwarf_size_type new_size = section_size;
13613       dwarf_size_type uncompressed_size = 0;
13614
13615       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13616         {
13617           Elf_Internal_Chdr chdr;
13618           unsigned int compression_header_size
13619             = get_compression_header (& chdr, start, section_size);
13620
13621           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13622             {
13623               warn (_("section '%s' has unsupported compress type: %d\n"),
13624                     printable_section_name (filedata, section), chdr.ch_type);
13625               return FALSE;
13626             }
13627           uncompressed_size = chdr.ch_size;
13628           start += compression_header_size;
13629           new_size -= compression_header_size;
13630         }
13631       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13632         {
13633           /* Read the zlib header.  In this case, it should be "ZLIB"
13634              followed by the uncompressed section size, 8 bytes in
13635              big-endian order.  */
13636           uncompressed_size = start[4]; uncompressed_size <<= 8;
13637           uncompressed_size += start[5]; uncompressed_size <<= 8;
13638           uncompressed_size += start[6]; uncompressed_size <<= 8;
13639           uncompressed_size += start[7]; uncompressed_size <<= 8;
13640           uncompressed_size += start[8]; uncompressed_size <<= 8;
13641           uncompressed_size += start[9]; uncompressed_size <<= 8;
13642           uncompressed_size += start[10]; uncompressed_size <<= 8;
13643           uncompressed_size += start[11];
13644           start += 12;
13645           new_size -= 12;
13646         }
13647
13648       if (uncompressed_size)
13649         {
13650           if (uncompress_section_contents (& start, uncompressed_size,
13651                                            & new_size))
13652             {
13653               section_size = new_size;
13654             }
13655           else
13656             {
13657               error (_("Unable to decompress section %s\n"),
13658                      printable_section_name (filedata, section));
13659               /* FIXME: Print the section anyway ?  */
13660               return FALSE;
13661             }
13662         }
13663       else
13664         start = real_start;
13665     }
13666
13667   if (relocate)
13668     {
13669       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13670         return FALSE;
13671     }
13672   else
13673     {
13674       /* If the section being dumped has relocations against it the user might
13675          be expecting these relocations to have been applied.  Check for this
13676          case and issue a warning message in order to avoid confusion.
13677          FIXME: Maybe we ought to have an option that dumps a section with
13678          relocs applied ?  */
13679       for (relsec = filedata->section_headers;
13680            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13681            ++relsec)
13682         {
13683           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13684               || relsec->sh_info >= filedata->file_header.e_shnum
13685               || filedata->section_headers + relsec->sh_info != section
13686               || relsec->sh_size == 0
13687               || relsec->sh_link >= filedata->file_header.e_shnum)
13688             continue;
13689
13690           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13691           break;
13692         }
13693     }
13694
13695   addr = section->sh_addr;
13696   bytes = section_size;
13697   data = start;
13698
13699   while (bytes)
13700     {
13701       int j;
13702       int k;
13703       int lbytes;
13704
13705       lbytes = (bytes > 16 ? 16 : bytes);
13706
13707       printf ("  0x%8.8lx ", (unsigned long) addr);
13708
13709       for (j = 0; j < 16; j++)
13710         {
13711           if (j < lbytes)
13712             printf ("%2.2x", data[j]);
13713           else
13714             printf ("  ");
13715
13716           if ((j & 3) == 3)
13717             printf (" ");
13718         }
13719
13720       for (j = 0; j < lbytes; j++)
13721         {
13722           k = data[j];
13723           if (k >= ' ' && k < 0x7f)
13724             printf ("%c", k);
13725           else
13726             printf (".");
13727         }
13728
13729       putchar ('\n');
13730
13731       data  += lbytes;
13732       addr  += lbytes;
13733       bytes -= lbytes;
13734     }
13735
13736   free (real_start);
13737
13738   putchar ('\n');
13739   return TRUE;
13740 }
13741
13742 static bfd_boolean
13743 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13744                              const Elf_Internal_Shdr *        sec,
13745                              void *                           data)
13746 {
13747   struct dwarf_section * section = &debug_displays [debug].section;
13748   char buf [64];
13749   Filedata * filedata = (Filedata *) data;
13750
13751   if (section->start != NULL)
13752     {
13753       /* If it is already loaded, do nothing.  */
13754       if (streq (section->filename, filedata->file_name))
13755         return TRUE;
13756       free (section->start);
13757     }
13758
13759   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13760   section->address = sec->sh_addr;
13761   section->user_data = NULL;
13762   section->filename = filedata->file_name;
13763   section->start = (unsigned char *) get_data (NULL, filedata,
13764                                                sec->sh_offset, 1,
13765                                                sec->sh_size, buf);
13766   if (section->start == NULL)
13767     section->size = 0;
13768   else
13769     {
13770       unsigned char *start = section->start;
13771       dwarf_size_type size = sec->sh_size;
13772       dwarf_size_type uncompressed_size = 0;
13773
13774       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13775         {
13776           Elf_Internal_Chdr chdr;
13777           unsigned int compression_header_size;
13778
13779           if (size < (is_32bit_elf
13780                       ? sizeof (Elf32_External_Chdr)
13781                       : sizeof (Elf64_External_Chdr)))
13782             {
13783               warn (_("compressed section %s is too small to contain a compression header"),
13784                     section->name);
13785               return FALSE;
13786             }
13787
13788           compression_header_size = get_compression_header (&chdr, start, size);
13789
13790           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13791             {
13792               warn (_("section '%s' has unsupported compress type: %d\n"),
13793                     section->name, chdr.ch_type);
13794               return FALSE;
13795             }
13796           uncompressed_size = chdr.ch_size;
13797           start += compression_header_size;
13798           size -= compression_header_size;
13799         }
13800       else if (size > 12 && streq ((char *) start, "ZLIB"))
13801         {
13802           /* Read the zlib header.  In this case, it should be "ZLIB"
13803              followed by the uncompressed section size, 8 bytes in
13804              big-endian order.  */
13805           uncompressed_size = start[4]; uncompressed_size <<= 8;
13806           uncompressed_size += start[5]; uncompressed_size <<= 8;
13807           uncompressed_size += start[6]; uncompressed_size <<= 8;
13808           uncompressed_size += start[7]; uncompressed_size <<= 8;
13809           uncompressed_size += start[8]; uncompressed_size <<= 8;
13810           uncompressed_size += start[9]; uncompressed_size <<= 8;
13811           uncompressed_size += start[10]; uncompressed_size <<= 8;
13812           uncompressed_size += start[11];
13813           start += 12;
13814           size -= 12;
13815         }
13816
13817       if (uncompressed_size)
13818         {
13819           if (uncompress_section_contents (&start, uncompressed_size,
13820                                            &size))
13821             {
13822               /* Free the compressed buffer, update the section buffer
13823                  and the section size if uncompress is successful.  */
13824               free (section->start);
13825               section->start = start;
13826             }
13827           else
13828             {
13829               error (_("Unable to decompress section %s\n"),
13830                      printable_section_name (filedata, sec));
13831               return FALSE;
13832             }
13833         }
13834
13835       section->size = size;
13836     }
13837
13838   if (section->start == NULL)
13839     return FALSE;
13840
13841   if (debug_displays [debug].relocate)
13842     {
13843       if (! apply_relocations (filedata, sec, section->start, section->size,
13844                                & section->reloc_info, & section->num_relocs))
13845         return FALSE;
13846     }
13847   else
13848     {
13849       section->reloc_info = NULL;
13850       section->num_relocs = 0;
13851     }
13852
13853   return TRUE;
13854 }
13855
13856 /* If this is not NULL, load_debug_section will only look for sections
13857    within the list of sections given here.  */
13858 static unsigned int * section_subset = NULL;
13859
13860 bfd_boolean
13861 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13862 {
13863   struct dwarf_section * section = &debug_displays [debug].section;
13864   Elf_Internal_Shdr * sec;
13865   Filedata * filedata = (Filedata *) data;
13866
13867   /* Without section headers we cannot find any sections.  */
13868   if (filedata->section_headers == NULL)
13869     return FALSE;
13870
13871   if (filedata->string_table == NULL
13872       && filedata->file_header.e_shstrndx != SHN_UNDEF
13873       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13874     {
13875       Elf_Internal_Shdr * strs;
13876
13877       /* Read in the string table, so that we have section names to scan.  */
13878       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13879
13880       if (strs != NULL && strs->sh_size != 0)
13881         {
13882           filedata->string_table
13883             = (char *) get_data (NULL, filedata, strs->sh_offset,
13884                                  1, strs->sh_size, _("string table"));
13885
13886           filedata->string_table_length
13887             = filedata->string_table != NULL ? strs->sh_size : 0;
13888         }
13889     }
13890
13891   /* Locate the debug section.  */
13892   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13893   if (sec != NULL)
13894     section->name = section->uncompressed_name;
13895   else
13896     {
13897       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13898       if (sec != NULL)
13899         section->name = section->compressed_name;
13900     }
13901   if (sec == NULL)
13902     return FALSE;
13903
13904   /* If we're loading from a subset of sections, and we've loaded
13905      a section matching this name before, it's likely that it's a
13906      different one.  */
13907   if (section_subset != NULL)
13908     free_debug_section (debug);
13909
13910   return load_specific_debug_section (debug, sec, data);
13911 }
13912
13913 void
13914 free_debug_section (enum dwarf_section_display_enum debug)
13915 {
13916   struct dwarf_section * section = &debug_displays [debug].section;
13917
13918   if (section->start == NULL)
13919     return;
13920
13921   free ((char *) section->start);
13922   section->start = NULL;
13923   section->address = 0;
13924   section->size = 0;
13925 }
13926
13927 static bfd_boolean
13928 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13929 {
13930   char * name = SECTION_NAME (section);
13931   const char * print_name = printable_section_name (filedata, section);
13932   bfd_size_type length;
13933   bfd_boolean result = TRUE;
13934   int i;
13935
13936   length = section->sh_size;
13937   if (length == 0)
13938     {
13939       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13940       return TRUE;
13941     }
13942   if (section->sh_type == SHT_NOBITS)
13943     {
13944       /* There is no point in dumping the contents of a debugging section
13945          which has the NOBITS type - the bits in the file will be random.
13946          This can happen when a file containing a .eh_frame section is
13947          stripped with the --only-keep-debug command line option.  */
13948       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13949               print_name);
13950       return FALSE;
13951     }
13952
13953   if (const_strneq (name, ".gnu.linkonce.wi."))
13954     name = ".debug_info";
13955
13956   /* See if we know how to display the contents of this section.  */
13957   for (i = 0; i < max; i++)
13958     {
13959       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13960       struct dwarf_section_display *   display = debug_displays + i;
13961       struct dwarf_section *           sec = & display->section;
13962
13963       if (streq (sec->uncompressed_name, name)
13964           || (id == line && const_strneq (name, ".debug_line."))
13965           || streq (sec->compressed_name, name))
13966         {
13967           bfd_boolean secondary = (section != find_section (filedata, name));
13968
13969           if (secondary)
13970             free_debug_section (id);
13971
13972           if (i == line && const_strneq (name, ".debug_line."))
13973             sec->name = name;
13974           else if (streq (sec->uncompressed_name, name))
13975             sec->name = sec->uncompressed_name;
13976           else
13977             sec->name = sec->compressed_name;
13978
13979           if (load_specific_debug_section (id, section, filedata))
13980             {
13981               /* If this debug section is part of a CU/TU set in a .dwp file,
13982                  restrict load_debug_section to the sections in that set.  */
13983               section_subset = find_cu_tu_set (filedata, shndx);
13984
13985               result &= display->display (sec, filedata);
13986
13987               section_subset = NULL;
13988
13989               if (secondary || (id != info && id != abbrev))
13990                 free_debug_section (id);
13991             }
13992           break;
13993         }
13994     }
13995
13996   if (i == max)
13997     {
13998       printf (_("Unrecognized debug section: %s\n"), print_name);
13999       result = FALSE;
14000     }
14001
14002   return result;
14003 }
14004
14005 /* Set DUMP_SECTS for all sections where dumps were requested
14006    based on section name.  */
14007
14008 static void
14009 initialise_dumps_byname (Filedata * filedata)
14010 {
14011   struct dump_list_entry * cur;
14012
14013   for (cur = dump_sects_byname; cur; cur = cur->next)
14014     {
14015       unsigned int i;
14016       bfd_boolean any = FALSE;
14017
14018       for (i = 0; i < filedata->file_header.e_shnum; i++)
14019         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
14020           {
14021             request_dump_bynumber (filedata, i, cur->type);
14022             any = TRUE;
14023           }
14024
14025       if (!any)
14026         warn (_("Section '%s' was not dumped because it does not exist!\n"),
14027               cur->name);
14028     }
14029 }
14030
14031 static bfd_boolean
14032 process_section_contents (Filedata * filedata)
14033 {
14034   Elf_Internal_Shdr * section;
14035   unsigned int i;
14036   bfd_boolean res = TRUE;
14037
14038   if (! do_dump)
14039     return TRUE;
14040
14041   initialise_dumps_byname (filedata);
14042
14043   for (i = 0, section = filedata->section_headers;
14044        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
14045        i++, section++)
14046     {
14047       dump_type dump = filedata->dump_sects[i];
14048
14049 #ifdef SUPPORT_DISASSEMBLY
14050       if (dump & DISASS_DUMP)
14051         {
14052           if (! disassemble_section (section, filedata))
14053             res = FALSE;
14054         }
14055 #endif
14056       if (dump & HEX_DUMP)
14057         {
14058           if (! dump_section_as_bytes (section, filedata, FALSE))
14059             res = FALSE;
14060         }
14061
14062       if (dump & RELOC_DUMP)
14063         {
14064           if (! dump_section_as_bytes (section, filedata, TRUE))
14065             res = FALSE;
14066         }
14067
14068       if (dump & STRING_DUMP)
14069         {
14070           if (! dump_section_as_strings (section, filedata))
14071             res = FALSE;
14072         }
14073
14074       if (dump & DEBUG_DUMP)
14075         {
14076           if (! display_debug_section (i, section, filedata))
14077             res = FALSE;
14078         }
14079     }
14080
14081   /* Check to see if the user requested a
14082      dump of a section that does not exist.  */
14083   while (i < filedata->num_dump_sects)
14084     {
14085       if (filedata->dump_sects[i])
14086         {
14087           warn (_("Section %d was not dumped because it does not exist!\n"), i);
14088           res = FALSE;
14089         }
14090       i++;
14091     }
14092
14093   return res;
14094 }
14095
14096 static void
14097 process_mips_fpe_exception (int mask)
14098 {
14099   if (mask)
14100     {
14101       bfd_boolean first = TRUE;
14102
14103       if (mask & OEX_FPU_INEX)
14104         fputs ("INEX", stdout), first = FALSE;
14105       if (mask & OEX_FPU_UFLO)
14106         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14107       if (mask & OEX_FPU_OFLO)
14108         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14109       if (mask & OEX_FPU_DIV0)
14110         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14111       if (mask & OEX_FPU_INVAL)
14112         printf ("%sINVAL", first ? "" : "|");
14113     }
14114   else
14115     fputs ("0", stdout);
14116 }
14117
14118 /* Display's the value of TAG at location P.  If TAG is
14119    greater than 0 it is assumed to be an unknown tag, and
14120    a message is printed to this effect.  Otherwise it is
14121    assumed that a message has already been printed.
14122
14123    If the bottom bit of TAG is set it assumed to have a
14124    string value, otherwise it is assumed to have an integer
14125    value.
14126
14127    Returns an updated P pointing to the first unread byte
14128    beyond the end of TAG's value.
14129
14130    Reads at or beyond END will not be made.  */
14131
14132 static unsigned char *
14133 display_tag_value (signed int tag,
14134                    unsigned char * p,
14135                    const unsigned char * const end)
14136 {
14137   unsigned long val;
14138
14139   if (tag > 0)
14140     printf ("  Tag_unknown_%d: ", tag);
14141
14142   if (p >= end)
14143     {
14144       warn (_("<corrupt tag>\n"));
14145     }
14146   else if (tag & 1)
14147     {
14148       /* PR 17531 file: 027-19978-0.004.  */
14149       size_t maxlen = (end - p) - 1;
14150
14151       putchar ('"');
14152       if (maxlen > 0)
14153         {
14154           print_symbol ((int) maxlen, (const char *) p);
14155           p += strnlen ((char *) p, maxlen) + 1;
14156         }
14157       else
14158         {
14159           printf (_("<corrupt string tag>"));
14160           p = (unsigned char *) end;
14161         }
14162       printf ("\"\n");
14163     }
14164   else
14165     {
14166       unsigned int len;
14167
14168       val = read_uleb128 (p, &len, end);
14169       p += len;
14170       printf ("%ld (0x%lx)\n", val, val);
14171     }
14172
14173   assert (p <= end);
14174   return p;
14175 }
14176
14177 /* ARC ABI attributes section.  */
14178
14179 static unsigned char *
14180 display_arc_attribute (unsigned char * p,
14181                        const unsigned char * const end)
14182 {
14183   unsigned int tag;
14184   unsigned int len;
14185   unsigned int val;
14186
14187   tag = read_uleb128 (p, &len, end);
14188   p += len;
14189
14190   switch (tag)
14191     {
14192     case Tag_ARC_PCS_config:
14193       val = read_uleb128 (p, &len, end);
14194       p += len;
14195       printf ("  Tag_ARC_PCS_config: ");
14196       switch (val)
14197         {
14198         case 0:
14199           printf (_("Absent/Non standard\n"));
14200           break;
14201         case 1:
14202           printf (_("Bare metal/mwdt\n"));
14203           break;
14204         case 2:
14205           printf (_("Bare metal/newlib\n"));
14206           break;
14207         case 3:
14208           printf (_("Linux/uclibc\n"));
14209           break;
14210         case 4:
14211           printf (_("Linux/glibc\n"));
14212           break;
14213         default:
14214           printf (_("Unknown\n"));
14215           break;
14216         }
14217       break;
14218
14219     case Tag_ARC_CPU_base:
14220       val = read_uleb128 (p, &len, end);
14221       p += len;
14222       printf ("  Tag_ARC_CPU_base: ");
14223       switch (val)
14224         {
14225         default:
14226         case TAG_CPU_NONE:
14227           printf (_("Absent\n"));
14228           break;
14229         case TAG_CPU_ARC6xx:
14230           printf ("ARC6xx\n");
14231           break;
14232         case TAG_CPU_ARC7xx:
14233           printf ("ARC7xx\n");
14234           break;
14235         case TAG_CPU_ARCEM:
14236           printf ("ARCEM\n");
14237           break;
14238         case TAG_CPU_ARCHS:
14239           printf ("ARCHS\n");
14240           break;
14241         }
14242       break;
14243
14244     case Tag_ARC_CPU_variation:
14245       val = read_uleb128 (p, &len, end);
14246       p += len;
14247       printf ("  Tag_ARC_CPU_variation: ");
14248       switch (val)
14249         {
14250         default:
14251           if (val > 0 && val < 16)
14252               printf ("Core%d\n", val);
14253           else
14254               printf ("Unknown\n");
14255           break;
14256
14257         case 0:
14258           printf (_("Absent\n"));
14259           break;
14260         }
14261       break;
14262
14263     case Tag_ARC_CPU_name:
14264       printf ("  Tag_ARC_CPU_name: ");
14265       p = display_tag_value (-1, p, end);
14266       break;
14267
14268     case Tag_ARC_ABI_rf16:
14269       val = read_uleb128 (p, &len, end);
14270       p += len;
14271       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14272       break;
14273
14274     case Tag_ARC_ABI_osver:
14275       val = read_uleb128 (p, &len, end);
14276       p += len;
14277       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14278       break;
14279
14280     case Tag_ARC_ABI_pic:
14281     case Tag_ARC_ABI_sda:
14282       val = read_uleb128 (p, &len, end);
14283       p += len;
14284       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14285               : "  Tag_ARC_ABI_pic: ");
14286       switch (val)
14287         {
14288         case 0:
14289           printf (_("Absent\n"));
14290           break;
14291         case 1:
14292           printf ("MWDT\n");
14293           break;
14294         case 2:
14295           printf ("GNU\n");
14296           break;
14297         default:
14298           printf (_("Unknown\n"));
14299           break;
14300         }
14301       break;
14302
14303     case Tag_ARC_ABI_tls:
14304       val = read_uleb128 (p, &len, end);
14305       p += len;
14306       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14307       break;
14308
14309     case Tag_ARC_ABI_enumsize:
14310       val = read_uleb128 (p, &len, end);
14311       p += len;
14312       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14313               _("smallest"));
14314       break;
14315
14316     case Tag_ARC_ABI_exceptions:
14317       val = read_uleb128 (p, &len, end);
14318       p += len;
14319       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14320               : _("default"));
14321       break;
14322
14323     case Tag_ARC_ABI_double_size:
14324       val = read_uleb128 (p, &len, end);
14325       p += len;
14326       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14327       break;
14328
14329     case Tag_ARC_ISA_config:
14330       printf ("  Tag_ARC_ISA_config: ");
14331       p = display_tag_value (-1, p, end);
14332       break;
14333
14334     case Tag_ARC_ISA_apex:
14335       printf ("  Tag_ARC_ISA_apex: ");
14336       p = display_tag_value (-1, p, end);
14337       break;
14338
14339     case Tag_ARC_ISA_mpy_option:
14340       val = read_uleb128 (p, &len, end);
14341       p += len;
14342       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14343       break;
14344
14345     case Tag_ARC_ATR_version:
14346       val = read_uleb128 (p, &len, end);
14347       p += len;
14348       printf ("  Tag_ARC_ATR_version: %d\n", val);
14349       break;
14350
14351     default:
14352       return display_tag_value (tag & 1, p, end);
14353     }
14354
14355   return p;
14356 }
14357
14358 /* ARM EABI attributes section.  */
14359 typedef struct
14360 {
14361   unsigned int tag;
14362   const char * name;
14363   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14364   unsigned int type;
14365   const char ** table;
14366 } arm_attr_public_tag;
14367
14368 static const char * arm_attr_tag_CPU_arch[] =
14369   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14370    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14371    "v8-M.mainline"};
14372 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14373 static const char * arm_attr_tag_THUMB_ISA_use[] =
14374   {"No", "Thumb-1", "Thumb-2", "Yes"};
14375 static const char * arm_attr_tag_FP_arch[] =
14376   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14377    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14378 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14379 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14380   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14381    "NEON for ARMv8.1"};
14382 static const char * arm_attr_tag_PCS_config[] =
14383   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14384    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14385 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14386   {"V6", "SB", "TLS", "Unused"};
14387 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14388   {"Absolute", "PC-relative", "SB-relative", "None"};
14389 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14390   {"Absolute", "PC-relative", "None"};
14391 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14392   {"None", "direct", "GOT-indirect"};
14393 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14394   {"None", "??? 1", "2", "??? 3", "4"};
14395 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14396 static const char * arm_attr_tag_ABI_FP_denormal[] =
14397   {"Unused", "Needed", "Sign only"};
14398 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14399 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14400 static const char * arm_attr_tag_ABI_FP_number_model[] =
14401   {"Unused", "Finite", "RTABI", "IEEE 754"};
14402 static const char * arm_attr_tag_ABI_enum_size[] =
14403   {"Unused", "small", "int", "forced to int"};
14404 static const char * arm_attr_tag_ABI_HardFP_use[] =
14405   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14406 static const char * arm_attr_tag_ABI_VFP_args[] =
14407   {"AAPCS", "VFP registers", "custom", "compatible"};
14408 static const char * arm_attr_tag_ABI_WMMX_args[] =
14409   {"AAPCS", "WMMX registers", "custom"};
14410 static const char * arm_attr_tag_ABI_optimization_goals[] =
14411   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14412     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14413 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14414   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14415     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14416 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14417 static const char * arm_attr_tag_FP_HP_extension[] =
14418   {"Not Allowed", "Allowed"};
14419 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14420   {"None", "IEEE 754", "Alternative Format"};
14421 static const char * arm_attr_tag_DSP_extension[] =
14422   {"Follow architecture", "Allowed"};
14423 static const char * arm_attr_tag_MPextension_use[] =
14424   {"Not Allowed", "Allowed"};
14425 static const char * arm_attr_tag_DIV_use[] =
14426   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14427     "Allowed in v7-A with integer division extension"};
14428 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14429 static const char * arm_attr_tag_Virtualization_use[] =
14430   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14431     "TrustZone and Virtualization Extensions"};
14432 static const char * arm_attr_tag_MPextension_use_legacy[] =
14433   {"Not Allowed", "Allowed"};
14434
14435 #define LOOKUP(id, name) \
14436   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14437 static arm_attr_public_tag arm_attr_public_tags[] =
14438 {
14439   {4, "CPU_raw_name", 1, NULL},
14440   {5, "CPU_name", 1, NULL},
14441   LOOKUP(6, CPU_arch),
14442   {7, "CPU_arch_profile", 0, NULL},
14443   LOOKUP(8, ARM_ISA_use),
14444   LOOKUP(9, THUMB_ISA_use),
14445   LOOKUP(10, FP_arch),
14446   LOOKUP(11, WMMX_arch),
14447   LOOKUP(12, Advanced_SIMD_arch),
14448   LOOKUP(13, PCS_config),
14449   LOOKUP(14, ABI_PCS_R9_use),
14450   LOOKUP(15, ABI_PCS_RW_data),
14451   LOOKUP(16, ABI_PCS_RO_data),
14452   LOOKUP(17, ABI_PCS_GOT_use),
14453   LOOKUP(18, ABI_PCS_wchar_t),
14454   LOOKUP(19, ABI_FP_rounding),
14455   LOOKUP(20, ABI_FP_denormal),
14456   LOOKUP(21, ABI_FP_exceptions),
14457   LOOKUP(22, ABI_FP_user_exceptions),
14458   LOOKUP(23, ABI_FP_number_model),
14459   {24, "ABI_align_needed", 0, NULL},
14460   {25, "ABI_align_preserved", 0, NULL},
14461   LOOKUP(26, ABI_enum_size),
14462   LOOKUP(27, ABI_HardFP_use),
14463   LOOKUP(28, ABI_VFP_args),
14464   LOOKUP(29, ABI_WMMX_args),
14465   LOOKUP(30, ABI_optimization_goals),
14466   LOOKUP(31, ABI_FP_optimization_goals),
14467   {32, "compatibility", 0, NULL},
14468   LOOKUP(34, CPU_unaligned_access),
14469   LOOKUP(36, FP_HP_extension),
14470   LOOKUP(38, ABI_FP_16bit_format),
14471   LOOKUP(42, MPextension_use),
14472   LOOKUP(44, DIV_use),
14473   LOOKUP(46, DSP_extension),
14474   {64, "nodefaults", 0, NULL},
14475   {65, "also_compatible_with", 0, NULL},
14476   LOOKUP(66, T2EE_use),
14477   {67, "conformance", 1, NULL},
14478   LOOKUP(68, Virtualization_use),
14479   LOOKUP(70, MPextension_use_legacy)
14480 };
14481 #undef LOOKUP
14482
14483 static unsigned char *
14484 display_arm_attribute (unsigned char * p,
14485                        const unsigned char * const end)
14486 {
14487   unsigned int tag;
14488   unsigned int len;
14489   unsigned int val;
14490   arm_attr_public_tag * attr;
14491   unsigned i;
14492   unsigned int type;
14493
14494   tag = read_uleb128 (p, &len, end);
14495   p += len;
14496   attr = NULL;
14497   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14498     {
14499       if (arm_attr_public_tags[i].tag == tag)
14500         {
14501           attr = &arm_attr_public_tags[i];
14502           break;
14503         }
14504     }
14505
14506   if (attr)
14507     {
14508       printf ("  Tag_%s: ", attr->name);
14509       switch (attr->type)
14510         {
14511         case 0:
14512           switch (tag)
14513             {
14514             case 7: /* Tag_CPU_arch_profile.  */
14515               val = read_uleb128 (p, &len, end);
14516               p += len;
14517               switch (val)
14518                 {
14519                 case 0: printf (_("None\n")); break;
14520                 case 'A': printf (_("Application\n")); break;
14521                 case 'R': printf (_("Realtime\n")); break;
14522                 case 'M': printf (_("Microcontroller\n")); break;
14523                 case 'S': printf (_("Application or Realtime\n")); break;
14524                 default: printf ("??? (%d)\n", val); break;
14525                 }
14526               break;
14527
14528             case 24: /* Tag_align_needed.  */
14529               val = read_uleb128 (p, &len, end);
14530               p += len;
14531               switch (val)
14532                 {
14533                 case 0: printf (_("None\n")); break;
14534                 case 1: printf (_("8-byte\n")); break;
14535                 case 2: printf (_("4-byte\n")); break;
14536                 case 3: printf ("??? 3\n"); break;
14537                 default:
14538                   if (val <= 12)
14539                     printf (_("8-byte and up to %d-byte extended\n"),
14540                             1 << val);
14541                   else
14542                     printf ("??? (%d)\n", val);
14543                   break;
14544                 }
14545               break;
14546
14547             case 25: /* Tag_align_preserved.  */
14548               val = read_uleb128 (p, &len, end);
14549               p += len;
14550               switch (val)
14551                 {
14552                 case 0: printf (_("None\n")); break;
14553                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14554                 case 2: printf (_("8-byte\n")); break;
14555                 case 3: printf ("??? 3\n"); break;
14556                 default:
14557                   if (val <= 12)
14558                     printf (_("8-byte and up to %d-byte extended\n"),
14559                             1 << val);
14560                   else
14561                     printf ("??? (%d)\n", val);
14562                   break;
14563                 }
14564               break;
14565
14566             case 32: /* Tag_compatibility.  */
14567               {
14568                 val = read_uleb128 (p, &len, end);
14569                 p += len;
14570                 printf (_("flag = %d, vendor = "), val);
14571                 if (p < end - 1)
14572                   {
14573                     size_t maxlen = (end - p) - 1;
14574
14575                     print_symbol ((int) maxlen, (const char *) p);
14576                     p += strnlen ((char *) p, maxlen) + 1;
14577                   }
14578                 else
14579                   {
14580                     printf (_("<corrupt>"));
14581                     p = (unsigned char *) end;
14582                   }
14583                 putchar ('\n');
14584               }
14585               break;
14586
14587             case 64: /* Tag_nodefaults.  */
14588               /* PR 17531: file: 001-505008-0.01.  */
14589               if (p < end)
14590                 p++;
14591               printf (_("True\n"));
14592               break;
14593
14594             case 65: /* Tag_also_compatible_with.  */
14595               val = read_uleb128 (p, &len, end);
14596               p += len;
14597               if (val == 6 /* Tag_CPU_arch.  */)
14598                 {
14599                   val = read_uleb128 (p, &len, end);
14600                   p += len;
14601                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14602                     printf ("??? (%d)\n", val);
14603                   else
14604                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14605                 }
14606               else
14607                 printf ("???\n");
14608               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14609                 ;
14610               break;
14611
14612             default:
14613               printf (_("<unknown: %d>\n"), tag);
14614               break;
14615             }
14616           return p;
14617
14618         case 1:
14619           return display_tag_value (-1, p, end);
14620         case 2:
14621           return display_tag_value (0, p, end);
14622
14623         default:
14624           assert (attr->type & 0x80);
14625           val = read_uleb128 (p, &len, end);
14626           p += len;
14627           type = attr->type & 0x7f;
14628           if (val >= type)
14629             printf ("??? (%d)\n", val);
14630           else
14631             printf ("%s\n", attr->table[val]);
14632           return p;
14633         }
14634     }
14635
14636   return display_tag_value (tag, p, end);
14637 }
14638
14639 static unsigned char *
14640 display_gnu_attribute (unsigned char * p,
14641                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14642                        const unsigned char * const end)
14643 {
14644   int tag;
14645   unsigned int len;
14646   unsigned int val;
14647
14648   tag = read_uleb128 (p, &len, end);
14649   p += len;
14650
14651   /* Tag_compatibility is the only generic GNU attribute defined at
14652      present.  */
14653   if (tag == 32)
14654     {
14655       val = read_uleb128 (p, &len, end);
14656       p += len;
14657
14658       printf (_("flag = %d, vendor = "), val);
14659       if (p == end)
14660         {
14661           printf (_("<corrupt>\n"));
14662           warn (_("corrupt vendor attribute\n"));
14663         }
14664       else
14665         {
14666           if (p < end - 1)
14667             {
14668               size_t maxlen = (end - p) - 1;
14669
14670               print_symbol ((int) maxlen, (const char *) p);
14671               p += strnlen ((char *) p, maxlen) + 1;
14672             }
14673           else
14674             {
14675               printf (_("<corrupt>"));
14676               p = (unsigned char *) end;
14677             }
14678           putchar ('\n');
14679         }
14680       return p;
14681     }
14682
14683   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14684     return display_proc_gnu_attribute (p, tag, end);
14685
14686   return display_tag_value (tag, p, end);
14687 }
14688
14689 static unsigned char *
14690 display_power_gnu_attribute (unsigned char * p,
14691                              unsigned int tag,
14692                              const unsigned char * const end)
14693 {
14694   unsigned int len;
14695   unsigned int val;
14696
14697   if (tag == Tag_GNU_Power_ABI_FP)
14698     {
14699       val = read_uleb128 (p, &len, end);
14700       p += len;
14701       printf ("  Tag_GNU_Power_ABI_FP: ");
14702       if (len == 0)
14703         {
14704           printf (_("<corrupt>\n"));
14705           return p;
14706         }
14707
14708       if (val > 15)
14709         printf ("(%#x), ", val);
14710
14711       switch (val & 3)
14712         {
14713         case 0:
14714           printf (_("unspecified hard/soft float, "));
14715           break;
14716         case 1:
14717           printf (_("hard float, "));
14718           break;
14719         case 2:
14720           printf (_("soft float, "));
14721           break;
14722         case 3:
14723           printf (_("single-precision hard float, "));
14724           break;
14725         }
14726
14727       switch (val & 0xC)
14728         {
14729         case 0:
14730           printf (_("unspecified long double\n"));
14731           break;
14732         case 4:
14733           printf (_("128-bit IBM long double\n"));
14734           break;
14735         case 8:
14736           printf (_("64-bit long double\n"));
14737           break;
14738         case 12:
14739           printf (_("128-bit IEEE long double\n"));
14740           break;
14741         }
14742       return p;
14743     }
14744
14745   if (tag == Tag_GNU_Power_ABI_Vector)
14746     {
14747       val = read_uleb128 (p, &len, end);
14748       p += len;
14749       printf ("  Tag_GNU_Power_ABI_Vector: ");
14750       if (len == 0)
14751         {
14752           printf (_("<corrupt>\n"));
14753           return p;
14754         }
14755
14756       if (val > 3)
14757         printf ("(%#x), ", val);
14758
14759       switch (val & 3)
14760         {
14761         case 0:
14762           printf (_("unspecified\n"));
14763           break;
14764         case 1:
14765           printf (_("generic\n"));
14766           break;
14767         case 2:
14768           printf ("AltiVec\n");
14769           break;
14770         case 3:
14771           printf ("SPE\n");
14772           break;
14773         }
14774       return p;
14775     }
14776
14777   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14778     {
14779       val = read_uleb128 (p, &len, end);
14780       p += len;
14781       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14782       if (len == 0)
14783         {
14784           printf (_("<corrupt>\n"));
14785           return p;
14786         }
14787
14788       if (val > 2)
14789         printf ("(%#x), ", val);
14790
14791       switch (val & 3)
14792         {
14793         case 0:
14794           printf (_("unspecified\n"));
14795           break;
14796         case 1:
14797           printf ("r3/r4\n");
14798           break;
14799         case 2:
14800           printf (_("memory\n"));
14801           break;
14802         case 3:
14803           printf ("???\n");
14804           break;
14805         }
14806       return p;
14807     }
14808
14809   return display_tag_value (tag & 1, p, end);
14810 }
14811
14812 static unsigned char *
14813 display_s390_gnu_attribute (unsigned char * p,
14814                             unsigned int tag,
14815                             const unsigned char * const end)
14816 {
14817   unsigned int len;
14818   int val;
14819
14820   if (tag == Tag_GNU_S390_ABI_Vector)
14821     {
14822       val = read_uleb128 (p, &len, end);
14823       p += len;
14824       printf ("  Tag_GNU_S390_ABI_Vector: ");
14825
14826       switch (val)
14827         {
14828         case 0:
14829           printf (_("any\n"));
14830           break;
14831         case 1:
14832           printf (_("software\n"));
14833           break;
14834         case 2:
14835           printf (_("hardware\n"));
14836           break;
14837         default:
14838           printf ("??? (%d)\n", val);
14839           break;
14840         }
14841       return p;
14842    }
14843
14844   return display_tag_value (tag & 1, p, end);
14845 }
14846
14847 static void
14848 display_sparc_hwcaps (unsigned int mask)
14849 {
14850   if (mask)
14851     {
14852       bfd_boolean first = TRUE;
14853
14854       if (mask & ELF_SPARC_HWCAP_MUL32)
14855         fputs ("mul32", stdout), first = FALSE;
14856       if (mask & ELF_SPARC_HWCAP_DIV32)
14857         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14858       if (mask & ELF_SPARC_HWCAP_FSMULD)
14859         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14860       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14861         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14862       if (mask & ELF_SPARC_HWCAP_POPC)
14863         printf ("%spopc", first ? "" : "|"), first = FALSE;
14864       if (mask & ELF_SPARC_HWCAP_VIS)
14865         printf ("%svis", first ? "" : "|"), first = FALSE;
14866       if (mask & ELF_SPARC_HWCAP_VIS2)
14867         printf ("%svis2", first ? "" : "|"), first = FALSE;
14868       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14869         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14870       if (mask & ELF_SPARC_HWCAP_FMAF)
14871         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14872       if (mask & ELF_SPARC_HWCAP_VIS3)
14873         printf ("%svis3", first ? "" : "|"), first = FALSE;
14874       if (mask & ELF_SPARC_HWCAP_HPC)
14875         printf ("%shpc", first ? "" : "|"), first = FALSE;
14876       if (mask & ELF_SPARC_HWCAP_RANDOM)
14877         printf ("%srandom", first ? "" : "|"), first = FALSE;
14878       if (mask & ELF_SPARC_HWCAP_TRANS)
14879         printf ("%strans", first ? "" : "|"), first = FALSE;
14880       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14881         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14882       if (mask & ELF_SPARC_HWCAP_IMA)
14883         printf ("%sima", first ? "" : "|"), first = FALSE;
14884       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14885         printf ("%scspare", first ? "" : "|"), first = FALSE;
14886     }
14887   else
14888     fputc ('0', stdout);
14889   fputc ('\n', stdout);
14890 }
14891
14892 static void
14893 display_sparc_hwcaps2 (unsigned int mask)
14894 {
14895   if (mask)
14896     {
14897       bfd_boolean first = TRUE;
14898
14899       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14900         fputs ("fjathplus", stdout), first = FALSE;
14901       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14902         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14903       if (mask & ELF_SPARC_HWCAP2_ADP)
14904         printf ("%sadp", first ? "" : "|"), first = FALSE;
14905       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14906         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14907       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14908         printf ("%smwait", first ? "" : "|"), first = FALSE;
14909       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14910         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14911       if (mask & ELF_SPARC_HWCAP2_XMONT)
14912         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14913       if (mask & ELF_SPARC_HWCAP2_NSEC)
14914         printf ("%snsec", first ? "" : "|"), first = FALSE;
14915       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14916         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14917       if (mask & ELF_SPARC_HWCAP2_FJDES)
14918         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14919       if (mask & ELF_SPARC_HWCAP2_FJAES)
14920         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14921     }
14922   else
14923     fputc ('0', stdout);
14924   fputc ('\n', stdout);
14925 }
14926
14927 static unsigned char *
14928 display_sparc_gnu_attribute (unsigned char * p,
14929                              unsigned int tag,
14930                              const unsigned char * const end)
14931 {
14932   unsigned int len;
14933   int val;
14934
14935   if (tag == Tag_GNU_Sparc_HWCAPS)
14936     {
14937       val = read_uleb128 (p, &len, end);
14938       p += len;
14939       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14940       display_sparc_hwcaps (val);
14941       return p;
14942     }
14943   if (tag == Tag_GNU_Sparc_HWCAPS2)
14944     {
14945       val = read_uleb128 (p, &len, end);
14946       p += len;
14947       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14948       display_sparc_hwcaps2 (val);
14949       return p;
14950     }
14951
14952   return display_tag_value (tag, p, end);
14953 }
14954
14955 static void
14956 print_mips_fp_abi_value (unsigned int val)
14957 {
14958   switch (val)
14959     {
14960     case Val_GNU_MIPS_ABI_FP_ANY:
14961       printf (_("Hard or soft float\n"));
14962       break;
14963     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14964       printf (_("Hard float (double precision)\n"));
14965       break;
14966     case Val_GNU_MIPS_ABI_FP_SINGLE:
14967       printf (_("Hard float (single precision)\n"));
14968       break;
14969     case Val_GNU_MIPS_ABI_FP_SOFT:
14970       printf (_("Soft float\n"));
14971       break;
14972     case Val_GNU_MIPS_ABI_FP_OLD_64:
14973       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14974       break;
14975     case Val_GNU_MIPS_ABI_FP_XX:
14976       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14977       break;
14978     case Val_GNU_MIPS_ABI_FP_64:
14979       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14980       break;
14981     case Val_GNU_MIPS_ABI_FP_64A:
14982       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14983       break;
14984     case Val_GNU_MIPS_ABI_FP_NAN2008:
14985       printf (_("NaN 2008 compatibility\n"));
14986       break;
14987     default:
14988       printf ("??? (%d)\n", val);
14989       break;
14990     }
14991 }
14992
14993 static unsigned char *
14994 display_mips_gnu_attribute (unsigned char * p,
14995                             unsigned int tag,
14996                             const unsigned char * const end)
14997 {
14998   if (tag == Tag_GNU_MIPS_ABI_FP)
14999     {
15000       unsigned int len;
15001       unsigned int val;
15002
15003       val = read_uleb128 (p, &len, end);
15004       p += len;
15005       printf ("  Tag_GNU_MIPS_ABI_FP: ");
15006
15007       print_mips_fp_abi_value (val);
15008
15009       return p;
15010    }
15011
15012   if (tag == Tag_GNU_MIPS_ABI_MSA)
15013     {
15014       unsigned int len;
15015       unsigned int val;
15016
15017       val = read_uleb128 (p, &len, end);
15018       p += len;
15019       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
15020
15021       switch (val)
15022         {
15023         case Val_GNU_MIPS_ABI_MSA_ANY:
15024           printf (_("Any MSA or not\n"));
15025           break;
15026         case Val_GNU_MIPS_ABI_MSA_128:
15027           printf (_("128-bit MSA\n"));
15028           break;
15029         default:
15030           printf ("??? (%d)\n", val);
15031           break;
15032         }
15033       return p;
15034     }
15035
15036   return display_tag_value (tag & 1, p, end);
15037 }
15038
15039 static unsigned char *
15040 display_tic6x_attribute (unsigned char * p,
15041                          const unsigned char * const end)
15042 {
15043   unsigned int tag;
15044   unsigned int len;
15045   int val;
15046
15047   tag = read_uleb128 (p, &len, end);
15048   p += len;
15049
15050   switch (tag)
15051     {
15052     case Tag_ISA:
15053       val = read_uleb128 (p, &len, end);
15054       p += len;
15055       printf ("  Tag_ISA: ");
15056
15057       switch (val)
15058         {
15059         case C6XABI_Tag_ISA_none:
15060           printf (_("None\n"));
15061           break;
15062         case C6XABI_Tag_ISA_C62X:
15063           printf ("C62x\n");
15064           break;
15065         case C6XABI_Tag_ISA_C67X:
15066           printf ("C67x\n");
15067           break;
15068         case C6XABI_Tag_ISA_C67XP:
15069           printf ("C67x+\n");
15070           break;
15071         case C6XABI_Tag_ISA_C64X:
15072           printf ("C64x\n");
15073           break;
15074         case C6XABI_Tag_ISA_C64XP:
15075           printf ("C64x+\n");
15076           break;
15077         case C6XABI_Tag_ISA_C674X:
15078           printf ("C674x\n");
15079           break;
15080         default:
15081           printf ("??? (%d)\n", val);
15082           break;
15083         }
15084       return p;
15085
15086     case Tag_ABI_wchar_t:
15087       val = read_uleb128 (p, &len, end);
15088       p += len;
15089       printf ("  Tag_ABI_wchar_t: ");
15090       switch (val)
15091         {
15092         case 0:
15093           printf (_("Not used\n"));
15094           break;
15095         case 1:
15096           printf (_("2 bytes\n"));
15097           break;
15098         case 2:
15099           printf (_("4 bytes\n"));
15100           break;
15101         default:
15102           printf ("??? (%d)\n", val);
15103           break;
15104         }
15105       return p;
15106
15107     case Tag_ABI_stack_align_needed:
15108       val = read_uleb128 (p, &len, end);
15109       p += len;
15110       printf ("  Tag_ABI_stack_align_needed: ");
15111       switch (val)
15112         {
15113         case 0:
15114           printf (_("8-byte\n"));
15115           break;
15116         case 1:
15117           printf (_("16-byte\n"));
15118           break;
15119         default:
15120           printf ("??? (%d)\n", val);
15121           break;
15122         }
15123       return p;
15124
15125     case Tag_ABI_stack_align_preserved:
15126       val = read_uleb128 (p, &len, end);
15127       p += len;
15128       printf ("  Tag_ABI_stack_align_preserved: ");
15129       switch (val)
15130         {
15131         case 0:
15132           printf (_("8-byte\n"));
15133           break;
15134         case 1:
15135           printf (_("16-byte\n"));
15136           break;
15137         default:
15138           printf ("??? (%d)\n", val);
15139           break;
15140         }
15141       return p;
15142
15143     case Tag_ABI_DSBT:
15144       val = read_uleb128 (p, &len, end);
15145       p += len;
15146       printf ("  Tag_ABI_DSBT: ");
15147       switch (val)
15148         {
15149         case 0:
15150           printf (_("DSBT addressing not used\n"));
15151           break;
15152         case 1:
15153           printf (_("DSBT addressing used\n"));
15154           break;
15155         default:
15156           printf ("??? (%d)\n", val);
15157           break;
15158         }
15159       return p;
15160
15161     case Tag_ABI_PID:
15162       val = read_uleb128 (p, &len, end);
15163       p += len;
15164       printf ("  Tag_ABI_PID: ");
15165       switch (val)
15166         {
15167         case 0:
15168           printf (_("Data addressing position-dependent\n"));
15169           break;
15170         case 1:
15171           printf (_("Data addressing position-independent, GOT near DP\n"));
15172           break;
15173         case 2:
15174           printf (_("Data addressing position-independent, GOT far from DP\n"));
15175           break;
15176         default:
15177           printf ("??? (%d)\n", val);
15178           break;
15179         }
15180       return p;
15181
15182     case Tag_ABI_PIC:
15183       val = read_uleb128 (p, &len, end);
15184       p += len;
15185       printf ("  Tag_ABI_PIC: ");
15186       switch (val)
15187         {
15188         case 0:
15189           printf (_("Code addressing position-dependent\n"));
15190           break;
15191         case 1:
15192           printf (_("Code addressing position-independent\n"));
15193           break;
15194         default:
15195           printf ("??? (%d)\n", val);
15196           break;
15197         }
15198       return p;
15199
15200     case Tag_ABI_array_object_alignment:
15201       val = read_uleb128 (p, &len, end);
15202       p += len;
15203       printf ("  Tag_ABI_array_object_alignment: ");
15204       switch (val)
15205         {
15206         case 0:
15207           printf (_("8-byte\n"));
15208           break;
15209         case 1:
15210           printf (_("4-byte\n"));
15211           break;
15212         case 2:
15213           printf (_("16-byte\n"));
15214           break;
15215         default:
15216           printf ("??? (%d)\n", val);
15217           break;
15218         }
15219       return p;
15220
15221     case Tag_ABI_array_object_align_expected:
15222       val = read_uleb128 (p, &len, end);
15223       p += len;
15224       printf ("  Tag_ABI_array_object_align_expected: ");
15225       switch (val)
15226         {
15227         case 0:
15228           printf (_("8-byte\n"));
15229           break;
15230         case 1:
15231           printf (_("4-byte\n"));
15232           break;
15233         case 2:
15234           printf (_("16-byte\n"));
15235           break;
15236         default:
15237           printf ("??? (%d)\n", val);
15238           break;
15239         }
15240       return p;
15241
15242     case Tag_ABI_compatibility:
15243       {
15244         val = read_uleb128 (p, &len, end);
15245         p += len;
15246         printf ("  Tag_ABI_compatibility: ");
15247         printf (_("flag = %d, vendor = "), val);
15248         if (p < end - 1)
15249           {
15250             size_t maxlen = (end - p) - 1;
15251
15252             print_symbol ((int) maxlen, (const char *) p);
15253             p += strnlen ((char *) p, maxlen) + 1;
15254           }
15255         else
15256           {
15257             printf (_("<corrupt>"));
15258             p = (unsigned char *) end;
15259           }
15260         putchar ('\n');
15261         return p;
15262       }
15263
15264     case Tag_ABI_conformance:
15265       {
15266         printf ("  Tag_ABI_conformance: \"");
15267         if (p < end - 1)
15268           {
15269             size_t maxlen = (end - p) - 1;
15270
15271             print_symbol ((int) maxlen, (const char *) p);
15272             p += strnlen ((char *) p, maxlen) + 1;
15273           }
15274         else
15275           {
15276             printf (_("<corrupt>"));
15277             p = (unsigned char *) end;
15278           }
15279         printf ("\"\n");
15280         return p;
15281       }
15282     }
15283
15284   return display_tag_value (tag, p, end);
15285 }
15286
15287 static void
15288 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15289 {
15290   unsigned long addr = 0;
15291   size_t bytes = end - p;
15292
15293   assert (end >= p);
15294   while (bytes)
15295     {
15296       int j;
15297       int k;
15298       int lbytes = (bytes > 16 ? 16 : bytes);
15299
15300       printf ("  0x%8.8lx ", addr);
15301
15302       for (j = 0; j < 16; j++)
15303         {
15304           if (j < lbytes)
15305             printf ("%2.2x", p[j]);
15306           else
15307             printf ("  ");
15308
15309           if ((j & 3) == 3)
15310             printf (" ");
15311         }
15312
15313       for (j = 0; j < lbytes; j++)
15314         {
15315           k = p[j];
15316           if (k >= ' ' && k < 0x7f)
15317             printf ("%c", k);
15318           else
15319             printf (".");
15320         }
15321
15322       putchar ('\n');
15323
15324       p  += lbytes;
15325       bytes -= lbytes;
15326       addr += lbytes;
15327     }
15328
15329   putchar ('\n');
15330 }
15331
15332 static unsigned char *
15333 display_msp430x_attribute (unsigned char * p,
15334                            const unsigned char * const end)
15335 {
15336   unsigned int len;
15337   unsigned int val;
15338   unsigned int tag;
15339
15340   tag = read_uleb128 (p, & len, end);
15341   p += len;
15342
15343   switch (tag)
15344     {
15345     case OFBA_MSPABI_Tag_ISA:
15346       val = read_uleb128 (p, &len, end);
15347       p += len;
15348       printf ("  Tag_ISA: ");
15349       switch (val)
15350         {
15351         case 0: printf (_("None\n")); break;
15352         case 1: printf (_("MSP430\n")); break;
15353         case 2: printf (_("MSP430X\n")); break;
15354         default: printf ("??? (%d)\n", val); break;
15355         }
15356       break;
15357
15358     case OFBA_MSPABI_Tag_Code_Model:
15359       val = read_uleb128 (p, &len, end);
15360       p += len;
15361       printf ("  Tag_Code_Model: ");
15362       switch (val)
15363         {
15364         case 0: printf (_("None\n")); break;
15365         case 1: printf (_("Small\n")); break;
15366         case 2: printf (_("Large\n")); break;
15367         default: printf ("??? (%d)\n", val); break;
15368         }
15369       break;
15370
15371     case OFBA_MSPABI_Tag_Data_Model:
15372       val = read_uleb128 (p, &len, end);
15373       p += len;
15374       printf ("  Tag_Data_Model: ");
15375       switch (val)
15376         {
15377         case 0: printf (_("None\n")); break;
15378         case 1: printf (_("Small\n")); break;
15379         case 2: printf (_("Large\n")); break;
15380         case 3: printf (_("Restricted Large\n")); break;
15381         default: printf ("??? (%d)\n", val); break;
15382         }
15383       break;
15384
15385     default:
15386       printf (_("  <unknown tag %d>: "), tag);
15387
15388       if (tag & 1)
15389         {
15390           putchar ('"');
15391           if (p < end - 1)
15392             {
15393               size_t maxlen = (end - p) - 1;
15394
15395               print_symbol ((int) maxlen, (const char *) p);
15396               p += strnlen ((char *) p, maxlen) + 1;
15397             }
15398           else
15399             {
15400               printf (_("<corrupt>"));
15401               p = (unsigned char *) end;
15402             }
15403           printf ("\"\n");
15404         }
15405       else
15406         {
15407           val = read_uleb128 (p, &len, end);
15408           p += len;
15409           printf ("%d (0x%x)\n", val, val);
15410         }
15411       break;
15412    }
15413
15414   assert (p <= end);
15415   return p;
15416 }
15417
15418 struct riscv_attr_tag_t {
15419   const char *name;
15420   int tag;
15421 };
15422
15423 static struct riscv_attr_tag_t riscv_attr_tag[] =
15424 {
15425 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15426   T(arch),
15427   T(priv_spec),
15428   T(priv_spec_minor),
15429   T(priv_spec_revision),
15430   T(unaligned_access),
15431   T(stack_align),
15432 #undef T
15433 };
15434
15435 static unsigned char *
15436 display_riscv_attribute (unsigned char *p,
15437                          const unsigned char * const end)
15438 {
15439   unsigned int len;
15440   int val;
15441   int tag;
15442   struct riscv_attr_tag_t *attr = NULL;
15443   unsigned i;
15444
15445   tag = read_uleb128 (p, &len, end);
15446   p += len;
15447
15448   /* Find the name of attribute. */
15449   for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
15450     {
15451       if (riscv_attr_tag[i].tag == tag)
15452         {
15453           attr = &riscv_attr_tag[i];
15454           break;
15455         }
15456     }
15457
15458   if (attr)
15459     printf ("  %s: ", attr->name);
15460   else
15461     return display_tag_value (tag, p, end);
15462
15463   switch (tag)
15464     {
15465     case Tag_RISCV_priv_spec:
15466     case Tag_RISCV_priv_spec_minor:
15467     case Tag_RISCV_priv_spec_revision:
15468       val = read_uleb128 (p, &len, end);
15469       p += len;
15470       printf (_("%d\n"), val);
15471       break;
15472     case Tag_RISCV_unaligned_access:
15473       val = read_uleb128 (p, &len, end);
15474       p += len;
15475       switch (val)
15476         {
15477         case 0:
15478           printf (_("No unaligned access\n"));
15479           break;
15480         case 1:
15481           printf (_("Unaligned access\n"));
15482           break;
15483         }
15484       break;
15485     case Tag_RISCV_stack_align:
15486       val = read_uleb128 (p, &len, end);
15487       p += len;
15488       printf (_("%d-bytes\n"), val);
15489       break;
15490     case Tag_RISCV_arch:
15491       p = display_tag_value (-1, p, end);
15492       break;
15493     default:
15494       return display_tag_value (tag, p, end);
15495     }
15496
15497   return p;
15498 }
15499
15500 static bfd_boolean
15501 process_attributes (Filedata * filedata,
15502                     const char * public_name,
15503                     unsigned int proc_type,
15504                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15505                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15506 {
15507   Elf_Internal_Shdr * sect;
15508   unsigned i;
15509   bfd_boolean res = TRUE;
15510
15511   /* Find the section header so that we get the size.  */
15512   for (i = 0, sect = filedata->section_headers;
15513        i < filedata->file_header.e_shnum;
15514        i++, sect++)
15515     {
15516       unsigned char * contents;
15517       unsigned char * p;
15518
15519       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15520         continue;
15521
15522       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15523                                              sect->sh_size, _("attributes"));
15524       if (contents == NULL)
15525         {
15526           res = FALSE;
15527           continue;
15528         }
15529
15530       p = contents;
15531       /* The first character is the version of the attributes.
15532          Currently only version 1, (aka 'A') is recognised here.  */
15533       if (*p != 'A')
15534         {
15535           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15536           res = FALSE;
15537         }
15538       else
15539         {
15540           bfd_vma section_len;
15541
15542           section_len = sect->sh_size - 1;
15543           p++;
15544
15545           while (section_len > 0)
15546             {
15547               bfd_vma attr_len;
15548               unsigned int namelen;
15549               bfd_boolean public_section;
15550               bfd_boolean gnu_section;
15551
15552               if (section_len <= 4)
15553                 {
15554                   error (_("Tag section ends prematurely\n"));
15555                   res = FALSE;
15556                   break;
15557                 }
15558               attr_len = byte_get (p, 4);
15559               p += 4;
15560
15561               if (attr_len > section_len)
15562                 {
15563                   error (_("Bad attribute length (%u > %u)\n"),
15564                           (unsigned) attr_len, (unsigned) section_len);
15565                   attr_len = section_len;
15566                   res = FALSE;
15567                 }
15568               /* PR 17531: file: 001-101425-0.004  */
15569               else if (attr_len < 5)
15570                 {
15571                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15572                   res = FALSE;
15573                   break;
15574                 }
15575
15576               section_len -= attr_len;
15577               attr_len -= 4;
15578
15579               namelen = strnlen ((char *) p, attr_len) + 1;
15580               if (namelen == 0 || namelen >= attr_len)
15581                 {
15582                   error (_("Corrupt attribute section name\n"));
15583                   res = FALSE;
15584                   break;
15585                 }
15586
15587               printf (_("Attribute Section: "));
15588               print_symbol (INT_MAX, (const char *) p);
15589               putchar ('\n');
15590
15591               if (public_name && streq ((char *) p, public_name))
15592                 public_section = TRUE;
15593               else
15594                 public_section = FALSE;
15595
15596               if (streq ((char *) p, "gnu"))
15597                 gnu_section = TRUE;
15598               else
15599                 gnu_section = FALSE;
15600
15601               p += namelen;
15602               attr_len -= namelen;
15603
15604               while (attr_len > 0 && p < contents + sect->sh_size)
15605                 {
15606                   int tag;
15607                   int val;
15608                   bfd_vma size;
15609                   unsigned char * end;
15610
15611                   /* PR binutils/17531: Safe handling of corrupt files.  */
15612                   if (attr_len < 6)
15613                     {
15614                       error (_("Unused bytes at end of section\n"));
15615                       res = FALSE;
15616                       section_len = 0;
15617                       break;
15618                     }
15619
15620                   tag = *(p++);
15621                   size = byte_get (p, 4);
15622                   if (size > attr_len)
15623                     {
15624                       error (_("Bad subsection length (%u > %u)\n"),
15625                               (unsigned) size, (unsigned) attr_len);
15626                       res = FALSE;
15627                       size = attr_len;
15628                     }
15629                   /* PR binutils/17531: Safe handling of corrupt files.  */
15630                   if (size < 6)
15631                     {
15632                       error (_("Bad subsection length (%u < 6)\n"),
15633                               (unsigned) size);
15634                       res = FALSE;
15635                       section_len = 0;
15636                       break;
15637                     }
15638
15639                   attr_len -= size;
15640                   end = p + size - 1;
15641                   assert (end <= contents + sect->sh_size);
15642                   p += 4;
15643
15644                   switch (tag)
15645                     {
15646                     case 1:
15647                       printf (_("File Attributes\n"));
15648                       break;
15649                     case 2:
15650                       printf (_("Section Attributes:"));
15651                       goto do_numlist;
15652                     case 3:
15653                       printf (_("Symbol Attributes:"));
15654                       /* Fall through.  */
15655                     do_numlist:
15656                       for (;;)
15657                         {
15658                           unsigned int j;
15659
15660                           val = read_uleb128 (p, &j, end);
15661                           p += j;
15662                           if (val == 0)
15663                             break;
15664                           printf (" %d", val);
15665                         }
15666                       printf ("\n");
15667                       break;
15668                     default:
15669                       printf (_("Unknown tag: %d\n"), tag);
15670                       public_section = FALSE;
15671                       break;
15672                     }
15673
15674                   if (public_section && display_pub_attribute != NULL)
15675                     {
15676                       while (p < end)
15677                         p = display_pub_attribute (p, end);
15678                       assert (p == end);
15679                     }
15680                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15681                     {
15682                       while (p < end)
15683                         p = display_gnu_attribute (p,
15684                                                    display_proc_gnu_attribute,
15685                                                    end);
15686                       assert (p == end);
15687                     }
15688                   else if (p < end)
15689                     {
15690                       printf (_("  Unknown attribute:\n"));
15691                       display_raw_attribute (p, end);
15692                       p = end;
15693                     }
15694                   else
15695                     attr_len = 0;
15696                 }
15697             }
15698         }
15699
15700       free (contents);
15701     }
15702
15703   return res;
15704 }
15705
15706 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15707    Print the Address, Access and Initial fields of an entry at VMA ADDR
15708    and return the VMA of the next entry, or -1 if there was a problem.
15709    Does not read from DATA_END or beyond.  */
15710
15711 static bfd_vma
15712 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15713                       unsigned char * data_end)
15714 {
15715   printf ("  ");
15716   print_vma (addr, LONG_HEX);
15717   printf (" ");
15718   if (addr < pltgot + 0xfff0)
15719     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15720   else
15721     printf ("%10s", "");
15722   printf (" ");
15723   if (data == NULL)
15724     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15725   else
15726     {
15727       bfd_vma entry;
15728       unsigned char * from = data + addr - pltgot;
15729
15730       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15731         {
15732           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15733           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15734           return (bfd_vma) -1;
15735         }
15736       else
15737         {
15738           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15739           print_vma (entry, LONG_HEX);
15740         }
15741     }
15742   return addr + (is_32bit_elf ? 4 : 8);
15743 }
15744
15745 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15746    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15747    ADDR and return the VMA of the next entry.  */
15748
15749 static bfd_vma
15750 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15751 {
15752   printf ("  ");
15753   print_vma (addr, LONG_HEX);
15754   printf (" ");
15755   if (data == NULL)
15756     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15757   else
15758     {
15759       bfd_vma entry;
15760
15761       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15762       print_vma (entry, LONG_HEX);
15763     }
15764   return addr + (is_32bit_elf ? 4 : 8);
15765 }
15766
15767 static void
15768 print_mips_ases (unsigned int mask)
15769 {
15770   if (mask & AFL_ASE_DSP)
15771     fputs ("\n\tDSP ASE", stdout);
15772   if (mask & AFL_ASE_DSPR2)
15773     fputs ("\n\tDSP R2 ASE", stdout);
15774   if (mask & AFL_ASE_DSPR3)
15775     fputs ("\n\tDSP R3 ASE", stdout);
15776   if (mask & AFL_ASE_EVA)
15777     fputs ("\n\tEnhanced VA Scheme", stdout);
15778   if (mask & AFL_ASE_MCU)
15779     fputs ("\n\tMCU (MicroController) ASE", stdout);
15780   if (mask & AFL_ASE_MDMX)
15781     fputs ("\n\tMDMX ASE", stdout);
15782   if (mask & AFL_ASE_MIPS3D)
15783     fputs ("\n\tMIPS-3D ASE", stdout);
15784   if (mask & AFL_ASE_MT)
15785     fputs ("\n\tMT ASE", stdout);
15786   if (mask & AFL_ASE_SMARTMIPS)
15787     fputs ("\n\tSmartMIPS ASE", stdout);
15788   if (mask & AFL_ASE_VIRT)
15789     fputs ("\n\tVZ ASE", stdout);
15790   if (mask & AFL_ASE_MSA)
15791     fputs ("\n\tMSA ASE", stdout);
15792   if (mask & AFL_ASE_MIPS16)
15793     fputs ("\n\tMIPS16 ASE", stdout);
15794   if (mask & AFL_ASE_MICROMIPS)
15795     fputs ("\n\tMICROMIPS ASE", stdout);
15796   if (mask & AFL_ASE_XPA)
15797     fputs ("\n\tXPA ASE", stdout);
15798   if (mask & AFL_ASE_MIPS16E2)
15799     fputs ("\n\tMIPS16e2 ASE", stdout);
15800   if (mask & AFL_ASE_CRC)
15801     fputs ("\n\tCRC ASE", stdout);
15802   if (mask & AFL_ASE_GINV)
15803     fputs ("\n\tGINV ASE", stdout);
15804   if (mask & AFL_ASE_LOONGSON_MMI)
15805     fputs ("\n\tLoongson MMI ASE", stdout);
15806   if (mask & AFL_ASE_LOONGSON_CAM)
15807     fputs ("\n\tLoongson CAM ASE", stdout);
15808   if (mask & AFL_ASE_LOONGSON_EXT)
15809     fputs ("\n\tLoongson EXT ASE", stdout);
15810   if (mask & AFL_ASE_LOONGSON_EXT2)
15811     fputs ("\n\tLoongson EXT2 ASE", stdout);
15812   if (mask == 0)
15813     fprintf (stdout, "\n\t%s", _("None"));
15814   else if ((mask & ~AFL_ASE_MASK) != 0)
15815     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15816 }
15817
15818 static void
15819 print_mips_isa_ext (unsigned int isa_ext)
15820 {
15821   switch (isa_ext)
15822     {
15823     case 0:
15824       fputs (_("None"), stdout);
15825       break;
15826     case AFL_EXT_XLR:
15827       fputs ("RMI XLR", stdout);
15828       break;
15829     case AFL_EXT_OCTEON3:
15830       fputs ("Cavium Networks Octeon3", stdout);
15831       break;
15832     case AFL_EXT_OCTEON2:
15833       fputs ("Cavium Networks Octeon2", stdout);
15834       break;
15835     case AFL_EXT_OCTEONP:
15836       fputs ("Cavium Networks OcteonP", stdout);
15837       break;
15838     case AFL_EXT_OCTEON:
15839       fputs ("Cavium Networks Octeon", stdout);
15840       break;
15841     case AFL_EXT_5900:
15842       fputs ("Toshiba R5900", stdout);
15843       break;
15844     case AFL_EXT_4650:
15845       fputs ("MIPS R4650", stdout);
15846       break;
15847     case AFL_EXT_4010:
15848       fputs ("LSI R4010", stdout);
15849       break;
15850     case AFL_EXT_4100:
15851       fputs ("NEC VR4100", stdout);
15852       break;
15853     case AFL_EXT_3900:
15854       fputs ("Toshiba R3900", stdout);
15855       break;
15856     case AFL_EXT_10000:
15857       fputs ("MIPS R10000", stdout);
15858       break;
15859     case AFL_EXT_SB1:
15860       fputs ("Broadcom SB-1", stdout);
15861       break;
15862     case AFL_EXT_4111:
15863       fputs ("NEC VR4111/VR4181", stdout);
15864       break;
15865     case AFL_EXT_4120:
15866       fputs ("NEC VR4120", stdout);
15867       break;
15868     case AFL_EXT_5400:
15869       fputs ("NEC VR5400", stdout);
15870       break;
15871     case AFL_EXT_5500:
15872       fputs ("NEC VR5500", stdout);
15873       break;
15874     case AFL_EXT_LOONGSON_2E:
15875       fputs ("ST Microelectronics Loongson 2E", stdout);
15876       break;
15877     case AFL_EXT_LOONGSON_2F:
15878       fputs ("ST Microelectronics Loongson 2F", stdout);
15879       break;
15880     case AFL_EXT_INTERAPTIV_MR2:
15881       fputs ("Imagination interAptiv MR2", stdout);
15882       break;
15883     default:
15884       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15885     }
15886 }
15887
15888 static signed int
15889 get_mips_reg_size (int reg_size)
15890 {
15891   return (reg_size == AFL_REG_NONE) ? 0
15892          : (reg_size == AFL_REG_32) ? 32
15893          : (reg_size == AFL_REG_64) ? 64
15894          : (reg_size == AFL_REG_128) ? 128
15895          : -1;
15896 }
15897
15898 static bfd_boolean
15899 process_mips_specific (Filedata * filedata)
15900 {
15901   Elf_Internal_Dyn * entry;
15902   Elf_Internal_Shdr *sect = NULL;
15903   size_t liblist_offset = 0;
15904   size_t liblistno = 0;
15905   size_t conflictsno = 0;
15906   size_t options_offset = 0;
15907   size_t conflicts_offset = 0;
15908   size_t pltrelsz = 0;
15909   size_t pltrel = 0;
15910   bfd_vma pltgot = 0;
15911   bfd_vma mips_pltgot = 0;
15912   bfd_vma jmprel = 0;
15913   bfd_vma local_gotno = 0;
15914   bfd_vma gotsym = 0;
15915   bfd_vma symtabno = 0;
15916   bfd_boolean res = TRUE;
15917
15918   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15919                             display_mips_gnu_attribute))
15920     res = FALSE;
15921
15922   sect = find_section (filedata, ".MIPS.abiflags");
15923
15924   if (sect != NULL)
15925     {
15926       Elf_External_ABIFlags_v0 *abiflags_ext;
15927       Elf_Internal_ABIFlags_v0 abiflags_in;
15928
15929       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15930         {
15931           error (_("Corrupt MIPS ABI Flags section.\n"));
15932           res = FALSE;
15933         }
15934       else
15935         {
15936           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15937                                    sect->sh_size, _("MIPS ABI Flags section"));
15938           if (abiflags_ext)
15939             {
15940               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15941               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15942               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15943               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15944               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15945               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15946               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15947               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15948               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15949               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15950               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15951
15952               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15953               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15954               if (abiflags_in.isa_rev > 1)
15955                 printf ("r%d", abiflags_in.isa_rev);
15956               printf ("\nGPR size: %d",
15957                       get_mips_reg_size (abiflags_in.gpr_size));
15958               printf ("\nCPR1 size: %d",
15959                       get_mips_reg_size (abiflags_in.cpr1_size));
15960               printf ("\nCPR2 size: %d",
15961                       get_mips_reg_size (abiflags_in.cpr2_size));
15962               fputs ("\nFP ABI: ", stdout);
15963               print_mips_fp_abi_value (abiflags_in.fp_abi);
15964               fputs ("ISA Extension: ", stdout);
15965               print_mips_isa_ext (abiflags_in.isa_ext);
15966               fputs ("\nASEs:", stdout);
15967               print_mips_ases (abiflags_in.ases);
15968               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15969               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15970               fputc ('\n', stdout);
15971               free (abiflags_ext);
15972             }
15973         }
15974     }
15975
15976   /* We have a lot of special sections.  Thanks SGI!  */
15977   if (dynamic_section == NULL)
15978     {
15979       /* No dynamic information available.  See if there is static GOT.  */
15980       sect = find_section (filedata, ".got");
15981       if (sect != NULL)
15982         {
15983           unsigned char *data_end;
15984           unsigned char *data;
15985           bfd_vma ent, end;
15986           int addr_size;
15987
15988           pltgot = sect->sh_addr;
15989
15990           ent = pltgot;
15991           addr_size = (is_32bit_elf ? 4 : 8);
15992           end = pltgot + sect->sh_size;
15993
15994           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15995                                              end - pltgot, 1,
15996                                              _("Global Offset Table data"));
15997           /* PR 12855: Null data is handled gracefully throughout.  */
15998           data_end = data + (end - pltgot);
15999
16000           printf (_("\nStatic GOT:\n"));
16001           printf (_(" Canonical gp value: "));
16002           print_vma (ent + 0x7ff0, LONG_HEX);
16003           printf ("\n\n");
16004
16005           /* In a dynamic binary GOT[0] is reserved for the dynamic
16006              loader to store the lazy resolver pointer, however in
16007              a static binary it may well have been omitted and GOT
16008              reduced to a table of addresses.
16009              PR 21344: Check for the entry being fully available
16010              before fetching it.  */
16011           if (data
16012               && data + ent - pltgot + addr_size <= data_end
16013               && byte_get (data + ent - pltgot, addr_size) == 0)
16014             {
16015               printf (_(" Reserved entries:\n"));
16016               printf (_("  %*s %10s %*s\n"),
16017                       addr_size * 2, _("Address"), _("Access"),
16018                       addr_size * 2, _("Value"));
16019               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16020               printf ("\n");
16021               if (ent == (bfd_vma) -1)
16022                 goto sgot_print_fail;
16023
16024               /* Check for the MSB of GOT[1] being set, identifying a
16025                  GNU object.  This entry will be used by some runtime
16026                  loaders, to store the module pointer.  Otherwise this
16027                  is an ordinary local entry.
16028                  PR 21344: Check for the entry being fully available
16029                  before fetching it.  */
16030               if (data
16031                   && data + ent - pltgot + addr_size <= data_end
16032                   && (byte_get (data + ent - pltgot, addr_size)
16033                       >> (addr_size * 8 - 1)) != 0)
16034                 {
16035                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
16036                   printf ("\n");
16037                   if (ent == (bfd_vma) -1)
16038                     goto sgot_print_fail;
16039                 }
16040               printf ("\n");
16041             }
16042
16043           if (data != NULL && ent < end)
16044             {
16045               printf (_(" Local entries:\n"));
16046               printf ("  %*s %10s %*s\n",
16047                       addr_size * 2, _("Address"), _("Access"),
16048                       addr_size * 2, _("Value"));
16049               while (ent < end)
16050                 {
16051                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
16052                   printf ("\n");
16053                   if (ent == (bfd_vma) -1)
16054                     goto sgot_print_fail;
16055                 }
16056               printf ("\n");
16057             }
16058
16059         sgot_print_fail:
16060           if (data)
16061             free (data);
16062         }
16063       return res;
16064     }
16065
16066   for (entry = dynamic_section;
16067        /* PR 17531 file: 012-50589-0.004.  */
16068        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
16069        ++entry)
16070     switch (entry->d_tag)
16071       {
16072       case DT_MIPS_LIBLIST:
16073         liblist_offset
16074           = offset_from_vma (filedata, entry->d_un.d_val,
16075                              liblistno * sizeof (Elf32_External_Lib));
16076         break;
16077       case DT_MIPS_LIBLISTNO:
16078         liblistno = entry->d_un.d_val;
16079         break;
16080       case DT_MIPS_OPTIONS:
16081         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
16082         break;
16083       case DT_MIPS_CONFLICT:
16084         conflicts_offset
16085           = offset_from_vma (filedata, entry->d_un.d_val,
16086                              conflictsno * sizeof (Elf32_External_Conflict));
16087         break;
16088       case DT_MIPS_CONFLICTNO:
16089         conflictsno = entry->d_un.d_val;
16090         break;
16091       case DT_PLTGOT:
16092         pltgot = entry->d_un.d_ptr;
16093         break;
16094       case DT_MIPS_LOCAL_GOTNO:
16095         local_gotno = entry->d_un.d_val;
16096         break;
16097       case DT_MIPS_GOTSYM:
16098         gotsym = entry->d_un.d_val;
16099         break;
16100       case DT_MIPS_SYMTABNO:
16101         symtabno = entry->d_un.d_val;
16102         break;
16103       case DT_MIPS_PLTGOT:
16104         mips_pltgot = entry->d_un.d_ptr;
16105         break;
16106       case DT_PLTREL:
16107         pltrel = entry->d_un.d_val;
16108         break;
16109       case DT_PLTRELSZ:
16110         pltrelsz = entry->d_un.d_val;
16111         break;
16112       case DT_JMPREL:
16113         jmprel = entry->d_un.d_ptr;
16114         break;
16115       default:
16116         break;
16117       }
16118
16119   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
16120     {
16121       Elf32_External_Lib * elib;
16122       size_t cnt;
16123
16124       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
16125                                               liblistno,
16126                                               sizeof (Elf32_External_Lib),
16127                                               _("liblist section data"));
16128       if (elib)
16129         {
16130           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16131                             "\nSection '.liblist' contains %lu entries:\n",
16132                             (unsigned long) liblistno),
16133                   (unsigned long) liblistno);
16134           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
16135                  stdout);
16136
16137           for (cnt = 0; cnt < liblistno; ++cnt)
16138             {
16139               Elf32_Lib liblist;
16140               time_t atime;
16141               char timebuf[128];
16142               struct tm * tmp;
16143
16144               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16145               atime = BYTE_GET (elib[cnt].l_time_stamp);
16146               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16147               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16148               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16149
16150               tmp = gmtime (&atime);
16151               snprintf (timebuf, sizeof (timebuf),
16152                         "%04u-%02u-%02uT%02u:%02u:%02u",
16153                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16154                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16155
16156               printf ("%3lu: ", (unsigned long) cnt);
16157               if (VALID_DYNAMIC_NAME (liblist.l_name))
16158                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16159               else
16160                 printf (_("<corrupt: %9ld>"), liblist.l_name);
16161               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16162                       liblist.l_version);
16163
16164               if (liblist.l_flags == 0)
16165                 puts (_(" NONE"));
16166               else
16167                 {
16168                   static const struct
16169                   {
16170                     const char * name;
16171                     int bit;
16172                   }
16173                   l_flags_vals[] =
16174                   {
16175                     { " EXACT_MATCH", LL_EXACT_MATCH },
16176                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16177                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16178                     { " EXPORTS", LL_EXPORTS },
16179                     { " DELAY_LOAD", LL_DELAY_LOAD },
16180                     { " DELTA", LL_DELTA }
16181                   };
16182                   int flags = liblist.l_flags;
16183                   size_t fcnt;
16184
16185                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16186                     if ((flags & l_flags_vals[fcnt].bit) != 0)
16187                       {
16188                         fputs (l_flags_vals[fcnt].name, stdout);
16189                         flags ^= l_flags_vals[fcnt].bit;
16190                       }
16191                   if (flags != 0)
16192                     printf (" %#x", (unsigned int) flags);
16193
16194                   puts ("");
16195                 }
16196             }
16197
16198           free (elib);
16199         }
16200       else
16201         res = FALSE;
16202     }
16203
16204   if (options_offset != 0)
16205     {
16206       Elf_External_Options * eopt;
16207       Elf_Internal_Options * iopt;
16208       Elf_Internal_Options * option;
16209       size_t offset;
16210       int cnt;
16211       sect = filedata->section_headers;
16212
16213       /* Find the section header so that we get the size.  */
16214       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16215       /* PR 17533 file: 012-277276-0.004.  */
16216       if (sect == NULL)
16217         {
16218           error (_("No MIPS_OPTIONS header found\n"));
16219           return FALSE;
16220         }
16221       /* PR 24243  */
16222       if (sect->sh_size < sizeof (* eopt))
16223         {
16224           error (_("The MIPS options section is too small.\n"));
16225           return FALSE;
16226         }
16227
16228       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16229                                                 sect->sh_size, _("options"));
16230       if (eopt)
16231         {
16232           iopt = (Elf_Internal_Options *)
16233               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16234           if (iopt == NULL)
16235             {
16236               error (_("Out of memory allocating space for MIPS options\n"));
16237               return FALSE;
16238             }
16239
16240           offset = cnt = 0;
16241           option = iopt;
16242
16243           while (offset <= sect->sh_size - sizeof (* eopt))
16244             {
16245               Elf_External_Options * eoption;
16246
16247               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16248
16249               option->kind = BYTE_GET (eoption->kind);
16250               option->size = BYTE_GET (eoption->size);
16251               option->section = BYTE_GET (eoption->section);
16252               option->info = BYTE_GET (eoption->info);
16253
16254               /* PR 17531: file: ffa0fa3b.  */
16255               if (option->size < sizeof (* eopt)
16256                   || offset + option->size > sect->sh_size)
16257                 {
16258                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
16259                   return FALSE;
16260                 }
16261               offset += option->size;
16262
16263               ++option;
16264               ++cnt;
16265             }
16266
16267           printf (ngettext ("\nSection '%s' contains %d entry:\n",
16268                             "\nSection '%s' contains %d entries:\n",
16269                             cnt),
16270                   printable_section_name (filedata, sect), cnt);
16271
16272           option = iopt;
16273           offset = 0;
16274
16275           while (cnt-- > 0)
16276             {
16277               size_t len;
16278
16279               switch (option->kind)
16280                 {
16281                 case ODK_NULL:
16282                   /* This shouldn't happen.  */
16283                   printf (" NULL       %d %lx", option->section, option->info);
16284                   break;
16285                 case ODK_REGINFO:
16286                   printf (" REGINFO    ");
16287                   if (filedata->file_header.e_machine == EM_MIPS)
16288                     {
16289                       /* 32bit form.  */
16290                       Elf32_External_RegInfo * ereg;
16291                       Elf32_RegInfo reginfo;
16292
16293                       ereg = (Elf32_External_RegInfo *) (option + 1);
16294                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16295                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16296                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16297                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16298                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16299                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16300
16301                       printf ("GPR %08lx  GP 0x%lx\n",
16302                               reginfo.ri_gprmask,
16303                               (unsigned long) reginfo.ri_gp_value);
16304                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16305                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16306                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16307                     }
16308                   else
16309                     {
16310                       /* 64 bit form.  */
16311                       Elf64_External_RegInfo * ereg;
16312                       Elf64_Internal_RegInfo reginfo;
16313
16314                       ereg = (Elf64_External_RegInfo *) (option + 1);
16315                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
16316                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16317                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16318                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16319                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16320                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16321
16322                       printf ("GPR %08lx  GP 0x",
16323                               reginfo.ri_gprmask);
16324                       printf_vma (reginfo.ri_gp_value);
16325                       printf ("\n");
16326
16327                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16328                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16329                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16330                     }
16331                   ++option;
16332                   continue;
16333                 case ODK_EXCEPTIONS:
16334                   fputs (" EXCEPTIONS fpe_min(", stdout);
16335                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16336                   fputs (") fpe_max(", stdout);
16337                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16338                   fputs (")", stdout);
16339
16340                   if (option->info & OEX_PAGE0)
16341                     fputs (" PAGE0", stdout);
16342                   if (option->info & OEX_SMM)
16343                     fputs (" SMM", stdout);
16344                   if (option->info & OEX_FPDBUG)
16345                     fputs (" FPDBUG", stdout);
16346                   if (option->info & OEX_DISMISS)
16347                     fputs (" DISMISS", stdout);
16348                   break;
16349                 case ODK_PAD:
16350                   fputs (" PAD       ", stdout);
16351                   if (option->info & OPAD_PREFIX)
16352                     fputs (" PREFIX", stdout);
16353                   if (option->info & OPAD_POSTFIX)
16354                     fputs (" POSTFIX", stdout);
16355                   if (option->info & OPAD_SYMBOL)
16356                     fputs (" SYMBOL", stdout);
16357                   break;
16358                 case ODK_HWPATCH:
16359                   fputs (" HWPATCH   ", stdout);
16360                   if (option->info & OHW_R4KEOP)
16361                     fputs (" R4KEOP", stdout);
16362                   if (option->info & OHW_R8KPFETCH)
16363                     fputs (" R8KPFETCH", stdout);
16364                   if (option->info & OHW_R5KEOP)
16365                     fputs (" R5KEOP", stdout);
16366                   if (option->info & OHW_R5KCVTL)
16367                     fputs (" R5KCVTL", stdout);
16368                   break;
16369                 case ODK_FILL:
16370                   fputs (" FILL       ", stdout);
16371                   /* XXX Print content of info word?  */
16372                   break;
16373                 case ODK_TAGS:
16374                   fputs (" TAGS       ", stdout);
16375                   /* XXX Print content of info word?  */
16376                   break;
16377                 case ODK_HWAND:
16378                   fputs (" HWAND     ", stdout);
16379                   if (option->info & OHWA0_R4KEOP_CHECKED)
16380                     fputs (" R4KEOP_CHECKED", stdout);
16381                   if (option->info & OHWA0_R4KEOP_CLEAN)
16382                     fputs (" R4KEOP_CLEAN", stdout);
16383                   break;
16384                 case ODK_HWOR:
16385                   fputs (" HWOR      ", stdout);
16386                   if (option->info & OHWA0_R4KEOP_CHECKED)
16387                     fputs (" R4KEOP_CHECKED", stdout);
16388                   if (option->info & OHWA0_R4KEOP_CLEAN)
16389                     fputs (" R4KEOP_CLEAN", stdout);
16390                   break;
16391                 case ODK_GP_GROUP:
16392                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16393                           option->info & OGP_GROUP,
16394                           (option->info & OGP_SELF) >> 16);
16395                   break;
16396                 case ODK_IDENT:
16397                   printf (" IDENT     %#06lx  self-contained %#06lx",
16398                           option->info & OGP_GROUP,
16399                           (option->info & OGP_SELF) >> 16);
16400                   break;
16401                 default:
16402                   /* This shouldn't happen.  */
16403                   printf (" %3d ???     %d %lx",
16404                           option->kind, option->section, option->info);
16405                   break;
16406                 }
16407
16408               len = sizeof (* eopt);
16409               while (len < option->size)
16410                 {
16411                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16412
16413                   if (ISPRINT (datum))
16414                     printf ("%c", datum);
16415                   else
16416                     printf ("\\%03o", datum);
16417                   len ++;
16418                 }
16419               fputs ("\n", stdout);
16420
16421               offset += option->size;
16422               ++option;
16423             }
16424
16425           free (eopt);
16426         }
16427       else
16428         res = FALSE;
16429     }
16430
16431   if (conflicts_offset != 0 && conflictsno != 0)
16432     {
16433       Elf32_Conflict * iconf;
16434       size_t cnt;
16435
16436       if (dynamic_symbols == NULL)
16437         {
16438           error (_("conflict list found without a dynamic symbol table\n"));
16439           return FALSE;
16440         }
16441
16442       /* PR 21345 - print a slightly more helpful error message
16443          if we are sure that the cmalloc will fail.  */
16444       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16445         {
16446           error (_("Overlarge number of conflicts detected: %lx\n"),
16447                  (long) conflictsno);
16448           return FALSE;
16449         }
16450
16451       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16452       if (iconf == NULL)
16453         {
16454           error (_("Out of memory allocating space for dynamic conflicts\n"));
16455           return FALSE;
16456         }
16457
16458       if (is_32bit_elf)
16459         {
16460           Elf32_External_Conflict * econf32;
16461
16462           econf32 = (Elf32_External_Conflict *)
16463               get_data (NULL, filedata, conflicts_offset, conflictsno,
16464                         sizeof (* econf32), _("conflict"));
16465           if (!econf32)
16466             return FALSE;
16467
16468           for (cnt = 0; cnt < conflictsno; ++cnt)
16469             iconf[cnt] = BYTE_GET (econf32[cnt]);
16470
16471           free (econf32);
16472         }
16473       else
16474         {
16475           Elf64_External_Conflict * econf64;
16476
16477           econf64 = (Elf64_External_Conflict *)
16478               get_data (NULL, filedata, conflicts_offset, conflictsno,
16479                         sizeof (* econf64), _("conflict"));
16480           if (!econf64)
16481             return FALSE;
16482
16483           for (cnt = 0; cnt < conflictsno; ++cnt)
16484             iconf[cnt] = BYTE_GET (econf64[cnt]);
16485
16486           free (econf64);
16487         }
16488
16489       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16490                         "\nSection '.conflict' contains %lu entries:\n",
16491                         (unsigned long) conflictsno),
16492               (unsigned long) conflictsno);
16493       puts (_("  Num:    Index       Value  Name"));
16494
16495       for (cnt = 0; cnt < conflictsno; ++cnt)
16496         {
16497           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16498
16499           if (iconf[cnt] >= num_dynamic_syms)
16500             printf (_("<corrupt symbol index>"));
16501           else
16502             {
16503               Elf_Internal_Sym * psym;
16504
16505               psym = & dynamic_symbols[iconf[cnt]];
16506               print_vma (psym->st_value, FULL_HEX);
16507               putchar (' ');
16508               if (VALID_DYNAMIC_NAME (psym->st_name))
16509                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16510               else
16511                 printf (_("<corrupt: %14ld>"), psym->st_name);
16512             }
16513           putchar ('\n');
16514         }
16515
16516       free (iconf);
16517     }
16518
16519   if (pltgot != 0 && local_gotno != 0)
16520     {
16521       bfd_vma ent, local_end, global_end;
16522       size_t i, offset;
16523       unsigned char * data;
16524       unsigned char * data_end;
16525       int addr_size;
16526
16527       ent = pltgot;
16528       addr_size = (is_32bit_elf ? 4 : 8);
16529       local_end = pltgot + local_gotno * addr_size;
16530
16531       /* PR binutils/17533 file: 012-111227-0.004  */
16532       if (symtabno < gotsym)
16533         {
16534           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16535                  (unsigned long) gotsym, (unsigned long) symtabno);
16536           return FALSE;
16537         }
16538
16539       global_end = local_end + (symtabno - gotsym) * addr_size;
16540       /* PR 17531: file: 54c91a34.  */
16541       if (global_end < local_end)
16542         {
16543           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16544           return FALSE;
16545         }
16546
16547       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16548       data = (unsigned char *) get_data (NULL, filedata, offset,
16549                                          global_end - pltgot, 1,
16550                                          _("Global Offset Table data"));
16551       /* PR 12855: Null data is handled gracefully throughout.  */
16552       data_end = data + (global_end - pltgot);
16553
16554       printf (_("\nPrimary GOT:\n"));
16555       printf (_(" Canonical gp value: "));
16556       print_vma (pltgot + 0x7ff0, LONG_HEX);
16557       printf ("\n\n");
16558
16559       printf (_(" Reserved entries:\n"));
16560       printf (_("  %*s %10s %*s Purpose\n"),
16561               addr_size * 2, _("Address"), _("Access"),
16562               addr_size * 2, _("Initial"));
16563       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16564       printf (_(" Lazy resolver\n"));
16565       if (ent == (bfd_vma) -1)
16566         goto got_print_fail;
16567
16568       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16569          This entry will be used by some runtime loaders, to store the
16570          module pointer.  Otherwise this is an ordinary local entry.
16571          PR 21344: Check for the entry being fully available before
16572          fetching it.  */
16573       if (data
16574           && data + ent - pltgot + addr_size <= data_end
16575           && (byte_get (data + ent - pltgot, addr_size)
16576               >> (addr_size * 8 - 1)) != 0)
16577         {
16578           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16579           printf (_(" Module pointer (GNU extension)\n"));
16580           if (ent == (bfd_vma) -1)
16581             goto got_print_fail;
16582         }
16583       printf ("\n");
16584
16585       if (data != NULL && ent < local_end)
16586         {
16587           printf (_(" Local entries:\n"));
16588           printf ("  %*s %10s %*s\n",
16589                   addr_size * 2, _("Address"), _("Access"),
16590                   addr_size * 2, _("Initial"));
16591           while (ent < local_end)
16592             {
16593               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16594               printf ("\n");
16595               if (ent == (bfd_vma) -1)
16596                 goto got_print_fail;
16597             }
16598           printf ("\n");
16599         }
16600
16601       if (data != NULL && gotsym < symtabno)
16602         {
16603           int sym_width;
16604
16605           printf (_(" Global entries:\n"));
16606           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16607                   addr_size * 2, _("Address"),
16608                   _("Access"),
16609                   addr_size * 2, _("Initial"),
16610                   addr_size * 2, _("Sym.Val."),
16611                   _("Type"),
16612                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16613                   _("Ndx"), _("Name"));
16614
16615           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16616
16617           for (i = gotsym; i < symtabno; i++)
16618             {
16619               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16620               printf (" ");
16621
16622               if (dynamic_symbols == NULL)
16623                 printf (_("<no dynamic symbols>"));
16624               else if (i < num_dynamic_syms)
16625                 {
16626                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16627
16628                   print_vma (psym->st_value, LONG_HEX);
16629                   printf (" %-7s %3s ",
16630                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16631                           get_symbol_index_type (filedata, psym->st_shndx));
16632
16633                   if (VALID_DYNAMIC_NAME (psym->st_name))
16634                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16635                   else
16636                     printf (_("<corrupt: %14ld>"), psym->st_name);
16637                 }
16638               else
16639                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16640                         (unsigned long) i);
16641
16642               printf ("\n");
16643               if (ent == (bfd_vma) -1)
16644                 break;
16645             }
16646           printf ("\n");
16647         }
16648
16649     got_print_fail:
16650       if (data)
16651         free (data);
16652     }
16653
16654   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16655     {
16656       bfd_vma ent, end;
16657       size_t offset, rel_offset;
16658       unsigned long count, i;
16659       unsigned char * data;
16660       int addr_size, sym_width;
16661       Elf_Internal_Rela * rels;
16662
16663       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16664       if (pltrel == DT_RELA)
16665         {
16666           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16667             return FALSE;
16668         }
16669       else
16670         {
16671           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16672             return FALSE;
16673         }
16674
16675       ent = mips_pltgot;
16676       addr_size = (is_32bit_elf ? 4 : 8);
16677       end = mips_pltgot + (2 + count) * addr_size;
16678
16679       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16680       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16681                                          1, _("Procedure Linkage Table data"));
16682       if (data == NULL)
16683         return FALSE;
16684
16685       printf ("\nPLT GOT:\n\n");
16686       printf (_(" Reserved entries:\n"));
16687       printf (_("  %*s %*s Purpose\n"),
16688               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16689       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16690       printf (_(" PLT lazy resolver\n"));
16691       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16692       printf (_(" Module pointer\n"));
16693       printf ("\n");
16694
16695       printf (_(" Entries:\n"));
16696       printf ("  %*s %*s %*s %-7s %3s %s\n",
16697               addr_size * 2, _("Address"),
16698               addr_size * 2, _("Initial"),
16699               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16700       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16701       for (i = 0; i < count; i++)
16702         {
16703           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16704
16705           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16706           printf (" ");
16707
16708           if (idx >= num_dynamic_syms)
16709             printf (_("<corrupt symbol index: %lu>"), idx);
16710           else
16711             {
16712               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16713
16714               print_vma (psym->st_value, LONG_HEX);
16715               printf (" %-7s %3s ",
16716                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16717                       get_symbol_index_type (filedata, psym->st_shndx));
16718               if (VALID_DYNAMIC_NAME (psym->st_name))
16719                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16720               else
16721                 printf (_("<corrupt: %14ld>"), psym->st_name);
16722             }
16723           printf ("\n");
16724         }
16725       printf ("\n");
16726
16727       if (data)
16728         free (data);
16729       free (rels);
16730     }
16731
16732   return res;
16733 }
16734
16735 static bfd_boolean
16736 process_nds32_specific (Filedata * filedata)
16737 {
16738   Elf_Internal_Shdr *sect = NULL;
16739
16740   sect = find_section (filedata, ".nds32_e_flags");
16741   if (sect != NULL)
16742     {
16743       unsigned int *flag;
16744
16745       printf ("\nNDS32 elf flags section:\n");
16746       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16747                        sect->sh_size, _("NDS32 elf flags section"));
16748
16749       if (! flag)
16750         return FALSE;
16751
16752       switch ((*flag) & 0x3)
16753         {
16754         case 0:
16755           printf ("(VEC_SIZE):\tNo entry.\n");
16756           break;
16757         case 1:
16758           printf ("(VEC_SIZE):\t4 bytes\n");
16759           break;
16760         case 2:
16761           printf ("(VEC_SIZE):\t16 bytes\n");
16762           break;
16763         case 3:
16764           printf ("(VEC_SIZE):\treserved\n");
16765           break;
16766         }
16767     }
16768
16769   return TRUE;
16770 }
16771
16772 static bfd_boolean
16773 process_gnu_liblist (Filedata * filedata)
16774 {
16775   Elf_Internal_Shdr * section;
16776   Elf_Internal_Shdr * string_sec;
16777   Elf32_External_Lib * elib;
16778   char * strtab;
16779   size_t strtab_size;
16780   size_t cnt;
16781   unsigned long num_liblist;
16782   unsigned i;
16783   bfd_boolean res = TRUE;
16784
16785   if (! do_arch)
16786     return TRUE;
16787
16788   for (i = 0, section = filedata->section_headers;
16789        i < filedata->file_header.e_shnum;
16790        i++, section++)
16791     {
16792       switch (section->sh_type)
16793         {
16794         case SHT_GNU_LIBLIST:
16795           if (section->sh_link >= filedata->file_header.e_shnum)
16796             break;
16797
16798           elib = (Elf32_External_Lib *)
16799               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16800                         _("liblist section data"));
16801
16802           if (elib == NULL)
16803             {
16804               res = FALSE;
16805               break;
16806             }
16807
16808           string_sec = filedata->section_headers + section->sh_link;
16809           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16810                                       string_sec->sh_size,
16811                                       _("liblist string table"));
16812           if (strtab == NULL
16813               || section->sh_entsize != sizeof (Elf32_External_Lib))
16814             {
16815               free (elib);
16816               free (strtab);
16817               res = FALSE;
16818               break;
16819             }
16820           strtab_size = string_sec->sh_size;
16821
16822           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16823           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16824                             "\nLibrary list section '%s' contains %lu entries:\n",
16825                             num_liblist),
16826                   printable_section_name (filedata, section),
16827                   num_liblist);
16828
16829           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16830
16831           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16832                ++cnt)
16833             {
16834               Elf32_Lib liblist;
16835               time_t atime;
16836               char timebuf[128];
16837               struct tm * tmp;
16838
16839               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16840               atime = BYTE_GET (elib[cnt].l_time_stamp);
16841               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16842               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16843               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16844
16845               tmp = gmtime (&atime);
16846               snprintf (timebuf, sizeof (timebuf),
16847                         "%04u-%02u-%02uT%02u:%02u:%02u",
16848                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16849                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16850
16851               printf ("%3lu: ", (unsigned long) cnt);
16852               if (do_wide)
16853                 printf ("%-20s", liblist.l_name < strtab_size
16854                         ? strtab + liblist.l_name : _("<corrupt>"));
16855               else
16856                 printf ("%-20.20s", liblist.l_name < strtab_size
16857                         ? strtab + liblist.l_name : _("<corrupt>"));
16858               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16859                       liblist.l_version, liblist.l_flags);
16860             }
16861
16862           free (elib);
16863           free (strtab);
16864         }
16865     }
16866
16867   return res;
16868 }
16869
16870 static const char *
16871 get_note_type (Filedata * filedata, unsigned e_type)
16872 {
16873   static char buff[64];
16874
16875   if (filedata->file_header.e_type == ET_CORE)
16876     switch (e_type)
16877       {
16878       case NT_AUXV:
16879         return _("NT_AUXV (auxiliary vector)");
16880       case NT_PRSTATUS:
16881         return _("NT_PRSTATUS (prstatus structure)");
16882       case NT_FPREGSET:
16883         return _("NT_FPREGSET (floating point registers)");
16884       case NT_PRPSINFO:
16885         return _("NT_PRPSINFO (prpsinfo structure)");
16886       case NT_TASKSTRUCT:
16887         return _("NT_TASKSTRUCT (task structure)");
16888       case NT_PRXFPREG:
16889         return _("NT_PRXFPREG (user_xfpregs structure)");
16890       case NT_PPC_VMX:
16891         return _("NT_PPC_VMX (ppc Altivec registers)");
16892       case NT_PPC_VSX:
16893         return _("NT_PPC_VSX (ppc VSX registers)");
16894       case NT_PPC_TAR:
16895         return _("NT_PPC_TAR (ppc TAR register)");
16896       case NT_PPC_PPR:
16897         return _("NT_PPC_PPR (ppc PPR register)");
16898       case NT_PPC_DSCR:
16899         return _("NT_PPC_DSCR (ppc DSCR register)");
16900       case NT_PPC_EBB:
16901         return _("NT_PPC_EBB (ppc EBB registers)");
16902       case NT_PPC_PMU:
16903         return _("NT_PPC_PMU (ppc PMU registers)");
16904       case NT_PPC_TM_CGPR:
16905         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16906       case NT_PPC_TM_CFPR:
16907         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16908       case NT_PPC_TM_CVMX:
16909         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16910       case NT_PPC_TM_CVSX:
16911         return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16912       case NT_PPC_TM_SPR:
16913         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16914       case NT_PPC_TM_CTAR:
16915         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16916       case NT_PPC_TM_CPPR:
16917         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16918       case NT_PPC_TM_CDSCR:
16919         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16920       case NT_386_TLS:
16921         return _("NT_386_TLS (x86 TLS information)");
16922       case NT_386_IOPERM:
16923         return _("NT_386_IOPERM (x86 I/O permissions)");
16924       case NT_X86_XSTATE:
16925         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16926       case NT_S390_HIGH_GPRS:
16927         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16928       case NT_S390_TIMER:
16929         return _("NT_S390_TIMER (s390 timer register)");
16930       case NT_S390_TODCMP:
16931         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16932       case NT_S390_TODPREG:
16933         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16934       case NT_S390_CTRS:
16935         return _("NT_S390_CTRS (s390 control registers)");
16936       case NT_S390_PREFIX:
16937         return _("NT_S390_PREFIX (s390 prefix register)");
16938       case NT_S390_LAST_BREAK:
16939         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16940       case NT_S390_SYSTEM_CALL:
16941         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16942       case NT_S390_TDB:
16943         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16944       case NT_S390_VXRS_LOW:
16945         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16946       case NT_S390_VXRS_HIGH:
16947         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16948       case NT_S390_GS_CB:
16949         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16950       case NT_S390_GS_BC:
16951         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16952       case NT_ARM_VFP:
16953         return _("NT_ARM_VFP (arm VFP registers)");
16954       case NT_ARM_TLS:
16955         return _("NT_ARM_TLS (AArch TLS registers)");
16956       case NT_ARM_HW_BREAK:
16957         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16958       case NT_ARM_HW_WATCH:
16959         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16960       case NT_PSTATUS:
16961         return _("NT_PSTATUS (pstatus structure)");
16962       case NT_FPREGS:
16963         return _("NT_FPREGS (floating point registers)");
16964       case NT_PSINFO:
16965         return _("NT_PSINFO (psinfo structure)");
16966       case NT_LWPSTATUS:
16967         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16968       case NT_LWPSINFO:
16969         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16970       case NT_WIN32PSTATUS:
16971         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16972       case NT_SIGINFO:
16973         return _("NT_SIGINFO (siginfo_t data)");
16974       case NT_FILE:
16975         return _("NT_FILE (mapped files)");
16976       default:
16977         break;
16978       }
16979   else
16980     switch (e_type)
16981       {
16982       case NT_VERSION:
16983         return _("NT_VERSION (version)");
16984       case NT_ARCH:
16985         return _("NT_ARCH (architecture)");
16986       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16987         return _("OPEN");
16988       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16989         return _("func");
16990       default:
16991         break;
16992       }
16993
16994   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16995   return buff;
16996 }
16997
16998 static bfd_boolean
16999 print_core_note (Elf_Internal_Note *pnote)
17000 {
17001   unsigned int addr_size = is_32bit_elf ? 4 : 8;
17002   bfd_vma count, page_size;
17003   unsigned char *descdata, *filenames, *descend;
17004
17005   if (pnote->type != NT_FILE)
17006     {
17007       if (do_wide)
17008         printf ("\n");
17009       return TRUE;
17010     }
17011
17012 #ifndef BFD64
17013   if (!is_32bit_elf)
17014     {
17015       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
17016       /* Still "successful".  */
17017       return TRUE;
17018     }
17019 #endif
17020
17021   if (pnote->descsz < 2 * addr_size)
17022     {
17023       error (_("    Malformed note - too short for header\n"));
17024       return FALSE;
17025     }
17026
17027   descdata = (unsigned char *) pnote->descdata;
17028   descend = descdata + pnote->descsz;
17029
17030   if (descdata[pnote->descsz - 1] != '\0')
17031     {
17032       error (_("    Malformed note - does not end with \\0\n"));
17033       return FALSE;
17034     }
17035
17036   count = byte_get (descdata, addr_size);
17037   descdata += addr_size;
17038
17039   page_size = byte_get (descdata, addr_size);
17040   descdata += addr_size;
17041
17042   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
17043       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
17044     {
17045       error (_("    Malformed note - too short for supplied file count\n"));
17046       return FALSE;
17047     }
17048
17049   printf (_("    Page size: "));
17050   print_vma (page_size, DEC);
17051   printf ("\n");
17052
17053   printf (_("    %*s%*s%*s\n"),
17054           (int) (2 + 2 * addr_size), _("Start"),
17055           (int) (4 + 2 * addr_size), _("End"),
17056           (int) (4 + 2 * addr_size), _("Page Offset"));
17057   filenames = descdata + count * 3 * addr_size;
17058   while (count-- > 0)
17059     {
17060       bfd_vma start, end, file_ofs;
17061
17062       if (filenames == descend)
17063         {
17064           error (_("    Malformed note - filenames end too early\n"));
17065           return FALSE;
17066         }
17067
17068       start = byte_get (descdata, addr_size);
17069       descdata += addr_size;
17070       end = byte_get (descdata, addr_size);
17071       descdata += addr_size;
17072       file_ofs = byte_get (descdata, addr_size);
17073       descdata += addr_size;
17074
17075       printf ("    ");
17076       print_vma (start, FULL_HEX);
17077       printf ("  ");
17078       print_vma (end, FULL_HEX);
17079       printf ("  ");
17080       print_vma (file_ofs, FULL_HEX);
17081       printf ("\n        %s\n", filenames);
17082
17083       filenames += 1 + strlen ((char *) filenames);
17084     }
17085
17086   return TRUE;
17087 }
17088
17089 static const char *
17090 get_gnu_elf_note_type (unsigned e_type)
17091 {
17092   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
17093   switch (e_type)
17094     {
17095     case NT_GNU_ABI_TAG:
17096       return _("NT_GNU_ABI_TAG (ABI version tag)");
17097     case NT_GNU_HWCAP:
17098       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17099     case NT_GNU_BUILD_ID:
17100       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17101     case NT_GNU_GOLD_VERSION:
17102       return _("NT_GNU_GOLD_VERSION (gold version)");
17103     case NT_GNU_PROPERTY_TYPE_0:
17104       return _("NT_GNU_PROPERTY_TYPE_0");
17105     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17106       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17107     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17108       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17109     default:
17110       {
17111         static char buff[64];
17112
17113         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17114         return buff;
17115       }
17116     }
17117 }
17118
17119 static void
17120 decode_x86_compat_isa (unsigned int bitmask)
17121 {
17122   while (bitmask)
17123     {
17124       unsigned int bit = bitmask & (- bitmask);
17125
17126       bitmask &= ~ bit;
17127       switch (bit)
17128         {
17129         case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
17130           printf ("i486");
17131           break;
17132         case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
17133           printf ("586");
17134           break;
17135         case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
17136           printf ("686");
17137           break;
17138         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
17139           printf ("SSE");
17140           break;
17141         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17142           printf ("SSE2");
17143           break;
17144         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17145           printf ("SSE3");
17146           break;
17147         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17148           printf ("SSSE3");
17149           break;
17150         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17151           printf ("SSE4_1");
17152           break;
17153         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17154           printf ("SSE4_2");
17155           break;
17156         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17157           printf ("AVX");
17158           break;
17159         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17160           printf ("AVX2");
17161           break;
17162         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17163           printf ("AVX512F");
17164           break;
17165         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17166           printf ("AVX512CD");
17167           break;
17168         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17169           printf ("AVX512ER");
17170           break;
17171         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17172           printf ("AVX512PF");
17173           break;
17174         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17175           printf ("AVX512VL");
17176           break;
17177         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17178           printf ("AVX512DQ");
17179           break;
17180         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17181           printf ("AVX512BW");
17182           break;
17183         default:
17184           printf (_("<unknown: %x>"), bit);
17185           break;
17186         }
17187       if (bitmask)
17188         printf (", ");
17189     }
17190 }
17191
17192 static void
17193 decode_x86_isa (unsigned int bitmask)
17194 {
17195   if (!bitmask)
17196     {
17197       printf (_("<None>"));
17198       return;
17199     }
17200
17201   while (bitmask)
17202     {
17203       unsigned int bit = bitmask & (- bitmask);
17204
17205       bitmask &= ~ bit;
17206       switch (bit)
17207         {
17208         case GNU_PROPERTY_X86_ISA_1_CMOV:
17209           printf ("CMOV");
17210           break;
17211         case GNU_PROPERTY_X86_ISA_1_SSE:
17212           printf ("SSE");
17213           break;
17214         case GNU_PROPERTY_X86_ISA_1_SSE2:
17215           printf ("SSE2");
17216           break;
17217         case GNU_PROPERTY_X86_ISA_1_SSE3:
17218           printf ("SSE3");
17219           break;
17220         case GNU_PROPERTY_X86_ISA_1_SSSE3:
17221           printf ("SSSE3");
17222           break;
17223         case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17224           printf ("SSE4_1");
17225           break;
17226         case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17227           printf ("SSE4_2");
17228           break;
17229         case GNU_PROPERTY_X86_ISA_1_AVX:
17230           printf ("AVX");
17231           break;
17232         case GNU_PROPERTY_X86_ISA_1_AVX2:
17233           printf ("AVX2");
17234           break;
17235         case GNU_PROPERTY_X86_ISA_1_FMA:
17236           printf ("FMA");
17237           break;
17238         case GNU_PROPERTY_X86_ISA_1_AVX512F:
17239           printf ("AVX512F");
17240           break;
17241         case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17242           printf ("AVX512CD");
17243           break;
17244         case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17245           printf ("AVX512ER");
17246           break;
17247         case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17248           printf ("AVX512PF");
17249           break;
17250         case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17251           printf ("AVX512VL");
17252           break;
17253         case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17254           printf ("AVX512DQ");
17255           break;
17256         case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17257           printf ("AVX512BW");
17258           break;
17259         case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17260           printf ("AVX512_4FMAPS");
17261           break;
17262         case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17263           printf ("AVX512_4VNNIW");
17264           break;
17265         case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17266           printf ("AVX512_BITALG");
17267           break;
17268         case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17269           printf ("AVX512_IFMA");
17270           break;
17271         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17272           printf ("AVX512_VBMI");
17273           break;
17274         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17275           printf ("AVX512_VBMI2");
17276           break;
17277         case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17278           printf ("AVX512_VNNI");
17279           break;
17280         default:
17281           printf (_("<unknown: %x>"), bit);
17282           break;
17283         }
17284       if (bitmask)
17285         printf (", ");
17286     }
17287 }
17288
17289 static void
17290 decode_x86_feature_1 (unsigned int bitmask)
17291 {
17292   if (!bitmask)
17293     {
17294       printf (_("<None>"));
17295       return;
17296     }
17297
17298   while (bitmask)
17299     {
17300       unsigned int bit = bitmask & (- bitmask);
17301
17302       bitmask &= ~ bit;
17303       switch (bit)
17304         {
17305         case GNU_PROPERTY_X86_FEATURE_1_IBT:
17306           printf ("IBT");
17307           break;
17308         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17309           printf ("SHSTK");
17310           break;
17311         default:
17312           printf (_("<unknown: %x>"), bit);
17313           break;
17314         }
17315       if (bitmask)
17316         printf (", ");
17317     }
17318 }
17319
17320 static void
17321 decode_x86_feature_2 (unsigned int bitmask)
17322 {
17323   if (!bitmask)
17324     {
17325       printf (_("<None>"));
17326       return;
17327     }
17328
17329   while (bitmask)
17330     {
17331       unsigned int bit = bitmask & (- bitmask);
17332
17333       bitmask &= ~ bit;
17334       switch (bit)
17335         {
17336         case GNU_PROPERTY_X86_FEATURE_2_X86:
17337           printf ("x86");
17338           break;
17339         case GNU_PROPERTY_X86_FEATURE_2_X87:
17340           printf ("x87");
17341           break;
17342         case GNU_PROPERTY_X86_FEATURE_2_MMX:
17343           printf ("MMX");
17344           break;
17345         case GNU_PROPERTY_X86_FEATURE_2_XMM:
17346           printf ("XMM");
17347           break;
17348         case GNU_PROPERTY_X86_FEATURE_2_YMM:
17349           printf ("YMM");
17350           break;
17351         case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17352           printf ("ZMM");
17353           break;
17354         case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17355           printf ("FXSR");
17356           break;
17357         case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17358           printf ("XSAVE");
17359           break;
17360         case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17361           printf ("XSAVEOPT");
17362           break;
17363         case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17364           printf ("XSAVEC");
17365           break;
17366         default:
17367           printf (_("<unknown: %x>"), bit);
17368           break;
17369         }
17370       if (bitmask)
17371         printf (", ");
17372     }
17373 }
17374
17375 static void
17376 decode_aarch64_feature_1_and (unsigned int bitmask)
17377 {
17378   while (bitmask)
17379     {
17380       unsigned int bit = bitmask & (- bitmask);
17381
17382       bitmask &= ~ bit;
17383       switch (bit)
17384         {
17385         case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
17386           printf ("BTI");
17387           break;
17388
17389         case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
17390           printf ("PAC");
17391           break;
17392
17393         default:
17394           printf (_("<unknown: %x>"), bit);
17395           break;
17396         }
17397       if (bitmask)
17398         printf (", ");
17399     }
17400 }
17401
17402 static void
17403 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17404 {
17405   unsigned char * ptr = (unsigned char *) pnote->descdata;
17406   unsigned char * ptr_end = ptr + pnote->descsz;
17407   unsigned int    size = is_32bit_elf ? 4 : 8;
17408
17409   printf (_("      Properties: "));
17410
17411   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17412     {
17413       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17414       return;
17415     }
17416
17417   while (ptr < ptr_end)
17418     {
17419       unsigned int j;
17420       unsigned int type;
17421       unsigned int datasz;
17422
17423       if ((size_t) (ptr_end - ptr) < 8)
17424         {
17425           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17426           break;
17427         }
17428
17429       type = byte_get (ptr, 4);
17430       datasz = byte_get (ptr + 4, 4);
17431
17432       ptr += 8;
17433
17434       if (datasz > (size_t) (ptr_end - ptr))
17435         {
17436           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17437                   type, datasz);
17438           break;
17439         }
17440
17441       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17442         {
17443           if (filedata->file_header.e_machine == EM_X86_64
17444               || filedata->file_header.e_machine == EM_IAMCU
17445               || filedata->file_header.e_machine == EM_386)
17446             {
17447               unsigned int bitmask;
17448
17449               if (datasz == 4)
17450                 bitmask = byte_get (ptr, 4);
17451               else
17452                 bitmask = 0;
17453
17454               switch (type)
17455                 {
17456                 case GNU_PROPERTY_X86_ISA_1_USED:
17457                   if (datasz != 4)
17458                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17459                             datasz);
17460                   else
17461                     {
17462                       printf ("x86 ISA used: ");
17463                       decode_x86_isa (bitmask);
17464                     }
17465                   goto next;
17466
17467                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17468                   if (datasz != 4)
17469                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17470                             datasz);
17471                   else
17472                     {
17473                       printf ("x86 ISA needed: ");
17474                       decode_x86_isa (bitmask);
17475                     }
17476                   goto next;
17477
17478                 case GNU_PROPERTY_X86_FEATURE_1_AND:
17479                   if (datasz != 4)
17480                     printf (_("x86 feature: <corrupt length: %#x> "),
17481                             datasz);
17482                   else
17483                     {
17484                       printf ("x86 feature: ");
17485                       decode_x86_feature_1 (bitmask);
17486                     }
17487                   goto next;
17488
17489                 case GNU_PROPERTY_X86_FEATURE_2_USED:
17490                   if (datasz != 4)
17491                     printf (_("x86 feature used: <corrupt length: %#x> "),
17492                             datasz);
17493                   else
17494                     {
17495                       printf ("x86 feature used: ");
17496                       decode_x86_feature_2 (bitmask);
17497                     }
17498                   goto next;
17499
17500                 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17501                   if (datasz != 4)
17502                     printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17503                   else
17504                     {
17505                       printf ("x86 feature needed: ");
17506                       decode_x86_feature_2 (bitmask);
17507                     }
17508                   goto next;
17509
17510                 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17511                   if (datasz != 4)
17512                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17513                             datasz);
17514                   else
17515                     {
17516                       printf ("x86 ISA used: ");
17517                       decode_x86_compat_isa (bitmask);
17518                     }
17519                   goto next;
17520
17521                 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17522                   if (datasz != 4)
17523                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17524                             datasz);
17525                   else
17526                     {
17527                       printf ("x86 ISA needed: ");
17528                       decode_x86_compat_isa (bitmask);
17529                     }
17530                   goto next;
17531
17532                 default:
17533                   break;
17534                 }
17535             }
17536           else if (filedata->file_header.e_machine == EM_AARCH64)
17537             {
17538               if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
17539                 {
17540                   printf ("AArch64 feature: ");
17541                   if (datasz != 4)
17542                     printf (_("<corrupt length: %#x> "), datasz);
17543                   else
17544                     decode_aarch64_feature_1_and (byte_get (ptr, 4));
17545                   goto next;
17546                 }
17547             }
17548         }
17549       else
17550         {
17551           switch (type)
17552             {
17553             case GNU_PROPERTY_STACK_SIZE:
17554               printf (_("stack size: "));
17555               if (datasz != size)
17556                 printf (_("<corrupt length: %#x> "), datasz);
17557               else
17558                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17559               goto next;
17560
17561             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17562               printf ("no copy on protected ");
17563               if (datasz)
17564                 printf (_("<corrupt length: %#x> "), datasz);
17565               goto next;
17566
17567             default:
17568               break;
17569             }
17570         }
17571
17572       if (type < GNU_PROPERTY_LOPROC)
17573         printf (_("<unknown type %#x data: "), type);
17574       else if (type < GNU_PROPERTY_LOUSER)
17575         printf (_("<procesor-specific type %#x data: "), type);
17576       else
17577         printf (_("<application-specific type %#x data: "), type);
17578       for (j = 0; j < datasz; ++j)
17579         printf ("%02x ", ptr[j] & 0xff);
17580       printf (">");
17581
17582 next:
17583       ptr += ((datasz + (size - 1)) & ~ (size - 1));
17584       if (ptr == ptr_end)
17585         break;
17586
17587       if (do_wide)
17588         printf (", ");
17589       else
17590         printf ("\n\t");
17591     }
17592
17593   printf ("\n");
17594 }
17595
17596 static bfd_boolean
17597 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17598 {
17599   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17600   switch (pnote->type)
17601     {
17602     case NT_GNU_BUILD_ID:
17603       {
17604         unsigned long i;
17605
17606         printf (_("    Build ID: "));
17607         for (i = 0; i < pnote->descsz; ++i)
17608           printf ("%02x", pnote->descdata[i] & 0xff);
17609         printf ("\n");
17610       }
17611       break;
17612
17613     case NT_GNU_ABI_TAG:
17614       {
17615         unsigned long os, major, minor, subminor;
17616         const char *osname;
17617
17618         /* PR 17531: file: 030-599401-0.004.  */
17619         if (pnote->descsz < 16)
17620           {
17621             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17622             break;
17623           }
17624
17625         os = byte_get ((unsigned char *) pnote->descdata, 4);
17626         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17627         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17628         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17629
17630         switch (os)
17631           {
17632           case GNU_ABI_TAG_LINUX:
17633             osname = "Linux";
17634             break;
17635           case GNU_ABI_TAG_HURD:
17636             osname = "Hurd";
17637             break;
17638           case GNU_ABI_TAG_SOLARIS:
17639             osname = "Solaris";
17640             break;
17641           case GNU_ABI_TAG_FREEBSD:
17642             osname = "FreeBSD";
17643             break;
17644           case GNU_ABI_TAG_NETBSD:
17645             osname = "NetBSD";
17646             break;
17647           case GNU_ABI_TAG_SYLLABLE:
17648             osname = "Syllable";
17649             break;
17650           case GNU_ABI_TAG_NACL:
17651             osname = "NaCl";
17652             break;
17653           default:
17654             osname = "Unknown";
17655             break;
17656           }
17657
17658         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17659                 major, minor, subminor);
17660       }
17661       break;
17662
17663     case NT_GNU_GOLD_VERSION:
17664       {
17665         unsigned long i;
17666
17667         printf (_("    Version: "));
17668         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17669           printf ("%c", pnote->descdata[i]);
17670         printf ("\n");
17671       }
17672       break;
17673
17674     case NT_GNU_HWCAP:
17675       {
17676         unsigned long num_entries, mask;
17677
17678         /* Hardware capabilities information.  Word 0 is the number of entries.
17679            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17680            is a series of entries, where each entry is a single byte followed
17681            by a nul terminated string.  The byte gives the bit number to test
17682            if enabled in the bitmask.  */
17683         printf (_("      Hardware Capabilities: "));
17684         if (pnote->descsz < 8)
17685           {
17686             error (_("<corrupt GNU_HWCAP>\n"));
17687             return FALSE;
17688           }
17689         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17690         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17691         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17692         /* FIXME: Add code to display the entries... */
17693       }
17694       break;
17695
17696     case NT_GNU_PROPERTY_TYPE_0:
17697       print_gnu_property_note (filedata, pnote);
17698       break;
17699
17700     default:
17701       /* Handle unrecognised types.  An error message should have already been
17702          created by get_gnu_elf_note_type(), so all that we need to do is to
17703          display the data.  */
17704       {
17705         unsigned long i;
17706
17707         printf (_("    Description data: "));
17708         for (i = 0; i < pnote->descsz; ++i)
17709           printf ("%02x ", pnote->descdata[i] & 0xff);
17710         printf ("\n");
17711       }
17712       break;
17713     }
17714
17715   return TRUE;
17716 }
17717
17718 static const char *
17719 get_v850_elf_note_type (enum v850_notes n_type)
17720 {
17721   static char buff[64];
17722
17723   switch (n_type)
17724     {
17725     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17726     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17727     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17728     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17729     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17730     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17731     default:
17732       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17733       return buff;
17734     }
17735 }
17736
17737 static bfd_boolean
17738 print_v850_note (Elf_Internal_Note * pnote)
17739 {
17740   unsigned int val;
17741
17742   if (pnote->descsz != 4)
17743     return FALSE;
17744
17745   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17746
17747   if (val == 0)
17748     {
17749       printf (_("not set\n"));
17750       return TRUE;
17751     }
17752
17753   switch (pnote->type)
17754     {
17755     case V850_NOTE_ALIGNMENT:
17756       switch (val)
17757         {
17758         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17759         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17760         }
17761       break;
17762
17763     case V850_NOTE_DATA_SIZE:
17764       switch (val)
17765         {
17766         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17767         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17768         }
17769       break;
17770
17771     case V850_NOTE_FPU_INFO:
17772       switch (val)
17773         {
17774         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17775         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17776         }
17777       break;
17778
17779     case V850_NOTE_MMU_INFO:
17780     case V850_NOTE_CACHE_INFO:
17781     case V850_NOTE_SIMD_INFO:
17782       if (val == EF_RH850_SIMD)
17783         {
17784           printf (_("yes\n"));
17785           return TRUE;
17786         }
17787       break;
17788
17789     default:
17790       /* An 'unknown note type' message will already have been displayed.  */
17791       break;
17792     }
17793
17794   printf (_("unknown value: %x\n"), val);
17795   return FALSE;
17796 }
17797
17798 static bfd_boolean
17799 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17800 {
17801   unsigned int version;
17802
17803   switch (pnote->type)
17804     {
17805     case NT_NETBSD_IDENT:
17806       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17807       if ((version / 10000) % 100)
17808         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17809                 version, version / 100000000, (version / 1000000) % 100,
17810                 (version / 10000) % 100 > 26 ? "Z" : "",
17811                 'A' + (version / 10000) % 26);
17812       else
17813         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17814                 version, version / 100000000, (version / 1000000) % 100,
17815                 (version / 100) % 100);
17816       return TRUE;
17817
17818     case NT_NETBSD_MARCH:
17819       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17820               pnote->descdata);
17821       return TRUE;
17822
17823     default:
17824       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17825               pnote->type);
17826       return FALSE;
17827     }
17828 }
17829
17830 static const char *
17831 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17832 {
17833   switch (e_type)
17834     {
17835     case NT_FREEBSD_THRMISC:
17836       return _("NT_THRMISC (thrmisc structure)");
17837     case NT_FREEBSD_PROCSTAT_PROC:
17838       return _("NT_PROCSTAT_PROC (proc data)");
17839     case NT_FREEBSD_PROCSTAT_FILES:
17840       return _("NT_PROCSTAT_FILES (files data)");
17841     case NT_FREEBSD_PROCSTAT_VMMAP:
17842       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17843     case NT_FREEBSD_PROCSTAT_GROUPS:
17844       return _("NT_PROCSTAT_GROUPS (groups data)");
17845     case NT_FREEBSD_PROCSTAT_UMASK:
17846       return _("NT_PROCSTAT_UMASK (umask data)");
17847     case NT_FREEBSD_PROCSTAT_RLIMIT:
17848       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17849     case NT_FREEBSD_PROCSTAT_OSREL:
17850       return _("NT_PROCSTAT_OSREL (osreldate data)");
17851     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17852       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17853     case NT_FREEBSD_PROCSTAT_AUXV:
17854       return _("NT_PROCSTAT_AUXV (auxv data)");
17855     case NT_FREEBSD_PTLWPINFO:
17856       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17857     }
17858   return get_note_type (filedata, e_type);
17859 }
17860
17861 static const char *
17862 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17863 {
17864   static char buff[64];
17865
17866   if (e_type == NT_NETBSDCORE_PROCINFO)
17867     return _("NetBSD procinfo structure");
17868
17869   /* As of Jan 2002 there are no other machine-independent notes
17870      defined for NetBSD core files.  If the note type is less
17871      than the start of the machine-dependent note types, we don't
17872      understand it.  */
17873
17874   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17875     {
17876       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17877       return buff;
17878     }
17879
17880   switch (filedata->file_header.e_machine)
17881     {
17882     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17883        and PT_GETFPREGS == mach+2.  */
17884
17885     case EM_OLD_ALPHA:
17886     case EM_ALPHA:
17887     case EM_SPARC:
17888     case EM_SPARC32PLUS:
17889     case EM_SPARCV9:
17890       switch (e_type)
17891         {
17892         case NT_NETBSDCORE_FIRSTMACH + 0:
17893           return _("PT_GETREGS (reg structure)");
17894         case NT_NETBSDCORE_FIRSTMACH + 2:
17895           return _("PT_GETFPREGS (fpreg structure)");
17896         default:
17897           break;
17898         }
17899       break;
17900
17901     /* On all other arch's, PT_GETREGS == mach+1 and
17902        PT_GETFPREGS == mach+3.  */
17903     default:
17904       switch (e_type)
17905         {
17906         case NT_NETBSDCORE_FIRSTMACH + 1:
17907           return _("PT_GETREGS (reg structure)");
17908         case NT_NETBSDCORE_FIRSTMACH + 3:
17909           return _("PT_GETFPREGS (fpreg structure)");
17910         default:
17911           break;
17912         }
17913     }
17914
17915   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17916             e_type - NT_NETBSDCORE_FIRSTMACH);
17917   return buff;
17918 }
17919
17920 static const char *
17921 get_stapsdt_note_type (unsigned e_type)
17922 {
17923   static char buff[64];
17924
17925   switch (e_type)
17926     {
17927     case NT_STAPSDT:
17928       return _("NT_STAPSDT (SystemTap probe descriptors)");
17929
17930     default:
17931       break;
17932     }
17933
17934   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17935   return buff;
17936 }
17937
17938 static bfd_boolean
17939 print_stapsdt_note (Elf_Internal_Note *pnote)
17940 {
17941   size_t len, maxlen;
17942   unsigned long addr_size = is_32bit_elf ? 4 : 8;
17943   char *data = pnote->descdata;
17944   char *data_end = pnote->descdata + pnote->descsz;
17945   bfd_vma pc, base_addr, semaphore;
17946   char *provider, *probe, *arg_fmt;
17947
17948   if (pnote->descsz < (addr_size * 3))
17949     goto stapdt_note_too_small;
17950
17951   pc = byte_get ((unsigned char *) data, addr_size);
17952   data += addr_size;
17953
17954   base_addr = byte_get ((unsigned char *) data, addr_size);
17955   data += addr_size;
17956
17957   semaphore = byte_get ((unsigned char *) data, addr_size);
17958   data += addr_size;
17959
17960   if (data >= data_end)
17961     goto stapdt_note_too_small;
17962   maxlen = data_end - data;
17963   len = strnlen (data, maxlen);
17964   if (len < maxlen)
17965     {
17966       provider = data;
17967       data += len + 1;
17968     }
17969   else
17970     goto stapdt_note_too_small;
17971
17972   if (data >= data_end)
17973     goto stapdt_note_too_small;
17974   maxlen = data_end - data;
17975   len = strnlen (data, maxlen);
17976   if (len < maxlen)
17977     {
17978       probe = data;
17979       data += len + 1;
17980     }
17981   else
17982     goto stapdt_note_too_small;
17983
17984   if (data >= data_end)
17985     goto stapdt_note_too_small;
17986   maxlen = data_end - data;
17987   len = strnlen (data, maxlen);
17988   if (len < maxlen)
17989     {
17990       arg_fmt = data;
17991       data += len + 1;
17992     }
17993   else
17994     goto stapdt_note_too_small;
17995
17996   printf (_("    Provider: %s\n"), provider);
17997   printf (_("    Name: %s\n"), probe);
17998   printf (_("    Location: "));
17999   print_vma (pc, FULL_HEX);
18000   printf (_(", Base: "));
18001   print_vma (base_addr, FULL_HEX);
18002   printf (_(", Semaphore: "));
18003   print_vma (semaphore, FULL_HEX);
18004   printf ("\n");
18005   printf (_("    Arguments: %s\n"), arg_fmt);
18006
18007   return data == data_end;
18008
18009  stapdt_note_too_small:
18010   printf (_("  <corrupt - note is too small>\n"));
18011   error (_("corrupt stapdt note - the data size is too small\n"));
18012   return FALSE;
18013 }
18014
18015 static const char *
18016 get_ia64_vms_note_type (unsigned e_type)
18017 {
18018   static char buff[64];
18019
18020   switch (e_type)
18021     {
18022     case NT_VMS_MHD:
18023       return _("NT_VMS_MHD (module header)");
18024     case NT_VMS_LNM:
18025       return _("NT_VMS_LNM (language name)");
18026     case NT_VMS_SRC:
18027       return _("NT_VMS_SRC (source files)");
18028     case NT_VMS_TITLE:
18029       return "NT_VMS_TITLE";
18030     case NT_VMS_EIDC:
18031       return _("NT_VMS_EIDC (consistency check)");
18032     case NT_VMS_FPMODE:
18033       return _("NT_VMS_FPMODE (FP mode)");
18034     case NT_VMS_LINKTIME:
18035       return "NT_VMS_LINKTIME";
18036     case NT_VMS_IMGNAM:
18037       return _("NT_VMS_IMGNAM (image name)");
18038     case NT_VMS_IMGID:
18039       return _("NT_VMS_IMGID (image id)");
18040     case NT_VMS_LINKID:
18041       return _("NT_VMS_LINKID (link id)");
18042     case NT_VMS_IMGBID:
18043       return _("NT_VMS_IMGBID (build id)");
18044     case NT_VMS_GSTNAM:
18045       return _("NT_VMS_GSTNAM (sym table name)");
18046     case NT_VMS_ORIG_DYN:
18047       return "NT_VMS_ORIG_DYN";
18048     case NT_VMS_PATCHTIME:
18049       return "NT_VMS_PATCHTIME";
18050     default:
18051       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18052       return buff;
18053     }
18054 }
18055
18056 static bfd_boolean
18057 print_ia64_vms_note (Elf_Internal_Note * pnote)
18058 {
18059   int maxlen = pnote->descsz;
18060
18061   if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
18062     goto desc_size_fail;
18063
18064   switch (pnote->type)
18065     {
18066     case NT_VMS_MHD:
18067       if (maxlen <= 36)
18068         goto desc_size_fail;
18069
18070       int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
18071
18072       printf (_("    Creation date  : %.17s\n"), pnote->descdata);
18073       printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
18074       if (l + 34 < maxlen)
18075         {
18076           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
18077           if (l + 35 < maxlen)
18078             printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
18079           else
18080             printf (_("    Module version : <missing>\n"));
18081         }
18082       else
18083         {
18084           printf (_("    Module name    : <missing>\n"));
18085           printf (_("    Module version : <missing>\n"));
18086         }
18087       break;
18088
18089     case NT_VMS_LNM:
18090       printf (_("   Language: %.*s\n"), maxlen, pnote->descdata);
18091       break;
18092
18093 #ifdef BFD64
18094     case NT_VMS_FPMODE:
18095       printf (_("   Floating Point mode: "));
18096       if (maxlen < 8)
18097         goto desc_size_fail;
18098       /* FIXME: Generate an error if descsz > 8 ?  */
18099
18100       printf ("0x%016" BFD_VMA_FMT "x\n",
18101               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
18102       break;
18103
18104     case NT_VMS_LINKTIME:
18105       printf (_("   Link time: "));
18106       if (maxlen < 8)
18107         goto desc_size_fail;
18108       /* FIXME: Generate an error if descsz > 8 ?  */
18109
18110       print_vms_time
18111         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18112       printf ("\n");
18113       break;
18114
18115     case NT_VMS_PATCHTIME:
18116       printf (_("   Patch time: "));
18117       if (maxlen < 8)
18118         goto desc_size_fail;
18119       /* FIXME: Generate an error if descsz > 8 ?  */
18120
18121       print_vms_time
18122         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18123       printf ("\n");
18124       break;
18125
18126     case NT_VMS_ORIG_DYN:
18127       if (maxlen < 34)
18128         goto desc_size_fail;
18129
18130       printf (_("   Major id: %u,  minor id: %u\n"),
18131               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
18132               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
18133       printf (_("   Last modified  : "));
18134       print_vms_time
18135         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
18136       printf (_("\n   Link flags  : "));
18137       printf ("0x%016" BFD_VMA_FMT "x\n",
18138               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
18139       printf (_("   Header flags: 0x%08x\n"),
18140               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
18141       printf (_("   Image id    : %.*s\n"), maxlen - 32, pnote->descdata + 32);
18142       break;
18143 #endif
18144
18145     case NT_VMS_IMGNAM:
18146       printf (_("    Image name: %.*s\n"), maxlen, pnote->descdata);
18147       break;
18148
18149     case NT_VMS_GSTNAM:
18150       printf (_("    Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
18151       break;
18152
18153     case NT_VMS_IMGID:
18154       printf (_("    Image id: %.*s\n"), maxlen, pnote->descdata);
18155       break;
18156
18157     case NT_VMS_LINKID:
18158       printf (_("    Linker id: %.*s\n"), maxlen, pnote->descdata);
18159       break;
18160
18161     default:
18162       return FALSE;
18163     }
18164
18165   return TRUE;
18166
18167  desc_size_fail:
18168   printf (_("  <corrupt - data size is too small>\n"));
18169   error (_("corrupt IA64 note: data size is too small\n"));
18170   return FALSE;
18171 }
18172
18173 /* Find the symbol associated with a build attribute that is attached
18174    to address OFFSET.  If PNAME is non-NULL then store the name of
18175    the symbol (if found) in the provided pointer,  Returns NULL if a
18176    symbol could not be found.  */
18177
18178 static Elf_Internal_Sym *
18179 get_symbol_for_build_attribute (Filedata *       filedata,
18180                                 unsigned long    offset,
18181                                 bfd_boolean      is_open_attr,
18182                                 const char **    pname)
18183 {
18184   static Filedata *         saved_filedata = NULL;
18185   static char *             strtab;
18186   static unsigned long      strtablen;
18187   static Elf_Internal_Sym * symtab;
18188   static unsigned long      nsyms;
18189   Elf_Internal_Sym *        saved_sym = NULL;
18190   Elf_Internal_Sym *        sym;
18191
18192   if (filedata->section_headers != NULL
18193       && (saved_filedata == NULL || filedata != saved_filedata))
18194     {
18195       Elf_Internal_Shdr * symsec;
18196
18197       /* Load the symbol and string sections.  */
18198       for (symsec = filedata->section_headers;
18199            symsec < filedata->section_headers + filedata->file_header.e_shnum;
18200            symsec ++)
18201         {
18202           if (symsec->sh_type == SHT_SYMTAB)
18203             {
18204               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
18205
18206               if (symsec->sh_link < filedata->file_header.e_shnum)
18207                 {
18208                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
18209
18210                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
18211                                               1, strtab_sec->sh_size,
18212                                               _("string table"));
18213                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
18214                 }
18215             }
18216         }
18217       saved_filedata = filedata;
18218     }
18219
18220   if (symtab == NULL || strtab == NULL)
18221     return NULL;
18222
18223   /* Find a symbol whose value matches offset.  */
18224   for (sym = symtab; sym < symtab + nsyms; sym ++)
18225     if (sym->st_value == offset)
18226       {
18227         if (sym->st_name >= strtablen)
18228           /* Huh ?  This should not happen.  */
18229           continue;
18230
18231         if (strtab[sym->st_name] == 0)
18232           continue;
18233
18234         /* The AArch64 and ARM architectures define mapping symbols
18235            (eg $d, $x, $t) which we want to ignore.  */
18236         if (strtab[sym->st_name] == '$'
18237             && strtab[sym->st_name + 1] != 0
18238             && strtab[sym->st_name + 2] == 0)
18239           continue;
18240
18241         if (is_open_attr)
18242           {
18243             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18244                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
18245                FUNC symbols entirely.  */
18246             switch (ELF_ST_TYPE (sym->st_info))
18247               {
18248               case STT_OBJECT:
18249               case STT_FILE:
18250                 saved_sym = sym;
18251                 if (sym->st_size)
18252                   {
18253                     /* If the symbol has a size associated
18254                        with it then we can stop searching.  */
18255                     sym = symtab + nsyms;
18256                   }
18257                 continue;
18258
18259               case STT_FUNC:
18260                 /* Ignore function symbols.  */
18261                 continue;
18262
18263               default:
18264                 break;
18265               }
18266
18267             switch (ELF_ST_BIND (sym->st_info))
18268               {
18269               case STB_GLOBAL:
18270                 if (saved_sym == NULL
18271                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18272                   saved_sym = sym;
18273                 break;
18274
18275               case STB_LOCAL:
18276                 if (saved_sym == NULL)
18277                   saved_sym = sym;
18278                 break;
18279
18280               default:
18281                 break;
18282               }
18283           }
18284         else
18285           {
18286             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18287               continue;
18288
18289             saved_sym = sym;
18290             break;
18291           }
18292       }
18293
18294   if (saved_sym && pname)
18295     * pname = strtab + saved_sym->st_name;
18296
18297   return saved_sym;
18298 }
18299
18300 /* Returns true iff addr1 and addr2 are in the same section.  */
18301
18302 static bfd_boolean
18303 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18304 {
18305   Elf_Internal_Shdr * a1;
18306   Elf_Internal_Shdr * a2;
18307
18308   a1 = find_section_by_address (filedata, addr1);
18309   a2 = find_section_by_address (filedata, addr2);
18310
18311   return a1 == a2 && a1 != NULL;
18312 }
18313
18314 static bfd_boolean
18315 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
18316                                        Filedata *           filedata)
18317 {
18318   static unsigned long  global_offset = 0;
18319   static unsigned long  global_end = 0;
18320   static unsigned long  func_offset = 0;
18321   static unsigned long  func_end = 0;
18322
18323   Elf_Internal_Sym *    sym;
18324   const char *          name;
18325   unsigned long         start;
18326   unsigned long         end;
18327   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18328
18329   switch (pnote->descsz)
18330     {
18331     case 0:
18332       /* A zero-length description means that the range of
18333          the previous note of the same type should be used.  */
18334       if (is_open_attr)
18335         {
18336           if (global_end > global_offset)
18337             printf (_("    Applies to region from %#lx to %#lx\n"),
18338                     global_offset, global_end);
18339           else
18340             printf (_("    Applies to region from %#lx\n"), global_offset);
18341         }
18342       else
18343         {
18344           if (func_end > func_offset)
18345             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18346           else
18347             printf (_("    Applies to region from %#lx\n"), func_offset);
18348         }
18349       return TRUE;
18350
18351     case 4:
18352       start = byte_get ((unsigned char *) pnote->descdata, 4);
18353       end = 0;
18354       break;
18355
18356     case 8:
18357       if (is_32bit_elf)
18358         {
18359           /* FIXME: We should check that version 3+ notes are being used here...  */
18360           start = byte_get ((unsigned char *) pnote->descdata, 4);
18361           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18362         }
18363       else
18364         {
18365           start = byte_get ((unsigned char *) pnote->descdata, 8);
18366           end = 0;
18367         }
18368       break;
18369
18370     case 16:
18371       start = byte_get ((unsigned char *) pnote->descdata, 8);
18372       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18373       break;
18374
18375     default:
18376       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
18377       printf (_("    <invalid descsz>"));
18378       return FALSE;
18379     }
18380
18381   name = NULL;
18382   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18383   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18384      in order to avoid them being confused with the start address of the
18385      first function in the file...  */
18386   if (sym == NULL && is_open_attr)
18387     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18388                                           & name);
18389
18390   if (end == 0 && sym != NULL && sym->st_size > 0)
18391     end = start + sym->st_size;
18392
18393   if (is_open_attr)
18394     {
18395       /* FIXME: Need to properly allow for section alignment.
18396          16 is just the alignment used on x86_64.  */
18397       if (global_end > 0
18398           && start > BFD_ALIGN (global_end, 16)
18399           /* Build notes are not guaranteed to be organised in order of
18400              increasing address, but we should find the all of the notes
18401              for one section in the same place.  */
18402           && same_section (filedata, start, global_end))
18403         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18404               global_end + 1, start - 1);
18405
18406       printf (_("    Applies to region from %#lx"), start);
18407       global_offset = start;
18408
18409       if (end)
18410         {
18411           printf (_(" to %#lx"), end);
18412           global_end = end;
18413         }
18414     }
18415   else
18416     {
18417       printf (_("    Applies to region from %#lx"), start);
18418       func_offset = start;
18419
18420       if (end)
18421         {
18422           printf (_(" to %#lx"), end);
18423           func_end = end;
18424         }
18425     }
18426
18427   if (sym && name)
18428     printf (_(" (%s)"), name);
18429
18430   printf ("\n");
18431   return TRUE;
18432 }
18433
18434 static bfd_boolean
18435 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18436 {
18437   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18438   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18439   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18440   char         name_type;
18441   char         name_attribute;
18442   const char * expected_types;
18443   const char * name = pnote->namedata;
18444   const char * text;
18445   signed int   left;
18446
18447   if (name == NULL || pnote->namesz < 2)
18448     {
18449       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18450       print_symbol (-20, _("  <corrupt name>"));
18451       return FALSE;
18452     }
18453
18454   if (do_wide)
18455     left = 28;
18456   else
18457     left = 20;
18458
18459   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
18460   if (name[0] == 'G' && name[1] == 'A')
18461     {
18462       if (pnote->namesz < 4)
18463         {
18464           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18465           print_symbol (-20, _("  <corrupt name>"));
18466           return FALSE;
18467         }
18468
18469       printf ("GA");
18470       name += 2;
18471       left -= 2;
18472     }
18473
18474   switch ((name_type = * name))
18475     {
18476     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18477     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18478     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18479     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18480       printf ("%c", * name);
18481       left --;
18482       break;
18483     default:
18484       error (_("unrecognised attribute type in name field: %d\n"), name_type);
18485       print_symbol (-20, _("<unknown name type>"));
18486       return FALSE;
18487     }
18488
18489   ++ name;
18490   text = NULL;
18491
18492   switch ((name_attribute = * name))
18493     {
18494     case GNU_BUILD_ATTRIBUTE_VERSION:
18495       text = _("<version>");
18496       expected_types = string_expected;
18497       ++ name;
18498       break;
18499     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18500       text = _("<stack prot>");
18501       expected_types = "!+*";
18502       ++ name;
18503       break;
18504     case GNU_BUILD_ATTRIBUTE_RELRO:
18505       text = _("<relro>");
18506       expected_types = bool_expected;
18507       ++ name;
18508       break;
18509     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18510       text = _("<stack size>");
18511       expected_types = number_expected;
18512       ++ name;
18513       break;
18514     case GNU_BUILD_ATTRIBUTE_TOOL:
18515       text = _("<tool>");
18516       expected_types = string_expected;
18517       ++ name;
18518       break;
18519     case GNU_BUILD_ATTRIBUTE_ABI:
18520       text = _("<ABI>");
18521       expected_types = "$*";
18522       ++ name;
18523       break;
18524     case GNU_BUILD_ATTRIBUTE_PIC:
18525       text = _("<PIC>");
18526       expected_types = number_expected;
18527       ++ name;
18528       break;
18529     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18530       text = _("<short enum>");
18531       expected_types = bool_expected;
18532       ++ name;
18533       break;
18534     default:
18535       if (ISPRINT (* name))
18536         {
18537           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18538
18539           if (len > left && ! do_wide)
18540             len = left;
18541           printf ("%.*s:", len, name);
18542           left -= len;
18543           name += len;
18544         }
18545       else
18546         {
18547           static char tmpbuf [128];
18548
18549           error (_("unrecognised byte in name field: %d\n"), * name);
18550           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18551           text = tmpbuf;
18552           name ++;
18553         }
18554       expected_types = "*$!+";
18555       break;
18556     }
18557
18558   if (text)
18559     left -= printf ("%s", text);
18560
18561   if (strchr (expected_types, name_type) == NULL)
18562     warn (_("attribute does not have an expected type (%c)\n"), name_type);
18563
18564   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18565     {
18566       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18567              (unsigned long) pnote->namesz,
18568              (long) (name - pnote->namedata));
18569       return FALSE;
18570     }
18571
18572   if (left < 1 && ! do_wide)
18573     return TRUE;
18574
18575   switch (name_type)
18576     {
18577     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18578       {
18579         unsigned int        bytes;
18580         unsigned long long  val = 0;
18581         unsigned int        shift = 0;
18582         char *              decoded = NULL;
18583
18584         bytes = pnote->namesz - (name - pnote->namedata);
18585         if (bytes > 0)
18586           /* The -1 is because the name field is always 0 terminated, and we
18587              want to be able to ensure that the shift in the while loop below
18588              will not overflow.  */
18589           -- bytes;
18590
18591         if (bytes > sizeof (val))
18592           {
18593             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18594                    bytes);
18595             bytes = sizeof (val);
18596           }
18597         /* We do not bother to warn if bytes == 0 as this can
18598            happen with some early versions of the gcc plugin.  */
18599
18600         while (bytes --)
18601           {
18602             unsigned long byte = (* name ++) & 0xff;
18603
18604             val |= byte << shift;
18605             shift += 8;
18606           }
18607
18608         switch (name_attribute)
18609           {
18610           case GNU_BUILD_ATTRIBUTE_PIC:
18611             switch (val)
18612               {
18613               case 0: decoded = "static"; break;
18614               case 1: decoded = "pic"; break;
18615               case 2: decoded = "PIC"; break;
18616               case 3: decoded = "pie"; break;
18617               case 4: decoded = "PIE"; break;
18618               default: break;
18619               }
18620             break;
18621           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18622             switch (val)
18623               {
18624                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
18625               case 0: decoded = "off"; break;
18626               case 1: decoded = "on"; break;
18627               case 2: decoded = "all"; break;
18628               case 3: decoded = "strong"; break;
18629               case 4: decoded = "explicit"; break;
18630               default: break;
18631               }
18632             break;
18633           default:
18634             break;
18635           }
18636
18637         if (decoded != NULL)
18638           {
18639             print_symbol (-left, decoded);
18640             left = 0;
18641           }
18642         else if (val == 0)
18643           {
18644             printf ("0x0");
18645             left -= 3;
18646           }
18647         else
18648           {
18649             if (do_wide)
18650               left -= printf ("0x%llx", val);
18651             else
18652               left -= printf ("0x%-.*llx", left, val);
18653           }
18654       }
18655       break;
18656     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18657       left -= print_symbol (- left, name);
18658       break;
18659     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18660       left -= print_symbol (- left, "true");
18661       break;
18662     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18663       left -= print_symbol (- left, "false");
18664       break;
18665     }
18666
18667   if (do_wide && left > 0)
18668     printf ("%-*s", left, " ");
18669
18670   return TRUE;
18671 }
18672
18673 /* Note that by the ELF standard, the name field is already null byte
18674    terminated, and namesz includes the terminating null byte.
18675    I.E. the value of namesz for the name "FSF" is 4.
18676
18677    If the value of namesz is zero, there is no name present.  */
18678
18679 static bfd_boolean
18680 process_note (Elf_Internal_Note *  pnote,
18681               Filedata *           filedata)
18682 {
18683   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18684   const char * nt;
18685
18686   if (pnote->namesz == 0)
18687     /* If there is no note name, then use the default set of
18688        note type strings.  */
18689     nt = get_note_type (filedata, pnote->type);
18690
18691   else if (const_strneq (pnote->namedata, "GNU"))
18692     /* GNU-specific object file notes.  */
18693     nt = get_gnu_elf_note_type (pnote->type);
18694
18695   else if (const_strneq (pnote->namedata, "FreeBSD"))
18696     /* FreeBSD-specific core file notes.  */
18697     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18698
18699   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18700     /* NetBSD-specific core file notes.  */
18701     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18702
18703   else if (const_strneq (pnote->namedata, "NetBSD"))
18704     /* NetBSD-specific core file notes.  */
18705     return process_netbsd_elf_note (pnote);
18706
18707   else if (strneq (pnote->namedata, "SPU/", 4))
18708     {
18709       /* SPU-specific core file notes.  */
18710       nt = pnote->namedata + 4;
18711       name = "SPU";
18712     }
18713
18714   else if (const_strneq (pnote->namedata, "IPF/VMS"))
18715     /* VMS/ia64-specific file notes.  */
18716     nt = get_ia64_vms_note_type (pnote->type);
18717
18718   else if (const_strneq (pnote->namedata, "stapsdt"))
18719     nt = get_stapsdt_note_type (pnote->type);
18720
18721   else
18722     /* Don't recognize this note name; just use the default set of
18723        note type strings.  */
18724     nt = get_note_type (filedata, pnote->type);
18725
18726   printf ("  ");
18727
18728   if (((const_strneq (pnote->namedata, "GA")
18729         && strchr ("*$!+", pnote->namedata[2]) != NULL)
18730        || strchr ("*$!+", pnote->namedata[0]) != NULL)
18731       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18732           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18733     print_gnu_build_attribute_name (pnote);
18734   else
18735     print_symbol (-20, name);
18736
18737   if (do_wide)
18738     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18739   else
18740     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18741
18742   if (const_strneq (pnote->namedata, "IPF/VMS"))
18743     return print_ia64_vms_note (pnote);
18744   else if (const_strneq (pnote->namedata, "GNU"))
18745     return print_gnu_note (filedata, pnote);
18746   else if (const_strneq (pnote->namedata, "stapsdt"))
18747     return print_stapsdt_note (pnote);
18748   else if (const_strneq (pnote->namedata, "CORE"))
18749     return print_core_note (pnote);
18750   else if (((const_strneq (pnote->namedata, "GA")
18751              && strchr ("*$!+", pnote->namedata[2]) != NULL)
18752             || strchr ("*$!+", pnote->namedata[0]) != NULL)
18753            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18754                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18755     return print_gnu_build_attribute_description (pnote, filedata);
18756
18757   if (pnote->descsz)
18758     {
18759       unsigned long i;
18760
18761       printf (_("   description data: "));
18762       for (i = 0; i < pnote->descsz; i++)
18763         printf ("%02x ", pnote->descdata[i]);
18764       if (!do_wide)
18765         printf ("\n");
18766     }
18767
18768   if (do_wide)
18769     printf ("\n");
18770
18771   return TRUE;
18772 }
18773
18774 static bfd_boolean
18775 process_notes_at (Filedata *           filedata,
18776                   Elf_Internal_Shdr *  section,
18777                   bfd_vma              offset,
18778                   bfd_vma              length,
18779                   bfd_vma              align)
18780 {
18781   Elf_External_Note * pnotes;
18782   Elf_External_Note * external;
18783   char *              end;
18784   bfd_boolean         res = TRUE;
18785
18786   if (length <= 0)
18787     return FALSE;
18788
18789   if (section)
18790     {
18791       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18792       if (pnotes)
18793         {
18794           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18795             return FALSE;
18796         }
18797     }
18798   else
18799     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18800                                              _("notes"));
18801
18802   if (pnotes == NULL)
18803     return FALSE;
18804
18805   external = pnotes;
18806
18807   if (section)
18808     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18809   else
18810     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18811             (unsigned long) offset, (unsigned long) length);
18812
18813   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18814      specifies that notes should be aligned to 4 bytes in 32-bit
18815      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18816      we also support 4 byte alignment in 64-bit objects.  If section
18817      alignment is less than 4, we treate alignment as 4 bytes.   */
18818   if (align < 4)
18819     align = 4;
18820   else if (align != 4 && align != 8)
18821     {
18822       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18823             (long) align);
18824       return FALSE;
18825     }
18826
18827   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18828
18829   end = (char *) pnotes + length;
18830   while ((char *) external < end)
18831     {
18832       Elf_Internal_Note inote;
18833       size_t min_notesz;
18834       char * next;
18835       char * temp = NULL;
18836       size_t data_remaining = end - (char *) external;
18837
18838       if (!is_ia64_vms (filedata))
18839         {
18840           /* PR binutils/15191
18841              Make sure that there is enough data to read.  */
18842           min_notesz = offsetof (Elf_External_Note, name);
18843           if (data_remaining < min_notesz)
18844             {
18845               warn (ngettext ("Corrupt note: only %ld byte remains, "
18846                               "not enough for a full note\n",
18847                               "Corrupt note: only %ld bytes remain, "
18848                               "not enough for a full note\n",
18849                               data_remaining),
18850                     (long) data_remaining);
18851               break;
18852             }
18853           data_remaining -= min_notesz;
18854
18855           inote.type     = BYTE_GET (external->type);
18856           inote.namesz   = BYTE_GET (external->namesz);
18857           inote.namedata = external->name;
18858           inote.descsz   = BYTE_GET (external->descsz);
18859           inote.descdata = ((char *) external
18860                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18861           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18862           next = ((char *) external
18863                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18864         }
18865       else
18866         {
18867           Elf64_External_VMS_Note *vms_external;
18868
18869           /* PR binutils/15191
18870              Make sure that there is enough data to read.  */
18871           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18872           if (data_remaining < min_notesz)
18873             {
18874               warn (ngettext ("Corrupt note: only %ld byte remains, "
18875                               "not enough for a full note\n",
18876                               "Corrupt note: only %ld bytes remain, "
18877                               "not enough for a full note\n",
18878                               data_remaining),
18879                     (long) data_remaining);
18880               break;
18881             }
18882           data_remaining -= min_notesz;
18883
18884           vms_external = (Elf64_External_VMS_Note *) external;
18885           inote.type     = BYTE_GET (vms_external->type);
18886           inote.namesz   = BYTE_GET (vms_external->namesz);
18887           inote.namedata = vms_external->name;
18888           inote.descsz   = BYTE_GET (vms_external->descsz);
18889           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18890           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18891           next = inote.descdata + align_power (inote.descsz, 3);
18892         }
18893
18894       /* PR 17531: file: 3443835e.  */
18895       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18896       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18897           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18898           || (size_t) (next - inote.descdata) < inote.descsz
18899           || ((size_t) (next - inote.descdata)
18900               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18901         {
18902           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18903                 (unsigned long) ((char *) external - (char *) pnotes));
18904           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18905                 inote.type, inote.namesz, inote.descsz, (int) align);
18906           break;
18907         }
18908
18909       external = (Elf_External_Note *) next;
18910
18911       /* Verify that name is null terminated.  It appears that at least
18912          one version of Linux (RedHat 6.0) generates corefiles that don't
18913          comply with the ELF spec by failing to include the null byte in
18914          namesz.  */
18915       if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
18916         {
18917           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18918             {
18919               temp = (char *) malloc (inote.namesz + 1);
18920               if (temp == NULL)
18921                 {
18922                   error (_("Out of memory allocating space for inote name\n"));
18923                   res = FALSE;
18924                   break;
18925                 }
18926
18927               memcpy (temp, inote.namedata, inote.namesz);
18928               inote.namedata = temp;
18929             }
18930           inote.namedata[inote.namesz] = 0;
18931         }
18932
18933       if (! process_note (& inote, filedata))
18934         res = FALSE;
18935
18936       if (temp != NULL)
18937         {
18938           free (temp);
18939           temp = NULL;
18940         }
18941     }
18942
18943   free (pnotes);
18944
18945   return res;
18946 }
18947
18948 static bfd_boolean
18949 process_corefile_note_segments (Filedata * filedata)
18950 {
18951   Elf_Internal_Phdr * segment;
18952   unsigned int i;
18953   bfd_boolean res = TRUE;
18954
18955   if (! get_program_headers (filedata))
18956     return TRUE;
18957
18958   for (i = 0, segment = filedata->program_headers;
18959        i < filedata->file_header.e_phnum;
18960        i++, segment++)
18961     {
18962       if (segment->p_type == PT_NOTE)
18963         if (! process_notes_at (filedata, NULL,
18964                                 (bfd_vma) segment->p_offset,
18965                                 (bfd_vma) segment->p_filesz,
18966                                 (bfd_vma) segment->p_align))
18967           res = FALSE;
18968     }
18969
18970   return res;
18971 }
18972
18973 static bfd_boolean
18974 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18975 {
18976   Elf_External_Note * pnotes;
18977   Elf_External_Note * external;
18978   char * end;
18979   bfd_boolean res = TRUE;
18980
18981   if (length <= 0)
18982     return FALSE;
18983
18984   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18985                                            _("v850 notes"));
18986   if (pnotes == NULL)
18987     return FALSE;
18988
18989   external = pnotes;
18990   end = (char*) pnotes + length;
18991
18992   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18993           (unsigned long) offset, (unsigned long) length);
18994
18995   while ((char *) external + sizeof (Elf_External_Note) < end)
18996     {
18997       Elf_External_Note * next;
18998       Elf_Internal_Note inote;
18999
19000       inote.type     = BYTE_GET (external->type);
19001       inote.namesz   = BYTE_GET (external->namesz);
19002       inote.namedata = external->name;
19003       inote.descsz   = BYTE_GET (external->descsz);
19004       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
19005       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19006
19007       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
19008         {
19009           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
19010           inote.descdata = inote.namedata;
19011           inote.namesz   = 0;
19012         }
19013
19014       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
19015
19016       if (   ((char *) next > end)
19017           || ((char *) next <  (char *) pnotes))
19018         {
19019           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19020                 (unsigned long) ((char *) external - (char *) pnotes));
19021           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19022                 inote.type, inote.namesz, inote.descsz);
19023           break;
19024         }
19025
19026       external = next;
19027
19028       /* Prevent out-of-bounds indexing.  */
19029       if (   inote.namedata + inote.namesz > end
19030           || inote.namedata + inote.namesz < inote.namedata)
19031         {
19032           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19033                 (unsigned long) ((char *) external - (char *) pnotes));
19034           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19035                 inote.type, inote.namesz, inote.descsz);
19036           break;
19037         }
19038
19039       printf ("  %s: ", get_v850_elf_note_type (inote.type));
19040
19041       if (! print_v850_note (& inote))
19042         {
19043           res = FALSE;
19044           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19045                   inote.namesz, inote.descsz);
19046         }
19047     }
19048
19049   free (pnotes);
19050
19051   return res;
19052 }
19053
19054 static bfd_boolean
19055 process_note_sections (Filedata * filedata)
19056 {
19057   Elf_Internal_Shdr * section;
19058   unsigned long i;
19059   unsigned int n = 0;
19060   bfd_boolean res = TRUE;
19061
19062   for (i = 0, section = filedata->section_headers;
19063        i < filedata->file_header.e_shnum && section != NULL;
19064        i++, section++)
19065     {
19066       if (section->sh_type == SHT_NOTE)
19067         {
19068           if (! process_notes_at (filedata, section,
19069                                   (bfd_vma) section->sh_offset,
19070                                   (bfd_vma) section->sh_size,
19071                                   (bfd_vma) section->sh_addralign))
19072             res = FALSE;
19073           n++;
19074         }
19075
19076       if ((   filedata->file_header.e_machine == EM_V800
19077            || filedata->file_header.e_machine == EM_V850
19078            || filedata->file_header.e_machine == EM_CYGNUS_V850)
19079           && section->sh_type == SHT_RENESAS_INFO)
19080         {
19081           if (! process_v850_notes (filedata,
19082                                     (bfd_vma) section->sh_offset,
19083                                     (bfd_vma) section->sh_size))
19084             res = FALSE;
19085           n++;
19086         }
19087     }
19088
19089   if (n == 0)
19090     /* Try processing NOTE segments instead.  */
19091     return process_corefile_note_segments (filedata);
19092
19093   return res;
19094 }
19095
19096 static bfd_boolean
19097 process_notes (Filedata * filedata)
19098 {
19099   /* If we have not been asked to display the notes then do nothing.  */
19100   if (! do_notes)
19101     return TRUE;
19102
19103   if (filedata->file_header.e_type != ET_CORE)
19104     return process_note_sections (filedata);
19105
19106   /* No program headers means no NOTE segment.  */
19107   if (filedata->file_header.e_phnum > 0)
19108     return process_corefile_note_segments (filedata);
19109
19110   printf (_("No note segments present in the core file.\n"));
19111   return TRUE;
19112 }
19113
19114 static unsigned char *
19115 display_public_gnu_attributes (unsigned char * start,
19116                                const unsigned char * const end)
19117 {
19118   printf (_("  Unknown GNU attribute: %s\n"), start);
19119
19120   start += strnlen ((char *) start, end - start);
19121   display_raw_attribute (start, end);
19122
19123   return (unsigned char *) end;
19124 }
19125
19126 static unsigned char *
19127 display_generic_attribute (unsigned char * start,
19128                            unsigned int tag,
19129                            const unsigned char * const end)
19130 {
19131   if (tag == 0)
19132     return (unsigned char *) end;
19133
19134   return display_tag_value (tag, start, end);
19135 }
19136
19137 static bfd_boolean
19138 process_arch_specific (Filedata * filedata)
19139 {
19140   if (! do_arch)
19141     return TRUE;
19142
19143   switch (filedata->file_header.e_machine)
19144     {
19145     case EM_ARC:
19146     case EM_ARC_COMPACT:
19147     case EM_ARC_COMPACT2:
19148       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
19149                                  display_arc_attribute,
19150                                  display_generic_attribute);
19151     case EM_ARM:
19152       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
19153                                  display_arm_attribute,
19154                                  display_generic_attribute);
19155
19156     case EM_MIPS:
19157     case EM_MIPS_RS3_LE:
19158       return process_mips_specific (filedata);
19159
19160     case EM_MSP430:
19161      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
19162                                 display_msp430x_attribute,
19163                                 display_generic_attribute);
19164
19165     case EM_RISCV:
19166      return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
19167                                 display_riscv_attribute,
19168                                 display_generic_attribute);
19169
19170     case EM_NDS32:
19171       return process_nds32_specific (filedata);
19172
19173     case EM_PPC:
19174     case EM_PPC64:
19175       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19176                                  display_power_gnu_attribute);
19177
19178     case EM_S390:
19179     case EM_S390_OLD:
19180       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19181                                  display_s390_gnu_attribute);
19182
19183     case EM_SPARC:
19184     case EM_SPARC32PLUS:
19185     case EM_SPARCV9:
19186       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19187                                  display_sparc_gnu_attribute);
19188
19189     case EM_TI_C6000:
19190       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
19191                                  display_tic6x_attribute,
19192                                  display_generic_attribute);
19193
19194     default:
19195       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
19196                                  display_public_gnu_attributes,
19197                                  display_generic_attribute);
19198     }
19199 }
19200
19201 static bfd_boolean
19202 get_file_header (Filedata * filedata)
19203 {
19204   /* Read in the identity array.  */
19205   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
19206     return FALSE;
19207
19208   /* Determine how to read the rest of the header.  */
19209   switch (filedata->file_header.e_ident[EI_DATA])
19210     {
19211     default:
19212     case ELFDATANONE:
19213     case ELFDATA2LSB:
19214       byte_get = byte_get_little_endian;
19215       byte_put = byte_put_little_endian;
19216       break;
19217     case ELFDATA2MSB:
19218       byte_get = byte_get_big_endian;
19219       byte_put = byte_put_big_endian;
19220       break;
19221     }
19222
19223   /* For now we only support 32 bit and 64 bit ELF files.  */
19224   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
19225
19226   /* Read in the rest of the header.  */
19227   if (is_32bit_elf)
19228     {
19229       Elf32_External_Ehdr ehdr32;
19230
19231       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
19232         return FALSE;
19233
19234       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
19235       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
19236       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
19237       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
19238       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
19239       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
19240       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
19241       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
19242       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
19243       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
19244       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
19245       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
19246       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
19247     }
19248   else
19249     {
19250       Elf64_External_Ehdr ehdr64;
19251
19252       /* If we have been compiled with sizeof (bfd_vma) == 4, then
19253          we will not be able to cope with the 64bit data found in
19254          64 ELF files.  Detect this now and abort before we start
19255          overwriting things.  */
19256       if (sizeof (bfd_vma) < 8)
19257         {
19258           error (_("This instance of readelf has been built without support for a\n\
19259 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19260           return FALSE;
19261         }
19262
19263       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
19264         return FALSE;
19265
19266       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
19267       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
19268       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
19269       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
19270       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
19271       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
19272       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
19273       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
19274       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19275       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
19276       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19277       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
19278       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
19279     }
19280
19281   if (filedata->file_header.e_shoff)
19282     {
19283       /* There may be some extensions in the first section header.  Don't
19284          bomb if we can't read it.  */
19285       if (is_32bit_elf)
19286         get_32bit_section_headers (filedata, TRUE);
19287       else
19288         get_64bit_section_headers (filedata, TRUE);
19289     }
19290
19291   return TRUE;
19292 }
19293
19294 static void
19295 close_file (Filedata * filedata)
19296 {
19297   if (filedata)
19298     {
19299       if (filedata->handle)
19300         fclose (filedata->handle);
19301       free (filedata);
19302     }
19303 }
19304
19305 void
19306 close_debug_file (void * data)
19307 {
19308   close_file ((Filedata *) data);
19309 }
19310
19311 static Filedata *
19312 open_file (const char * pathname)
19313 {
19314   struct stat  statbuf;
19315   Filedata *   filedata = NULL;
19316
19317   if (stat (pathname, & statbuf) < 0
19318       || ! S_ISREG (statbuf.st_mode))
19319     goto fail;
19320
19321   filedata = calloc (1, sizeof * filedata);
19322   if (filedata == NULL)
19323     goto fail;
19324
19325   filedata->handle = fopen (pathname, "rb");
19326   if (filedata->handle == NULL)
19327     goto fail;
19328
19329   filedata->file_size = (bfd_size_type) statbuf.st_size;
19330   filedata->file_name = pathname;
19331
19332   if (! get_file_header (filedata))
19333     goto fail;
19334
19335   if (filedata->file_header.e_shoff)
19336     {
19337       bfd_boolean res;
19338
19339       /* Read the section headers again, this time for real.  */
19340       if (is_32bit_elf)
19341         res = get_32bit_section_headers (filedata, FALSE);
19342       else
19343         res = get_64bit_section_headers (filedata, FALSE);
19344
19345       if (!res)
19346         goto fail;
19347     }
19348
19349   return filedata;
19350
19351  fail:
19352   if (filedata)
19353     {
19354       if (filedata->handle)
19355         fclose (filedata->handle);
19356       free (filedata);
19357     }
19358   return NULL;
19359 }
19360
19361 void *
19362 open_debug_file (const char * pathname)
19363 {
19364   return open_file (pathname);
19365 }
19366
19367 /* Process one ELF object file according to the command line options.
19368    This file may actually be stored in an archive.  The file is
19369    positioned at the start of the ELF object.  Returns TRUE if no
19370    problems were encountered, FALSE otherwise.  */
19371
19372 static bfd_boolean
19373 process_object (Filedata * filedata)
19374 {
19375   bfd_boolean  have_separate_files;
19376   unsigned int i;
19377   bfd_boolean res = TRUE;
19378
19379   if (! get_file_header (filedata))
19380     {
19381       error (_("%s: Failed to read file header\n"), filedata->file_name);
19382       return FALSE;
19383     }
19384
19385   /* Initialise per file variables.  */
19386   for (i = ARRAY_SIZE (version_info); i--;)
19387     version_info[i] = 0;
19388
19389   for (i = ARRAY_SIZE (dynamic_info); i--;)
19390     dynamic_info[i] = 0;
19391   dynamic_info_DT_GNU_HASH = 0;
19392
19393   /* Process the file.  */
19394   if (show_name)
19395     printf (_("\nFile: %s\n"), filedata->file_name);
19396
19397   /* Initialise the dump_sects array from the cmdline_dump_sects array.
19398      Note we do this even if cmdline_dump_sects is empty because we
19399      must make sure that the dump_sets array is zeroed out before each
19400      object file is processed.  */
19401   if (filedata->num_dump_sects > cmdline.num_dump_sects)
19402     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19403
19404   if (cmdline.num_dump_sects > 0)
19405     {
19406       if (filedata->num_dump_sects == 0)
19407         /* A sneaky way of allocating the dump_sects array.  */
19408         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19409
19410       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19411       memcpy (filedata->dump_sects, cmdline.dump_sects,
19412               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19413     }
19414
19415   if (! process_file_header (filedata))
19416     return FALSE;
19417
19418   if (! process_section_headers (filedata))
19419     {
19420       /* Without loaded section headers we cannot process lots of things.  */
19421       do_unwind = do_version = do_dump = do_arch = FALSE;
19422
19423       if (! do_using_dynamic)
19424         do_syms = do_dyn_syms = do_reloc = FALSE;
19425     }
19426
19427   if (! process_section_groups (filedata))
19428     /* Without loaded section groups we cannot process unwind.  */
19429     do_unwind = FALSE;
19430
19431   if (process_program_headers (filedata))
19432     process_dynamic_section (filedata);
19433   else
19434     res = FALSE;
19435
19436   if (! process_relocs (filedata))
19437     res = FALSE;
19438
19439   if (! process_unwind (filedata))
19440     res = FALSE;
19441
19442   if (! process_symbol_table (filedata))
19443     res = FALSE;
19444
19445   if (! process_syminfo (filedata))
19446     res = FALSE;
19447
19448   if (! process_version_sections (filedata))
19449     res = FALSE;
19450
19451   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19452     have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
19453   else
19454     have_separate_files = FALSE;
19455
19456   if (! process_section_contents (filedata))
19457     res = FALSE;
19458
19459   if (have_separate_files)
19460     {
19461       separate_info * d;
19462
19463       for (d = first_separate_info; d != NULL; d = d->next)
19464         {
19465           if (! process_section_headers (d->handle))
19466             res = FALSE;
19467           else if (! process_section_contents (d->handle))
19468             res = FALSE;
19469         }
19470
19471       /* The file handles are closed by the call to free_debug_memory() below.  */
19472     }
19473
19474   if (! process_notes (filedata))
19475     res = FALSE;
19476
19477   if (! process_gnu_liblist (filedata))
19478     res = FALSE;
19479
19480   if (! process_arch_specific (filedata))
19481     res = FALSE;
19482
19483   free (filedata->program_headers);
19484   filedata->program_headers = NULL;
19485
19486   free (filedata->section_headers);
19487   filedata->section_headers = NULL;
19488
19489   free (filedata->string_table);
19490   filedata->string_table = NULL;
19491   filedata->string_table_length = 0;
19492
19493   if (dynamic_strings)
19494     {
19495       free (dynamic_strings);
19496       dynamic_strings = NULL;
19497       dynamic_strings_length = 0;
19498     }
19499
19500   if (dynamic_symbols)
19501     {
19502       free (dynamic_symbols);
19503       dynamic_symbols = NULL;
19504       num_dynamic_syms = 0;
19505     }
19506
19507   if (dynamic_syminfo)
19508     {
19509       free (dynamic_syminfo);
19510       dynamic_syminfo = NULL;
19511     }
19512
19513   if (dynamic_section)
19514     {
19515       free (dynamic_section);
19516       dynamic_section = NULL;
19517     }
19518
19519   if (section_headers_groups)
19520     {
19521       free (section_headers_groups);
19522       section_headers_groups = NULL;
19523     }
19524
19525   if (section_groups)
19526     {
19527       struct group_list * g;
19528       struct group_list * next;
19529
19530       for (i = 0; i < group_count; i++)
19531         {
19532           for (g = section_groups [i].root; g != NULL; g = next)
19533             {
19534               next = g->next;
19535               free (g);
19536             }
19537         }
19538
19539       free (section_groups);
19540       section_groups = NULL;
19541     }
19542
19543   free_debug_memory ();
19544
19545   return res;
19546 }
19547
19548 /* Process an ELF archive.
19549    On entry the file is positioned just after the ARMAG string.
19550    Returns TRUE upon success, FALSE otherwise.  */
19551
19552 static bfd_boolean
19553 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19554 {
19555   struct archive_info arch;
19556   struct archive_info nested_arch;
19557   size_t got;
19558   bfd_boolean ret = TRUE;
19559
19560   show_name = TRUE;
19561
19562   /* The ARCH structure is used to hold information about this archive.  */
19563   arch.file_name = NULL;
19564   arch.file = NULL;
19565   arch.index_array = NULL;
19566   arch.sym_table = NULL;
19567   arch.longnames = NULL;
19568
19569   /* The NESTED_ARCH structure is used as a single-item cache of information
19570      about a nested archive (when members of a thin archive reside within
19571      another regular archive file).  */
19572   nested_arch.file_name = NULL;
19573   nested_arch.file = NULL;
19574   nested_arch.index_array = NULL;
19575   nested_arch.sym_table = NULL;
19576   nested_arch.longnames = NULL;
19577
19578   if (setup_archive (&arch, filedata->file_name, filedata->handle,
19579                      is_thin_archive, do_archive_index) != 0)
19580     {
19581       ret = FALSE;
19582       goto out;
19583     }
19584
19585   if (do_archive_index)
19586     {
19587       if (arch.sym_table == NULL)
19588         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19589       else
19590         {
19591           unsigned long i, l;
19592           unsigned long current_pos;
19593
19594           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19595                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19596
19597           current_pos = ftell (filedata->handle);
19598
19599           for (i = l = 0; i < arch.index_num; i++)
19600             {
19601               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19602                 {
19603                   char * member_name;
19604
19605                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19606
19607                   if (member_name != NULL)
19608                     {
19609                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19610
19611                       if (qualified_name != NULL)
19612                         {
19613                           printf (_("Contents of binary %s at offset "), qualified_name);
19614                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
19615                           putchar ('\n');
19616                           free (qualified_name);
19617                         }
19618                     }
19619                 }
19620
19621               if (l >= arch.sym_size)
19622                 {
19623                   error (_("%s: end of the symbol table reached before the end of the index\n"),
19624                          filedata->file_name);
19625                   ret = FALSE;
19626                   break;
19627                 }
19628               /* PR 17531: file: 0b6630b2.  */
19629               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19630               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19631             }
19632
19633           if (arch.uses_64bit_indices)
19634             l = (l + 7) & ~ 7;
19635           else
19636             l += l & 1;
19637
19638           if (l < arch.sym_size)
19639             {
19640               error (ngettext ("%s: %ld byte remains in the symbol table, "
19641                                "but without corresponding entries in "
19642                                "the index table\n",
19643                                "%s: %ld bytes remain in the symbol table, "
19644                                "but without corresponding entries in "
19645                                "the index table\n",
19646                                arch.sym_size - l),
19647                      filedata->file_name, arch.sym_size - l);
19648               ret = FALSE;
19649             }
19650
19651           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19652             {
19653               error (_("%s: failed to seek back to start of object files in the archive\n"),
19654                      filedata->file_name);
19655               ret = FALSE;
19656               goto out;
19657             }
19658         }
19659
19660       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19661           && !do_segments && !do_header && !do_dump && !do_version
19662           && !do_histogram && !do_debugging && !do_arch && !do_notes
19663           && !do_section_groups && !do_dyn_syms)
19664         {
19665           ret = TRUE; /* Archive index only.  */
19666           goto out;
19667         }
19668     }
19669
19670   while (1)
19671     {
19672       char * name;
19673       size_t namelen;
19674       char * qualified_name;
19675
19676       /* Read the next archive header.  */
19677       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19678         {
19679           error (_("%s: failed to seek to next archive header\n"), arch.file_name);
19680           return FALSE;
19681         }
19682       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19683       if (got != sizeof arch.arhdr)
19684         {
19685           if (got == 0)
19686             break;
19687           /* PR 24049 - we cannot use filedata->file_name as this will
19688              have already been freed.  */
19689           error (_("%s: failed to read archive header\n"), arch.file_name);
19690
19691           ret = FALSE;
19692           break;
19693         }
19694       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19695         {
19696           error (_("%s: did not find a valid archive header\n"), arch.file_name);
19697           ret = FALSE;
19698           break;
19699         }
19700
19701       arch.next_arhdr_offset += sizeof arch.arhdr;
19702
19703       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19704       if (archive_file_size & 01)
19705         ++archive_file_size;
19706
19707       name = get_archive_member_name (&arch, &nested_arch);
19708       if (name == NULL)
19709         {
19710           error (_("%s: bad archive file name\n"), arch.file_name);
19711           ret = FALSE;
19712           break;
19713         }
19714       namelen = strlen (name);
19715
19716       qualified_name = make_qualified_name (&arch, &nested_arch, name);
19717       if (qualified_name == NULL)
19718         {
19719           error (_("%s: bad archive file name\n"), arch.file_name);
19720           ret = FALSE;
19721           break;
19722         }
19723
19724       if (is_thin_archive && arch.nested_member_origin == 0)
19725         {
19726           /* This is a proxy for an external member of a thin archive.  */
19727           Filedata * member_filedata;
19728           char * member_file_name = adjust_relative_path
19729             (filedata->file_name, name, namelen);
19730
19731           if (member_file_name == NULL)
19732             {
19733               ret = FALSE;
19734               break;
19735             }
19736
19737           member_filedata = open_file (member_file_name);
19738           if (member_filedata == NULL)
19739             {
19740               error (_("Input file '%s' is not readable.\n"), member_file_name);
19741               free (member_file_name);
19742               ret = FALSE;
19743               break;
19744             }
19745
19746           archive_file_offset = arch.nested_member_origin;
19747           member_filedata->file_name = qualified_name;
19748
19749           if (! process_object (member_filedata))
19750             ret = FALSE;
19751
19752           close_file (member_filedata);
19753           free (member_file_name);
19754         }
19755       else if (is_thin_archive)
19756         {
19757           Filedata thin_filedata;
19758
19759           memset (&thin_filedata, 0, sizeof (thin_filedata));
19760
19761           /* PR 15140: Allow for corrupt thin archives.  */
19762           if (nested_arch.file == NULL)
19763             {
19764               error (_("%s: contains corrupt thin archive: %s\n"),
19765                      qualified_name, name);
19766               ret = FALSE;
19767               break;
19768             }
19769
19770           /* This is a proxy for a member of a nested archive.  */
19771           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19772
19773           /* The nested archive file will have been opened and setup by
19774              get_archive_member_name.  */
19775           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19776             {
19777               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19778               ret = FALSE;
19779               break;
19780             }
19781
19782           thin_filedata.handle = nested_arch.file;
19783           thin_filedata.file_name = qualified_name;
19784
19785           if (! process_object (& thin_filedata))
19786             ret = FALSE;
19787         }
19788       else
19789         {
19790           archive_file_offset = arch.next_arhdr_offset;
19791           arch.next_arhdr_offset += archive_file_size;
19792
19793           filedata->file_name = qualified_name;
19794           if (! process_object (filedata))
19795             ret = FALSE;
19796         }
19797
19798       if (filedata->dump_sects != NULL)
19799         {
19800           free (filedata->dump_sects);
19801           filedata->dump_sects = NULL;
19802           filedata->num_dump_sects = 0;
19803         }
19804
19805       free (qualified_name);
19806     }
19807
19808  out:
19809   if (nested_arch.file != NULL)
19810     fclose (nested_arch.file);
19811   release_archive (&nested_arch);
19812   release_archive (&arch);
19813
19814   return ret;
19815 }
19816
19817 static bfd_boolean
19818 process_file (char * file_name)
19819 {
19820   Filedata * filedata = NULL;
19821   struct stat statbuf;
19822   char armag[SARMAG];
19823   bfd_boolean ret = TRUE;
19824
19825   if (stat (file_name, &statbuf) < 0)
19826     {
19827       if (errno == ENOENT)
19828         error (_("'%s': No such file\n"), file_name);
19829       else
19830         error (_("Could not locate '%s'.  System error message: %s\n"),
19831                file_name, strerror (errno));
19832       return FALSE;
19833     }
19834
19835   if (! S_ISREG (statbuf.st_mode))
19836     {
19837       error (_("'%s' is not an ordinary file\n"), file_name);
19838       return FALSE;
19839     }
19840
19841   filedata = calloc (1, sizeof * filedata);
19842   if (filedata == NULL)
19843     {
19844       error (_("Out of memory allocating file data structure\n"));
19845       return FALSE;
19846     }
19847
19848   filedata->file_name = file_name;
19849   filedata->handle = fopen (file_name, "rb");
19850   if (filedata->handle == NULL)
19851     {
19852       error (_("Input file '%s' is not readable.\n"), file_name);
19853       free (filedata);
19854       return FALSE;
19855     }
19856
19857   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19858     {
19859       error (_("%s: Failed to read file's magic number\n"), file_name);
19860       fclose (filedata->handle);
19861       free (filedata);
19862       return FALSE;
19863     }
19864
19865   filedata->file_size = (bfd_size_type) statbuf.st_size;
19866
19867   if (memcmp (armag, ARMAG, SARMAG) == 0)
19868     {
19869       if (! process_archive (filedata, FALSE))
19870         ret = FALSE;
19871     }
19872   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19873     {
19874       if ( ! process_archive (filedata, TRUE))
19875         ret = FALSE;
19876     }
19877   else
19878     {
19879       if (do_archive_index)
19880         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19881                file_name);
19882
19883       rewind (filedata->handle);
19884       archive_file_size = archive_file_offset = 0;
19885
19886       if (! process_object (filedata))
19887         ret = FALSE;
19888     }
19889
19890   fclose (filedata->handle);
19891   free (filedata);
19892
19893   return ret;
19894 }
19895
19896 #ifdef SUPPORT_DISASSEMBLY
19897 /* Needed by the i386 disassembler.  For extra credit, someone could
19898    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19899    symbols.  */
19900
19901 void
19902 print_address (unsigned int addr, FILE * outfile)
19903 {
19904   fprintf (outfile,"0x%8.8x", addr);
19905 }
19906
19907 /* Needed by the i386 disassembler.  */
19908
19909 void
19910 db_task_printsym (unsigned int addr)
19911 {
19912   print_address (addr, stderr);
19913 }
19914 #endif
19915
19916 int
19917 main (int argc, char ** argv)
19918 {
19919   int err;
19920
19921 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19922   setlocale (LC_MESSAGES, "");
19923 #endif
19924 #if defined (HAVE_SETLOCALE)
19925   setlocale (LC_CTYPE, "");
19926 #endif
19927   bindtextdomain (PACKAGE, LOCALEDIR);
19928   textdomain (PACKAGE);
19929
19930   expandargv (&argc, &argv);
19931
19932   cmdline.file_name = "<cmdline>";
19933   parse_args (& cmdline, argc, argv);
19934
19935   if (optind < (argc - 1))
19936     show_name = TRUE;
19937   else if (optind >= argc)
19938     {
19939       warn (_("Nothing to do.\n"));
19940       usage (stderr);
19941     }
19942
19943   err = FALSE;
19944   while (optind < argc)
19945     if (! process_file (argv[optind++]))
19946       err = TRUE;
19947
19948   if (cmdline.dump_sects != NULL)
19949     free (cmdline.dump_sects);
19950
19951   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19952 }