binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2018 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #include <zlib.h>
  47 #ifdef HAVE_WCHAR_H
  48 #include <wchar.h>
  49 #endif
  50
  51 #if __GNUC__ >= 2
  52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  53    as this will allow us to read in and parse 64bit and 32bit ELF files.
  54    Only do this if we believe that the compiler can support a 64 bit
  55    data type.  For now we only rely on GCC being able to do this.  */
  56 #define BFD64
  57 #endif
  58
  59 #include "bfd.h"
  60 #include "bucomm.h"
  61 #include "elfcomm.h"
  62 #include "dwarf.h"
  63
  64 #include "elf/common.h"
  65 #include "elf/external.h"
  66 #include "elf/internal.h"
  67
  68
  69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  70    we can obtain the H8 reloc numbers.  We need these for the
  71    get_reloc_size() function.  We include h8.h again after defining
  72    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  73
  74 #include "elf/h8.h"
  75 #undef _ELF_H8_H
  76
  77 /* Undo the effects of #including reloc-macros.h.  */
  78
  79 #undef START_RELOC_NUMBERS
  80 #undef RELOC_NUMBER
  81 #undef FAKE_RELOC
  82 #undef EMPTY_RELOC
  83 #undef END_RELOC_NUMBERS
  84 #undef _RELOC_MACROS_H
  85
  86 /* The following headers use the elf/reloc-macros.h file to
  87    automatically generate relocation recognition functions
  88    such as elf_mips_reloc_type()  */
  89
  90 #define RELOC_MACROS_GEN_FUNC
  91
  92 #include "elf/aarch64.h"
  93 #include "elf/alpha.h"
  94 #include "elf/arc.h"
  95 #include "elf/arm.h"
  96 #include "elf/avr.h"
  97 #include "elf/bfin.h"
  98 #include "elf/cr16.h"
  99 #include "elf/cris.h"
 100 #include "elf/crx.h"
 101 #include "elf/csky.h"
 102 #include "elf/d10v.h"
 103 #include "elf/d30v.h"
 104 #include "elf/dlx.h"
 105 #include "elf/epiphany.h"
 106 #include "elf/fr30.h"
 107 #include "elf/frv.h"
 108 #include "elf/ft32.h"
 109 #include "elf/h8.h"
 110 #include "elf/hppa.h"
 111 #include "elf/i386.h"
 112 #include "elf/i370.h"
 113 #include "elf/i860.h"
 114 #include "elf/i960.h"
 115 #include "elf/ia64.h"
 116 #include "elf/ip2k.h"
 117 #include "elf/lm32.h"
 118 #include "elf/iq2000.h"
 119 #include "elf/m32c.h"
 120 #include "elf/m32r.h"
 121 #include "elf/m68k.h"
 122 #include "elf/m68hc11.h"
 123 #include "elf/s12z.h"
 124 #include "elf/mcore.h"
 125 #include "elf/mep.h"
 126 #include "elf/metag.h"
 127 #include "elf/microblaze.h"
 128 #include "elf/mips.h"
 129 #include "elf/mmix.h"
 130 #include "elf/mn10200.h"
 131 #include "elf/mn10300.h"
 132 #include "elf/moxie.h"
 133 #include "elf/mt.h"
 134 #include "elf/msp430.h"
 135 #include "elf/nds32.h"
 136 #include "elf/nfp.h"
 137 #include "elf/nios2.h"
 138 #include "elf/or1k.h"
 139 #include "elf/pj.h"
 140 #include "elf/ppc.h"
 141 #include "elf/ppc64.h"
 142 #include "elf/pru.h"
 143 #include "elf/riscv.h"
 144 #include "elf/rl78.h"
 145 #include "elf/rx.h"
 146 #include "elf/s390.h"
 147 #include "elf/score.h"
 148 #include "elf/sh.h"
 149 #include "elf/sparc.h"
 150 #include "elf/spu.h"
 151 #include "elf/tic6x.h"
 152 #include "elf/tilegx.h"
 153 #include "elf/tilepro.h"
 154 #include "elf/v850.h"
 155 #include "elf/vax.h"
 156 #include "elf/visium.h"
 157 #include "elf/wasm32.h"
 158 #include "elf/x86-64.h"
 159 #include "elf/xc16x.h"
 160 #include "elf/xgate.h"
 161 #include "elf/xstormy16.h"
 162 #include "elf/xtensa.h"
 163
 164 #include "getopt.h"
 165 #include "libiberty.h"
 166 #include "safe-ctype.h"
 167 #include "filenames.h"
 168
 169 #ifndef offsetof
 170 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 171 #endif
 172
 173 typedef struct elf_section_list
 174 {
 175   Elf_Internal_Shdr *        hdr;
 176   struct elf_section_list *  next;
 177 } elf_section_list;
 178
 179 /* Flag bits indicating particular types of dump.  */
 180 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 181 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 182 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 183 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 184 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 185
 186 typedef unsigned char dump_type;
 187
 188 /* A linked list of the section names for which dumps were requested.  */
 189 struct dump_list_entry
 190 {
 191   char *                    name;
 192   dump_type                 type;
 193   struct dump_list_entry *  next;
 194 };
 195
 196 typedef struct filedata
 197 {
 198   const char *         file_name;
 199   FILE *               handle;
 200   bfd_size_type        file_size;
 201   Elf_Internal_Ehdr    file_header;
 202   Elf_Internal_Shdr *  section_headers;
 203   Elf_Internal_Phdr *  program_headers;
 204   char *               string_table;
 205   unsigned long        string_table_length;
 206   /* A dynamic array of flags indicating for which sections a dump of
 207      some kind has been requested.  It is reset on a per-object file
 208      basis and then initialised from the cmdline_dump_sects array,
 209      the results of interpreting the -w switch, and the
 210      dump_sects_byname list.  */
 211   dump_type *          dump_sects;
 212   unsigned int         num_dump_sects;
 213 } Filedata;
 214
 215 char * program_name = "readelf";
 216
 217 static unsigned long archive_file_offset;
 218 static unsigned long archive_file_size;
 219 static unsigned long dynamic_addr;
 220 static bfd_size_type dynamic_size;
 221 static size_t dynamic_nent;
 222 static char * dynamic_strings;
 223 static unsigned long dynamic_strings_length;
 224 static unsigned long num_dynamic_syms;
 225 static Elf_Internal_Sym * dynamic_symbols;
 226 static Elf_Internal_Syminfo * dynamic_syminfo;
 227 static unsigned long dynamic_syminfo_offset;
 228 static unsigned int dynamic_syminfo_nent;
 229 static char program_interpreter[PATH_MAX];
 230 static bfd_vma dynamic_info[DT_ENCODING];
 231 static bfd_vma dynamic_info_DT_GNU_HASH;
 232 static bfd_vma version_info[16];
 233 static Elf_Internal_Dyn *  dynamic_section;
 234 static elf_section_list * symtab_shndx_list;
 235 static bfd_boolean show_name = FALSE;
 236 static bfd_boolean do_dynamic = FALSE;
 237 static bfd_boolean do_syms = FALSE;
 238 static bfd_boolean do_dyn_syms = FALSE;
 239 static bfd_boolean do_reloc = FALSE;
 240 static bfd_boolean do_sections = FALSE;
 241 static bfd_boolean do_section_groups = FALSE;
 242 static bfd_boolean do_section_details = FALSE;
 243 static bfd_boolean do_segments = FALSE;
 244 static bfd_boolean do_unwind = FALSE;
 245 static bfd_boolean do_using_dynamic = FALSE;
 246 static bfd_boolean do_header = FALSE;
 247 static bfd_boolean do_dump = FALSE;
 248 static bfd_boolean do_version = FALSE;
 249 static bfd_boolean do_histogram = FALSE;
 250 static bfd_boolean do_debugging = FALSE;
 251 static bfd_boolean do_arch = FALSE;
 252 static bfd_boolean do_notes = FALSE;
 253 static bfd_boolean do_archive_index = FALSE;
 254 static bfd_boolean is_32bit_elf = FALSE;
 255 static bfd_boolean decompress_dumps = FALSE;
 256
 257 struct group_list
 258 {
 259   struct group_list *  next;
 260   unsigned int         section_index;
 261 };
 262
 263 struct group
 264 {
 265   struct group_list *  root;
 266   unsigned int         group_index;
 267 };
 268
 269 static size_t           group_count;
 270 static struct group *   section_groups;
 271 static struct group **  section_headers_groups;
 272
 273 /* A dynamic array of flags indicating for which sections a dump
 274    has been requested via command line switches.  */
 275 static Filedata         cmdline;
 276
 277 static struct dump_list_entry * dump_sects_byname;
 278
 279 /* How to print a vma value.  */
 280 typedef enum print_mode
 281 {
 282   HEX,
 283   DEC,
 284   DEC_5,
 285   UNSIGNED,
 286   PREFIX_HEX,
 287   FULL_HEX,
 288   LONG_HEX
 289 }
 290 print_mode;
 291
 292 /* Versioned symbol info.  */
 293 enum versioned_symbol_info
 294 {
 295   symbol_undefined,
 296   symbol_hidden,
 297   symbol_public
 298 };
 299
 300 static const char * get_symbol_version_string
 301   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 302    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 303
 304 #define UNKNOWN -1
 305
 306 #define SECTION_NAME(X)                                         \
 307   ((X) == NULL ? _("<none>")                                    \
 308    : filedata->string_table == NULL ? _("<no-strings>")         \
 309    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 310   : filedata->string_table + (X)->sh_name))
 311
 312 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 313
 314 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 315   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 316    : get_64bit_elf_symbols (file, section, sym_count))
 317
 318 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 319 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 320    already been called and verified that the string exists.  */
 321 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 322
 323 #define REMOVE_ARCH_BITS(ADDR)                  \
 324   do                                            \
 325     {                                           \
 326       if (filedata->file_header.e_machine == EM_ARM)    \
 327         (ADDR) &= ~1;                           \
 328     }                                           \
 329   while (0)
 330 \f
 331 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 332    BFD_FMA_FMT can't be used in translated strings.  */
 333
 334 static const char *
 335 bfd_vmatoa (char *fmtch, bfd_vma value)
 336 {
 337   /* bfd_vmatoa is used more then once in a printf call for output.
 338      Cycle through an array of buffers.  */
 339   static int buf_pos = 0;
 340   static struct bfd_vmatoa_buf
 341   {
 342     char place[64];
 343   } buf[4];
 344   char *ret;
 345   char fmt[32];
 346
 347   ret = buf[buf_pos++].place;
 348   buf_pos %= ARRAY_SIZE (buf);
 349
 350   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 351   snprintf (ret, sizeof (buf[0].place), fmt, value);
 352   return ret;
 353 }
 354
 355 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 356    OFFSET + the offset of the current archive member, if we are examining an
 357    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 358    allocate a buffer using malloc and fill that.  In either case return the
 359    pointer to the start of the retrieved data or NULL if something went wrong.
 360    If something does go wrong and REASON is not NULL then emit an error
 361    message using REASON as part of the context.  */
 362
 363 static void *
 364 get_data (void *         var,
 365           Filedata *     filedata,
 366           unsigned long  offset,
 367           bfd_size_type  size,
 368           bfd_size_type  nmemb,
 369           const char *   reason)
 370 {
 371   void * mvar;
 372   bfd_size_type amt = size * nmemb;
 373
 374   if (size == 0 || nmemb == 0)
 375     return NULL;
 376
 377   /* If the size_t type is smaller than the bfd_size_type, eg because
 378      you are building a 32-bit tool on a 64-bit host, then make sure
 379      that when the sizes are cast to (size_t) no information is lost.  */
 380   if (sizeof (size_t) < sizeof (bfd_size_type)
 381       && (   (bfd_size_type) ((size_t) size) != size
 382           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 383     {
 384       if (reason)
 385         error (_("Size truncation prevents reading %s"
 386                  " elements of size %s for %s\n"),
 387                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 388       return NULL;
 389     }
 390
 391   /* Check for size overflow.  */
 392   if (amt < nmemb)
 393     {
 394       if (reason)
 395         error (_("Size overflow prevents reading %s"
 396                  " elements of size %s for %s\n"),
 397                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 398       return NULL;
 399     }
 400
 401   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 402      attempting to allocate memory when the read is bound to fail.  */
 403   if (amt > filedata->file_size
 404       || offset + archive_file_offset + amt > filedata->file_size)
 405     {
 406       if (reason)
 407         error (_("Reading %s bytes extends past end of file for %s\n"),
 408                bfd_vmatoa ("u", amt), reason);
 409       return NULL;
 410     }
 411
 412   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 413     {
 414       if (reason)
 415         error (_("Unable to seek to 0x%lx for %s\n"),
 416                archive_file_offset + offset, reason);
 417       return NULL;
 418     }
 419
 420   mvar = var;
 421   if (mvar == NULL)
 422     {
 423       /* Check for overflow.  */
 424       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 425         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 426         mvar = malloc ((size_t) amt + 1);
 427
 428       if (mvar == NULL)
 429         {
 430           if (reason)
 431             error (_("Out of memory allocating %s bytes for %s\n"),
 432                    bfd_vmatoa ("u", amt), reason);
 433           return NULL;
 434         }
 435
 436       ((char *) mvar)[amt] = '\0';
 437     }
 438
 439   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 440     {
 441       if (reason)
 442         error (_("Unable to read in %s bytes of %s\n"),
 443                bfd_vmatoa ("u", amt), reason);
 444       if (mvar != var)
 445         free (mvar);
 446       return NULL;
 447     }
 448
 449   return mvar;
 450 }
 451
 452 /* Print a VMA value in the MODE specified.
 453    Returns the number of characters displayed.  */
 454
 455 static unsigned int
 456 print_vma (bfd_vma vma, print_mode mode)
 457 {
 458   unsigned int nc = 0;
 459
 460   switch (mode)
 461     {
 462     case FULL_HEX:
 463       nc = printf ("0x");
 464       /* Fall through.  */
 465     case LONG_HEX:
 466 #ifdef BFD64
 467       if (is_32bit_elf)
 468         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 469 #endif
 470       printf_vma (vma);
 471       return nc + 16;
 472
 473     case DEC_5:
 474       if (vma <= 99999)
 475         return printf ("%5" BFD_VMA_FMT "d", vma);
 476       /* Fall through.  */
 477     case PREFIX_HEX:
 478       nc = printf ("0x");
 479       /* Fall through.  */
 480     case HEX:
 481       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 482
 483     case DEC:
 484       return printf ("%" BFD_VMA_FMT "d", vma);
 485
 486     case UNSIGNED:
 487       return printf ("%" BFD_VMA_FMT "u", vma);
 488
 489     default:
 490       /* FIXME: Report unrecognised mode ?  */
 491       return 0;
 492     }
 493 }
 494
 495 /* Display a symbol on stdout.  Handles the display of control characters and
 496    multibye characters (assuming the host environment supports them).
 497
 498    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 499
 500    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 501    padding as necessary.
 502
 503    Returns the number of emitted characters.  */
 504
 505 static unsigned int
 506 print_symbol (signed int width, const char *symbol)
 507 {
 508   bfd_boolean extra_padding = FALSE;
 509   signed int num_printed = 0;
 510 #ifdef HAVE_MBSTATE_T
 511   mbstate_t state;
 512 #endif
 513   unsigned int width_remaining;
 514
 515   if (width < 0)
 516     {
 517       /* Keep the width positive.  This helps the code below.  */
 518       width = - width;
 519       extra_padding = TRUE;
 520     }
 521   else if (width == 0)
 522     return 0;
 523
 524   if (do_wide)
 525     /* Set the remaining width to a very large value.
 526        This simplifies the code below.  */
 527     width_remaining = INT_MAX;
 528   else
 529     width_remaining = width;
 530
 531 #ifdef HAVE_MBSTATE_T
 532   /* Initialise the multibyte conversion state.  */
 533   memset (& state, 0, sizeof (state));
 534 #endif
 535
 536   while (width_remaining)
 537     {
 538       size_t  n;
 539       const char c = *symbol++;
 540
 541       if (c == 0)
 542         break;
 543
 544       /* Do not print control characters directly as they can affect terminal
 545          settings.  Such characters usually appear in the names generated
 546          by the assembler for local labels.  */
 547       if (ISCNTRL (c))
 548         {
 549           if (width_remaining < 2)
 550             break;
 551
 552           printf ("^%c", c + 0x40);
 553           width_remaining -= 2;
 554           num_printed += 2;
 555         }
 556       else if (ISPRINT (c))
 557         {
 558           putchar (c);
 559           width_remaining --;
 560           num_printed ++;
 561         }
 562       else
 563         {
 564 #ifdef HAVE_MBSTATE_T
 565           wchar_t w;
 566 #endif
 567           /* Let printf do the hard work of displaying multibyte characters.  */
 568           printf ("%.1s", symbol - 1);
 569           width_remaining --;
 570           num_printed ++;
 571
 572 #ifdef HAVE_MBSTATE_T
 573           /* Try to find out how many bytes made up the character that was
 574              just printed.  Advance the symbol pointer past the bytes that
 575              were displayed.  */
 576           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 577 #else
 578           n = 1;
 579 #endif
 580           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 581             symbol += (n - 1);
 582         }
 583     }
 584
 585   if (extra_padding && num_printed < width)
 586     {
 587       /* Fill in the remaining spaces.  */
 588       printf ("%-*s", width - num_printed, " ");
 589       num_printed = width;
 590     }
 591
 592   return num_printed;
 593 }
 594
 595 /* Returns a pointer to a static buffer containing a printable version of
 596    the given section's name.  Like print_symbol, except that it does not try
 597    to print multibyte characters, it just interprets them as hex values.  */
 598
 599 static const char *
 600 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 601 {
 602 #define MAX_PRINT_SEC_NAME_LEN 128
 603   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 604   const char * name = SECTION_NAME (sec);
 605   char *       buf = sec_name_buf;
 606   char         c;
 607   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 608
 609   while ((c = * name ++) != 0)
 610     {
 611       if (ISCNTRL (c))
 612         {
 613           if (remaining < 2)
 614             break;
 615
 616           * buf ++ = '^';
 617           * buf ++ = c + 0x40;
 618           remaining -= 2;
 619         }
 620       else if (ISPRINT (c))
 621         {
 622           * buf ++ = c;
 623           remaining -= 1;
 624         }
 625       else
 626         {
 627           static char hex[17] = "0123456789ABCDEF";
 628
 629           if (remaining < 4)
 630             break;
 631           * buf ++ = '<';
 632           * buf ++ = hex[(c & 0xf0) >> 4];
 633           * buf ++ = hex[c & 0x0f];
 634           * buf ++ = '>';
 635           remaining -= 4;
 636         }
 637
 638       if (remaining == 0)
 639         break;
 640     }
 641
 642   * buf = 0;
 643   return sec_name_buf;
 644 }
 645
 646 static const char *
 647 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 648 {
 649   if (ndx >= filedata->file_header.e_shnum)
 650     return _("<corrupt>");
 651
 652   return printable_section_name (filedata, filedata->section_headers + ndx);
 653 }
 654
 655 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 656
 657 static Elf_Internal_Shdr *
 658 find_section (Filedata * filedata, const char * name)
 659 {
 660   unsigned int i;
 661
 662   if (filedata->section_headers == NULL)
 663     return NULL;
 664
 665   for (i = 0; i < filedata->file_header.e_shnum; i++)
 666     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 667       return filedata->section_headers + i;
 668
 669   return NULL;
 670 }
 671
 672 /* Return a pointer to a section containing ADDR, or NULL if no such
 673    section exists.  */
 674
 675 static Elf_Internal_Shdr *
 676 find_section_by_address (Filedata * filedata, bfd_vma addr)
 677 {
 678   unsigned int i;
 679
 680   if (filedata->section_headers == NULL)
 681     return NULL;
 682
 683   for (i = 0; i < filedata->file_header.e_shnum; i++)
 684     {
 685       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 686
 687       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 688         return sec;
 689     }
 690
 691   return NULL;
 692 }
 693
 694 static Elf_Internal_Shdr *
 695 find_section_by_type (Filedata * filedata, unsigned int type)
 696 {
 697   unsigned int i;
 698
 699   if (filedata->section_headers == NULL)
 700     return NULL;
 701
 702   for (i = 0; i < filedata->file_header.e_shnum; i++)
 703     {
 704       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 705
 706       if (sec->sh_type == type)
 707         return sec;
 708     }
 709
 710   return NULL;
 711 }
 712
 713 /* Return a pointer to section NAME, or NULL if no such section exists,
 714    restricted to the list of sections given in SET.  */
 715
 716 static Elf_Internal_Shdr *
 717 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 718 {
 719   unsigned int i;
 720
 721   if (filedata->section_headers == NULL)
 722     return NULL;
 723
 724   if (set != NULL)
 725     {
 726       while ((i = *set++) > 0)
 727         {
 728           /* See PR 21156 for a reproducer.  */
 729           if (i >= filedata->file_header.e_shnum)
 730             continue; /* FIXME: Should we issue an error message ?  */
 731
 732           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 733             return filedata->section_headers + i;
 734         }
 735     }
 736
 737   return find_section (filedata, name);
 738 }
 739
 740 /* Read an unsigned LEB128 encoded value from DATA.
 741    Set *LENGTH_RETURN to the number of bytes read.  */
 742
 743 static inline unsigned long
 744 read_uleb128 (unsigned char * data,
 745               unsigned int * length_return,
 746               const unsigned char * const end)
 747 {
 748   return read_leb128 (data, length_return, FALSE, end);
 749 }
 750
 751 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 752    This OS has so many departures from the ELF standard that we test it at
 753    many places.  */
 754
 755 static inline bfd_boolean
 756 is_ia64_vms (Filedata * filedata)
 757 {
 758   return filedata->file_header.e_machine == EM_IA_64
 759     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 760 }
 761
 762 /* Guess the relocation size commonly used by the specific machines.  */
 763
 764 static bfd_boolean
 765 guess_is_rela (unsigned int e_machine)
 766 {
 767   switch (e_machine)
 768     {
 769       /* Targets that use REL relocations.  */
 770     case EM_386:
 771     case EM_IAMCU:
 772     case EM_960:
 773     case EM_ARM:
 774     case EM_D10V:
 775     case EM_CYGNUS_D10V:
 776     case EM_DLX:
 777     case EM_MIPS:
 778     case EM_MIPS_RS3_LE:
 779     case EM_CYGNUS_M32R:
 780     case EM_SCORE:
 781     case EM_XGATE:
 782     case EM_NFP:
 783       return FALSE;
 784
 785       /* Targets that use RELA relocations.  */
 786     case EM_68K:
 787     case EM_860:
 788     case EM_AARCH64:
 789     case EM_ADAPTEVA_EPIPHANY:
 790     case EM_ALPHA:
 791     case EM_ALTERA_NIOS2:
 792     case EM_ARC:
 793     case EM_ARC_COMPACT:
 794     case EM_ARC_COMPACT2:
 795     case EM_AVR:
 796     case EM_AVR_OLD:
 797     case EM_BLACKFIN:
 798     case EM_CR16:
 799     case EM_CRIS:
 800     case EM_CRX:
 801     case EM_CSKY:
 802     case EM_D30V:
 803     case EM_CYGNUS_D30V:
 804     case EM_FR30:
 805     case EM_FT32:
 806     case EM_CYGNUS_FR30:
 807     case EM_CYGNUS_FRV:
 808     case EM_H8S:
 809     case EM_H8_300:
 810     case EM_H8_300H:
 811     case EM_IA_64:
 812     case EM_IP2K:
 813     case EM_IP2K_OLD:
 814     case EM_IQ2000:
 815     case EM_LATTICEMICO32:
 816     case EM_M32C_OLD:
 817     case EM_M32C:
 818     case EM_M32R:
 819     case EM_MCORE:
 820     case EM_CYGNUS_MEP:
 821     case EM_METAG:
 822     case EM_MMIX:
 823     case EM_MN10200:
 824     case EM_CYGNUS_MN10200:
 825     case EM_MN10300:
 826     case EM_CYGNUS_MN10300:
 827     case EM_MOXIE:
 828     case EM_MSP430:
 829     case EM_MSP430_OLD:
 830     case EM_MT:
 831     case EM_NDS32:
 832     case EM_NIOS32:
 833     case EM_OR1K:
 834     case EM_PPC64:
 835     case EM_PPC:
 836     case EM_TI_PRU:
 837     case EM_RISCV:
 838     case EM_RL78:
 839     case EM_RX:
 840     case EM_S390:
 841     case EM_S390_OLD:
 842     case EM_SH:
 843     case EM_SPARC:
 844     case EM_SPARC32PLUS:
 845     case EM_SPARCV9:
 846     case EM_SPU:
 847     case EM_TI_C6000:
 848     case EM_TILEGX:
 849     case EM_TILEPRO:
 850     case EM_V800:
 851     case EM_V850:
 852     case EM_CYGNUS_V850:
 853     case EM_VAX:
 854     case EM_VISIUM:
 855     case EM_X86_64:
 856     case EM_L1OM:
 857     case EM_K1OM:
 858     case EM_XSTORMY16:
 859     case EM_XTENSA:
 860     case EM_XTENSA_OLD:
 861     case EM_MICROBLAZE:
 862     case EM_MICROBLAZE_OLD:
 863     case EM_WEBASSEMBLY:
 864       return TRUE;
 865
 866     case EM_68HC05:
 867     case EM_68HC08:
 868     case EM_68HC11:
 869     case EM_68HC16:
 870     case EM_FX66:
 871     case EM_ME16:
 872     case EM_MMA:
 873     case EM_NCPU:
 874     case EM_NDR1:
 875     case EM_PCP:
 876     case EM_ST100:
 877     case EM_ST19:
 878     case EM_ST7:
 879     case EM_ST9PLUS:
 880     case EM_STARCORE:
 881     case EM_SVX:
 882     case EM_TINYJ:
 883     default:
 884       warn (_("Don't know about relocations on this machine architecture\n"));
 885       return FALSE;
 886     }
 887 }
 888
 889 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 890    Returns TRUE upon success, FALSE otherwise.  If successful then a
 891    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 892    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 893    responsibility to free the allocated buffer.  */
 894
 895 static bfd_boolean
 896 slurp_rela_relocs (Filedata *            filedata,
 897                    unsigned long         rel_offset,
 898                    unsigned long         rel_size,
 899                    Elf_Internal_Rela **  relasp,
 900                    unsigned long *       nrelasp)
 901 {
 902   Elf_Internal_Rela * relas;
 903   size_t nrelas;
 904   unsigned int i;
 905
 906   if (is_32bit_elf)
 907     {
 908       Elf32_External_Rela * erelas;
 909
 910       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 911                                                  rel_size, _("32-bit relocation data"));
 912       if (!erelas)
 913         return FALSE;
 914
 915       nrelas = rel_size / sizeof (Elf32_External_Rela);
 916
 917       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 918                                              sizeof (Elf_Internal_Rela));
 919
 920       if (relas == NULL)
 921         {
 922           free (erelas);
 923           error (_("out of memory parsing relocs\n"));
 924           return FALSE;
 925         }
 926
 927       for (i = 0; i < nrelas; i++)
 928         {
 929           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 930           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 931           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 932         }
 933
 934       free (erelas);
 935     }
 936   else
 937     {
 938       Elf64_External_Rela * erelas;
 939
 940       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 941                                                  rel_size, _("64-bit relocation data"));
 942       if (!erelas)
 943         return FALSE;
 944
 945       nrelas = rel_size / sizeof (Elf64_External_Rela);
 946
 947       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 948                                              sizeof (Elf_Internal_Rela));
 949
 950       if (relas == NULL)
 951         {
 952           free (erelas);
 953           error (_("out of memory parsing relocs\n"));
 954           return FALSE;
 955         }
 956
 957       for (i = 0; i < nrelas; i++)
 958         {
 959           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 960           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 961           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 962
 963           /* The #ifdef BFD64 below is to prevent a compile time
 964              warning.  We know that if we do not have a 64 bit data
 965              type that we will never execute this code anyway.  */
 966 #ifdef BFD64
 967           if (filedata->file_header.e_machine == EM_MIPS
 968               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 969             {
 970               /* In little-endian objects, r_info isn't really a
 971                  64-bit little-endian value: it has a 32-bit
 972                  little-endian symbol index followed by four
 973                  individual byte fields.  Reorder INFO
 974                  accordingly.  */
 975               bfd_vma inf = relas[i].r_info;
 976               inf = (((inf & 0xffffffff) << 32)
 977                       | ((inf >> 56) & 0xff)
 978                       | ((inf >> 40) & 0xff00)
 979                       | ((inf >> 24) & 0xff0000)
 980                       | ((inf >> 8) & 0xff000000));
 981               relas[i].r_info = inf;
 982             }
 983 #endif /* BFD64 */
 984         }
 985
 986       free (erelas);
 987     }
 988
 989   *relasp = relas;
 990   *nrelasp = nrelas;
 991   return TRUE;
 992 }
 993
 994 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 995    Returns TRUE upon success, FALSE otherwise.  If successful then a
 996    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 997    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 998    responsibility to free the allocated buffer.  */
 999
1000 static bfd_boolean
1001 slurp_rel_relocs (Filedata *            filedata,
1002                   unsigned long         rel_offset,
1003                   unsigned long         rel_size,
1004                   Elf_Internal_Rela **  relsp,
1005                   unsigned long *       nrelsp)
1006 {
1007   Elf_Internal_Rela * rels;
1008   size_t nrels;
1009   unsigned int i;
1010
1011   if (is_32bit_elf)
1012     {
1013       Elf32_External_Rel * erels;
1014
1015       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1016                                                rel_size, _("32-bit relocation data"));
1017       if (!erels)
1018         return FALSE;
1019
1020       nrels = rel_size / sizeof (Elf32_External_Rel);
1021
1022       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1023
1024       if (rels == NULL)
1025         {
1026           free (erels);
1027           error (_("out of memory parsing relocs\n"));
1028           return FALSE;
1029         }
1030
1031       for (i = 0; i < nrels; i++)
1032         {
1033           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1034           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1035           rels[i].r_addend = 0;
1036         }
1037
1038       free (erels);
1039     }
1040   else
1041     {
1042       Elf64_External_Rel * erels;
1043
1044       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1045                                                rel_size, _("64-bit relocation data"));
1046       if (!erels)
1047         return FALSE;
1048
1049       nrels = rel_size / sizeof (Elf64_External_Rel);
1050
1051       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1052
1053       if (rels == NULL)
1054         {
1055           free (erels);
1056           error (_("out of memory parsing relocs\n"));
1057           return FALSE;
1058         }
1059
1060       for (i = 0; i < nrels; i++)
1061         {
1062           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1063           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1064           rels[i].r_addend = 0;
1065
1066           /* The #ifdef BFD64 below is to prevent a compile time
1067              warning.  We know that if we do not have a 64 bit data
1068              type that we will never execute this code anyway.  */
1069 #ifdef BFD64
1070           if (filedata->file_header.e_machine == EM_MIPS
1071               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1072             {
1073               /* In little-endian objects, r_info isn't really a
1074                  64-bit little-endian value: it has a 32-bit
1075                  little-endian symbol index followed by four
1076                  individual byte fields.  Reorder INFO
1077                  accordingly.  */
1078               bfd_vma inf = rels[i].r_info;
1079               inf = (((inf & 0xffffffff) << 32)
1080                      | ((inf >> 56) & 0xff)
1081                      | ((inf >> 40) & 0xff00)
1082                      | ((inf >> 24) & 0xff0000)
1083                      | ((inf >> 8) & 0xff000000));
1084               rels[i].r_info = inf;
1085             }
1086 #endif /* BFD64 */
1087         }
1088
1089       free (erels);
1090     }
1091
1092   *relsp = rels;
1093   *nrelsp = nrels;
1094   return TRUE;
1095 }
1096
1097 /* Returns the reloc type extracted from the reloc info field.  */
1098
1099 static unsigned int
1100 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1101 {
1102   if (is_32bit_elf)
1103     return ELF32_R_TYPE (reloc_info);
1104
1105   switch (filedata->file_header.e_machine)
1106     {
1107     case EM_MIPS:
1108       /* Note: We assume that reloc_info has already been adjusted for us.  */
1109       return ELF64_MIPS_R_TYPE (reloc_info);
1110
1111     case EM_SPARCV9:
1112       return ELF64_R_TYPE_ID (reloc_info);
1113
1114     default:
1115       return ELF64_R_TYPE (reloc_info);
1116     }
1117 }
1118
1119 /* Return the symbol index extracted from the reloc info field.  */
1120
1121 static bfd_vma
1122 get_reloc_symindex (bfd_vma reloc_info)
1123 {
1124   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1125 }
1126
1127 static inline bfd_boolean
1128 uses_msp430x_relocs (Filedata * filedata)
1129 {
1130   return
1131     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1132     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1133     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1134         /* TI compiler uses ELFOSABI_NONE.  */
1135         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1136 }
1137
1138 /* Display the contents of the relocation data found at the specified
1139    offset.  */
1140
1141 static bfd_boolean
1142 dump_relocations (Filedata *          filedata,
1143                   unsigned long       rel_offset,
1144                   unsigned long       rel_size,
1145                   Elf_Internal_Sym *  symtab,
1146                   unsigned long       nsyms,
1147                   char *              strtab,
1148                   unsigned long       strtablen,
1149                   int                 is_rela,
1150                   bfd_boolean         is_dynsym)
1151 {
1152   unsigned long i;
1153   Elf_Internal_Rela * rels;
1154   bfd_boolean res = TRUE;
1155
1156   if (is_rela == UNKNOWN)
1157     is_rela = guess_is_rela (filedata->file_header.e_machine);
1158
1159   if (is_rela)
1160     {
1161       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1162         return FALSE;
1163     }
1164   else
1165     {
1166       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1167         return FALSE;
1168     }
1169
1170   if (is_32bit_elf)
1171     {
1172       if (is_rela)
1173         {
1174           if (do_wide)
1175             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1176           else
1177             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1178         }
1179       else
1180         {
1181           if (do_wide)
1182             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1183           else
1184             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1185         }
1186     }
1187   else
1188     {
1189       if (is_rela)
1190         {
1191           if (do_wide)
1192             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1193           else
1194             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1195         }
1196       else
1197         {
1198           if (do_wide)
1199             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1200           else
1201             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1202         }
1203     }
1204
1205   for (i = 0; i < rel_size; i++)
1206     {
1207       const char * rtype;
1208       bfd_vma offset;
1209       bfd_vma inf;
1210       bfd_vma symtab_index;
1211       bfd_vma type;
1212
1213       offset = rels[i].r_offset;
1214       inf    = rels[i].r_info;
1215
1216       type = get_reloc_type (filedata, inf);
1217       symtab_index = get_reloc_symindex  (inf);
1218
1219       if (is_32bit_elf)
1220         {
1221           printf ("%8.8lx  %8.8lx ",
1222                   (unsigned long) offset & 0xffffffff,
1223                   (unsigned long) inf & 0xffffffff);
1224         }
1225       else
1226         {
1227 #if BFD_HOST_64BIT_LONG
1228           printf (do_wide
1229                   ? "%16.16lx  %16.16lx "
1230                   : "%12.12lx  %12.12lx ",
1231                   offset, inf);
1232 #elif BFD_HOST_64BIT_LONG_LONG
1233 #ifndef __MSVCRT__
1234           printf (do_wide
1235                   ? "%16.16llx  %16.16llx "
1236                   : "%12.12llx  %12.12llx ",
1237                   offset, inf);
1238 #else
1239           printf (do_wide
1240                   ? "%16.16I64x  %16.16I64x "
1241                   : "%12.12I64x  %12.12I64x ",
1242                   offset, inf);
1243 #endif
1244 #else
1245           printf (do_wide
1246                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1247                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1248                   _bfd_int64_high (offset),
1249                   _bfd_int64_low (offset),
1250                   _bfd_int64_high (inf),
1251                   _bfd_int64_low (inf));
1252 #endif
1253         }
1254
1255       switch (filedata->file_header.e_machine)
1256         {
1257         default:
1258           rtype = NULL;
1259           break;
1260
1261         case EM_AARCH64:
1262           rtype = elf_aarch64_reloc_type (type);
1263           break;
1264
1265         case EM_M32R:
1266         case EM_CYGNUS_M32R:
1267           rtype = elf_m32r_reloc_type (type);
1268           break;
1269
1270         case EM_386:
1271         case EM_IAMCU:
1272           rtype = elf_i386_reloc_type (type);
1273           break;
1274
1275         case EM_68HC11:
1276         case EM_68HC12:
1277           rtype = elf_m68hc11_reloc_type (type);
1278           break;
1279
1280         case EM_S12Z:
1281           rtype = elf_s12z_reloc_type (type);
1282           break;
1283
1284         case EM_68K:
1285           rtype = elf_m68k_reloc_type (type);
1286           break;
1287
1288         case EM_960:
1289           rtype = elf_i960_reloc_type (type);
1290           break;
1291
1292         case EM_AVR:
1293         case EM_AVR_OLD:
1294           rtype = elf_avr_reloc_type (type);
1295           break;
1296
1297         case EM_OLD_SPARCV9:
1298         case EM_SPARC32PLUS:
1299         case EM_SPARCV9:
1300         case EM_SPARC:
1301           rtype = elf_sparc_reloc_type (type);
1302           break;
1303
1304         case EM_SPU:
1305           rtype = elf_spu_reloc_type (type);
1306           break;
1307
1308         case EM_V800:
1309           rtype = v800_reloc_type (type);
1310           break;
1311         case EM_V850:
1312         case EM_CYGNUS_V850:
1313           rtype = v850_reloc_type (type);
1314           break;
1315
1316         case EM_D10V:
1317         case EM_CYGNUS_D10V:
1318           rtype = elf_d10v_reloc_type (type);
1319           break;
1320
1321         case EM_D30V:
1322         case EM_CYGNUS_D30V:
1323           rtype = elf_d30v_reloc_type (type);
1324           break;
1325
1326         case EM_DLX:
1327           rtype = elf_dlx_reloc_type (type);
1328           break;
1329
1330         case EM_SH:
1331           rtype = elf_sh_reloc_type (type);
1332           break;
1333
1334         case EM_MN10300:
1335         case EM_CYGNUS_MN10300:
1336           rtype = elf_mn10300_reloc_type (type);
1337           break;
1338
1339         case EM_MN10200:
1340         case EM_CYGNUS_MN10200:
1341           rtype = elf_mn10200_reloc_type (type);
1342           break;
1343
1344         case EM_FR30:
1345         case EM_CYGNUS_FR30:
1346           rtype = elf_fr30_reloc_type (type);
1347           break;
1348
1349         case EM_CYGNUS_FRV:
1350           rtype = elf_frv_reloc_type (type);
1351           break;
1352
1353         case EM_CSKY:
1354           rtype = elf_csky_reloc_type (type);
1355           break;
1356
1357         case EM_FT32:
1358           rtype = elf_ft32_reloc_type (type);
1359           break;
1360
1361         case EM_MCORE:
1362           rtype = elf_mcore_reloc_type (type);
1363           break;
1364
1365         case EM_MMIX:
1366           rtype = elf_mmix_reloc_type (type);
1367           break;
1368
1369         case EM_MOXIE:
1370           rtype = elf_moxie_reloc_type (type);
1371           break;
1372
1373         case EM_MSP430:
1374           if (uses_msp430x_relocs (filedata))
1375             {
1376               rtype = elf_msp430x_reloc_type (type);
1377               break;
1378             }
1379           /* Fall through.  */
1380         case EM_MSP430_OLD:
1381           rtype = elf_msp430_reloc_type (type);
1382           break;
1383
1384         case EM_NDS32:
1385           rtype = elf_nds32_reloc_type (type);
1386           break;
1387
1388         case EM_PPC:
1389           rtype = elf_ppc_reloc_type (type);
1390           break;
1391
1392         case EM_PPC64:
1393           rtype = elf_ppc64_reloc_type (type);
1394           break;
1395
1396         case EM_MIPS:
1397         case EM_MIPS_RS3_LE:
1398           rtype = elf_mips_reloc_type (type);
1399           break;
1400
1401         case EM_RISCV:
1402           rtype = elf_riscv_reloc_type (type);
1403           break;
1404
1405         case EM_ALPHA:
1406           rtype = elf_alpha_reloc_type (type);
1407           break;
1408
1409         case EM_ARM:
1410           rtype = elf_arm_reloc_type (type);
1411           break;
1412
1413         case EM_ARC:
1414         case EM_ARC_COMPACT:
1415         case EM_ARC_COMPACT2:
1416           rtype = elf_arc_reloc_type (type);
1417           break;
1418
1419         case EM_PARISC:
1420           rtype = elf_hppa_reloc_type (type);
1421           break;
1422
1423         case EM_H8_300:
1424         case EM_H8_300H:
1425         case EM_H8S:
1426           rtype = elf_h8_reloc_type (type);
1427           break;
1428
1429         case EM_OR1K:
1430           rtype = elf_or1k_reloc_type (type);
1431           break;
1432
1433         case EM_PJ:
1434         case EM_PJ_OLD:
1435           rtype = elf_pj_reloc_type (type);
1436           break;
1437         case EM_IA_64:
1438           rtype = elf_ia64_reloc_type (type);
1439           break;
1440
1441         case EM_CRIS:
1442           rtype = elf_cris_reloc_type (type);
1443           break;
1444
1445         case EM_860:
1446           rtype = elf_i860_reloc_type (type);
1447           break;
1448
1449         case EM_X86_64:
1450         case EM_L1OM:
1451         case EM_K1OM:
1452           rtype = elf_x86_64_reloc_type (type);
1453           break;
1454
1455         case EM_S370:
1456           rtype = i370_reloc_type (type);
1457           break;
1458
1459         case EM_S390_OLD:
1460         case EM_S390:
1461           rtype = elf_s390_reloc_type (type);
1462           break;
1463
1464         case EM_SCORE:
1465           rtype = elf_score_reloc_type (type);
1466           break;
1467
1468         case EM_XSTORMY16:
1469           rtype = elf_xstormy16_reloc_type (type);
1470           break;
1471
1472         case EM_CRX:
1473           rtype = elf_crx_reloc_type (type);
1474           break;
1475
1476         case EM_VAX:
1477           rtype = elf_vax_reloc_type (type);
1478           break;
1479
1480         case EM_VISIUM:
1481           rtype = elf_visium_reloc_type (type);
1482           break;
1483
1484         case EM_ADAPTEVA_EPIPHANY:
1485           rtype = elf_epiphany_reloc_type (type);
1486           break;
1487
1488         case EM_IP2K:
1489         case EM_IP2K_OLD:
1490           rtype = elf_ip2k_reloc_type (type);
1491           break;
1492
1493         case EM_IQ2000:
1494           rtype = elf_iq2000_reloc_type (type);
1495           break;
1496
1497         case EM_XTENSA_OLD:
1498         case EM_XTENSA:
1499           rtype = elf_xtensa_reloc_type (type);
1500           break;
1501
1502         case EM_LATTICEMICO32:
1503           rtype = elf_lm32_reloc_type (type);
1504           break;
1505
1506         case EM_M32C_OLD:
1507         case EM_M32C:
1508           rtype = elf_m32c_reloc_type (type);
1509           break;
1510
1511         case EM_MT:
1512           rtype = elf_mt_reloc_type (type);
1513           break;
1514
1515         case EM_BLACKFIN:
1516           rtype = elf_bfin_reloc_type (type);
1517           break;
1518
1519         case EM_CYGNUS_MEP:
1520           rtype = elf_mep_reloc_type (type);
1521           break;
1522
1523         case EM_CR16:
1524           rtype = elf_cr16_reloc_type (type);
1525           break;
1526
1527         case EM_MICROBLAZE:
1528         case EM_MICROBLAZE_OLD:
1529           rtype = elf_microblaze_reloc_type (type);
1530           break;
1531
1532         case EM_RL78:
1533           rtype = elf_rl78_reloc_type (type);
1534           break;
1535
1536         case EM_RX:
1537           rtype = elf_rx_reloc_type (type);
1538           break;
1539
1540         case EM_METAG:
1541           rtype = elf_metag_reloc_type (type);
1542           break;
1543
1544         case EM_XC16X:
1545         case EM_C166:
1546           rtype = elf_xc16x_reloc_type (type);
1547           break;
1548
1549         case EM_TI_C6000:
1550           rtype = elf_tic6x_reloc_type (type);
1551           break;
1552
1553         case EM_TILEGX:
1554           rtype = elf_tilegx_reloc_type (type);
1555           break;
1556
1557         case EM_TILEPRO:
1558           rtype = elf_tilepro_reloc_type (type);
1559           break;
1560
1561         case EM_WEBASSEMBLY:
1562           rtype = elf_wasm32_reloc_type (type);
1563           break;
1564
1565         case EM_XGATE:
1566           rtype = elf_xgate_reloc_type (type);
1567           break;
1568
1569         case EM_ALTERA_NIOS2:
1570           rtype = elf_nios2_reloc_type (type);
1571           break;
1572
1573         case EM_TI_PRU:
1574           rtype = elf_pru_reloc_type (type);
1575           break;
1576
1577         case EM_NFP:
1578           if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1579             rtype = elf_nfp3200_reloc_type (type);
1580           else
1581             rtype = elf_nfp_reloc_type (type);
1582           break;
1583         }
1584
1585       if (rtype == NULL)
1586         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1587       else
1588         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1589
1590       if (filedata->file_header.e_machine == EM_ALPHA
1591           && rtype != NULL
1592           && streq (rtype, "R_ALPHA_LITUSE")
1593           && is_rela)
1594         {
1595           switch (rels[i].r_addend)
1596             {
1597             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1598             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1599             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1600             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1601             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1602             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1603             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1604             default: rtype = NULL;
1605             }
1606
1607           if (rtype)
1608             printf (" (%s)", rtype);
1609           else
1610             {
1611               putchar (' ');
1612               printf (_("<unknown addend: %lx>"),
1613                       (unsigned long) rels[i].r_addend);
1614               res = FALSE;
1615             }
1616         }
1617       else if (symtab_index)
1618         {
1619           if (symtab == NULL || symtab_index >= nsyms)
1620             {
1621               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1622               res = FALSE;
1623             }
1624           else
1625             {
1626               Elf_Internal_Sym * psym;
1627               const char * version_string;
1628               enum versioned_symbol_info sym_info;
1629               unsigned short vna_other;
1630
1631               psym = symtab + symtab_index;
1632
1633               version_string
1634                 = get_symbol_version_string (filedata, is_dynsym,
1635                                              strtab, strtablen,
1636                                              symtab_index,
1637                                              psym,
1638                                              &sym_info,
1639                                              &vna_other);
1640
1641               printf (" ");
1642
1643               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1644                 {
1645                   const char * name;
1646                   unsigned int len;
1647                   unsigned int width = is_32bit_elf ? 8 : 14;
1648
1649                   /* Relocations against GNU_IFUNC symbols do not use the value
1650                      of the symbol as the address to relocate against.  Instead
1651                      they invoke the function named by the symbol and use its
1652                      result as the address for relocation.
1653
1654                      To indicate this to the user, do not display the value of
1655                      the symbol in the "Symbols's Value" field.  Instead show
1656                      its name followed by () as a hint that the symbol is
1657                      invoked.  */
1658
1659                   if (strtab == NULL
1660                       || psym->st_name == 0
1661                       || psym->st_name >= strtablen)
1662                     name = "??";
1663                   else
1664                     name = strtab + psym->st_name;
1665
1666                   len = print_symbol (width, name);
1667                   if (version_string)
1668                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1669                             version_string);
1670                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1671                 }
1672               else
1673                 {
1674                   print_vma (psym->st_value, LONG_HEX);
1675
1676                   printf (is_32bit_elf ? "   " : " ");
1677                 }
1678
1679               if (psym->st_name == 0)
1680                 {
1681                   const char * sec_name = "<null>";
1682                   char name_buf[40];
1683
1684                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1685                     {
1686                       if (psym->st_shndx < filedata->file_header.e_shnum)
1687                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1688                       else if (psym->st_shndx == SHN_ABS)
1689                         sec_name = "ABS";
1690                       else if (psym->st_shndx == SHN_COMMON)
1691                         sec_name = "COMMON";
1692                       else if ((filedata->file_header.e_machine == EM_MIPS
1693                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1694                                || (filedata->file_header.e_machine == EM_TI_C6000
1695                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1696                         sec_name = "SCOMMON";
1697                       else if (filedata->file_header.e_machine == EM_MIPS
1698                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1699                         sec_name = "SUNDEF";
1700                       else if ((filedata->file_header.e_machine == EM_X86_64
1701                                 || filedata->file_header.e_machine == EM_L1OM
1702                                 || filedata->file_header.e_machine == EM_K1OM)
1703                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1704                         sec_name = "LARGE_COMMON";
1705                       else if (filedata->file_header.e_machine == EM_IA_64
1706                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1707                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1708                         sec_name = "ANSI_COM";
1709                       else if (is_ia64_vms (filedata)
1710                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1711                         sec_name = "VMS_SYMVEC";
1712                       else
1713                         {
1714                           sprintf (name_buf, "<section 0x%x>",
1715                                    (unsigned int) psym->st_shndx);
1716                           sec_name = name_buf;
1717                         }
1718                     }
1719                   print_symbol (22, sec_name);
1720                 }
1721               else if (strtab == NULL)
1722                 printf (_("<string table index: %3ld>"), psym->st_name);
1723               else if (psym->st_name >= strtablen)
1724                 {
1725                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1726                   res = FALSE;
1727                 }
1728               else
1729                 {
1730                   print_symbol (22, strtab + psym->st_name);
1731                   if (version_string)
1732                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1733                             version_string);
1734                 }
1735
1736               if (is_rela)
1737                 {
1738                   bfd_vma off = rels[i].r_addend;
1739
1740                   if ((bfd_signed_vma) off < 0)
1741                     printf (" - %" BFD_VMA_FMT "x", - off);
1742                   else
1743                     printf (" + %" BFD_VMA_FMT "x", off);
1744                 }
1745             }
1746         }
1747       else if (is_rela)
1748         {
1749           bfd_vma off = rels[i].r_addend;
1750
1751           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1752           if ((bfd_signed_vma) off < 0)
1753             printf ("-%" BFD_VMA_FMT "x", - off);
1754           else
1755             printf ("%" BFD_VMA_FMT "x", off);
1756         }
1757
1758       if (filedata->file_header.e_machine == EM_SPARCV9
1759           && rtype != NULL
1760           && streq (rtype, "R_SPARC_OLO10"))
1761         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1762
1763       putchar ('\n');
1764
1765 #ifdef BFD64
1766       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1767         {
1768           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1769           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1770           const char * rtype2 = elf_mips_reloc_type (type2);
1771           const char * rtype3 = elf_mips_reloc_type (type3);
1772
1773           printf ("                    Type2: ");
1774
1775           if (rtype2 == NULL)
1776             printf (_("unrecognized: %-7lx"),
1777                     (unsigned long) type2 & 0xffffffff);
1778           else
1779             printf ("%-17.17s", rtype2);
1780
1781           printf ("\n                    Type3: ");
1782
1783           if (rtype3 == NULL)
1784             printf (_("unrecognized: %-7lx"),
1785                     (unsigned long) type3 & 0xffffffff);
1786           else
1787             printf ("%-17.17s", rtype3);
1788
1789           putchar ('\n');
1790         }
1791 #endif /* BFD64 */
1792     }
1793
1794   free (rels);
1795
1796   return res;
1797 }
1798
1799 static const char *
1800 get_mips_dynamic_type (unsigned long type)
1801 {
1802   switch (type)
1803     {
1804     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1805     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1806     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1807     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1808     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1809     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1810     case DT_MIPS_MSYM: return "MIPS_MSYM";
1811     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1812     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1813     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1814     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1815     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1816     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1817     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1818     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1819     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1820     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1821     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1822     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1823     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1824     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1825     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1826     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1827     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1828     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1829     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1830     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1831     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1832     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1833     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1834     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1835     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1836     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1837     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1838     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1839     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1840     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1841     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1842     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1843     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1844     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1845     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1846     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1847     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1848     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1849     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1850     default:
1851       return NULL;
1852     }
1853 }
1854
1855 static const char *
1856 get_sparc64_dynamic_type (unsigned long type)
1857 {
1858   switch (type)
1859     {
1860     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1861     default:
1862       return NULL;
1863     }
1864 }
1865
1866 static const char *
1867 get_ppc_dynamic_type (unsigned long type)
1868 {
1869   switch (type)
1870     {
1871     case DT_PPC_GOT:    return "PPC_GOT";
1872     case DT_PPC_OPT:    return "PPC_OPT";
1873     default:
1874       return NULL;
1875     }
1876 }
1877
1878 static const char *
1879 get_ppc64_dynamic_type (unsigned long type)
1880 {
1881   switch (type)
1882     {
1883     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1884     case DT_PPC64_OPD:    return "PPC64_OPD";
1885     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1886     case DT_PPC64_OPT:    return "PPC64_OPT";
1887     default:
1888       return NULL;
1889     }
1890 }
1891
1892 static const char *
1893 get_parisc_dynamic_type (unsigned long type)
1894 {
1895   switch (type)
1896     {
1897     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1898     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1899     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1900     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1901     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1902     case DT_HP_PREINIT:         return "HP_PREINIT";
1903     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1904     case DT_HP_NEEDED:          return "HP_NEEDED";
1905     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1906     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1907     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1908     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1909     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1910     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1911     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1912     case DT_HP_FILTERED:        return "HP_FILTERED";
1913     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1914     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1915     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1916     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1917     case DT_PLT:                return "PLT";
1918     case DT_PLT_SIZE:           return "PLT_SIZE";
1919     case DT_DLT:                return "DLT";
1920     case DT_DLT_SIZE:           return "DLT_SIZE";
1921     default:
1922       return NULL;
1923     }
1924 }
1925
1926 static const char *
1927 get_ia64_dynamic_type (unsigned long type)
1928 {
1929   switch (type)
1930     {
1931     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1932     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1933     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1934     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1935     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1936     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1937     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1938     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1939     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1940     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1941     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1942     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1943     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1944     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1945     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1946     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1947     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1948     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1949     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1950     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1951     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1952     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1953     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1954     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1955     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1956     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1957     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1958     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1959     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1960     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1961     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1962     default:
1963       return NULL;
1964     }
1965 }
1966
1967 static const char *
1968 get_solaris_section_type (unsigned long type)
1969 {
1970   switch (type)
1971     {
1972     case 0x6fffffee: return "SUNW_ancillary";
1973     case 0x6fffffef: return "SUNW_capchain";
1974     case 0x6ffffff0: return "SUNW_capinfo";
1975     case 0x6ffffff1: return "SUNW_symsort";
1976     case 0x6ffffff2: return "SUNW_tlssort";
1977     case 0x6ffffff3: return "SUNW_LDYNSYM";
1978     case 0x6ffffff4: return "SUNW_dof";
1979     case 0x6ffffff5: return "SUNW_cap";
1980     case 0x6ffffff6: return "SUNW_SIGNATURE";
1981     case 0x6ffffff7: return "SUNW_ANNOTATE";
1982     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1983     case 0x6ffffff9: return "SUNW_DEBUG";
1984     case 0x6ffffffa: return "SUNW_move";
1985     case 0x6ffffffb: return "SUNW_COMDAT";
1986     case 0x6ffffffc: return "SUNW_syminfo";
1987     case 0x6ffffffd: return "SUNW_verdef";
1988     case 0x6ffffffe: return "SUNW_verneed";
1989     case 0x6fffffff: return "SUNW_versym";
1990     case 0x70000000: return "SPARC_GOTDATA";
1991     default: return NULL;
1992     }
1993 }
1994
1995 static const char *
1996 get_alpha_dynamic_type (unsigned long type)
1997 {
1998   switch (type)
1999     {
2000     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2001     default: return NULL;
2002     }
2003 }
2004
2005 static const char *
2006 get_score_dynamic_type (unsigned long type)
2007 {
2008   switch (type)
2009     {
2010     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2011     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
2012     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
2013     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
2014     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
2015     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
2016     default:                    return NULL;
2017     }
2018 }
2019
2020 static const char *
2021 get_tic6x_dynamic_type (unsigned long type)
2022 {
2023   switch (type)
2024     {
2025     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2026     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2027     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2028     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2029     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2030     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2031     default:                   return NULL;
2032     }
2033 }
2034
2035 static const char *
2036 get_nios2_dynamic_type (unsigned long type)
2037 {
2038   switch (type)
2039     {
2040     case DT_NIOS2_GP: return "NIOS2_GP";
2041     default:          return NULL;
2042     }
2043 }
2044
2045 static const char *
2046 get_solaris_dynamic_type (unsigned long type)
2047 {
2048   switch (type)
2049     {
2050     case 0x6000000d: return "SUNW_AUXILIARY";
2051     case 0x6000000e: return "SUNW_RTLDINF";
2052     case 0x6000000f: return "SUNW_FILTER";
2053     case 0x60000010: return "SUNW_CAP";
2054     case 0x60000011: return "SUNW_SYMTAB";
2055     case 0x60000012: return "SUNW_SYMSZ";
2056     case 0x60000013: return "SUNW_SORTENT";
2057     case 0x60000014: return "SUNW_SYMSORT";
2058     case 0x60000015: return "SUNW_SYMSORTSZ";
2059     case 0x60000016: return "SUNW_TLSSORT";
2060     case 0x60000017: return "SUNW_TLSSORTSZ";
2061     case 0x60000018: return "SUNW_CAPINFO";
2062     case 0x60000019: return "SUNW_STRPAD";
2063     case 0x6000001a: return "SUNW_CAPCHAIN";
2064     case 0x6000001b: return "SUNW_LDMACH";
2065     case 0x6000001d: return "SUNW_CAPCHAINENT";
2066     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2067     case 0x60000021: return "SUNW_PARENT";
2068     case 0x60000023: return "SUNW_ASLR";
2069     case 0x60000025: return "SUNW_RELAX";
2070     case 0x60000029: return "SUNW_NXHEAP";
2071     case 0x6000002b: return "SUNW_NXSTACK";
2072
2073     case 0x70000001: return "SPARC_REGISTER";
2074     case 0x7ffffffd: return "AUXILIARY";
2075     case 0x7ffffffe: return "USED";
2076     case 0x7fffffff: return "FILTER";
2077
2078     default: return NULL;
2079     }
2080 }
2081
2082 static const char *
2083 get_dynamic_type (Filedata * filedata, unsigned long type)
2084 {
2085   static char buff[64];
2086
2087   switch (type)
2088     {
2089     case DT_NULL:       return "NULL";
2090     case DT_NEEDED:     return "NEEDED";
2091     case DT_PLTRELSZ:   return "PLTRELSZ";
2092     case DT_PLTGOT:     return "PLTGOT";
2093     case DT_HASH:       return "HASH";
2094     case DT_STRTAB:     return "STRTAB";
2095     case DT_SYMTAB:     return "SYMTAB";
2096     case DT_RELA:       return "RELA";
2097     case DT_RELASZ:     return "RELASZ";
2098     case DT_RELAENT:    return "RELAENT";
2099     case DT_STRSZ:      return "STRSZ";
2100     case DT_SYMENT:     return "SYMENT";
2101     case DT_INIT:       return "INIT";
2102     case DT_FINI:       return "FINI";
2103     case DT_SONAME:     return "SONAME";
2104     case DT_RPATH:      return "RPATH";
2105     case DT_SYMBOLIC:   return "SYMBOLIC";
2106     case DT_REL:        return "REL";
2107     case DT_RELSZ:      return "RELSZ";
2108     case DT_RELENT:     return "RELENT";
2109     case DT_PLTREL:     return "PLTREL";
2110     case DT_DEBUG:      return "DEBUG";
2111     case DT_TEXTREL:    return "TEXTREL";
2112     case DT_JMPREL:     return "JMPREL";
2113     case DT_BIND_NOW:   return "BIND_NOW";
2114     case DT_INIT_ARRAY: return "INIT_ARRAY";
2115     case DT_FINI_ARRAY: return "FINI_ARRAY";
2116     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2117     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2118     case DT_RUNPATH:    return "RUNPATH";
2119     case DT_FLAGS:      return "FLAGS";
2120
2121     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2122     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2123     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2124
2125     case DT_CHECKSUM:   return "CHECKSUM";
2126     case DT_PLTPADSZ:   return "PLTPADSZ";
2127     case DT_MOVEENT:    return "MOVEENT";
2128     case DT_MOVESZ:     return "MOVESZ";
2129     case DT_FEATURE:    return "FEATURE";
2130     case DT_POSFLAG_1:  return "POSFLAG_1";
2131     case DT_SYMINSZ:    return "SYMINSZ";
2132     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2133
2134     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2135     case DT_CONFIG:     return "CONFIG";
2136     case DT_DEPAUDIT:   return "DEPAUDIT";
2137     case DT_AUDIT:      return "AUDIT";
2138     case DT_PLTPAD:     return "PLTPAD";
2139     case DT_MOVETAB:    return "MOVETAB";
2140     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2141
2142     case DT_VERSYM:     return "VERSYM";
2143
2144     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2145     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2146     case DT_RELACOUNT:  return "RELACOUNT";
2147     case DT_RELCOUNT:   return "RELCOUNT";
2148     case DT_FLAGS_1:    return "FLAGS_1";
2149     case DT_VERDEF:     return "VERDEF";
2150     case DT_VERDEFNUM:  return "VERDEFNUM";
2151     case DT_VERNEED:    return "VERNEED";
2152     case DT_VERNEEDNUM: return "VERNEEDNUM";
2153
2154     case DT_AUXILIARY:  return "AUXILIARY";
2155     case DT_USED:       return "USED";
2156     case DT_FILTER:     return "FILTER";
2157
2158     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2159     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2160     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2161     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2162     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2163     case DT_GNU_HASH:   return "GNU_HASH";
2164
2165     default:
2166       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2167         {
2168           const char * result;
2169
2170           switch (filedata->file_header.e_machine)
2171             {
2172             case EM_MIPS:
2173             case EM_MIPS_RS3_LE:
2174               result = get_mips_dynamic_type (type);
2175               break;
2176             case EM_SPARCV9:
2177               result = get_sparc64_dynamic_type (type);
2178               break;
2179             case EM_PPC:
2180               result = get_ppc_dynamic_type (type);
2181               break;
2182             case EM_PPC64:
2183               result = get_ppc64_dynamic_type (type);
2184               break;
2185             case EM_IA_64:
2186               result = get_ia64_dynamic_type (type);
2187               break;
2188             case EM_ALPHA:
2189               result = get_alpha_dynamic_type (type);
2190               break;
2191             case EM_SCORE:
2192               result = get_score_dynamic_type (type);
2193               break;
2194             case EM_TI_C6000:
2195               result = get_tic6x_dynamic_type (type);
2196               break;
2197             case EM_ALTERA_NIOS2:
2198               result = get_nios2_dynamic_type (type);
2199               break;
2200             default:
2201               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2202                 result = get_solaris_dynamic_type (type);
2203               else
2204                 result = NULL;
2205               break;
2206             }
2207
2208           if (result != NULL)
2209             return result;
2210
2211           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2212         }
2213       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2214                || (filedata->file_header.e_machine == EM_PARISC
2215                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2216         {
2217           const char * result;
2218
2219           switch (filedata->file_header.e_machine)
2220             {
2221             case EM_PARISC:
2222               result = get_parisc_dynamic_type (type);
2223               break;
2224             case EM_IA_64:
2225               result = get_ia64_dynamic_type (type);
2226               break;
2227             default:
2228               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2229                 result = get_solaris_dynamic_type (type);
2230               else
2231                 result = NULL;
2232               break;
2233             }
2234
2235           if (result != NULL)
2236             return result;
2237
2238           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2239                     type);
2240         }
2241       else
2242         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2243
2244       return buff;
2245     }
2246 }
2247
2248 static char *
2249 get_file_type (unsigned e_type)
2250 {
2251   static char buff[32];
2252
2253   switch (e_type)
2254     {
2255     case ET_NONE: return _("NONE (None)");
2256     case ET_REL:  return _("REL (Relocatable file)");
2257     case ET_EXEC: return _("EXEC (Executable file)");
2258     case ET_DYN:  return _("DYN (Shared object file)");
2259     case ET_CORE: return _("CORE (Core file)");
2260
2261     default:
2262       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2263         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2264       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2265         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2266       else
2267         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2268       return buff;
2269     }
2270 }
2271
2272 static char *
2273 get_machine_name (unsigned e_machine)
2274 {
2275   static char buff[64]; /* XXX */
2276
2277   switch (e_machine)
2278     {
2279       /* Please keep this switch table sorted by increasing EM_ value.  */
2280       /* 0 */
2281     case EM_NONE:               return _("None");
2282     case EM_M32:                return "WE32100";
2283     case EM_SPARC:              return "Sparc";
2284     case EM_386:                return "Intel 80386";
2285     case EM_68K:                return "MC68000";
2286     case EM_88K:                return "MC88000";
2287     case EM_IAMCU:              return "Intel MCU";
2288     case EM_860:                return "Intel 80860";
2289     case EM_MIPS:               return "MIPS R3000";
2290     case EM_S370:               return "IBM System/370";
2291       /* 10 */
2292     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2293     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2294     case EM_PARISC:             return "HPPA";
2295     case EM_VPP550:             return "Fujitsu VPP500";
2296     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2297     case EM_960:                return "Intel 80960";
2298     case EM_PPC:                return "PowerPC";
2299       /* 20 */
2300     case EM_PPC64:              return "PowerPC64";
2301     case EM_S390_OLD:
2302     case EM_S390:               return "IBM S/390";
2303     case EM_SPU:                return "SPU";
2304       /* 30 */
2305     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2306     case EM_FR20:               return "Fujitsu FR20";
2307     case EM_RH32:               return "TRW RH32";
2308     case EM_MCORE:              return "MCORE";
2309       /* 40 */
2310     case EM_ARM:                return "ARM";
2311     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2312     case EM_SH:                 return "Renesas / SuperH SH";
2313     case EM_SPARCV9:            return "Sparc v9";
2314     case EM_TRICORE:            return "Siemens Tricore";
2315     case EM_ARC:                return "ARC";
2316     case EM_H8_300:             return "Renesas H8/300";
2317     case EM_H8_300H:            return "Renesas H8/300H";
2318     case EM_H8S:                return "Renesas H8S";
2319     case EM_H8_500:             return "Renesas H8/500";
2320       /* 50 */
2321     case EM_IA_64:              return "Intel IA-64";
2322     case EM_MIPS_X:             return "Stanford MIPS-X";
2323     case EM_COLDFIRE:           return "Motorola Coldfire";
2324     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2325     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2326     case EM_PCP:                return "Siemens PCP";
2327     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2328     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2329     case EM_STARCORE:           return "Motorola Star*Core processor";
2330     case EM_ME16:               return "Toyota ME16 processor";
2331       /* 60 */
2332     case EM_ST100:              return "STMicroelectronics ST100 processor";
2333     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2334     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2335     case EM_PDSP:               return "Sony DSP processor";
2336     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2337     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2338     case EM_FX66:               return "Siemens FX66 microcontroller";
2339     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2340     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2341     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2342       /* 70 */
2343     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2344     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2345     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2346     case EM_SVX:                return "Silicon Graphics SVx";
2347     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2348     case EM_VAX:                return "Digital VAX";
2349     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2350     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2351     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2352     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2353       /* 80 */
2354     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2355     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2356     case EM_PRISM:              return "Vitesse Prism";
2357     case EM_AVR_OLD:
2358     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2359     case EM_CYGNUS_FR30:
2360     case EM_FR30:               return "Fujitsu FR30";
2361     case EM_CYGNUS_D10V:
2362     case EM_D10V:               return "d10v";
2363     case EM_CYGNUS_D30V:
2364     case EM_D30V:               return "d30v";
2365     case EM_CYGNUS_V850:
2366     case EM_V850:               return "Renesas V850";
2367     case EM_CYGNUS_M32R:
2368     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2369     case EM_CYGNUS_MN10300:
2370     case EM_MN10300:            return "mn10300";
2371       /* 90 */
2372     case EM_CYGNUS_MN10200:
2373     case EM_MN10200:            return "mn10200";
2374     case EM_PJ:                 return "picoJava";
2375     case EM_OR1K:               return "OpenRISC 1000";
2376     case EM_ARC_COMPACT:        return "ARCompact";
2377     case EM_XTENSA_OLD:
2378     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2379     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2380     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2381     case EM_NS32K:              return "National Semiconductor 32000 series";
2382     case EM_TPC:                return "Tenor Network TPC processor";
2383     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2384       /* 100 */
2385     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2386     case EM_IP2K_OLD:
2387     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2388     case EM_MAX:                return "MAX Processor";
2389     case EM_CR:                 return "National Semiconductor CompactRISC";
2390     case EM_F2MC16:             return "Fujitsu F2MC16";
2391     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2392     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2393     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2394     case EM_SEP:                return "Sharp embedded microprocessor";
2395     case EM_ARCA:               return "Arca RISC microprocessor";
2396       /* 110 */
2397     case EM_UNICORE:            return "Unicore";
2398     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2399     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2400     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2401     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2402     case EM_XGATE:              return "Motorola XGATE embedded processor";
2403     case EM_C166:
2404     case EM_XC16X:              return "Infineon Technologies xc16x";
2405     case EM_M16C:               return "Renesas M16C series microprocessors";
2406     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2407     case EM_CE:                 return "Freescale Communication Engine RISC core";
2408       /* 120 */
2409     case EM_M32C:               return "Renesas M32c";
2410       /* 130 */
2411     case EM_TSK3000:            return "Altium TSK3000 core";
2412     case EM_RS08:               return "Freescale RS08 embedded processor";
2413     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2414     case EM_SCORE:              return "SUNPLUS S+Core";
2415     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2416     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2417     case EM_LATTICEMICO32:      return "Lattice Mico32";
2418     case EM_SE_C17:             return "Seiko Epson C17 family";
2419       /* 140 */
2420     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2421     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2422     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2423     case EM_TI_PRU:             return "TI PRU I/O processor";
2424       /* 160 */
2425     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2426     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2427     case EM_R32C:               return "Renesas R32C series microprocessors";
2428     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2429     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2430     case EM_8051:               return "Intel 8051 and variants";
2431     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2432     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2433     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2434     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2435       /* 170 */
2436     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2437     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2438     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2439     case EM_RX:                 return "Renesas RX";
2440     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2441     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2442     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2443     case EM_CR16:
2444     case EM_MICROBLAZE:
2445     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2446     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2447     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2448       /* 180 */
2449     case EM_L1OM:               return "Intel L1OM";
2450     case EM_K1OM:               return "Intel K1OM";
2451     case EM_INTEL182:           return "Intel (reserved)";
2452     case EM_AARCH64:            return "AArch64";
2453     case EM_ARM184:             return "ARM (reserved)";
2454     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2455     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2456     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2457     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2458       /* 190 */
2459     case EM_CUDA:               return "NVIDIA CUDA architecture";
2460     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2461     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2462     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2463     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2464     case EM_ARC_COMPACT2:       return "ARCv2";
2465     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2466     case EM_RL78:               return "Renesas RL78";
2467     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2468     case EM_78K0R:              return "Renesas 78K0R";
2469       /* 200 */
2470     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2471     case EM_BA1:                return "Beyond BA1 CPU architecture";
2472     case EM_BA2:                return "Beyond BA2 CPU architecture";
2473     case EM_XCORE:              return "XMOS xCORE processor family";
2474     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2475       /* 210 */
2476     case EM_KM32:               return "KM211 KM32 32-bit processor";
2477     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2478     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2479     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2480     case EM_KVARC:              return "KM211 KVARC processor";
2481     case EM_CDP:                return "Paneve CDP architecture family";
2482     case EM_COGE:               return "Cognitive Smart Memory Processor";
2483     case EM_COOL:               return "Bluechip Systems CoolEngine";
2484     case EM_NORC:               return "Nanoradio Optimized RISC";
2485     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2486       /* 220 */
2487     case EM_Z80:                return "Zilog Z80";
2488     case EM_VISIUM:             return "CDS VISIUMcore processor";
2489     case EM_FT32:               return "FTDI Chip FT32";
2490     case EM_MOXIE:              return "Moxie";
2491     case EM_AMDGPU:             return "AMD GPU";
2492     case EM_RISCV:              return "RISC-V";
2493     case EM_LANAI:              return "Lanai 32-bit processor";
2494     case EM_BPF:                return "Linux BPF";
2495     case EM_NFP:                return "Netronome Flow Processor";
2496
2497       /* Large numbers...  */
2498     case EM_MT:                 return "Morpho Techologies MT processor";
2499     case EM_ALPHA:              return "Alpha";
2500     case EM_WEBASSEMBLY:        return "Web Assembly";
2501     case EM_DLX:                return "OpenDLX";
2502     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2503     case EM_IQ2000:             return "Vitesse IQ2000";
2504     case EM_M32C_OLD:
2505     case EM_NIOS32:             return "Altera Nios";
2506     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2507     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2508     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2509     case EM_S12Z:               return "Freescale S12Z";
2510     case EM_CSKY:               return "C-SKY";
2511
2512     default:
2513       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2514       return buff;
2515     }
2516 }
2517
2518 static void
2519 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2520 {
2521   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2522      other compilers don't a specific architecture type in the e_flags, and
2523      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2524      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2525      architectures.
2526
2527      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2528      but also sets a specific architecture type in the e_flags field.
2529
2530      However, when decoding the flags we don't worry if we see an
2531      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2532      ARCEM architecture type.  */
2533
2534   switch (e_flags & EF_ARC_MACH_MSK)
2535     {
2536       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2537     case EF_ARC_CPU_ARCV2EM:
2538       strcat (buf, ", ARC EM");
2539       break;
2540     case EF_ARC_CPU_ARCV2HS:
2541       strcat (buf, ", ARC HS");
2542       break;
2543
2544       /* We only expect these to occur for EM_ARC_COMPACT.  */
2545     case E_ARC_MACH_ARC600:
2546       strcat (buf, ", ARC600");
2547       break;
2548     case E_ARC_MACH_ARC601:
2549       strcat (buf, ", ARC601");
2550       break;
2551     case E_ARC_MACH_ARC700:
2552       strcat (buf, ", ARC700");
2553       break;
2554
2555       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2556          new ELF with new architecture being read by an old version of
2557          readelf, or (c) An ELF built with non-GNU compiler that does not
2558          set the architecture in the e_flags.  */
2559     default:
2560       if (e_machine == EM_ARC_COMPACT)
2561         strcat (buf, ", Unknown ARCompact");
2562       else
2563         strcat (buf, ", Unknown ARC");
2564       break;
2565     }
2566
2567   switch (e_flags & EF_ARC_OSABI_MSK)
2568     {
2569     case E_ARC_OSABI_ORIG:
2570       strcat (buf, ", (ABI:legacy)");
2571       break;
2572     case E_ARC_OSABI_V2:
2573       strcat (buf, ", (ABI:v2)");
2574       break;
2575       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2576     case E_ARC_OSABI_V3:
2577       strcat (buf, ", v3 no-legacy-syscalls ABI");
2578       break;
2579     case E_ARC_OSABI_V4:
2580       strcat (buf, ", v4 ABI");
2581       break;
2582     default:
2583       strcat (buf, ", unrecognised ARC OSABI flag");
2584       break;
2585     }
2586 }
2587
2588 static void
2589 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2590 {
2591   unsigned eabi;
2592   bfd_boolean unknown = FALSE;
2593
2594   eabi = EF_ARM_EABI_VERSION (e_flags);
2595   e_flags &= ~ EF_ARM_EABIMASK;
2596
2597   /* Handle "generic" ARM flags.  */
2598   if (e_flags & EF_ARM_RELEXEC)
2599     {
2600       strcat (buf, ", relocatable executable");
2601       e_flags &= ~ EF_ARM_RELEXEC;
2602     }
2603
2604   if (e_flags & EF_ARM_PIC)
2605     {
2606       strcat (buf, ", position independent");
2607       e_flags &= ~ EF_ARM_PIC;
2608     }
2609
2610   /* Now handle EABI specific flags.  */
2611   switch (eabi)
2612     {
2613     default:
2614       strcat (buf, ", <unrecognized EABI>");
2615       if (e_flags)
2616         unknown = TRUE;
2617       break;
2618
2619     case EF_ARM_EABI_VER1:
2620       strcat (buf, ", Version1 EABI");
2621       while (e_flags)
2622         {
2623           unsigned flag;
2624
2625           /* Process flags one bit at a time.  */
2626           flag = e_flags & - e_flags;
2627           e_flags &= ~ flag;
2628
2629           switch (flag)
2630             {
2631             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2632               strcat (buf, ", sorted symbol tables");
2633               break;
2634
2635             default:
2636               unknown = TRUE;
2637               break;
2638             }
2639         }
2640       break;
2641
2642     case EF_ARM_EABI_VER2:
2643       strcat (buf, ", Version2 EABI");
2644       while (e_flags)
2645         {
2646           unsigned flag;
2647
2648           /* Process flags one bit at a time.  */
2649           flag = e_flags & - e_flags;
2650           e_flags &= ~ flag;
2651
2652           switch (flag)
2653             {
2654             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2655               strcat (buf, ", sorted symbol tables");
2656               break;
2657
2658             case EF_ARM_DYNSYMSUSESEGIDX:
2659               strcat (buf, ", dynamic symbols use segment index");
2660               break;
2661
2662             case EF_ARM_MAPSYMSFIRST:
2663               strcat (buf, ", mapping symbols precede others");
2664               break;
2665
2666             default:
2667               unknown = TRUE;
2668               break;
2669             }
2670         }
2671       break;
2672
2673     case EF_ARM_EABI_VER3:
2674       strcat (buf, ", Version3 EABI");
2675       break;
2676
2677     case EF_ARM_EABI_VER4:
2678       strcat (buf, ", Version4 EABI");
2679       while (e_flags)
2680         {
2681           unsigned flag;
2682
2683           /* Process flags one bit at a time.  */
2684           flag = e_flags & - e_flags;
2685           e_flags &= ~ flag;
2686
2687           switch (flag)
2688             {
2689             case EF_ARM_BE8:
2690               strcat (buf, ", BE8");
2691               break;
2692
2693             case EF_ARM_LE8:
2694               strcat (buf, ", LE8");
2695               break;
2696
2697             default:
2698               unknown = TRUE;
2699               break;
2700             }
2701         }
2702       break;
2703
2704     case EF_ARM_EABI_VER5:
2705       strcat (buf, ", Version5 EABI");
2706       while (e_flags)
2707         {
2708           unsigned flag;
2709
2710           /* Process flags one bit at a time.  */
2711           flag = e_flags & - e_flags;
2712           e_flags &= ~ flag;
2713
2714           switch (flag)
2715             {
2716             case EF_ARM_BE8:
2717               strcat (buf, ", BE8");
2718               break;
2719
2720             case EF_ARM_LE8:
2721               strcat (buf, ", LE8");
2722               break;
2723
2724             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2725               strcat (buf, ", soft-float ABI");
2726               break;
2727
2728             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2729               strcat (buf, ", hard-float ABI");
2730               break;
2731
2732             default:
2733               unknown = TRUE;
2734               break;
2735             }
2736         }
2737       break;
2738
2739     case EF_ARM_EABI_UNKNOWN:
2740       strcat (buf, ", GNU EABI");
2741       while (e_flags)
2742         {
2743           unsigned flag;
2744
2745           /* Process flags one bit at a time.  */
2746           flag = e_flags & - e_flags;
2747           e_flags &= ~ flag;
2748
2749           switch (flag)
2750             {
2751             case EF_ARM_INTERWORK:
2752               strcat (buf, ", interworking enabled");
2753               break;
2754
2755             case EF_ARM_APCS_26:
2756               strcat (buf, ", uses APCS/26");
2757               break;
2758
2759             case EF_ARM_APCS_FLOAT:
2760               strcat (buf, ", uses APCS/float");
2761               break;
2762
2763             case EF_ARM_PIC:
2764               strcat (buf, ", position independent");
2765               break;
2766
2767             case EF_ARM_ALIGN8:
2768               strcat (buf, ", 8 bit structure alignment");
2769               break;
2770
2771             case EF_ARM_NEW_ABI:
2772               strcat (buf, ", uses new ABI");
2773               break;
2774
2775             case EF_ARM_OLD_ABI:
2776               strcat (buf, ", uses old ABI");
2777               break;
2778
2779             case EF_ARM_SOFT_FLOAT:
2780               strcat (buf, ", software FP");
2781               break;
2782
2783             case EF_ARM_VFP_FLOAT:
2784               strcat (buf, ", VFP");
2785               break;
2786
2787             case EF_ARM_MAVERICK_FLOAT:
2788               strcat (buf, ", Maverick FP");
2789               break;
2790
2791             default:
2792               unknown = TRUE;
2793               break;
2794             }
2795         }
2796     }
2797
2798   if (unknown)
2799     strcat (buf,_(", <unknown>"));
2800 }
2801
2802 static void
2803 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2804 {
2805   --size; /* Leave space for null terminator.  */
2806
2807   switch (e_flags & EF_AVR_MACH)
2808     {
2809     case E_AVR_MACH_AVR1:
2810       strncat (buf, ", avr:1", size);
2811       break;
2812     case E_AVR_MACH_AVR2:
2813       strncat (buf, ", avr:2", size);
2814       break;
2815     case E_AVR_MACH_AVR25:
2816       strncat (buf, ", avr:25", size);
2817       break;
2818     case E_AVR_MACH_AVR3:
2819       strncat (buf, ", avr:3", size);
2820       break;
2821     case E_AVR_MACH_AVR31:
2822       strncat (buf, ", avr:31", size);
2823       break;
2824     case E_AVR_MACH_AVR35:
2825       strncat (buf, ", avr:35", size);
2826       break;
2827     case E_AVR_MACH_AVR4:
2828       strncat (buf, ", avr:4", size);
2829       break;
2830     case E_AVR_MACH_AVR5:
2831       strncat (buf, ", avr:5", size);
2832       break;
2833     case E_AVR_MACH_AVR51:
2834       strncat (buf, ", avr:51", size);
2835       break;
2836     case E_AVR_MACH_AVR6:
2837       strncat (buf, ", avr:6", size);
2838       break;
2839     case E_AVR_MACH_AVRTINY:
2840       strncat (buf, ", avr:100", size);
2841       break;
2842     case E_AVR_MACH_XMEGA1:
2843       strncat (buf, ", avr:101", size);
2844       break;
2845     case E_AVR_MACH_XMEGA2:
2846       strncat (buf, ", avr:102", size);
2847       break;
2848     case E_AVR_MACH_XMEGA3:
2849       strncat (buf, ", avr:103", size);
2850       break;
2851     case E_AVR_MACH_XMEGA4:
2852       strncat (buf, ", avr:104", size);
2853       break;
2854     case E_AVR_MACH_XMEGA5:
2855       strncat (buf, ", avr:105", size);
2856       break;
2857     case E_AVR_MACH_XMEGA6:
2858       strncat (buf, ", avr:106", size);
2859       break;
2860     case E_AVR_MACH_XMEGA7:
2861       strncat (buf, ", avr:107", size);
2862       break;
2863     default:
2864       strncat (buf, ", avr:<unknown>", size);
2865       break;
2866     }
2867
2868   size -= strlen (buf);
2869   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2870     strncat (buf, ", link-relax", size);
2871 }
2872
2873 static void
2874 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2875 {
2876   unsigned abi;
2877   unsigned arch;
2878   unsigned config;
2879   unsigned version;
2880   bfd_boolean has_fpu = FALSE;
2881   unsigned int r = 0;
2882
2883   static const char *ABI_STRINGS[] =
2884   {
2885     "ABI v0", /* use r5 as return register; only used in N1213HC */
2886     "ABI v1", /* use r0 as return register */
2887     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2888     "ABI v2fp", /* for FPU */
2889     "AABI",
2890     "ABI2 FP+"
2891   };
2892   static const char *VER_STRINGS[] =
2893   {
2894     "Andes ELF V1.3 or older",
2895     "Andes ELF V1.3.1",
2896     "Andes ELF V1.4"
2897   };
2898   static const char *ARCH_STRINGS[] =
2899   {
2900     "",
2901     "Andes Star v1.0",
2902     "Andes Star v2.0",
2903     "Andes Star v3.0",
2904     "Andes Star v3.0m"
2905   };
2906
2907   abi = EF_NDS_ABI & e_flags;
2908   arch = EF_NDS_ARCH & e_flags;
2909   config = EF_NDS_INST & e_flags;
2910   version = EF_NDS32_ELF_VERSION & e_flags;
2911
2912   memset (buf, 0, size);
2913
2914   switch (abi)
2915     {
2916     case E_NDS_ABI_V0:
2917     case E_NDS_ABI_V1:
2918     case E_NDS_ABI_V2:
2919     case E_NDS_ABI_V2FP:
2920     case E_NDS_ABI_AABI:
2921     case E_NDS_ABI_V2FP_PLUS:
2922       /* In case there are holes in the array.  */
2923       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2924       break;
2925
2926     default:
2927       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2928       break;
2929     }
2930
2931   switch (version)
2932     {
2933     case E_NDS32_ELF_VER_1_2:
2934     case E_NDS32_ELF_VER_1_3:
2935     case E_NDS32_ELF_VER_1_4:
2936       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2937       break;
2938
2939     default:
2940       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2941       break;
2942     }
2943
2944   if (E_NDS_ABI_V0 == abi)
2945     {
2946       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2947       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2948       if (arch == E_NDS_ARCH_STAR_V1_0)
2949         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2950       return;
2951     }
2952
2953   switch (arch)
2954     {
2955     case E_NDS_ARCH_STAR_V1_0:
2956     case E_NDS_ARCH_STAR_V2_0:
2957     case E_NDS_ARCH_STAR_V3_0:
2958     case E_NDS_ARCH_STAR_V3_M:
2959       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2960       break;
2961
2962     default:
2963       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2964       /* ARCH version determines how the e_flags are interpreted.
2965          If it is unknown, we cannot proceed.  */
2966       return;
2967     }
2968
2969   /* Newer ABI; Now handle architecture specific flags.  */
2970   if (arch == E_NDS_ARCH_STAR_V1_0)
2971     {
2972       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2973         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2974
2975       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2976         r += snprintf (buf + r, size -r, ", MAC");
2977
2978       if (config & E_NDS32_HAS_DIV_INST)
2979         r += snprintf (buf + r, size -r, ", DIV");
2980
2981       if (config & E_NDS32_HAS_16BIT_INST)
2982         r += snprintf (buf + r, size -r, ", 16b");
2983     }
2984   else
2985     {
2986       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2987         {
2988           if (version <= E_NDS32_ELF_VER_1_3)
2989             r += snprintf (buf + r, size -r, ", [B8]");
2990           else
2991             r += snprintf (buf + r, size -r, ", EX9");
2992         }
2993
2994       if (config & E_NDS32_HAS_MAC_DX_INST)
2995         r += snprintf (buf + r, size -r, ", MAC_DX");
2996
2997       if (config & E_NDS32_HAS_DIV_DX_INST)
2998         r += snprintf (buf + r, size -r, ", DIV_DX");
2999
3000       if (config & E_NDS32_HAS_16BIT_INST)
3001         {
3002           if (version <= E_NDS32_ELF_VER_1_3)
3003             r += snprintf (buf + r, size -r, ", 16b");
3004           else
3005             r += snprintf (buf + r, size -r, ", IFC");
3006         }
3007     }
3008
3009   if (config & E_NDS32_HAS_EXT_INST)
3010     r += snprintf (buf + r, size -r, ", PERF1");
3011
3012   if (config & E_NDS32_HAS_EXT2_INST)
3013     r += snprintf (buf + r, size -r, ", PERF2");
3014
3015   if (config & E_NDS32_HAS_FPU_INST)
3016     {
3017       has_fpu = TRUE;
3018       r += snprintf (buf + r, size -r, ", FPU_SP");
3019     }
3020
3021   if (config & E_NDS32_HAS_FPU_DP_INST)
3022     {
3023       has_fpu = TRUE;
3024       r += snprintf (buf + r, size -r, ", FPU_DP");
3025     }
3026
3027   if (config & E_NDS32_HAS_FPU_MAC_INST)
3028     {
3029       has_fpu = TRUE;
3030       r += snprintf (buf + r, size -r, ", FPU_MAC");
3031     }
3032
3033   if (has_fpu)
3034     {
3035       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3036         {
3037         case E_NDS32_FPU_REG_8SP_4DP:
3038           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3039           break;
3040         case E_NDS32_FPU_REG_16SP_8DP:
3041           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3042           break;
3043         case E_NDS32_FPU_REG_32SP_16DP:
3044           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3045           break;
3046         case E_NDS32_FPU_REG_32SP_32DP:
3047           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3048           break;
3049         }
3050     }
3051
3052   if (config & E_NDS32_HAS_AUDIO_INST)
3053     r += snprintf (buf + r, size -r, ", AUDIO");
3054
3055   if (config & E_NDS32_HAS_STRING_INST)
3056     r += snprintf (buf + r, size -r, ", STR");
3057
3058   if (config & E_NDS32_HAS_REDUCED_REGS)
3059     r += snprintf (buf + r, size -r, ", 16REG");
3060
3061   if (config & E_NDS32_HAS_VIDEO_INST)
3062     {
3063       if (version <= E_NDS32_ELF_VER_1_3)
3064         r += snprintf (buf + r, size -r, ", VIDEO");
3065       else
3066         r += snprintf (buf + r, size -r, ", SATURATION");
3067     }
3068
3069   if (config & E_NDS32_HAS_ENCRIPT_INST)
3070     r += snprintf (buf + r, size -r, ", ENCRP");
3071
3072   if (config & E_NDS32_HAS_L2C_INST)
3073     r += snprintf (buf + r, size -r, ", L2C");
3074 }
3075
3076 static char *
3077 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3078 {
3079   static char buf[1024];
3080
3081   buf[0] = '\0';
3082
3083   if (e_flags)
3084     {
3085       switch (e_machine)
3086         {
3087         default:
3088           break;
3089
3090         case EM_ARC_COMPACT2:
3091         case EM_ARC_COMPACT:
3092           decode_ARC_machine_flags (e_flags, e_machine, buf);
3093           break;
3094
3095         case EM_ARM:
3096           decode_ARM_machine_flags (e_flags, buf);
3097           break;
3098
3099         case EM_AVR:
3100           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3101           break;
3102
3103         case EM_BLACKFIN:
3104           if (e_flags & EF_BFIN_PIC)
3105             strcat (buf, ", PIC");
3106
3107           if (e_flags & EF_BFIN_FDPIC)
3108             strcat (buf, ", FDPIC");
3109
3110           if (e_flags & EF_BFIN_CODE_IN_L1)
3111             strcat (buf, ", code in L1");
3112
3113           if (e_flags & EF_BFIN_DATA_IN_L1)
3114             strcat (buf, ", data in L1");
3115
3116           break;
3117
3118         case EM_CYGNUS_FRV:
3119           switch (e_flags & EF_FRV_CPU_MASK)
3120             {
3121             case EF_FRV_CPU_GENERIC:
3122               break;
3123
3124             default:
3125               strcat (buf, ", fr???");
3126               break;
3127
3128             case EF_FRV_CPU_FR300:
3129               strcat (buf, ", fr300");
3130               break;
3131
3132             case EF_FRV_CPU_FR400:
3133               strcat (buf, ", fr400");
3134               break;
3135             case EF_FRV_CPU_FR405:
3136               strcat (buf, ", fr405");
3137               break;
3138
3139             case EF_FRV_CPU_FR450:
3140               strcat (buf, ", fr450");
3141               break;
3142
3143             case EF_FRV_CPU_FR500:
3144               strcat (buf, ", fr500");
3145               break;
3146             case EF_FRV_CPU_FR550:
3147               strcat (buf, ", fr550");
3148               break;
3149
3150             case EF_FRV_CPU_SIMPLE:
3151               strcat (buf, ", simple");
3152               break;
3153             case EF_FRV_CPU_TOMCAT:
3154               strcat (buf, ", tomcat");
3155               break;
3156             }
3157           break;
3158
3159         case EM_68K:
3160           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3161             strcat (buf, ", m68000");
3162           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3163             strcat (buf, ", cpu32");
3164           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3165             strcat (buf, ", fido_a");
3166           else
3167             {
3168               char const * isa = _("unknown");
3169               char const * mac = _("unknown mac");
3170               char const * additional = NULL;
3171
3172               switch (e_flags & EF_M68K_CF_ISA_MASK)
3173                 {
3174                 case EF_M68K_CF_ISA_A_NODIV:
3175                   isa = "A";
3176                   additional = ", nodiv";
3177                   break;
3178                 case EF_M68K_CF_ISA_A:
3179                   isa = "A";
3180                   break;
3181                 case EF_M68K_CF_ISA_A_PLUS:
3182                   isa = "A+";
3183                   break;
3184                 case EF_M68K_CF_ISA_B_NOUSP:
3185                   isa = "B";
3186                   additional = ", nousp";
3187                   break;
3188                 case EF_M68K_CF_ISA_B:
3189                   isa = "B";
3190                   break;
3191                 case EF_M68K_CF_ISA_C:
3192                   isa = "C";
3193                   break;
3194                 case EF_M68K_CF_ISA_C_NODIV:
3195                   isa = "C";
3196                   additional = ", nodiv";
3197                   break;
3198                 }
3199               strcat (buf, ", cf, isa ");
3200               strcat (buf, isa);
3201               if (additional)
3202                 strcat (buf, additional);
3203               if (e_flags & EF_M68K_CF_FLOAT)
3204                 strcat (buf, ", float");
3205               switch (e_flags & EF_M68K_CF_MAC_MASK)
3206                 {
3207                 case 0:
3208                   mac = NULL;
3209                   break;
3210                 case EF_M68K_CF_MAC:
3211                   mac = "mac";
3212                   break;
3213                 case EF_M68K_CF_EMAC:
3214                   mac = "emac";
3215                   break;
3216                 case EF_M68K_CF_EMAC_B:
3217                   mac = "emac_b";
3218                   break;
3219                 }
3220               if (mac)
3221                 {
3222                   strcat (buf, ", ");
3223                   strcat (buf, mac);
3224                 }
3225             }
3226           break;
3227
3228         case EM_CYGNUS_MEP:
3229           switch (e_flags & EF_MEP_CPU_MASK)
3230             {
3231             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3232             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3233             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3234             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3235             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3236             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3237             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3238             }
3239
3240           switch (e_flags & EF_MEP_COP_MASK)
3241             {
3242             case EF_MEP_COP_NONE: break;
3243             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3244             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3245             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3246             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3247             default: strcat (buf, _("<unknown MeP copro type>")); break;
3248             }
3249
3250           if (e_flags & EF_MEP_LIBRARY)
3251             strcat (buf, ", Built for Library");
3252
3253           if (e_flags & EF_MEP_INDEX_MASK)
3254             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3255                      e_flags & EF_MEP_INDEX_MASK);
3256
3257           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3258             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3259                      e_flags & ~ EF_MEP_ALL_FLAGS);
3260           break;
3261
3262         case EM_PPC:
3263           if (e_flags & EF_PPC_EMB)
3264             strcat (buf, ", emb");
3265
3266           if (e_flags & EF_PPC_RELOCATABLE)
3267             strcat (buf, _(", relocatable"));
3268
3269           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3270             strcat (buf, _(", relocatable-lib"));
3271           break;
3272
3273         case EM_PPC64:
3274           if (e_flags & EF_PPC64_ABI)
3275             {
3276               char abi[] = ", abiv0";
3277
3278               abi[6] += e_flags & EF_PPC64_ABI;
3279               strcat (buf, abi);
3280             }
3281           break;
3282
3283         case EM_V800:
3284           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3285             strcat (buf, ", RH850 ABI");
3286
3287           if (e_flags & EF_V800_850E3)
3288             strcat (buf, ", V3 architecture");
3289
3290           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3291             strcat (buf, ", FPU not used");
3292
3293           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3294             strcat (buf, ", regmode: COMMON");
3295
3296           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3297             strcat (buf, ", r4 not used");
3298
3299           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3300             strcat (buf, ", r30 not used");
3301
3302           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3303             strcat (buf, ", r5 not used");
3304
3305           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3306             strcat (buf, ", r2 not used");
3307
3308           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3309             {
3310               switch (e_flags & - e_flags)
3311                 {
3312                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3313                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3314                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3315                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3316                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3317                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3318                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3319                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3320                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3321                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3322                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3323                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3324                 default: break;
3325                 }
3326             }
3327           break;
3328
3329         case EM_V850:
3330         case EM_CYGNUS_V850:
3331           switch (e_flags & EF_V850_ARCH)
3332             {
3333             case E_V850E3V5_ARCH:
3334               strcat (buf, ", v850e3v5");
3335               break;
3336             case E_V850E2V3_ARCH:
3337               strcat (buf, ", v850e2v3");
3338               break;
3339             case E_V850E2_ARCH:
3340               strcat (buf, ", v850e2");
3341               break;
3342             case E_V850E1_ARCH:
3343               strcat (buf, ", v850e1");
3344               break;
3345             case E_V850E_ARCH:
3346               strcat (buf, ", v850e");
3347               break;
3348             case E_V850_ARCH:
3349               strcat (buf, ", v850");
3350               break;
3351             default:
3352               strcat (buf, _(", unknown v850 architecture variant"));
3353               break;
3354             }
3355           break;
3356
3357         case EM_M32R:
3358         case EM_CYGNUS_M32R:
3359           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3360             strcat (buf, ", m32r");
3361           break;
3362
3363         case EM_MIPS:
3364         case EM_MIPS_RS3_LE:
3365           if (e_flags & EF_MIPS_NOREORDER)
3366             strcat (buf, ", noreorder");
3367
3368           if (e_flags & EF_MIPS_PIC)
3369             strcat (buf, ", pic");
3370
3371           if (e_flags & EF_MIPS_CPIC)
3372             strcat (buf, ", cpic");
3373
3374           if (e_flags & EF_MIPS_UCODE)
3375             strcat (buf, ", ugen_reserved");
3376
3377           if (e_flags & EF_MIPS_ABI2)
3378             strcat (buf, ", abi2");
3379
3380           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3381             strcat (buf, ", odk first");
3382
3383           if (e_flags & EF_MIPS_32BITMODE)
3384             strcat (buf, ", 32bitmode");
3385
3386           if (e_flags & EF_MIPS_NAN2008)
3387             strcat (buf, ", nan2008");
3388
3389           if (e_flags & EF_MIPS_FP64)
3390             strcat (buf, ", fp64");
3391
3392           switch ((e_flags & EF_MIPS_MACH))
3393             {
3394             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3395             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3396             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3397             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3398             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3399             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3400             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3401             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3402             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3403             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3404             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3405             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3406             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3407             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3408             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3409             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3410             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3411             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3412             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3413             case 0:
3414             /* We simply ignore the field in this case to avoid confusion:
3415                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3416                extension.  */
3417               break;
3418             default: strcat (buf, _(", unknown CPU")); break;
3419             }
3420
3421           switch ((e_flags & EF_MIPS_ABI))
3422             {
3423             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3424             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3425             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3426             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3427             case 0:
3428             /* We simply ignore the field in this case to avoid confusion:
3429                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3430                This means it is likely to be an o32 file, but not for
3431                sure.  */
3432               break;
3433             default: strcat (buf, _(", unknown ABI")); break;
3434             }
3435
3436           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3437             strcat (buf, ", mdmx");
3438
3439           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3440             strcat (buf, ", mips16");
3441
3442           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3443             strcat (buf, ", micromips");
3444
3445           switch ((e_flags & EF_MIPS_ARCH))
3446             {
3447             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3448             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3449             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3450             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3451             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3452             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3453             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3454             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3455             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3456             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3457             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3458             default: strcat (buf, _(", unknown ISA")); break;
3459             }
3460           break;
3461
3462         case EM_NDS32:
3463           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3464           break;
3465
3466         case EM_NFP:
3467           switch (EF_NFP_MACH (e_flags))
3468             {
3469             case E_NFP_MACH_3200:
3470               strcat (buf, ", NFP-32xx");
3471               break;
3472             case E_NFP_MACH_6000:
3473               strcat (buf, ", NFP-6xxx");
3474               break;
3475             }
3476           break;
3477
3478         case EM_RISCV:
3479           if (e_flags & EF_RISCV_RVC)
3480             strcat (buf, ", RVC");
3481
3482           if (e_flags & EF_RISCV_RVE)
3483             strcat (buf, ", RVE");
3484
3485           switch (e_flags & EF_RISCV_FLOAT_ABI)
3486             {
3487             case EF_RISCV_FLOAT_ABI_SOFT:
3488               strcat (buf, ", soft-float ABI");
3489               break;
3490
3491             case EF_RISCV_FLOAT_ABI_SINGLE:
3492               strcat (buf, ", single-float ABI");
3493               break;
3494
3495             case EF_RISCV_FLOAT_ABI_DOUBLE:
3496               strcat (buf, ", double-float ABI");
3497               break;
3498
3499             case EF_RISCV_FLOAT_ABI_QUAD:
3500               strcat (buf, ", quad-float ABI");
3501               break;
3502             }
3503           break;
3504
3505         case EM_SH:
3506           switch ((e_flags & EF_SH_MACH_MASK))
3507             {
3508             case EF_SH1: strcat (buf, ", sh1"); break;
3509             case EF_SH2: strcat (buf, ", sh2"); break;
3510             case EF_SH3: strcat (buf, ", sh3"); break;
3511             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3512             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3513             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3514             case EF_SH3E: strcat (buf, ", sh3e"); break;
3515             case EF_SH4: strcat (buf, ", sh4"); break;
3516             case EF_SH5: strcat (buf, ", sh5"); break;
3517             case EF_SH2E: strcat (buf, ", sh2e"); break;
3518             case EF_SH4A: strcat (buf, ", sh4a"); break;
3519             case EF_SH2A: strcat (buf, ", sh2a"); break;
3520             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3521             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3522             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3523             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3524             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3525             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3526             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3527             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3528             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3529             default: strcat (buf, _(", unknown ISA")); break;
3530             }
3531
3532           if (e_flags & EF_SH_PIC)
3533             strcat (buf, ", pic");
3534
3535           if (e_flags & EF_SH_FDPIC)
3536             strcat (buf, ", fdpic");
3537           break;
3538
3539         case EM_OR1K:
3540           if (e_flags & EF_OR1K_NODELAY)
3541             strcat (buf, ", no delay");
3542           break;
3543
3544         case EM_SPARCV9:
3545           if (e_flags & EF_SPARC_32PLUS)
3546             strcat (buf, ", v8+");
3547
3548           if (e_flags & EF_SPARC_SUN_US1)
3549             strcat (buf, ", ultrasparcI");
3550
3551           if (e_flags & EF_SPARC_SUN_US3)
3552             strcat (buf, ", ultrasparcIII");
3553
3554           if (e_flags & EF_SPARC_HAL_R1)
3555             strcat (buf, ", halr1");
3556
3557           if (e_flags & EF_SPARC_LEDATA)
3558             strcat (buf, ", ledata");
3559
3560           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3561             strcat (buf, ", tso");
3562
3563           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3564             strcat (buf, ", pso");
3565
3566           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3567             strcat (buf, ", rmo");
3568           break;
3569
3570         case EM_PARISC:
3571           switch (e_flags & EF_PARISC_ARCH)
3572             {
3573             case EFA_PARISC_1_0:
3574               strcpy (buf, ", PA-RISC 1.0");
3575               break;
3576             case EFA_PARISC_1_1:
3577               strcpy (buf, ", PA-RISC 1.1");
3578               break;
3579             case EFA_PARISC_2_0:
3580               strcpy (buf, ", PA-RISC 2.0");
3581               break;
3582             default:
3583               break;
3584             }
3585           if (e_flags & EF_PARISC_TRAPNIL)
3586             strcat (buf, ", trapnil");
3587           if (e_flags & EF_PARISC_EXT)
3588             strcat (buf, ", ext");
3589           if (e_flags & EF_PARISC_LSB)
3590             strcat (buf, ", lsb");
3591           if (e_flags & EF_PARISC_WIDE)
3592             strcat (buf, ", wide");
3593           if (e_flags & EF_PARISC_NO_KABP)
3594             strcat (buf, ", no kabp");
3595           if (e_flags & EF_PARISC_LAZYSWAP)
3596             strcat (buf, ", lazyswap");
3597           break;
3598
3599         case EM_PJ:
3600         case EM_PJ_OLD:
3601           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3602             strcat (buf, ", new calling convention");
3603
3604           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3605             strcat (buf, ", gnu calling convention");
3606           break;
3607
3608         case EM_IA_64:
3609           if ((e_flags & EF_IA_64_ABI64))
3610             strcat (buf, ", 64-bit");
3611           else
3612             strcat (buf, ", 32-bit");
3613           if ((e_flags & EF_IA_64_REDUCEDFP))
3614             strcat (buf, ", reduced fp model");
3615           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3616             strcat (buf, ", no function descriptors, constant gp");
3617           else if ((e_flags & EF_IA_64_CONS_GP))
3618             strcat (buf, ", constant gp");
3619           if ((e_flags & EF_IA_64_ABSOLUTE))
3620             strcat (buf, ", absolute");
3621           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3622             {
3623               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3624                 strcat (buf, ", vms_linkages");
3625               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3626                 {
3627                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3628                   break;
3629                 case EF_IA_64_VMS_COMCOD_WARNING:
3630                   strcat (buf, ", warning");
3631                   break;
3632                 case EF_IA_64_VMS_COMCOD_ERROR:
3633                   strcat (buf, ", error");
3634                   break;
3635                 case EF_IA_64_VMS_COMCOD_ABORT:
3636                   strcat (buf, ", abort");
3637                   break;
3638                 default:
3639                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3640                         e_flags & EF_IA_64_VMS_COMCOD);
3641                   strcat (buf, ", <unknown>");
3642                 }
3643             }
3644           break;
3645
3646         case EM_VAX:
3647           if ((e_flags & EF_VAX_NONPIC))
3648             strcat (buf, ", non-PIC");
3649           if ((e_flags & EF_VAX_DFLOAT))
3650             strcat (buf, ", D-Float");
3651           if ((e_flags & EF_VAX_GFLOAT))
3652             strcat (buf, ", G-Float");
3653           break;
3654
3655         case EM_VISIUM:
3656           if (e_flags & EF_VISIUM_ARCH_MCM)
3657             strcat (buf, ", mcm");
3658           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3659             strcat (buf, ", mcm24");
3660           if (e_flags & EF_VISIUM_ARCH_GR6)
3661             strcat (buf, ", gr6");
3662           break;
3663
3664         case EM_RL78:
3665           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3666             {
3667             case E_FLAG_RL78_ANY_CPU: break;
3668             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3669             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3670             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3671             }
3672           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3673             strcat (buf, ", 64-bit doubles");
3674           break;
3675
3676         case EM_RX:
3677           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3678             strcat (buf, ", 64-bit doubles");
3679           if (e_flags & E_FLAG_RX_DSP)
3680             strcat (buf, ", dsp");
3681           if (e_flags & E_FLAG_RX_PID)
3682             strcat (buf, ", pid");
3683           if (e_flags & E_FLAG_RX_ABI)
3684             strcat (buf, ", RX ABI");
3685           if (e_flags & E_FLAG_RX_SINSNS_SET)
3686             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3687                     ? ", uses String instructions" : ", bans String instructions");
3688           if (e_flags & E_FLAG_RX_V2)
3689             strcat (buf, ", V2");
3690           break;
3691
3692         case EM_S390:
3693           if (e_flags & EF_S390_HIGH_GPRS)
3694             strcat (buf, ", highgprs");
3695           break;
3696
3697         case EM_TI_C6000:
3698           if ((e_flags & EF_C6000_REL))
3699             strcat (buf, ", relocatable module");
3700           break;
3701
3702         case EM_MSP430:
3703           strcat (buf, _(": architecture variant: "));
3704           switch (e_flags & EF_MSP430_MACH)
3705             {
3706             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3707             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3708             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3709             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3710             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3711             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3712             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3713             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3714             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3715             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3716             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3717             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3718             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3719             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3720             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3721             default:
3722               strcat (buf, _(": unknown")); break;
3723             }
3724
3725           if (e_flags & ~ EF_MSP430_MACH)
3726             strcat (buf, _(": unknown extra flag bits also present"));
3727         }
3728     }
3729
3730   return buf;
3731 }
3732
3733 static const char *
3734 get_osabi_name (Filedata * filedata, unsigned int osabi)
3735 {
3736   static char buff[32];
3737
3738   switch (osabi)
3739     {
3740     case ELFOSABI_NONE:         return "UNIX - System V";
3741     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3742     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3743     case ELFOSABI_GNU:          return "UNIX - GNU";
3744     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3745     case ELFOSABI_AIX:          return "UNIX - AIX";
3746     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3747     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3748     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3749     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3750     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3751     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3752     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3753     case ELFOSABI_AROS:         return "AROS";
3754     case ELFOSABI_FENIXOS:      return "FenixOS";
3755     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3756     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3757     default:
3758       if (osabi >= 64)
3759         switch (filedata->file_header.e_machine)
3760           {
3761           case EM_ARM:
3762             switch (osabi)
3763               {
3764               case ELFOSABI_ARM:        return "ARM";
3765               case ELFOSABI_ARM_FDPIC:  return "ARM FDPIC";
3766               default:
3767                 break;
3768               }
3769             break;
3770
3771           case EM_MSP430:
3772           case EM_MSP430_OLD:
3773           case EM_VISIUM:
3774             switch (osabi)
3775               {
3776               case ELFOSABI_STANDALONE: return _("Standalone App");
3777               default:
3778                 break;
3779               }
3780             break;
3781
3782           case EM_TI_C6000:
3783             switch (osabi)
3784               {
3785               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3786               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3787               default:
3788                 break;
3789               }
3790             break;
3791
3792           default:
3793             break;
3794           }
3795       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3796       return buff;
3797     }
3798 }
3799
3800 static const char *
3801 get_aarch64_segment_type (unsigned long type)
3802 {
3803   switch (type)
3804     {
3805     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3806     default:                  return NULL;
3807     }
3808 }
3809
3810 static const char *
3811 get_arm_segment_type (unsigned long type)
3812 {
3813   switch (type)
3814     {
3815     case PT_ARM_EXIDX: return "EXIDX";
3816     default:           return NULL;
3817     }
3818 }
3819
3820 static const char *
3821 get_s390_segment_type (unsigned long type)
3822 {
3823   switch (type)
3824     {
3825     case PT_S390_PGSTE: return "S390_PGSTE";
3826     default:            return NULL;
3827     }
3828 }
3829
3830 static const char *
3831 get_mips_segment_type (unsigned long type)
3832 {
3833   switch (type)
3834     {
3835     case PT_MIPS_REGINFO:   return "REGINFO";
3836     case PT_MIPS_RTPROC:    return "RTPROC";
3837     case PT_MIPS_OPTIONS:   return "OPTIONS";
3838     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3839     default:                return NULL;
3840     }
3841 }
3842
3843 static const char *
3844 get_parisc_segment_type (unsigned long type)
3845 {
3846   switch (type)
3847     {
3848     case PT_HP_TLS:             return "HP_TLS";
3849     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3850     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3851     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3852     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3853     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3854     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3855     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3856     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3857     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3858     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3859     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3860     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3861     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3862     case PT_HP_STACK:           return "HP_STACK";
3863     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3864     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3865     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3866     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3867     default:                    return NULL;
3868     }
3869 }
3870
3871 static const char *
3872 get_ia64_segment_type (unsigned long type)
3873 {
3874   switch (type)
3875     {
3876     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3877     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3878     case PT_HP_TLS:             return "HP_TLS";
3879     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3880     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3881     case PT_IA_64_HP_STACK:     return "HP_STACK";
3882     default:                    return NULL;
3883     }
3884 }
3885
3886 static const char *
3887 get_tic6x_segment_type (unsigned long type)
3888 {
3889   switch (type)
3890     {
3891     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3892     default:               return NULL;
3893     }
3894 }
3895
3896 static const char *
3897 get_solaris_segment_type (unsigned long type)
3898 {
3899   switch (type)
3900     {
3901     case 0x6464e550: return "PT_SUNW_UNWIND";
3902     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3903     case 0x6ffffff7: return "PT_LOSUNW";
3904     case 0x6ffffffa: return "PT_SUNWBSS";
3905     case 0x6ffffffb: return "PT_SUNWSTACK";
3906     case 0x6ffffffc: return "PT_SUNWDTRACE";
3907     case 0x6ffffffd: return "PT_SUNWCAP";
3908     case 0x6fffffff: return "PT_HISUNW";
3909     default:         return NULL;
3910     }
3911 }
3912
3913 static const char *
3914 get_segment_type (Filedata * filedata, unsigned long p_type)
3915 {
3916   static char buff[32];
3917
3918   switch (p_type)
3919     {
3920     case PT_NULL:       return "NULL";
3921     case PT_LOAD:       return "LOAD";
3922     case PT_DYNAMIC:    return "DYNAMIC";
3923     case PT_INTERP:     return "INTERP";
3924     case PT_NOTE:       return "NOTE";
3925     case PT_SHLIB:      return "SHLIB";
3926     case PT_PHDR:       return "PHDR";
3927     case PT_TLS:        return "TLS";
3928     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3929     case PT_GNU_STACK:  return "GNU_STACK";
3930     case PT_GNU_RELRO:  return "GNU_RELRO";
3931
3932     default:
3933       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3934         {
3935           sprintf (buff, "GNU_MBIND+%#lx",
3936                    p_type - PT_GNU_MBIND_LO);
3937         }
3938       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3939         {
3940           const char * result;
3941
3942           switch (filedata->file_header.e_machine)
3943             {
3944             case EM_AARCH64:
3945               result = get_aarch64_segment_type (p_type);
3946               break;
3947             case EM_ARM:
3948               result = get_arm_segment_type (p_type);
3949               break;
3950             case EM_MIPS:
3951             case EM_MIPS_RS3_LE:
3952               result = get_mips_segment_type (p_type);
3953               break;
3954             case EM_PARISC:
3955               result = get_parisc_segment_type (p_type);
3956               break;
3957             case EM_IA_64:
3958               result = get_ia64_segment_type (p_type);
3959               break;
3960             case EM_TI_C6000:
3961               result = get_tic6x_segment_type (p_type);
3962               break;
3963             case EM_S390:
3964             case EM_S390_OLD:
3965               result = get_s390_segment_type (p_type);
3966               break;
3967             default:
3968               result = NULL;
3969               break;
3970             }
3971
3972           if (result != NULL)
3973             return result;
3974
3975           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3976         }
3977       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3978         {
3979           const char * result;
3980
3981           switch (filedata->file_header.e_machine)
3982             {
3983             case EM_PARISC:
3984               result = get_parisc_segment_type (p_type);
3985               break;
3986             case EM_IA_64:
3987               result = get_ia64_segment_type (p_type);
3988               break;
3989             default:
3990               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3991                 result = get_solaris_segment_type (p_type);
3992               else
3993                 result = NULL;
3994               break;
3995             }
3996
3997           if (result != NULL)
3998             return result;
3999
4000           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4001         }
4002       else
4003         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4004
4005       return buff;
4006     }
4007 }
4008
4009 static const char *
4010 get_arc_section_type_name (unsigned int sh_type)
4011 {
4012   switch (sh_type)
4013     {
4014     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
4015     default:
4016       break;
4017     }
4018   return NULL;
4019 }
4020
4021 static const char *
4022 get_mips_section_type_name (unsigned int sh_type)
4023 {
4024   switch (sh_type)
4025     {
4026     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
4027     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
4028     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
4029     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
4030     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
4031     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
4032     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
4033     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
4034     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
4035     case SHT_MIPS_RELD:          return "MIPS_RELD";
4036     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
4037     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
4038     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
4039     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
4040     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
4041     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
4042     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
4043     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
4044     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
4045     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4046     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4047     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4048     case SHT_MIPS_LINE:          return "MIPS_LINE";
4049     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4050     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4051     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4052     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4053     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4054     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4055     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4056     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4057     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4058     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4059     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4060     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4061     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4062     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4063     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4064     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4065     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4066     default:
4067       break;
4068     }
4069   return NULL;
4070 }
4071
4072 static const char *
4073 get_parisc_section_type_name (unsigned int sh_type)
4074 {
4075   switch (sh_type)
4076     {
4077     case SHT_PARISC_EXT:        return "PARISC_EXT";
4078     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4079     case SHT_PARISC_DOC:        return "PARISC_DOC";
4080     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4081     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4082     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4083     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4084     default:                    return NULL;
4085     }
4086 }
4087
4088 static const char *
4089 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4090 {
4091   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4092   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4093     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4094
4095   switch (sh_type)
4096     {
4097     case SHT_IA_64_EXT:                return "IA_64_EXT";
4098     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4099     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4100     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4101     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4102     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4103     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4104     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4105     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4106     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4107     default:
4108       break;
4109     }
4110   return NULL;
4111 }
4112
4113 static const char *
4114 get_x86_64_section_type_name (unsigned int sh_type)
4115 {
4116   switch (sh_type)
4117     {
4118     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4119     default:                    return NULL;
4120     }
4121 }
4122
4123 static const char *
4124 get_aarch64_section_type_name (unsigned int sh_type)
4125 {
4126   switch (sh_type)
4127     {
4128     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4129     default:                     return NULL;
4130     }
4131 }
4132
4133 static const char *
4134 get_arm_section_type_name (unsigned int sh_type)
4135 {
4136   switch (sh_type)
4137     {
4138     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4139     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4140     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4141     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4142     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4143     default:                      return NULL;
4144     }
4145 }
4146
4147 static const char *
4148 get_tic6x_section_type_name (unsigned int sh_type)
4149 {
4150   switch (sh_type)
4151     {
4152     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4153     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4154     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4155     case SHT_TI_ICODE:          return "TI_ICODE";
4156     case SHT_TI_XREF:           return "TI_XREF";
4157     case SHT_TI_HANDLER:        return "TI_HANDLER";
4158     case SHT_TI_INITINFO:       return "TI_INITINFO";
4159     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4160     default:                    return NULL;
4161     }
4162 }
4163
4164 static const char *
4165 get_msp430x_section_type_name (unsigned int sh_type)
4166 {
4167   switch (sh_type)
4168     {
4169     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4170     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4171     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4172     default:                      return NULL;
4173     }
4174 }
4175
4176 static const char *
4177 get_nfp_section_type_name (unsigned int sh_type)
4178 {
4179   switch (sh_type)
4180     {
4181     case SHT_NFP_MECONFIG:      return "NFP_MECONFIG";
4182     case SHT_NFP_INITREG:       return "NFP_INITREG";
4183     case SHT_NFP_UDEBUG:        return "NFP_UDEBUG";
4184     default:                    return NULL;
4185     }
4186 }
4187
4188 static const char *
4189 get_v850_section_type_name (unsigned int sh_type)
4190 {
4191   switch (sh_type)
4192     {
4193     case SHT_V850_SCOMMON:  return "V850 Small Common";
4194     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4195     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4196     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4197     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4198     default:                return NULL;
4199     }
4200 }
4201
4202 static const char *
4203 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4204 {
4205   static char buff[32];
4206   const char * result;
4207
4208   switch (sh_type)
4209     {
4210     case SHT_NULL:              return "NULL";
4211     case SHT_PROGBITS:          return "PROGBITS";
4212     case SHT_SYMTAB:            return "SYMTAB";
4213     case SHT_STRTAB:            return "STRTAB";
4214     case SHT_RELA:              return "RELA";
4215     case SHT_HASH:              return "HASH";
4216     case SHT_DYNAMIC:           return "DYNAMIC";
4217     case SHT_NOTE:              return "NOTE";
4218     case SHT_NOBITS:            return "NOBITS";
4219     case SHT_REL:               return "REL";
4220     case SHT_SHLIB:             return "SHLIB";
4221     case SHT_DYNSYM:            return "DYNSYM";
4222     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4223     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4224     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4225     case SHT_GNU_HASH:          return "GNU_HASH";
4226     case SHT_GROUP:             return "GROUP";
4227     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICES";
4228     case SHT_GNU_verdef:        return "VERDEF";
4229     case SHT_GNU_verneed:       return "VERNEED";
4230     case SHT_GNU_versym:        return "VERSYM";
4231     case 0x6ffffff0:            return "VERSYM";
4232     case 0x6ffffffc:            return "VERDEF";
4233     case 0x7ffffffd:            return "AUXILIARY";
4234     case 0x7fffffff:            return "FILTER";
4235     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4236
4237     default:
4238       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4239         {
4240           switch (filedata->file_header.e_machine)
4241             {
4242             case EM_ARC:
4243             case EM_ARC_COMPACT:
4244             case EM_ARC_COMPACT2:
4245               result = get_arc_section_type_name (sh_type);
4246               break;
4247             case EM_MIPS:
4248             case EM_MIPS_RS3_LE:
4249               result = get_mips_section_type_name (sh_type);
4250               break;
4251             case EM_PARISC:
4252               result = get_parisc_section_type_name (sh_type);
4253               break;
4254             case EM_IA_64:
4255               result = get_ia64_section_type_name (filedata, sh_type);
4256               break;
4257             case EM_X86_64:
4258             case EM_L1OM:
4259             case EM_K1OM:
4260               result = get_x86_64_section_type_name (sh_type);
4261               break;
4262             case EM_AARCH64:
4263               result = get_aarch64_section_type_name (sh_type);
4264               break;
4265             case EM_ARM:
4266               result = get_arm_section_type_name (sh_type);
4267               break;
4268             case EM_TI_C6000:
4269               result = get_tic6x_section_type_name (sh_type);
4270               break;
4271             case EM_MSP430:
4272               result = get_msp430x_section_type_name (sh_type);
4273               break;
4274             case EM_NFP:
4275               result = get_nfp_section_type_name (sh_type);
4276               break;
4277             case EM_V800:
4278             case EM_V850:
4279             case EM_CYGNUS_V850:
4280               result = get_v850_section_type_name (sh_type);
4281               break;
4282             default:
4283               result = NULL;
4284               break;
4285             }
4286
4287           if (result != NULL)
4288             return result;
4289
4290           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4291         }
4292       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4293         {
4294           switch (filedata->file_header.e_machine)
4295             {
4296             case EM_IA_64:
4297               result = get_ia64_section_type_name (filedata, sh_type);
4298               break;
4299             default:
4300               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4301                 result = get_solaris_section_type (sh_type);
4302               else
4303                 {
4304                   switch (sh_type)
4305                     {
4306                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4307                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4308                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4309                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4310                     default:
4311                       result = NULL;
4312                       break;
4313                     }
4314                 }
4315               break;
4316             }
4317
4318           if (result != NULL)
4319             return result;
4320
4321           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4322         }
4323       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4324         {
4325           switch (filedata->file_header.e_machine)
4326             {
4327             case EM_V800:
4328             case EM_V850:
4329             case EM_CYGNUS_V850:
4330               result = get_v850_section_type_name (sh_type);
4331               break;
4332             default:
4333               result = NULL;
4334               break;
4335             }
4336
4337           if (result != NULL)
4338             return result;
4339
4340           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4341         }
4342       else
4343         /* This message is probably going to be displayed in a 15
4344            character wide field, so put the hex value first.  */
4345         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4346
4347       return buff;
4348     }
4349 }
4350
4351 #define OPTION_DEBUG_DUMP       512
4352 #define OPTION_DYN_SYMS         513
4353 #define OPTION_DWARF_DEPTH      514
4354 #define OPTION_DWARF_START      515
4355 #define OPTION_DWARF_CHECK      516
4356
4357 static struct option options[] =
4358 {
4359   {"all",              no_argument, 0, 'a'},
4360   {"file-header",      no_argument, 0, 'h'},
4361   {"program-headers",  no_argument, 0, 'l'},
4362   {"headers",          no_argument, 0, 'e'},
4363   {"histogram",        no_argument, 0, 'I'},
4364   {"segments",         no_argument, 0, 'l'},
4365   {"sections",         no_argument, 0, 'S'},
4366   {"section-headers",  no_argument, 0, 'S'},
4367   {"section-groups",   no_argument, 0, 'g'},
4368   {"section-details",  no_argument, 0, 't'},
4369   {"full-section-name",no_argument, 0, 'N'},
4370   {"symbols",          no_argument, 0, 's'},
4371   {"syms",             no_argument, 0, 's'},
4372   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4373   {"relocs",           no_argument, 0, 'r'},
4374   {"notes",            no_argument, 0, 'n'},
4375   {"dynamic",          no_argument, 0, 'd'},
4376   {"arch-specific",    no_argument, 0, 'A'},
4377   {"version-info",     no_argument, 0, 'V'},
4378   {"use-dynamic",      no_argument, 0, 'D'},
4379   {"unwind",           no_argument, 0, 'u'},
4380   {"archive-index",    no_argument, 0, 'c'},
4381   {"hex-dump",         required_argument, 0, 'x'},
4382   {"relocated-dump",   required_argument, 0, 'R'},
4383   {"string-dump",      required_argument, 0, 'p'},
4384   {"decompress",       no_argument, 0, 'z'},
4385 #ifdef SUPPORT_DISASSEMBLY
4386   {"instruction-dump", required_argument, 0, 'i'},
4387 #endif
4388   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4389
4390   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4391   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4392   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4393
4394   {"version",          no_argument, 0, 'v'},
4395   {"wide",             no_argument, 0, 'W'},
4396   {"help",             no_argument, 0, 'H'},
4397   {0,                  no_argument, 0, 0}
4398 };
4399
4400 static void
4401 usage (FILE * stream)
4402 {
4403   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4404   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4405   fprintf (stream, _(" Options are:\n\
4406   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4407   -h --file-header       Display the ELF file header\n\
4408   -l --program-headers   Display the program headers\n\
4409      --segments          An alias for --program-headers\n\
4410   -S --section-headers   Display the sections' header\n\
4411      --sections          An alias for --section-headers\n\
4412   -g --section-groups    Display the section groups\n\
4413   -t --section-details   Display the section details\n\
4414   -e --headers           Equivalent to: -h -l -S\n\
4415   -s --syms              Display the symbol table\n\
4416      --symbols           An alias for --syms\n\
4417   --dyn-syms             Display the dynamic symbol table\n\
4418   -n --notes             Display the core notes (if present)\n\
4419   -r --relocs            Display the relocations (if present)\n\
4420   -u --unwind            Display the unwind info (if present)\n\
4421   -d --dynamic           Display the dynamic section (if present)\n\
4422   -V --version-info      Display the version sections (if present)\n\
4423   -A --arch-specific     Display architecture specific information (if any)\n\
4424   -c --archive-index     Display the symbol/file index in an archive\n\
4425   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4426   -x --hex-dump=<number|name>\n\
4427                          Dump the contents of section <number|name> as bytes\n\
4428   -p --string-dump=<number|name>\n\
4429                          Dump the contents of section <number|name> as strings\n\
4430   -R --relocated-dump=<number|name>\n\
4431                          Dump the contents of section <number|name> as relocated bytes\n\
4432   -z --decompress        Decompress section before dumping it\n\
4433   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4434   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4435                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4436                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4437                =addr,=cu_index,=links,=follow-links]\n\
4438                          Display the contents of DWARF debug sections\n"));
4439   fprintf (stream, _("\
4440   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4441   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4442                          or deeper\n"));
4443 #ifdef SUPPORT_DISASSEMBLY
4444   fprintf (stream, _("\
4445   -i --instruction-dump=<number|name>\n\
4446                          Disassemble the contents of section <number|name>\n"));
4447 #endif
4448   fprintf (stream, _("\
4449   -I --histogram         Display histogram of bucket list lengths\n\
4450   -W --wide              Allow output width to exceed 80 characters\n\
4451   @<file>                Read options from <file>\n\
4452   -H --help              Display this information\n\
4453   -v --version           Display the version number of readelf\n"));
4454
4455   if (REPORT_BUGS_TO[0] && stream == stdout)
4456     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4457
4458   exit (stream == stdout ? 0 : 1);
4459 }
4460
4461 /* Record the fact that the user wants the contents of section number
4462    SECTION to be displayed using the method(s) encoded as flags bits
4463    in TYPE.  Note, TYPE can be zero if we are creating the array for
4464    the first time.  */
4465
4466 static void
4467 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4468 {
4469   if (section >= filedata->num_dump_sects)
4470     {
4471       dump_type * new_dump_sects;
4472
4473       new_dump_sects = (dump_type *) calloc (section + 1,
4474                                              sizeof (* new_dump_sects));
4475
4476       if (new_dump_sects == NULL)
4477         error (_("Out of memory allocating dump request table.\n"));
4478       else
4479         {
4480           if (filedata->dump_sects)
4481             {
4482               /* Copy current flag settings.  */
4483               memcpy (new_dump_sects, filedata->dump_sects,
4484                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4485
4486               free (filedata->dump_sects);
4487             }
4488
4489           filedata->dump_sects = new_dump_sects;
4490           filedata->num_dump_sects = section + 1;
4491         }
4492     }
4493
4494   if (filedata->dump_sects)
4495     filedata->dump_sects[section] |= type;
4496 }
4497
4498 /* Request a dump by section name.  */
4499
4500 static void
4501 request_dump_byname (const char * section, dump_type type)
4502 {
4503   struct dump_list_entry * new_request;
4504
4505   new_request = (struct dump_list_entry *)
4506       malloc (sizeof (struct dump_list_entry));
4507   if (!new_request)
4508     error (_("Out of memory allocating dump request table.\n"));
4509
4510   new_request->name = strdup (section);
4511   if (!new_request->name)
4512     error (_("Out of memory allocating dump request table.\n"));
4513
4514   new_request->type = type;
4515
4516   new_request->next = dump_sects_byname;
4517   dump_sects_byname = new_request;
4518 }
4519
4520 static inline void
4521 request_dump (Filedata * filedata, dump_type type)
4522 {
4523   int section;
4524   char * cp;
4525
4526   do_dump++;
4527   section = strtoul (optarg, & cp, 0);
4528
4529   if (! *cp && section >= 0)
4530     request_dump_bynumber (filedata, section, type);
4531   else
4532     request_dump_byname (optarg, type);
4533 }
4534
4535 static void
4536 parse_args (Filedata * filedata, int argc, char ** argv)
4537 {
4538   int c;
4539
4540   if (argc < 2)
4541     usage (stderr);
4542
4543   while ((c = getopt_long
4544           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4545     {
4546       switch (c)
4547         {
4548         case 0:
4549           /* Long options.  */
4550           break;
4551         case 'H':
4552           usage (stdout);
4553           break;
4554
4555         case 'a':
4556           do_syms = TRUE;
4557           do_reloc = TRUE;
4558           do_unwind = TRUE;
4559           do_dynamic = TRUE;
4560           do_header = TRUE;
4561           do_sections = TRUE;
4562           do_section_groups = TRUE;
4563           do_segments = TRUE;
4564           do_version = TRUE;
4565           do_histogram = TRUE;
4566           do_arch = TRUE;
4567           do_notes = TRUE;
4568           break;
4569         case 'g':
4570           do_section_groups = TRUE;
4571           break;
4572         case 't':
4573         case 'N':
4574           do_sections = TRUE;
4575           do_section_details = TRUE;
4576           break;
4577         case 'e':
4578           do_header = TRUE;
4579           do_sections = TRUE;
4580           do_segments = TRUE;
4581           break;
4582         case 'A':
4583           do_arch = TRUE;
4584           break;
4585         case 'D':
4586           do_using_dynamic = TRUE;
4587           break;
4588         case 'r':
4589           do_reloc = TRUE;
4590           break;
4591         case 'u':
4592           do_unwind = TRUE;
4593           break;
4594         case 'h':
4595           do_header = TRUE;
4596           break;
4597         case 'l':
4598           do_segments = TRUE;
4599           break;
4600         case 's':
4601           do_syms = TRUE;
4602           break;
4603         case 'S':
4604           do_sections = TRUE;
4605           break;
4606         case 'd':
4607           do_dynamic = TRUE;
4608           break;
4609         case 'I':
4610           do_histogram = TRUE;
4611           break;
4612         case 'n':
4613           do_notes = TRUE;
4614           break;
4615         case 'c':
4616           do_archive_index = TRUE;
4617           break;
4618         case 'x':
4619           request_dump (filedata, HEX_DUMP);
4620           break;
4621         case 'p':
4622           request_dump (filedata, STRING_DUMP);
4623           break;
4624         case 'R':
4625           request_dump (filedata, RELOC_DUMP);
4626           break;
4627         case 'z':
4628           decompress_dumps = TRUE;
4629           break;
4630         case 'w':
4631           do_dump = TRUE;
4632           if (optarg == 0)
4633             {
4634               do_debugging = TRUE;
4635               dwarf_select_sections_all ();
4636             }
4637           else
4638             {
4639               do_debugging = FALSE;
4640               dwarf_select_sections_by_letters (optarg);
4641             }
4642           break;
4643         case OPTION_DEBUG_DUMP:
4644           do_dump = TRUE;
4645           if (optarg == 0)
4646             do_debugging = TRUE;
4647           else
4648             {
4649               do_debugging = FALSE;
4650               dwarf_select_sections_by_names (optarg);
4651             }
4652           break;
4653         case OPTION_DWARF_DEPTH:
4654           {
4655             char *cp;
4656
4657             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4658           }
4659           break;
4660         case OPTION_DWARF_START:
4661           {
4662             char *cp;
4663
4664             dwarf_start_die = strtoul (optarg, & cp, 0);
4665           }
4666           break;
4667         case OPTION_DWARF_CHECK:
4668           dwarf_check = TRUE;
4669           break;
4670         case OPTION_DYN_SYMS:
4671           do_dyn_syms = TRUE;
4672           break;
4673 #ifdef SUPPORT_DISASSEMBLY
4674         case 'i':
4675           request_dump (filedata, DISASS_DUMP);
4676           break;
4677 #endif
4678         case 'v':
4679           print_version (program_name);
4680           break;
4681         case 'V':
4682           do_version = TRUE;
4683           break;
4684         case 'W':
4685           do_wide = TRUE;
4686           break;
4687         default:
4688           /* xgettext:c-format */
4689           error (_("Invalid option '-%c'\n"), c);
4690           /* Fall through.  */
4691         case '?':
4692           usage (stderr);
4693         }
4694     }
4695
4696   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4697       && !do_segments && !do_header && !do_dump && !do_version
4698       && !do_histogram && !do_debugging && !do_arch && !do_notes
4699       && !do_section_groups && !do_archive_index
4700       && !do_dyn_syms)
4701     usage (stderr);
4702 }
4703
4704 static const char *
4705 get_elf_class (unsigned int elf_class)
4706 {
4707   static char buff[32];
4708
4709   switch (elf_class)
4710     {
4711     case ELFCLASSNONE: return _("none");
4712     case ELFCLASS32:   return "ELF32";
4713     case ELFCLASS64:   return "ELF64";
4714     default:
4715       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4716       return buff;
4717     }
4718 }
4719
4720 static const char *
4721 get_data_encoding (unsigned int encoding)
4722 {
4723   static char buff[32];
4724
4725   switch (encoding)
4726     {
4727     case ELFDATANONE: return _("none");
4728     case ELFDATA2LSB: return _("2's complement, little endian");
4729     case ELFDATA2MSB: return _("2's complement, big endian");
4730     default:
4731       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4732       return buff;
4733     }
4734 }
4735
4736 /* Decode the data held in 'filedata->file_header'.  */
4737
4738 static bfd_boolean
4739 process_file_header (Filedata * filedata)
4740 {
4741   Elf_Internal_Ehdr * header = & filedata->file_header;
4742
4743   if (   header->e_ident[EI_MAG0] != ELFMAG0
4744       || header->e_ident[EI_MAG1] != ELFMAG1
4745       || header->e_ident[EI_MAG2] != ELFMAG2
4746       || header->e_ident[EI_MAG3] != ELFMAG3)
4747     {
4748       error
4749         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4750       return FALSE;
4751     }
4752
4753   init_dwarf_regnames (header->e_machine);
4754
4755   if (do_header)
4756     {
4757       unsigned i;
4758
4759       printf (_("ELF Header:\n"));
4760       printf (_("  Magic:   "));
4761       for (i = 0; i < EI_NIDENT; i++)
4762         printf ("%2.2x ", header->e_ident[i]);
4763       printf ("\n");
4764       printf (_("  Class:                             %s\n"),
4765               get_elf_class (header->e_ident[EI_CLASS]));
4766       printf (_("  Data:                              %s\n"),
4767               get_data_encoding (header->e_ident[EI_DATA]));
4768       printf (_("  Version:                           %d %s\n"),
4769               header->e_ident[EI_VERSION],
4770               (header->e_ident[EI_VERSION] == EV_CURRENT
4771                ? "(current)"
4772                : (header->e_ident[EI_VERSION] != EV_NONE
4773                   ? _("<unknown: %lx>")
4774                   : "")));
4775       printf (_("  OS/ABI:                            %s\n"),
4776               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4777       printf (_("  ABI Version:                       %d\n"),
4778               header->e_ident[EI_ABIVERSION]);
4779       printf (_("  Type:                              %s\n"),
4780               get_file_type (header->e_type));
4781       printf (_("  Machine:                           %s\n"),
4782               get_machine_name (header->e_machine));
4783       printf (_("  Version:                           0x%lx\n"),
4784               (unsigned long) header->e_version);
4785
4786       printf (_("  Entry point address:               "));
4787       print_vma ((bfd_vma) header->e_entry, PREFIX_HEX);
4788       printf (_("\n  Start of program headers:          "));
4789       print_vma ((bfd_vma) header->e_phoff, DEC);
4790       printf (_(" (bytes into file)\n  Start of section headers:          "));
4791       print_vma ((bfd_vma) header->e_shoff, DEC);
4792       printf (_(" (bytes into file)\n"));
4793
4794       printf (_("  Flags:                             0x%lx%s\n"),
4795               (unsigned long) header->e_flags,
4796               get_machine_flags (filedata, header->e_flags, header->e_machine));
4797       printf (_("  Size of this header:               %ld (bytes)\n"),
4798               (long) header->e_ehsize);
4799       printf (_("  Size of program headers:           %ld (bytes)\n"),
4800               (long) header->e_phentsize);
4801       printf (_("  Number of program headers:         %ld"),
4802               (long) header->e_phnum);
4803       if (filedata->section_headers != NULL
4804           && header->e_phnum == PN_XNUM
4805           && filedata->section_headers[0].sh_info != 0)
4806         printf (" (%ld)", (long) filedata->section_headers[0].sh_info);
4807       putc ('\n', stdout);
4808       printf (_("  Size of section headers:           %ld (bytes)\n"),
4809               (long) header->e_shentsize);
4810       printf (_("  Number of section headers:         %ld"),
4811               (long) header->e_shnum);
4812       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4813         printf (" (%ld)", (long) filedata->section_headers[0].sh_size);
4814       putc ('\n', stdout);
4815       printf (_("  Section header string table index: %ld"),
4816               (long) header->e_shstrndx);
4817       if (filedata->section_headers != NULL
4818           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4819         printf (" (%u)", filedata->section_headers[0].sh_link);
4820       else if (header->e_shstrndx != SHN_UNDEF
4821                && header->e_shstrndx >= header->e_shnum)
4822         printf (_(" <corrupt: out of range>"));
4823       putc ('\n', stdout);
4824     }
4825
4826   if (filedata->section_headers != NULL)
4827     {
4828       if (header->e_phnum == PN_XNUM
4829           && filedata->section_headers[0].sh_info != 0)
4830         header->e_phnum = filedata->section_headers[0].sh_info;
4831       if (header->e_shnum == SHN_UNDEF)
4832         header->e_shnum = filedata->section_headers[0].sh_size;
4833       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4834         header->e_shstrndx = filedata->section_headers[0].sh_link;
4835       if (header->e_shstrndx >= header->e_shnum)
4836         header->e_shstrndx = SHN_UNDEF;
4837       free (filedata->section_headers);
4838       filedata->section_headers = NULL;
4839     }
4840
4841   return TRUE;
4842 }
4843
4844 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4845    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4846
4847 static bfd_boolean
4848 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4849 {
4850   Elf32_External_Phdr * phdrs;
4851   Elf32_External_Phdr * external;
4852   Elf_Internal_Phdr *   internal;
4853   unsigned int i;
4854   unsigned int size = filedata->file_header.e_phentsize;
4855   unsigned int num  = filedata->file_header.e_phnum;
4856
4857   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4858   if (size == 0 || num == 0)
4859     return FALSE;
4860   if (size < sizeof * phdrs)
4861     {
4862       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4863       return FALSE;
4864     }
4865   if (size > sizeof * phdrs)
4866     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4867
4868   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4869                                             size, num, _("program headers"));
4870   if (phdrs == NULL)
4871     return FALSE;
4872
4873   for (i = 0, internal = pheaders, external = phdrs;
4874        i < filedata->file_header.e_phnum;
4875        i++, internal++, external++)
4876     {
4877       internal->p_type   = BYTE_GET (external->p_type);
4878       internal->p_offset = BYTE_GET (external->p_offset);
4879       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4880       internal->p_paddr  = BYTE_GET (external->p_paddr);
4881       internal->p_filesz = BYTE_GET (external->p_filesz);
4882       internal->p_memsz  = BYTE_GET (external->p_memsz);
4883       internal->p_flags  = BYTE_GET (external->p_flags);
4884       internal->p_align  = BYTE_GET (external->p_align);
4885     }
4886
4887   free (phdrs);
4888   return TRUE;
4889 }
4890
4891 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4892    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4893
4894 static bfd_boolean
4895 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4896 {
4897   Elf64_External_Phdr * phdrs;
4898   Elf64_External_Phdr * external;
4899   Elf_Internal_Phdr *   internal;
4900   unsigned int i;
4901   unsigned int size = filedata->file_header.e_phentsize;
4902   unsigned int num  = filedata->file_header.e_phnum;
4903
4904   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4905   if (size == 0 || num == 0)
4906     return FALSE;
4907   if (size < sizeof * phdrs)
4908     {
4909       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4910       return FALSE;
4911     }
4912   if (size > sizeof * phdrs)
4913     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4914
4915   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4916                                             size, num, _("program headers"));
4917   if (!phdrs)
4918     return FALSE;
4919
4920   for (i = 0, internal = pheaders, external = phdrs;
4921        i < filedata->file_header.e_phnum;
4922        i++, internal++, external++)
4923     {
4924       internal->p_type   = BYTE_GET (external->p_type);
4925       internal->p_flags  = BYTE_GET (external->p_flags);
4926       internal->p_offset = BYTE_GET (external->p_offset);
4927       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4928       internal->p_paddr  = BYTE_GET (external->p_paddr);
4929       internal->p_filesz = BYTE_GET (external->p_filesz);
4930       internal->p_memsz  = BYTE_GET (external->p_memsz);
4931       internal->p_align  = BYTE_GET (external->p_align);
4932     }
4933
4934   free (phdrs);
4935   return TRUE;
4936 }
4937
4938 /* Returns TRUE if the program headers were read into `program_headers'.  */
4939
4940 static bfd_boolean
4941 get_program_headers (Filedata * filedata)
4942 {
4943   Elf_Internal_Phdr * phdrs;
4944
4945   /* Check cache of prior read.  */
4946   if (filedata->program_headers != NULL)
4947     return TRUE;
4948
4949   /* Be kind to memory checkers by looking for
4950      e_phnum values which we know must be invalid.  */
4951   if (filedata->file_header.e_phnum
4952       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4953       >= filedata->file_size)
4954     {
4955       error (_("Too many program headers - %#x - the file is not that big\n"),
4956              filedata->file_header.e_phnum);
4957       return FALSE;
4958     }
4959
4960   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4961                                          sizeof (Elf_Internal_Phdr));
4962   if (phdrs == NULL)
4963     {
4964       error (_("Out of memory reading %u program headers\n"),
4965              filedata->file_header.e_phnum);
4966       return FALSE;
4967     }
4968
4969   if (is_32bit_elf
4970       ? get_32bit_program_headers (filedata, phdrs)
4971       : get_64bit_program_headers (filedata, phdrs))
4972     {
4973       filedata->program_headers = phdrs;
4974       return TRUE;
4975     }
4976
4977   free (phdrs);
4978   return FALSE;
4979 }
4980
4981 /* Returns TRUE if the program headers were loaded.  */
4982
4983 static bfd_boolean
4984 process_program_headers (Filedata * filedata)
4985 {
4986   Elf_Internal_Phdr * segment;
4987   unsigned int i;
4988   Elf_Internal_Phdr * previous_load = NULL;
4989
4990   if (filedata->file_header.e_phnum == 0)
4991     {
4992       /* PR binutils/12467.  */
4993       if (filedata->file_header.e_phoff != 0)
4994         {
4995           warn (_("possibly corrupt ELF header - it has a non-zero program"
4996                   " header offset, but no program headers\n"));
4997           return FALSE;
4998         }
4999       else if (do_segments)
5000         printf (_("\nThere are no program headers in this file.\n"));
5001       return TRUE;
5002     }
5003
5004   if (do_segments && !do_header)
5005     {
5006       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5007       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5008       printf (ngettext ("There is %d program header, starting at offset %s\n",
5009                         "There are %d program headers, starting at offset %s\n",
5010                         filedata->file_header.e_phnum),
5011               filedata->file_header.e_phnum,
5012               bfd_vmatoa ("u", filedata->file_header.e_phoff));
5013     }
5014
5015   if (! get_program_headers (filedata))
5016     return TRUE;
5017
5018   if (do_segments)
5019     {
5020       if (filedata->file_header.e_phnum > 1)
5021         printf (_("\nProgram Headers:\n"));
5022       else
5023         printf (_("\nProgram Headers:\n"));
5024
5025       if (is_32bit_elf)
5026         printf
5027           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
5028       else if (do_wide)
5029         printf
5030           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
5031       else
5032         {
5033           printf
5034             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
5035           printf
5036             (_("                 FileSiz            MemSiz              Flags  Align\n"));
5037         }
5038     }
5039
5040   dynamic_addr = 0;
5041   dynamic_size = 0;
5042
5043   for (i = 0, segment = filedata->program_headers;
5044        i < filedata->file_header.e_phnum;
5045        i++, segment++)
5046     {
5047       if (do_segments)
5048         {
5049           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
5050
5051           if (is_32bit_elf)
5052             {
5053               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5054               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5055               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5056               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5057               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5058               printf ("%c%c%c ",
5059                       (segment->p_flags & PF_R ? 'R' : ' '),
5060                       (segment->p_flags & PF_W ? 'W' : ' '),
5061                       (segment->p_flags & PF_X ? 'E' : ' '));
5062               printf ("%#lx", (unsigned long) segment->p_align);
5063             }
5064           else if (do_wide)
5065             {
5066               if ((unsigned long) segment->p_offset == segment->p_offset)
5067                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5068               else
5069                 {
5070                   print_vma (segment->p_offset, FULL_HEX);
5071                   putchar (' ');
5072                 }
5073
5074               print_vma (segment->p_vaddr, FULL_HEX);
5075               putchar (' ');
5076               print_vma (segment->p_paddr, FULL_HEX);
5077               putchar (' ');
5078
5079               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5080                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5081               else
5082                 {
5083                   print_vma (segment->p_filesz, FULL_HEX);
5084                   putchar (' ');
5085                 }
5086
5087               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5088                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5089               else
5090                 {
5091                   print_vma (segment->p_memsz, FULL_HEX);
5092                 }
5093
5094               printf (" %c%c%c ",
5095                       (segment->p_flags & PF_R ? 'R' : ' '),
5096                       (segment->p_flags & PF_W ? 'W' : ' '),
5097                       (segment->p_flags & PF_X ? 'E' : ' '));
5098
5099               if ((unsigned long) segment->p_align == segment->p_align)
5100                 printf ("%#lx", (unsigned long) segment->p_align);
5101               else
5102                 {
5103                   print_vma (segment->p_align, PREFIX_HEX);
5104                 }
5105             }
5106           else
5107             {
5108               print_vma (segment->p_offset, FULL_HEX);
5109               putchar (' ');
5110               print_vma (segment->p_vaddr, FULL_HEX);
5111               putchar (' ');
5112               print_vma (segment->p_paddr, FULL_HEX);
5113               printf ("\n                 ");
5114               print_vma (segment->p_filesz, FULL_HEX);
5115               putchar (' ');
5116               print_vma (segment->p_memsz, FULL_HEX);
5117               printf ("  %c%c%c    ",
5118                       (segment->p_flags & PF_R ? 'R' : ' '),
5119                       (segment->p_flags & PF_W ? 'W' : ' '),
5120                       (segment->p_flags & PF_X ? 'E' : ' '));
5121               print_vma (segment->p_align, PREFIX_HEX);
5122             }
5123
5124           putc ('\n', stdout);
5125         }
5126
5127       switch (segment->p_type)
5128         {
5129         case PT_LOAD:
5130 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5131          required by the ELF standard, several programs, including the Linux
5132          kernel, make use of non-ordered segments.  */
5133           if (previous_load
5134               && previous_load->p_vaddr > segment->p_vaddr)
5135             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5136 #endif
5137           if (segment->p_memsz < segment->p_filesz)
5138             error (_("the segment's file size is larger than its memory size\n"));
5139           previous_load = segment;
5140           break;
5141
5142         case PT_PHDR:
5143           /* PR 20815 - Verify that the program header is loaded into memory.  */
5144           if (i > 0 && previous_load != NULL)
5145             error (_("the PHDR segment must occur before any LOAD segment\n"));
5146           if (filedata->file_header.e_machine != EM_PARISC)
5147             {
5148               unsigned int j;
5149
5150               for (j = 1; j < filedata->file_header.e_phnum; j++)
5151                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5152                     && (filedata->program_headers[j].p_vaddr
5153                         + filedata->program_headers[j].p_memsz)
5154                     >= (segment->p_vaddr + segment->p_filesz))
5155                   break;
5156               if (j == filedata->file_header.e_phnum)
5157                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5158             }
5159           break;
5160
5161         case PT_DYNAMIC:
5162           if (dynamic_addr)
5163             error (_("more than one dynamic segment\n"));
5164
5165           /* By default, assume that the .dynamic section is the first
5166              section in the DYNAMIC segment.  */
5167           dynamic_addr = segment->p_offset;
5168           dynamic_size = segment->p_filesz;
5169
5170           /* Try to locate the .dynamic section. If there is
5171              a section header table, we can easily locate it.  */
5172           if (filedata->section_headers != NULL)
5173             {
5174               Elf_Internal_Shdr * sec;
5175
5176               sec = find_section (filedata, ".dynamic");
5177               if (sec == NULL || sec->sh_size == 0)
5178                 {
5179                   /* A corresponding .dynamic section is expected, but on
5180                      IA-64/OpenVMS it is OK for it to be missing.  */
5181                   if (!is_ia64_vms (filedata))
5182                     error (_("no .dynamic section in the dynamic segment\n"));
5183                   break;
5184                 }
5185
5186               if (sec->sh_type == SHT_NOBITS)
5187                 {
5188                   dynamic_size = 0;
5189                   break;
5190                 }
5191
5192               dynamic_addr = sec->sh_offset;
5193               dynamic_size = sec->sh_size;
5194
5195               if (dynamic_addr < segment->p_offset
5196                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5197                 warn (_("the .dynamic section is not contained"
5198                         " within the dynamic segment\n"));
5199               else if (dynamic_addr > segment->p_offset)
5200                 warn (_("the .dynamic section is not the first section"
5201                         " in the dynamic segment.\n"));
5202             }
5203
5204           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5205              segment.  Check this after matching against the section headers
5206              so we don't warn on debuginfo file (which have NOBITS .dynamic
5207              sections).  */
5208           if (dynamic_addr + dynamic_size >= filedata->file_size)
5209             {
5210               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5211               dynamic_addr = dynamic_size = 0;
5212             }
5213           break;
5214
5215         case PT_INTERP:
5216           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5217                      SEEK_SET))
5218             error (_("Unable to find program interpreter name\n"));
5219           else
5220             {
5221               char fmt [32];
5222               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5223
5224               if (ret >= (int) sizeof (fmt) || ret < 0)
5225                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5226
5227               program_interpreter[0] = 0;
5228               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5229                 error (_("Unable to read program interpreter name\n"));
5230
5231               if (do_segments)
5232                 printf (_("      [Requesting program interpreter: %s]\n"),
5233                     program_interpreter);
5234             }
5235           break;
5236         }
5237     }
5238
5239   if (do_segments
5240       && filedata->section_headers != NULL
5241       && filedata->string_table != NULL)
5242     {
5243       printf (_("\n Section to Segment mapping:\n"));
5244       printf (_("  Segment Sections...\n"));
5245
5246       for (i = 0; i < filedata->file_header.e_phnum; i++)
5247         {
5248           unsigned int j;
5249           Elf_Internal_Shdr * section;
5250
5251           segment = filedata->program_headers + i;
5252           section = filedata->section_headers + 1;
5253
5254           printf ("   %2.2d     ", i);
5255
5256           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5257             {
5258               if (!ELF_TBSS_SPECIAL (section, segment)
5259                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5260                 printf ("%s ", printable_section_name (filedata, section));
5261             }
5262
5263           putc ('\n',stdout);
5264         }
5265     }
5266
5267   return TRUE;
5268 }
5269
5270
5271 /* Find the file offset corresponding to VMA by using the program headers.  */
5272
5273 static long
5274 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5275 {
5276   Elf_Internal_Phdr * seg;
5277
5278   if (! get_program_headers (filedata))
5279     {
5280       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5281       return (long) vma;
5282     }
5283
5284   for (seg = filedata->program_headers;
5285        seg < filedata->program_headers + filedata->file_header.e_phnum;
5286        ++seg)
5287     {
5288       if (seg->p_type != PT_LOAD)
5289         continue;
5290
5291       if (vma >= (seg->p_vaddr & -seg->p_align)
5292           && vma + size <= seg->p_vaddr + seg->p_filesz)
5293         return vma - seg->p_vaddr + seg->p_offset;
5294     }
5295
5296   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5297         (unsigned long) vma);
5298   return (long) vma;
5299 }
5300
5301
5302 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5303    If PROBE is true, this is just a probe and we do not generate any error
5304    messages if the load fails.  */
5305
5306 static bfd_boolean
5307 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5308 {
5309   Elf32_External_Shdr * shdrs;
5310   Elf_Internal_Shdr *   internal;
5311   unsigned int          i;
5312   unsigned int          size = filedata->file_header.e_shentsize;
5313   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5314
5315   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5316   if (size == 0 || num == 0)
5317     return FALSE;
5318   if (size < sizeof * shdrs)
5319     {
5320       if (! probe)
5321         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5322       return FALSE;
5323     }
5324   if (!probe && size > sizeof * shdrs)
5325     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5326
5327   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5328                                             size, num,
5329                                             probe ? NULL : _("section headers"));
5330   if (shdrs == NULL)
5331     return FALSE;
5332
5333   free (filedata->section_headers);
5334   filedata->section_headers = (Elf_Internal_Shdr *)
5335     cmalloc (num, sizeof (Elf_Internal_Shdr));
5336   if (filedata->section_headers == NULL)
5337     {
5338       if (!probe)
5339         error (_("Out of memory reading %u section headers\n"), num);
5340       free (shdrs);
5341       return FALSE;
5342     }
5343
5344   for (i = 0, internal = filedata->section_headers;
5345        i < num;
5346        i++, internal++)
5347     {
5348       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5349       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5350       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5351       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5352       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5353       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5354       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5355       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5356       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5357       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5358       if (!probe && internal->sh_link > num)
5359         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5360       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5361         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5362     }
5363
5364   free (shdrs);
5365   return TRUE;
5366 }
5367
5368 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5369
5370 static bfd_boolean
5371 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5372 {
5373   Elf64_External_Shdr *  shdrs;
5374   Elf_Internal_Shdr *    internal;
5375   unsigned int           i;
5376   unsigned int           size = filedata->file_header.e_shentsize;
5377   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5378
5379   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5380   if (size == 0 || num == 0)
5381     return FALSE;
5382
5383   if (size < sizeof * shdrs)
5384     {
5385       if (! probe)
5386         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5387       return FALSE;
5388     }
5389
5390   if (! probe && size > sizeof * shdrs)
5391     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5392
5393   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5394                                             filedata->file_header.e_shoff,
5395                                             size, num,
5396                                             probe ? NULL : _("section headers"));
5397   if (shdrs == NULL)
5398     return FALSE;
5399
5400   free (filedata->section_headers);
5401   filedata->section_headers = (Elf_Internal_Shdr *)
5402     cmalloc (num, sizeof (Elf_Internal_Shdr));
5403   if (filedata->section_headers == NULL)
5404     {
5405       if (! probe)
5406         error (_("Out of memory reading %u section headers\n"), num);
5407       free (shdrs);
5408       return FALSE;
5409     }
5410
5411   for (i = 0, internal = filedata->section_headers;
5412        i < num;
5413        i++, internal++)
5414     {
5415       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5416       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5417       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5418       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5419       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5420       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5421       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5422       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5423       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5424       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5425       if (!probe && internal->sh_link > num)
5426         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5427       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5428         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5429     }
5430
5431   free (shdrs);
5432   return TRUE;
5433 }
5434
5435 static Elf_Internal_Sym *
5436 get_32bit_elf_symbols (Filedata *           filedata,
5437                        Elf_Internal_Shdr *  section,
5438                        unsigned long *      num_syms_return)
5439 {
5440   unsigned long number = 0;
5441   Elf32_External_Sym * esyms = NULL;
5442   Elf_External_Sym_Shndx * shndx = NULL;
5443   Elf_Internal_Sym * isyms = NULL;
5444   Elf_Internal_Sym * psym;
5445   unsigned int j;
5446   elf_section_list * entry;
5447
5448   if (section->sh_size == 0)
5449     {
5450       if (num_syms_return != NULL)
5451         * num_syms_return = 0;
5452       return NULL;
5453     }
5454
5455   /* Run some sanity checks first.  */
5456   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5457     {
5458       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5459              printable_section_name (filedata, section),
5460              (unsigned long) section->sh_entsize);
5461       goto exit_point;
5462     }
5463
5464   if (section->sh_size > filedata->file_size)
5465     {
5466       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5467              printable_section_name (filedata, section),
5468              (unsigned long) section->sh_size);
5469       goto exit_point;
5470     }
5471
5472   number = section->sh_size / section->sh_entsize;
5473
5474   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5475     {
5476       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5477              (unsigned long) section->sh_size,
5478              printable_section_name (filedata, section),
5479              (unsigned long) section->sh_entsize);
5480       goto exit_point;
5481     }
5482
5483   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5484                                            section->sh_size, _("symbols"));
5485   if (esyms == NULL)
5486     goto exit_point;
5487
5488   shndx = NULL;
5489   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5490     {
5491       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5492         continue;
5493
5494       if (shndx != NULL)
5495         {
5496           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5497           free (shndx);
5498         }
5499
5500       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5501                                                    entry->hdr->sh_offset,
5502                                                    1, entry->hdr->sh_size,
5503                                                    _("symbol table section indices"));
5504       if (shndx == NULL)
5505         goto exit_point;
5506
5507       /* PR17531: file: heap-buffer-overflow */
5508       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5509         {
5510           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5511                  printable_section_name (filedata, entry->hdr),
5512                  (unsigned long) entry->hdr->sh_size,
5513                  (unsigned long) section->sh_size);
5514           goto exit_point;
5515         }
5516     }
5517
5518   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5519
5520   if (isyms == NULL)
5521     {
5522       error (_("Out of memory reading %lu symbols\n"),
5523              (unsigned long) number);
5524       goto exit_point;
5525     }
5526
5527   for (j = 0, psym = isyms; j < number; j++, psym++)
5528     {
5529       psym->st_name  = BYTE_GET (esyms[j].st_name);
5530       psym->st_value = BYTE_GET (esyms[j].st_value);
5531       psym->st_size  = BYTE_GET (esyms[j].st_size);
5532       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5533       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5534         psym->st_shndx
5535           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5536       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5537         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5538       psym->st_info  = BYTE_GET (esyms[j].st_info);
5539       psym->st_other = BYTE_GET (esyms[j].st_other);
5540     }
5541
5542  exit_point:
5543   free (shndx);
5544   free (esyms);
5545
5546   if (num_syms_return != NULL)
5547     * num_syms_return = isyms == NULL ? 0 : number;
5548
5549   return isyms;
5550 }
5551
5552 static Elf_Internal_Sym *
5553 get_64bit_elf_symbols (Filedata *           filedata,
5554                        Elf_Internal_Shdr *  section,
5555                        unsigned long *      num_syms_return)
5556 {
5557   unsigned long number = 0;
5558   Elf64_External_Sym * esyms = NULL;
5559   Elf_External_Sym_Shndx * shndx = NULL;
5560   Elf_Internal_Sym * isyms = NULL;
5561   Elf_Internal_Sym * psym;
5562   unsigned int j;
5563   elf_section_list * entry;
5564
5565   if (section->sh_size == 0)
5566     {
5567       if (num_syms_return != NULL)
5568         * num_syms_return = 0;
5569       return NULL;
5570     }
5571
5572   /* Run some sanity checks first.  */
5573   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5574     {
5575       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5576              printable_section_name (filedata, section),
5577              (unsigned long) section->sh_entsize);
5578       goto exit_point;
5579     }
5580
5581   if (section->sh_size > filedata->file_size)
5582     {
5583       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5584              printable_section_name (filedata, section),
5585              (unsigned long) section->sh_size);
5586       goto exit_point;
5587     }
5588
5589   number = section->sh_size / section->sh_entsize;
5590
5591   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5592     {
5593       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5594              (unsigned long) section->sh_size,
5595              printable_section_name (filedata, section),
5596              (unsigned long) section->sh_entsize);
5597       goto exit_point;
5598     }
5599
5600   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5601                                            section->sh_size, _("symbols"));
5602   if (!esyms)
5603     goto exit_point;
5604
5605   shndx = NULL;
5606   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5607     {
5608       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5609         continue;
5610
5611       if (shndx != NULL)
5612         {
5613           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5614           free (shndx);
5615         }
5616
5617       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5618                                                    entry->hdr->sh_offset,
5619                                                    1, entry->hdr->sh_size,
5620                                                    _("symbol table section indices"));
5621       if (shndx == NULL)
5622         goto exit_point;
5623
5624       /* PR17531: file: heap-buffer-overflow */
5625       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5626         {
5627           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5628                  printable_section_name (filedata, entry->hdr),
5629                  (unsigned long) entry->hdr->sh_size,
5630                  (unsigned long) section->sh_size);
5631           goto exit_point;
5632         }
5633     }
5634
5635   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5636
5637   if (isyms == NULL)
5638     {
5639       error (_("Out of memory reading %lu symbols\n"),
5640              (unsigned long) number);
5641       goto exit_point;
5642     }
5643
5644   for (j = 0, psym = isyms; j < number; j++, psym++)
5645     {
5646       psym->st_name  = BYTE_GET (esyms[j].st_name);
5647       psym->st_info  = BYTE_GET (esyms[j].st_info);
5648       psym->st_other = BYTE_GET (esyms[j].st_other);
5649       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5650
5651       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5652         psym->st_shndx
5653           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5654       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5655         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5656
5657       psym->st_value = BYTE_GET (esyms[j].st_value);
5658       psym->st_size  = BYTE_GET (esyms[j].st_size);
5659     }
5660
5661  exit_point:
5662   free (shndx);
5663   free (esyms);
5664
5665   if (num_syms_return != NULL)
5666     * num_syms_return = isyms == NULL ? 0 : number;
5667
5668   return isyms;
5669 }
5670
5671 static const char *
5672 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5673 {
5674   static char buff[1024];
5675   char * p = buff;
5676   unsigned int field_size = is_32bit_elf ? 8 : 16;
5677   signed int sindex;
5678   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5679   bfd_vma os_flags = 0;
5680   bfd_vma proc_flags = 0;
5681   bfd_vma unknown_flags = 0;
5682   static const struct
5683     {
5684       const char * str;
5685       unsigned int len;
5686     }
5687   flags [] =
5688     {
5689       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5690       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5691       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5692       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5693       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5694       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5695       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5696       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5697       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5698       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5699       /* IA-64 specific.  */
5700       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5701       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5702       /* IA-64 OpenVMS specific.  */
5703       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5704       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5705       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5706       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5707       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5708       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5709       /* Generic.  */
5710       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5711       /* SPARC specific.  */
5712       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5713       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5714       /* ARM specific.  */
5715       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5716       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5717       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5718       /* GNU specific.  */
5719       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5720       /* VLE specific.  */
5721       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5722     };
5723
5724   if (do_section_details)
5725     {
5726       sprintf (buff, "[%*.*lx]: ",
5727                field_size, field_size, (unsigned long) sh_flags);
5728       p += field_size + 4;
5729     }
5730
5731   while (sh_flags)
5732     {
5733       bfd_vma flag;
5734
5735       flag = sh_flags & - sh_flags;
5736       sh_flags &= ~ flag;
5737
5738       if (do_section_details)
5739         {
5740           switch (flag)
5741             {
5742             case SHF_WRITE:             sindex = 0; break;
5743             case SHF_ALLOC:             sindex = 1; break;
5744             case SHF_EXECINSTR:         sindex = 2; break;
5745             case SHF_MERGE:             sindex = 3; break;
5746             case SHF_STRINGS:           sindex = 4; break;
5747             case SHF_INFO_LINK:         sindex = 5; break;
5748             case SHF_LINK_ORDER:        sindex = 6; break;
5749             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5750             case SHF_GROUP:             sindex = 8; break;
5751             case SHF_TLS:               sindex = 9; break;
5752             case SHF_EXCLUDE:           sindex = 18; break;
5753             case SHF_COMPRESSED:        sindex = 20; break;
5754             case SHF_GNU_MBIND:         sindex = 24; break;
5755
5756             default:
5757               sindex = -1;
5758               switch (filedata->file_header.e_machine)
5759                 {
5760                 case EM_IA_64:
5761                   if (flag == SHF_IA_64_SHORT)
5762                     sindex = 10;
5763                   else if (flag == SHF_IA_64_NORECOV)
5764                     sindex = 11;
5765 #ifdef BFD64
5766                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5767                     switch (flag)
5768                       {
5769                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5770                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5771                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5772                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5773                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5774                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5775                       default:                        break;
5776                       }
5777 #endif
5778                   break;
5779
5780                 case EM_386:
5781                 case EM_IAMCU:
5782                 case EM_X86_64:
5783                 case EM_L1OM:
5784                 case EM_K1OM:
5785                 case EM_OLD_SPARCV9:
5786                 case EM_SPARC32PLUS:
5787                 case EM_SPARCV9:
5788                 case EM_SPARC:
5789                   if (flag == SHF_ORDERED)
5790                     sindex = 19;
5791                   break;
5792
5793                 case EM_ARM:
5794                   switch (flag)
5795                     {
5796                     case SHF_ENTRYSECT: sindex = 21; break;
5797                     case SHF_ARM_PURECODE: sindex = 22; break;
5798                     case SHF_COMDEF: sindex = 23; break;
5799                     default: break;
5800                     }
5801                   break;
5802                 case EM_PPC:
5803                   if (flag == SHF_PPC_VLE)
5804                     sindex = 25;
5805                   break;
5806
5807                 default:
5808                   break;
5809                 }
5810             }
5811
5812           if (sindex != -1)
5813             {
5814               if (p != buff + field_size + 4)
5815                 {
5816                   if (size < (10 + 2))
5817                     {
5818                       warn (_("Internal error: not enough buffer room for section flag info"));
5819                       return _("<unknown>");
5820                     }
5821                   size -= 2;
5822                   *p++ = ',';
5823                   *p++ = ' ';
5824                 }
5825
5826               size -= flags [sindex].len;
5827               p = stpcpy (p, flags [sindex].str);
5828             }
5829           else if (flag & SHF_MASKOS)
5830             os_flags |= flag;
5831           else if (flag & SHF_MASKPROC)
5832             proc_flags |= flag;
5833           else
5834             unknown_flags |= flag;
5835         }
5836       else
5837         {
5838           switch (flag)
5839             {
5840             case SHF_WRITE:             *p = 'W'; break;
5841             case SHF_ALLOC:             *p = 'A'; break;
5842             case SHF_EXECINSTR:         *p = 'X'; break;
5843             case SHF_MERGE:             *p = 'M'; break;
5844             case SHF_STRINGS:           *p = 'S'; break;
5845             case SHF_INFO_LINK:         *p = 'I'; break;
5846             case SHF_LINK_ORDER:        *p = 'L'; break;
5847             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5848             case SHF_GROUP:             *p = 'G'; break;
5849             case SHF_TLS:               *p = 'T'; break;
5850             case SHF_EXCLUDE:           *p = 'E'; break;
5851             case SHF_COMPRESSED:        *p = 'C'; break;
5852             case SHF_GNU_MBIND:         *p = 'D'; break;
5853
5854             default:
5855               if ((filedata->file_header.e_machine == EM_X86_64
5856                    || filedata->file_header.e_machine == EM_L1OM
5857                    || filedata->file_header.e_machine == EM_K1OM)
5858                   && flag == SHF_X86_64_LARGE)
5859                 *p = 'l';
5860               else if (filedata->file_header.e_machine == EM_ARM
5861                        && flag == SHF_ARM_PURECODE)
5862                   *p = 'y';
5863               else if (filedata->file_header.e_machine == EM_PPC
5864                        && flag == SHF_PPC_VLE)
5865                   *p = 'v';
5866               else if (flag & SHF_MASKOS)
5867                 {
5868                   *p = 'o';
5869                   sh_flags &= ~ SHF_MASKOS;
5870                 }
5871               else if (flag & SHF_MASKPROC)
5872                 {
5873                   *p = 'p';
5874                   sh_flags &= ~ SHF_MASKPROC;
5875                 }
5876               else
5877                 *p = 'x';
5878               break;
5879             }
5880           p++;
5881         }
5882     }
5883
5884   if (do_section_details)
5885     {
5886       if (os_flags)
5887         {
5888           size -= 5 + field_size;
5889           if (p != buff + field_size + 4)
5890             {
5891               if (size < (2 + 1))
5892                 {
5893                   warn (_("Internal error: not enough buffer room for section flag info"));
5894                   return _("<unknown>");
5895                 }
5896               size -= 2;
5897               *p++ = ',';
5898               *p++ = ' ';
5899             }
5900           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5901                    (unsigned long) os_flags);
5902           p += 5 + field_size;
5903         }
5904       if (proc_flags)
5905         {
5906           size -= 7 + field_size;
5907           if (p != buff + field_size + 4)
5908             {
5909               if (size < (2 + 1))
5910                 {
5911                   warn (_("Internal error: not enough buffer room for section flag info"));
5912                   return _("<unknown>");
5913                 }
5914               size -= 2;
5915               *p++ = ',';
5916               *p++ = ' ';
5917             }
5918           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5919                    (unsigned long) proc_flags);
5920           p += 7 + field_size;
5921         }
5922       if (unknown_flags)
5923         {
5924           size -= 10 + field_size;
5925           if (p != buff + field_size + 4)
5926             {
5927               if (size < (2 + 1))
5928                 {
5929                   warn (_("Internal error: not enough buffer room for section flag info"));
5930                   return _("<unknown>");
5931                 }
5932               size -= 2;
5933               *p++ = ',';
5934               *p++ = ' ';
5935             }
5936           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5937                    (unsigned long) unknown_flags);
5938           p += 10 + field_size;
5939         }
5940     }
5941
5942   *p = '\0';
5943   return buff;
5944 }
5945
5946 static unsigned int
5947 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5948 {
5949   if (is_32bit_elf)
5950     {
5951       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5952
5953       if (size < sizeof (* echdr))
5954         {
5955           error (_("Compressed section is too small even for a compression header\n"));
5956           return 0;
5957         }
5958
5959       chdr->ch_type = BYTE_GET (echdr->ch_type);
5960       chdr->ch_size = BYTE_GET (echdr->ch_size);
5961       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5962       return sizeof (*echdr);
5963     }
5964   else
5965     {
5966       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5967
5968       if (size < sizeof (* echdr))
5969         {
5970           error (_("Compressed section is too small even for a compression header\n"));
5971           return 0;
5972         }
5973
5974       chdr->ch_type = BYTE_GET (echdr->ch_type);
5975       chdr->ch_size = BYTE_GET (echdr->ch_size);
5976       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5977       return sizeof (*echdr);
5978     }
5979 }
5980
5981 static bfd_boolean
5982 process_section_headers (Filedata * filedata)
5983 {
5984   Elf_Internal_Shdr * section;
5985   unsigned int i;
5986
5987   filedata->section_headers = NULL;
5988
5989   if (filedata->file_header.e_shnum == 0)
5990     {
5991       /* PR binutils/12467.  */
5992       if (filedata->file_header.e_shoff != 0)
5993         {
5994           warn (_("possibly corrupt ELF file header - it has a non-zero"
5995                   " section header offset, but no section headers\n"));
5996           return FALSE;
5997         }
5998       else if (do_sections)
5999         printf (_("\nThere are no sections in this file.\n"));
6000
6001       return TRUE;
6002     }
6003
6004   if (do_sections && !do_header)
6005     printf (ngettext ("There is %d section header, "
6006                       "starting at offset 0x%lx:\n",
6007                       "There are %d section headers, "
6008                       "starting at offset 0x%lx:\n",
6009                       filedata->file_header.e_shnum),
6010             filedata->file_header.e_shnum,
6011             (unsigned long) filedata->file_header.e_shoff);
6012
6013   if (is_32bit_elf)
6014     {
6015       if (! get_32bit_section_headers (filedata, FALSE))
6016         return FALSE;
6017     }
6018   else
6019     {
6020       if (! get_64bit_section_headers (filedata, FALSE))
6021         return FALSE;
6022     }
6023
6024   /* Read in the string table, so that we have names to display.  */
6025   if (filedata->file_header.e_shstrndx != SHN_UNDEF
6026        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6027     {
6028       section = filedata->section_headers + filedata->file_header.e_shstrndx;
6029
6030       if (section->sh_size != 0)
6031         {
6032           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6033                                                       1, section->sh_size,
6034                                                       _("string table"));
6035
6036           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6037         }
6038     }
6039
6040   /* Scan the sections for the dynamic symbol table
6041      and dynamic string table and debug sections.  */
6042   dynamic_symbols = NULL;
6043   dynamic_strings = NULL;
6044   dynamic_syminfo = NULL;
6045   symtab_shndx_list = NULL;
6046
6047   eh_addr_size = is_32bit_elf ? 4 : 8;
6048   switch (filedata->file_header.e_machine)
6049     {
6050     case EM_MIPS:
6051     case EM_MIPS_RS3_LE:
6052       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6053          FDE addresses.  However, the ABI also has a semi-official ILP32
6054          variant for which the normal FDE address size rules apply.
6055
6056          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6057          section, where XX is the size of longs in bits.  Unfortunately,
6058          earlier compilers provided no way of distinguishing ILP32 objects
6059          from LP64 objects, so if there's any doubt, we should assume that
6060          the official LP64 form is being used.  */
6061       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6062           && find_section (filedata, ".gcc_compiled_long32") == NULL)
6063         eh_addr_size = 8;
6064       break;
6065
6066     case EM_H8_300:
6067     case EM_H8_300H:
6068       switch (filedata->file_header.e_flags & EF_H8_MACH)
6069         {
6070         case E_H8_MACH_H8300:
6071         case E_H8_MACH_H8300HN:
6072         case E_H8_MACH_H8300SN:
6073         case E_H8_MACH_H8300SXN:
6074           eh_addr_size = 2;
6075           break;
6076         case E_H8_MACH_H8300H:
6077         case E_H8_MACH_H8300S:
6078         case E_H8_MACH_H8300SX:
6079           eh_addr_size = 4;
6080           break;
6081         }
6082       break;
6083
6084     case EM_M32C_OLD:
6085     case EM_M32C:
6086       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6087         {
6088         case EF_M32C_CPU_M16C:
6089           eh_addr_size = 2;
6090           break;
6091         }
6092       break;
6093     }
6094
6095 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6096   do                                                                    \
6097     {                                                                   \
6098       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6099       if (section->sh_entsize != expected_entsize)                      \
6100         {                                                               \
6101           char buf[40];                                                 \
6102           sprintf_vma (buf, section->sh_entsize);                       \
6103           /* Note: coded this way so that there is a single string for  \
6104              translation.  */ \
6105           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6106           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6107                    (unsigned) expected_entsize);                        \
6108           section->sh_entsize = expected_entsize;                       \
6109         }                                                               \
6110     }                                                                   \
6111   while (0)
6112
6113 #define CHECK_ENTSIZE(section, i, type)                                 \
6114   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6115                         sizeof (Elf64_External_##type))
6116
6117   for (i = 0, section = filedata->section_headers;
6118        i < filedata->file_header.e_shnum;
6119        i++, section++)
6120     {
6121       char * name = SECTION_NAME (section);
6122
6123       if (section->sh_type == SHT_DYNSYM)
6124         {
6125           if (dynamic_symbols != NULL)
6126             {
6127               error (_("File contains multiple dynamic symbol tables\n"));
6128               continue;
6129             }
6130
6131           CHECK_ENTSIZE (section, i, Sym);
6132           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6133         }
6134       else if (section->sh_type == SHT_STRTAB
6135                && streq (name, ".dynstr"))
6136         {
6137           if (dynamic_strings != NULL)
6138             {
6139               error (_("File contains multiple dynamic string tables\n"));
6140               continue;
6141             }
6142
6143           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6144                                                1, section->sh_size,
6145                                                _("dynamic strings"));
6146           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6147         }
6148       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6149         {
6150           elf_section_list * entry = xmalloc (sizeof * entry);
6151
6152           entry->hdr = section;
6153           entry->next = symtab_shndx_list;
6154           symtab_shndx_list = entry;
6155         }
6156       else if (section->sh_type == SHT_SYMTAB)
6157         CHECK_ENTSIZE (section, i, Sym);
6158       else if (section->sh_type == SHT_GROUP)
6159         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6160       else if (section->sh_type == SHT_REL)
6161         CHECK_ENTSIZE (section, i, Rel);
6162       else if (section->sh_type == SHT_RELA)
6163         CHECK_ENTSIZE (section, i, Rela);
6164       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6165                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6166                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6167                 || do_debug_str || do_debug_loc || do_debug_ranges
6168                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6169                && (const_strneq (name, ".debug_")
6170                    || const_strneq (name, ".zdebug_")))
6171         {
6172           if (name[1] == 'z')
6173             name += sizeof (".zdebug_") - 1;
6174           else
6175             name += sizeof (".debug_") - 1;
6176
6177           if (do_debugging
6178               || (do_debug_info     && const_strneq (name, "info"))
6179               || (do_debug_info     && const_strneq (name, "types"))
6180               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6181               || (do_debug_lines    && strcmp (name, "line") == 0)
6182               || (do_debug_lines    && const_strneq (name, "line."))
6183               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6184               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6185               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6186               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6187               || (do_debug_aranges  && const_strneq (name, "aranges"))
6188               || (do_debug_ranges   && const_strneq (name, "ranges"))
6189               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6190               || (do_debug_frames   && const_strneq (name, "frame"))
6191               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6192               || (do_debug_macinfo  && const_strneq (name, "macro"))
6193               || (do_debug_str      && const_strneq (name, "str"))
6194               || (do_debug_loc      && const_strneq (name, "loc"))
6195               || (do_debug_loc      && const_strneq (name, "loclists"))
6196               || (do_debug_addr     && const_strneq (name, "addr"))
6197               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6198               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6199               )
6200             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6201         }
6202       /* Linkonce section to be combined with .debug_info at link time.  */
6203       else if ((do_debugging || do_debug_info)
6204                && const_strneq (name, ".gnu.linkonce.wi."))
6205         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6206       else if (do_debug_frames && streq (name, ".eh_frame"))
6207         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6208       else if (do_gdb_index && (streq (name, ".gdb_index")
6209                                 || streq (name, ".debug_names")))
6210         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6211       /* Trace sections for Itanium VMS.  */
6212       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6213                 || do_trace_aranges)
6214                && const_strneq (name, ".trace_"))
6215         {
6216           name += sizeof (".trace_") - 1;
6217
6218           if (do_debugging
6219               || (do_trace_info     && streq (name, "info"))
6220               || (do_trace_abbrevs  && streq (name, "abbrev"))
6221               || (do_trace_aranges  && streq (name, "aranges"))
6222               )
6223             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6224         }
6225       else if ((do_debugging || do_debug_links)
6226                && (const_strneq (name, ".gnu_debuglink")
6227                    || const_strneq (name, ".gnu_debugaltlink")))
6228         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6229     }
6230
6231   if (! do_sections)
6232     return TRUE;
6233
6234   if (filedata->file_header.e_shnum > 1)
6235     printf (_("\nSection Headers:\n"));
6236   else
6237     printf (_("\nSection Header:\n"));
6238
6239   if (is_32bit_elf)
6240     {
6241       if (do_section_details)
6242         {
6243           printf (_("  [Nr] Name\n"));
6244           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6245         }
6246       else
6247         printf
6248           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6249     }
6250   else if (do_wide)
6251     {
6252       if (do_section_details)
6253         {
6254           printf (_("  [Nr] Name\n"));
6255           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6256         }
6257       else
6258         printf
6259           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6260     }
6261   else
6262     {
6263       if (do_section_details)
6264         {
6265           printf (_("  [Nr] Name\n"));
6266           printf (_("       Type              Address          Offset            Link\n"));
6267           printf (_("       Size              EntSize          Info              Align\n"));
6268         }
6269       else
6270         {
6271           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6272           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6273         }
6274     }
6275
6276   if (do_section_details)
6277     printf (_("       Flags\n"));
6278
6279   for (i = 0, section = filedata->section_headers;
6280        i < filedata->file_header.e_shnum;
6281        i++, section++)
6282     {
6283       /* Run some sanity checks on the section header.  */
6284
6285       /* Check the sh_link field.  */
6286       switch (section->sh_type)
6287         {
6288         case SHT_SYMTAB_SHNDX:
6289         case SHT_GROUP:
6290         case SHT_HASH:
6291         case SHT_GNU_HASH:
6292         case SHT_GNU_versym:
6293         case SHT_REL:
6294         case SHT_RELA:
6295           if (section->sh_link < 1
6296               || section->sh_link >= filedata->file_header.e_shnum
6297               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6298                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6299             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6300                   i, section->sh_link);
6301           break;
6302
6303         case SHT_DYNAMIC:
6304         case SHT_SYMTAB:
6305         case SHT_DYNSYM:
6306         case SHT_GNU_verneed:
6307         case SHT_GNU_verdef:
6308         case SHT_GNU_LIBLIST:
6309           if (section->sh_link < 1
6310               || section->sh_link >= filedata->file_header.e_shnum
6311               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6312             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6313                   i, section->sh_link);
6314           break;
6315
6316         case SHT_INIT_ARRAY:
6317         case SHT_FINI_ARRAY:
6318         case SHT_PREINIT_ARRAY:
6319           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6320             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6321                   i, section->sh_link);
6322           break;
6323
6324         default:
6325           /* FIXME: Add support for target specific section types.  */
6326 #if 0     /* Currently we do not check other section types as there are too
6327              many special cases.  Stab sections for example have a type
6328              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6329              section.  */
6330           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6331             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6332                   i, section->sh_link);
6333 #endif
6334           break;
6335         }
6336
6337       /* Check the sh_info field.  */
6338       switch (section->sh_type)
6339         {
6340         case SHT_REL:
6341         case SHT_RELA:
6342           if (section->sh_info < 1
6343               || section->sh_info >= filedata->file_header.e_shnum
6344               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6345                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6346                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6347                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6348                   /* FIXME: Are other section types valid ?  */
6349                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6350             {
6351               if (section->sh_info == 0
6352                   && (filedata->file_header.e_type == ET_EXEC
6353                       || filedata->file_header.e_type == ET_DYN
6354                       /* These next two tests may be redundant, but
6355                          they have been left in for paranoia's sake.  */
6356                       || streq (SECTION_NAME (section), ".rel.dyn")
6357                       || streq (SECTION_NAME (section), ".rela.dyn")))
6358                 /* Dynamic relocations apply to segments, not sections, so
6359                    they do not need an sh_info value.  */
6360                 ;
6361               else
6362                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6363                       i, section->sh_info);
6364             }
6365           break;
6366
6367         case SHT_DYNAMIC:
6368         case SHT_HASH:
6369         case SHT_SYMTAB_SHNDX:
6370         case SHT_INIT_ARRAY:
6371         case SHT_FINI_ARRAY:
6372         case SHT_PREINIT_ARRAY:
6373           if (section->sh_info != 0)
6374             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6375                   i, section->sh_info);
6376           break;
6377
6378         case SHT_GROUP:
6379         case SHT_SYMTAB:
6380         case SHT_DYNSYM:
6381           /* A symbol index - we assume that it is valid.  */
6382           break;
6383
6384         default:
6385           /* FIXME: Add support for target specific section types.  */
6386           if (section->sh_type == SHT_NOBITS)
6387             /* NOBITS section headers with non-zero sh_info fields can be
6388                created when a binary is stripped of everything but its debug
6389                information.  The stripped sections have their headers
6390                preserved but their types set to SHT_NOBITS.  So do not check
6391                this type of section.  */
6392             ;
6393           else if (section->sh_flags & SHF_INFO_LINK)
6394             {
6395               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6396                 warn (_("[%2u]: Expected link to another section in info field"), i);
6397             }
6398           else if (section->sh_type < SHT_LOOS
6399                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6400                    && section->sh_info != 0)
6401             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6402                   i, section->sh_info);
6403           break;
6404         }
6405
6406       /* Check the sh_size field.  */
6407       if (section->sh_size > filedata->file_size
6408           && section->sh_type != SHT_NOBITS
6409           && section->sh_type != SHT_NULL
6410           && section->sh_type < SHT_LOOS)
6411         warn (_("Size of section %u is larger than the entire file!\n"), i);
6412
6413       printf ("  [%2u] ", i);
6414       if (do_section_details)
6415         printf ("%s\n      ", printable_section_name (filedata, section));
6416       else
6417         print_symbol (-17, SECTION_NAME (section));
6418
6419       printf (do_wide ? " %-15s " : " %-15.15s ",
6420               get_section_type_name (filedata, section->sh_type));
6421
6422       if (is_32bit_elf)
6423         {
6424           const char * link_too_big = NULL;
6425
6426           print_vma (section->sh_addr, LONG_HEX);
6427
6428           printf ( " %6.6lx %6.6lx %2.2lx",
6429                    (unsigned long) section->sh_offset,
6430                    (unsigned long) section->sh_size,
6431                    (unsigned long) section->sh_entsize);
6432
6433           if (do_section_details)
6434             fputs ("  ", stdout);
6435           else
6436             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6437
6438           if (section->sh_link >= filedata->file_header.e_shnum)
6439             {
6440               link_too_big = "";
6441               /* The sh_link value is out of range.  Normally this indicates
6442                  an error but it can have special values in Solaris binaries.  */
6443               switch (filedata->file_header.e_machine)
6444                 {
6445                 case EM_386:
6446                 case EM_IAMCU:
6447                 case EM_X86_64:
6448                 case EM_L1OM:
6449                 case EM_K1OM:
6450                 case EM_OLD_SPARCV9:
6451                 case EM_SPARC32PLUS:
6452                 case EM_SPARCV9:
6453                 case EM_SPARC:
6454                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6455                     link_too_big = "BEFORE";
6456                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6457                     link_too_big = "AFTER";
6458                   break;
6459                 default:
6460                   break;
6461                 }
6462             }
6463
6464           if (do_section_details)
6465             {
6466               if (link_too_big != NULL && * link_too_big)
6467                 printf ("<%s> ", link_too_big);
6468               else
6469                 printf ("%2u ", section->sh_link);
6470               printf ("%3u %2lu\n", section->sh_info,
6471                       (unsigned long) section->sh_addralign);
6472             }
6473           else
6474             printf ("%2u %3u %2lu\n",
6475                     section->sh_link,
6476                     section->sh_info,
6477                     (unsigned long) section->sh_addralign);
6478
6479           if (link_too_big && ! * link_too_big)
6480             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6481                   i, section->sh_link);
6482         }
6483       else if (do_wide)
6484         {
6485           print_vma (section->sh_addr, LONG_HEX);
6486
6487           if ((long) section->sh_offset == section->sh_offset)
6488             printf (" %6.6lx", (unsigned long) section->sh_offset);
6489           else
6490             {
6491               putchar (' ');
6492               print_vma (section->sh_offset, LONG_HEX);
6493             }
6494
6495           if ((unsigned long) section->sh_size == section->sh_size)
6496             printf (" %6.6lx", (unsigned long) section->sh_size);
6497           else
6498             {
6499               putchar (' ');
6500               print_vma (section->sh_size, LONG_HEX);
6501             }
6502
6503           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6504             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6505           else
6506             {
6507               putchar (' ');
6508               print_vma (section->sh_entsize, LONG_HEX);
6509             }
6510
6511           if (do_section_details)
6512             fputs ("  ", stdout);
6513           else
6514             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6515
6516           printf ("%2u %3u ", section->sh_link, section->sh_info);
6517
6518           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6519             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6520           else
6521             {
6522               print_vma (section->sh_addralign, DEC);
6523               putchar ('\n');
6524             }
6525         }
6526       else if (do_section_details)
6527         {
6528           putchar (' ');
6529           print_vma (section->sh_addr, LONG_HEX);
6530           if ((long) section->sh_offset == section->sh_offset)
6531             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6532           else
6533             {
6534               printf ("  ");
6535               print_vma (section->sh_offset, LONG_HEX);
6536             }
6537           printf ("  %u\n       ", section->sh_link);
6538           print_vma (section->sh_size, LONG_HEX);
6539           putchar (' ');
6540           print_vma (section->sh_entsize, LONG_HEX);
6541
6542           printf ("  %-16u  %lu\n",
6543                   section->sh_info,
6544                   (unsigned long) section->sh_addralign);
6545         }
6546       else
6547         {
6548           putchar (' ');
6549           print_vma (section->sh_addr, LONG_HEX);
6550           if ((long) section->sh_offset == section->sh_offset)
6551             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6552           else
6553             {
6554               printf ("  ");
6555               print_vma (section->sh_offset, LONG_HEX);
6556             }
6557           printf ("\n       ");
6558           print_vma (section->sh_size, LONG_HEX);
6559           printf ("  ");
6560           print_vma (section->sh_entsize, LONG_HEX);
6561
6562           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6563
6564           printf ("     %2u   %3u     %lu\n",
6565                   section->sh_link,
6566                   section->sh_info,
6567                   (unsigned long) section->sh_addralign);
6568         }
6569
6570       if (do_section_details)
6571         {
6572           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6573           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6574             {
6575               /* Minimum section size is 12 bytes for 32-bit compression
6576                  header + 12 bytes for compressed data header.  */
6577               unsigned char buf[24];
6578
6579               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6580               if (get_data (&buf, filedata, section->sh_offset, 1,
6581                             sizeof (buf), _("compression header")))
6582                 {
6583                   Elf_Internal_Chdr chdr;
6584
6585                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6586
6587                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6588                     printf ("       ZLIB, ");
6589                   else
6590                     printf (_("       [<unknown>: 0x%x], "),
6591                             chdr.ch_type);
6592                   print_vma (chdr.ch_size, LONG_HEX);
6593                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6594                 }
6595             }
6596         }
6597     }
6598
6599   if (!do_section_details)
6600     {
6601       /* The ordering of the letters shown here matches the ordering of the
6602          corresponding SHF_xxx values, and hence the order in which these
6603          letters will be displayed to the user.  */
6604       printf (_("Key to Flags:\n\
6605   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6606   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6607   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6608       if (filedata->file_header.e_machine == EM_X86_64
6609           || filedata->file_header.e_machine == EM_L1OM
6610           || filedata->file_header.e_machine == EM_K1OM)
6611         printf (_("l (large), "));
6612       else if (filedata->file_header.e_machine == EM_ARM)
6613         printf (_("y (purecode), "));
6614       else if (filedata->file_header.e_machine == EM_PPC)
6615         printf (_("v (VLE), "));
6616       printf ("p (processor specific)\n");
6617     }
6618
6619   return TRUE;
6620 }
6621
6622 static const char *
6623 get_group_flags (unsigned int flags)
6624 {
6625   static char buff[128];
6626
6627   if (flags == 0)
6628     return "";
6629   else if (flags == GRP_COMDAT)
6630     return "COMDAT ";
6631
6632   snprintf (buff, 14, _("[0x%x: "), flags);
6633
6634   flags &= ~ GRP_COMDAT;
6635   if (flags & GRP_MASKOS)
6636     {
6637       strcat (buff, "<OS specific>");
6638       flags &= ~ GRP_MASKOS;
6639     }
6640
6641   if (flags & GRP_MASKPROC)
6642     {
6643       strcat (buff, "<PROC specific>");
6644       flags &= ~ GRP_MASKPROC;
6645     }
6646
6647   if (flags)
6648     strcat (buff, "<unknown>");
6649
6650   strcat (buff, "]");
6651   return buff;
6652 }
6653
6654 static bfd_boolean
6655 process_section_groups (Filedata * filedata)
6656 {
6657   Elf_Internal_Shdr * section;
6658   unsigned int i;
6659   struct group * group;
6660   Elf_Internal_Shdr * symtab_sec;
6661   Elf_Internal_Shdr * strtab_sec;
6662   Elf_Internal_Sym * symtab;
6663   unsigned long num_syms;
6664   char * strtab;
6665   size_t strtab_size;
6666
6667   /* Don't process section groups unless needed.  */
6668   if (!do_unwind && !do_section_groups)
6669     return TRUE;
6670
6671   if (filedata->file_header.e_shnum == 0)
6672     {
6673       if (do_section_groups)
6674         printf (_("\nThere are no sections to group in this file.\n"));
6675
6676       return TRUE;
6677     }
6678
6679   if (filedata->section_headers == NULL)
6680     {
6681       error (_("Section headers are not available!\n"));
6682       /* PR 13622: This can happen with a corrupt ELF header.  */
6683       return FALSE;
6684     }
6685
6686   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6687                                                      sizeof (struct group *));
6688
6689   if (section_headers_groups == NULL)
6690     {
6691       error (_("Out of memory reading %u section group headers\n"),
6692              filedata->file_header.e_shnum);
6693       return FALSE;
6694     }
6695
6696   /* Scan the sections for the group section.  */
6697   group_count = 0;
6698   for (i = 0, section = filedata->section_headers;
6699        i < filedata->file_header.e_shnum;
6700        i++, section++)
6701     if (section->sh_type == SHT_GROUP)
6702       group_count++;
6703
6704   if (group_count == 0)
6705     {
6706       if (do_section_groups)
6707         printf (_("\nThere are no section groups in this file.\n"));
6708
6709       return TRUE;
6710     }
6711
6712   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6713
6714   if (section_groups == NULL)
6715     {
6716       error (_("Out of memory reading %lu groups\n"),
6717              (unsigned long) group_count);
6718       return FALSE;
6719     }
6720
6721   symtab_sec = NULL;
6722   strtab_sec = NULL;
6723   symtab = NULL;
6724   num_syms = 0;
6725   strtab = NULL;
6726   strtab_size = 0;
6727   for (i = 0, section = filedata->section_headers, group = section_groups;
6728        i < filedata->file_header.e_shnum;
6729        i++, section++)
6730     {
6731       if (section->sh_type == SHT_GROUP)
6732         {
6733           const char * name = printable_section_name (filedata, section);
6734           const char * group_name;
6735           unsigned char * start;
6736           unsigned char * indices;
6737           unsigned int entry, j, size;
6738           Elf_Internal_Shdr * sec;
6739           Elf_Internal_Sym * sym;
6740
6741           /* Get the symbol table.  */
6742           if (section->sh_link >= filedata->file_header.e_shnum
6743               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6744                   != SHT_SYMTAB))
6745             {
6746               error (_("Bad sh_link in group section `%s'\n"), name);
6747               continue;
6748             }
6749
6750           if (symtab_sec != sec)
6751             {
6752               symtab_sec = sec;
6753               if (symtab)
6754                 free (symtab);
6755               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6756             }
6757
6758           if (symtab == NULL)
6759             {
6760               error (_("Corrupt header in group section `%s'\n"), name);
6761               continue;
6762             }
6763
6764           if (section->sh_info >= num_syms)
6765             {
6766               error (_("Bad sh_info in group section `%s'\n"), name);
6767               continue;
6768             }
6769
6770           sym = symtab + section->sh_info;
6771
6772           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6773             {
6774               if (sym->st_shndx == 0
6775                   || sym->st_shndx >= filedata->file_header.e_shnum)
6776                 {
6777                   error (_("Bad sh_info in group section `%s'\n"), name);
6778                   continue;
6779                 }
6780
6781               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6782               strtab_sec = NULL;
6783               if (strtab)
6784                 free (strtab);
6785               strtab = NULL;
6786               strtab_size = 0;
6787             }
6788           else
6789             {
6790               /* Get the string table.  */
6791               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6792                 {
6793                   strtab_sec = NULL;
6794                   if (strtab)
6795                     free (strtab);
6796                   strtab = NULL;
6797                   strtab_size = 0;
6798                 }
6799               else if (strtab_sec
6800                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6801                 {
6802                   strtab_sec = sec;
6803                   if (strtab)
6804                     free (strtab);
6805
6806                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6807                                               1, strtab_sec->sh_size,
6808                                               _("string table"));
6809                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6810                 }
6811               group_name = sym->st_name < strtab_size
6812                 ? strtab + sym->st_name : _("<corrupt>");
6813             }
6814
6815           /* PR 17531: file: loop.  */
6816           if (section->sh_entsize > section->sh_size)
6817             {
6818               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6819                      printable_section_name (filedata, section),
6820                      (unsigned long) section->sh_entsize,
6821                      (unsigned long) section->sh_size);
6822               break;
6823             }
6824
6825           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6826                                               1, section->sh_size,
6827                                               _("section data"));
6828           if (start == NULL)
6829             continue;
6830
6831           indices = start;
6832           size = (section->sh_size / section->sh_entsize) - 1;
6833           entry = byte_get (indices, 4);
6834           indices += 4;
6835
6836           if (do_section_groups)
6837             {
6838               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6839                       get_group_flags (entry), i, name, group_name, size);
6840
6841               printf (_("   [Index]    Name\n"));
6842             }
6843
6844           group->group_index = i;
6845
6846           for (j = 0; j < size; j++)
6847             {
6848               struct group_list * g;
6849
6850               entry = byte_get (indices, 4);
6851               indices += 4;
6852
6853               if (entry >= filedata->file_header.e_shnum)
6854                 {
6855                   static unsigned num_group_errors = 0;
6856
6857                   if (num_group_errors ++ < 10)
6858                     {
6859                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6860                              entry, i, filedata->file_header.e_shnum - 1);
6861                       if (num_group_errors == 10)
6862                         warn (_("Further error messages about overlarge group section indices suppressed\n"));
6863                     }
6864                   continue;
6865                 }
6866
6867               if (section_headers_groups [entry] != NULL)
6868                 {
6869                   if (entry)
6870                     {
6871                       static unsigned num_errs = 0;
6872
6873                       if (num_errs ++ < 10)
6874                         {
6875                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6876                                  entry, i,
6877                                  section_headers_groups [entry]->group_index);
6878                           if (num_errs == 10)
6879                             warn (_("Further error messages about already contained group sections suppressed\n"));
6880                         }
6881                       continue;
6882                     }
6883                   else
6884                     {
6885                       /* Intel C/C++ compiler may put section 0 in a
6886                          section group.  We just warn it the first time
6887                          and ignore it afterwards.  */
6888                       static bfd_boolean warned = FALSE;
6889                       if (!warned)
6890                         {
6891                           error (_("section 0 in group section [%5u]\n"),
6892                                  section_headers_groups [entry]->group_index);
6893                           warned = TRUE;
6894                         }
6895                     }
6896                 }
6897
6898               section_headers_groups [entry] = group;
6899
6900               if (do_section_groups)
6901                 {
6902                   sec = filedata->section_headers + entry;
6903                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6904                 }
6905
6906               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6907               g->section_index = entry;
6908               g->next = group->root;
6909               group->root = g;
6910             }
6911
6912           if (start)
6913             free (start);
6914
6915           group++;
6916         }
6917     }
6918
6919   if (symtab)
6920     free (symtab);
6921   if (strtab)
6922     free (strtab);
6923   return TRUE;
6924 }
6925
6926 /* Data used to display dynamic fixups.  */
6927
6928 struct ia64_vms_dynfixup
6929 {
6930   bfd_vma needed_ident;         /* Library ident number.  */
6931   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6932   bfd_vma fixup_needed;         /* Index of the library.  */
6933   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6934   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6935 };
6936
6937 /* Data used to display dynamic relocations.  */
6938
6939 struct ia64_vms_dynimgrela
6940 {
6941   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6942   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6943 };
6944
6945 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6946    library).  */
6947
6948 static bfd_boolean
6949 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6950                               struct ia64_vms_dynfixup *  fixup,
6951                               const char *                strtab,
6952                               unsigned int                strtab_sz)
6953 {
6954   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6955   long i;
6956   const char * lib_name;
6957
6958   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6959                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6960                    _("dynamic section image fixups"));
6961   if (!imfs)
6962     return FALSE;
6963
6964   if (fixup->needed < strtab_sz)
6965     lib_name = strtab + fixup->needed;
6966   else
6967     {
6968       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6969             (unsigned long) fixup->needed);
6970       lib_name = "???";
6971     }
6972   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6973           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6974   printf
6975     (_("Seg Offset           Type                             SymVec DataType\n"));
6976
6977   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6978     {
6979       unsigned int type;
6980       const char *rtype;
6981
6982       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6983       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6984       type = BYTE_GET (imfs [i].type);
6985       rtype = elf_ia64_reloc_type (type);
6986       if (rtype == NULL)
6987         printf (" 0x%08x                       ", type);
6988       else
6989         printf (" %-32s ", rtype);
6990       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6991       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6992     }
6993
6994   free (imfs);
6995   return TRUE;
6996 }
6997
6998 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6999
7000 static bfd_boolean
7001 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7002 {
7003   Elf64_External_VMS_IMAGE_RELA *imrs;
7004   long i;
7005
7006   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7007                    1, imgrela->img_rela_cnt * sizeof (*imrs),
7008                    _("dynamic section image relocations"));
7009   if (!imrs)
7010     return FALSE;
7011
7012   printf (_("\nImage relocs\n"));
7013   printf
7014     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
7015
7016   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7017     {
7018       unsigned int type;
7019       const char *rtype;
7020
7021       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7022       printf ("%08" BFD_VMA_FMT "x ",
7023               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7024       type = BYTE_GET (imrs [i].type);
7025       rtype = elf_ia64_reloc_type (type);
7026       if (rtype == NULL)
7027         printf ("0x%08x                      ", type);
7028       else
7029         printf ("%-31s ", rtype);
7030       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7031       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7032       printf ("%08" BFD_VMA_FMT "x\n",
7033               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7034     }
7035
7036   free (imrs);
7037   return TRUE;
7038 }
7039
7040 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
7041
7042 static bfd_boolean
7043 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7044 {
7045   struct ia64_vms_dynfixup fixup;
7046   struct ia64_vms_dynimgrela imgrela;
7047   Elf_Internal_Dyn *entry;
7048   bfd_vma strtab_off = 0;
7049   bfd_vma strtab_sz = 0;
7050   char *strtab = NULL;
7051   bfd_boolean res = TRUE;
7052
7053   memset (&fixup, 0, sizeof (fixup));
7054   memset (&imgrela, 0, sizeof (imgrela));
7055
7056   /* Note: the order of the entries is specified by the OpenVMS specs.  */
7057   for (entry = dynamic_section;
7058        entry < dynamic_section + dynamic_nent;
7059        entry++)
7060     {
7061       switch (entry->d_tag)
7062         {
7063         case DT_IA_64_VMS_STRTAB_OFFSET:
7064           strtab_off = entry->d_un.d_val;
7065           break;
7066         case DT_STRSZ:
7067           strtab_sz = entry->d_un.d_val;
7068           if (strtab == NULL)
7069             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7070                                1, strtab_sz, _("dynamic string section"));
7071           break;
7072
7073         case DT_IA_64_VMS_NEEDED_IDENT:
7074           fixup.needed_ident = entry->d_un.d_val;
7075           break;
7076         case DT_NEEDED:
7077           fixup.needed = entry->d_un.d_val;
7078           break;
7079         case DT_IA_64_VMS_FIXUP_NEEDED:
7080           fixup.fixup_needed = entry->d_un.d_val;
7081           break;
7082         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7083           fixup.fixup_rela_cnt = entry->d_un.d_val;
7084           break;
7085         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7086           fixup.fixup_rela_off = entry->d_un.d_val;
7087           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7088             res = FALSE;
7089           break;
7090         case DT_IA_64_VMS_IMG_RELA_CNT:
7091           imgrela.img_rela_cnt = entry->d_un.d_val;
7092           break;
7093         case DT_IA_64_VMS_IMG_RELA_OFF:
7094           imgrela.img_rela_off = entry->d_un.d_val;
7095           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7096             res = FALSE;
7097           break;
7098
7099         default:
7100           break;
7101         }
7102     }
7103
7104   if (strtab != NULL)
7105     free (strtab);
7106
7107   return res;
7108 }
7109
7110 static struct
7111 {
7112   const char * name;
7113   int reloc;
7114   int size;
7115   int rela;
7116 }
7117   dynamic_relocations [] =
7118 {
7119   { "REL", DT_REL, DT_RELSZ, FALSE },
7120   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7121   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7122 };
7123
7124 /* Process the reloc section.  */
7125
7126 static bfd_boolean
7127 process_relocs (Filedata * filedata)
7128 {
7129   unsigned long rel_size;
7130   unsigned long rel_offset;
7131
7132   if (!do_reloc)
7133     return TRUE;
7134
7135   if (do_using_dynamic)
7136     {
7137       int          is_rela;
7138       const char * name;
7139       bfd_boolean  has_dynamic_reloc;
7140       unsigned int i;
7141
7142       has_dynamic_reloc = FALSE;
7143
7144       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7145         {
7146           is_rela = dynamic_relocations [i].rela;
7147           name = dynamic_relocations [i].name;
7148           rel_size = dynamic_info [dynamic_relocations [i].size];
7149           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7150
7151           if (rel_size)
7152             has_dynamic_reloc = TRUE;
7153
7154           if (is_rela == UNKNOWN)
7155             {
7156               if (dynamic_relocations [i].reloc == DT_JMPREL)
7157                 switch (dynamic_info[DT_PLTREL])
7158                   {
7159                   case DT_REL:
7160                     is_rela = FALSE;
7161                     break;
7162                   case DT_RELA:
7163                     is_rela = TRUE;
7164                     break;
7165                   }
7166             }
7167
7168           if (rel_size)
7169             {
7170               printf
7171                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7172                  name, rel_offset, rel_size);
7173
7174               dump_relocations (filedata,
7175                                 offset_from_vma (filedata, rel_offset, rel_size),
7176                                 rel_size,
7177                                 dynamic_symbols, num_dynamic_syms,
7178                                 dynamic_strings, dynamic_strings_length,
7179                                 is_rela, TRUE /* is_dynamic */);
7180             }
7181         }
7182
7183       if (is_ia64_vms (filedata))
7184         if (process_ia64_vms_dynamic_relocs (filedata))
7185           has_dynamic_reloc = TRUE;
7186
7187       if (! has_dynamic_reloc)
7188         printf (_("\nThere are no dynamic relocations in this file.\n"));
7189     }
7190   else
7191     {
7192       Elf_Internal_Shdr * section;
7193       unsigned long i;
7194       bfd_boolean found = FALSE;
7195
7196       for (i = 0, section = filedata->section_headers;
7197            i < filedata->file_header.e_shnum;
7198            i++, section++)
7199         {
7200           if (   section->sh_type != SHT_RELA
7201               && section->sh_type != SHT_REL)
7202             continue;
7203
7204           rel_offset = section->sh_offset;
7205           rel_size   = section->sh_size;
7206
7207           if (rel_size)
7208             {
7209               Elf_Internal_Shdr * strsec;
7210               int is_rela;
7211               unsigned long num_rela;
7212
7213               printf (_("\nRelocation section "));
7214
7215               if (filedata->string_table == NULL)
7216                 printf ("%d", section->sh_name);
7217               else
7218                 printf ("'%s'", printable_section_name (filedata, section));
7219
7220               num_rela = rel_size / section->sh_entsize;
7221               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7222                                 " at offset 0x%lx contains %lu entries:\n",
7223                                 num_rela),
7224                       rel_offset, num_rela);
7225
7226               is_rela = section->sh_type == SHT_RELA;
7227
7228               if (section->sh_link != 0
7229                   && section->sh_link < filedata->file_header.e_shnum)
7230                 {
7231                   Elf_Internal_Shdr * symsec;
7232                   Elf_Internal_Sym *  symtab;
7233                   unsigned long nsyms;
7234                   unsigned long strtablen = 0;
7235                   char * strtab = NULL;
7236
7237                   symsec = filedata->section_headers + section->sh_link;
7238                   if (symsec->sh_type != SHT_SYMTAB
7239                       && symsec->sh_type != SHT_DYNSYM)
7240                     continue;
7241
7242                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7243
7244                   if (symtab == NULL)
7245                     continue;
7246
7247                   if (symsec->sh_link != 0
7248                       && symsec->sh_link < filedata->file_header.e_shnum)
7249                     {
7250                       strsec = filedata->section_headers + symsec->sh_link;
7251
7252                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7253                                                   1, strsec->sh_size,
7254                                                   _("string table"));
7255                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7256                     }
7257
7258                   dump_relocations (filedata, rel_offset, rel_size,
7259                                     symtab, nsyms, strtab, strtablen,
7260                                     is_rela,
7261                                     symsec->sh_type == SHT_DYNSYM);
7262                   if (strtab)
7263                     free (strtab);
7264                   free (symtab);
7265                 }
7266               else
7267                 dump_relocations (filedata, rel_offset, rel_size,
7268                                   NULL, 0, NULL, 0, is_rela,
7269                                   FALSE /* is_dynamic */);
7270
7271               found = TRUE;
7272             }
7273         }
7274
7275       if (! found)
7276         {
7277           /* Users sometimes forget the -D option, so try to be helpful.  */
7278           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7279             {
7280               if (dynamic_info [dynamic_relocations [i].size])
7281                 {
7282                   printf (_("\nThere are no static relocations in this file."));
7283                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7284
7285                   break;
7286                 }
7287             }
7288           if (i == ARRAY_SIZE (dynamic_relocations))
7289             printf (_("\nThere are no relocations in this file.\n"));
7290         }
7291     }
7292
7293   return TRUE;
7294 }
7295
7296 /* An absolute address consists of a section and an offset.  If the
7297    section is NULL, the offset itself is the address, otherwise, the
7298    address equals to LOAD_ADDRESS(section) + offset.  */
7299
7300 struct absaddr
7301 {
7302   unsigned short section;
7303   bfd_vma offset;
7304 };
7305
7306 #define ABSADDR(a) \
7307   ((a).section \
7308    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7309    : (a).offset)
7310
7311 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7312    name, if found, and the offset from the symbol to ADDR.  */
7313
7314 static void
7315 find_symbol_for_address (Filedata *          filedata,
7316                          Elf_Internal_Sym *  symtab,
7317                          unsigned long       nsyms,
7318                          const char *        strtab,
7319                          unsigned long       strtab_size,
7320                          struct absaddr      addr,
7321                          const char **       symname,
7322                          bfd_vma *           offset)
7323 {
7324   bfd_vma dist = 0x100000;
7325   Elf_Internal_Sym * sym;
7326   Elf_Internal_Sym * beg;
7327   Elf_Internal_Sym * end;
7328   Elf_Internal_Sym * best = NULL;
7329
7330   REMOVE_ARCH_BITS (addr.offset);
7331   beg = symtab;
7332   end = symtab + nsyms;
7333
7334   while (beg < end)
7335     {
7336       bfd_vma value;
7337
7338       sym = beg + (end - beg) / 2;
7339
7340       value = sym->st_value;
7341       REMOVE_ARCH_BITS (value);
7342
7343       if (sym->st_name != 0
7344           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7345           && addr.offset >= value
7346           && addr.offset - value < dist)
7347         {
7348           best = sym;
7349           dist = addr.offset - value;
7350           if (!dist)
7351             break;
7352         }
7353
7354       if (addr.offset < value)
7355         end = sym;
7356       else
7357         beg = sym + 1;
7358     }
7359
7360   if (best)
7361     {
7362       *symname = (best->st_name >= strtab_size
7363                   ? _("<corrupt>") : strtab + best->st_name);
7364       *offset = dist;
7365       return;
7366     }
7367
7368   *symname = NULL;
7369   *offset = addr.offset;
7370 }
7371
7372 static /* signed */ int
7373 symcmp (const void *p, const void *q)
7374 {
7375   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7376   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7377
7378   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7379 }
7380
7381 /* Process the unwind section.  */
7382
7383 #include "unwind-ia64.h"
7384
7385 struct ia64_unw_table_entry
7386 {
7387   struct absaddr start;
7388   struct absaddr end;
7389   struct absaddr info;
7390 };
7391
7392 struct ia64_unw_aux_info
7393 {
7394   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7395   unsigned long                 table_len;      /* Length of unwind table.  */
7396   unsigned char *               info;           /* Unwind info.  */
7397   unsigned long                 info_size;      /* Size of unwind info.  */
7398   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7399   bfd_vma                       seg_base;       /* Starting address of segment.  */
7400   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7401   unsigned long                 nsyms;          /* Number of symbols.  */
7402   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7403   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7404   char *                        strtab;         /* The string table.  */
7405   unsigned long                 strtab_size;    /* Size of string table.  */
7406 };
7407
7408 static bfd_boolean
7409 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7410 {
7411   struct ia64_unw_table_entry * tp;
7412   unsigned long j, nfuns;
7413   int in_body;
7414   bfd_boolean res = TRUE;
7415
7416   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7417   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7418     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7419       aux->funtab[nfuns++] = aux->symtab[j];
7420   aux->nfuns = nfuns;
7421   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7422
7423   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7424     {
7425       bfd_vma stamp;
7426       bfd_vma offset;
7427       const unsigned char * dp;
7428       const unsigned char * head;
7429       const unsigned char * end;
7430       const char * procname;
7431
7432       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7433                                aux->strtab_size, tp->start, &procname, &offset);
7434
7435       fputs ("\n<", stdout);
7436
7437       if (procname)
7438         {
7439           fputs (procname, stdout);
7440
7441           if (offset)
7442             printf ("+%lx", (unsigned long) offset);
7443         }
7444
7445       fputs (">: [", stdout);
7446       print_vma (tp->start.offset, PREFIX_HEX);
7447       fputc ('-', stdout);
7448       print_vma (tp->end.offset, PREFIX_HEX);
7449       printf ("], info at +0x%lx\n",
7450               (unsigned long) (tp->info.offset - aux->seg_base));
7451
7452       /* PR 17531: file: 86232b32.  */
7453       if (aux->info == NULL)
7454         continue;
7455
7456       /* PR 17531: file: 0997b4d1.  */
7457       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7458         {
7459           warn (_("Invalid offset %lx in table entry %ld\n"),
7460                 (long) tp->info.offset, (long) (tp - aux->table));
7461           res = FALSE;
7462           continue;
7463         }
7464
7465       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7466       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7467
7468       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7469               (unsigned) UNW_VER (stamp),
7470               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7471               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7472               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7473               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7474
7475       if (UNW_VER (stamp) != 1)
7476         {
7477           printf (_("\tUnknown version.\n"));
7478           continue;
7479         }
7480
7481       in_body = 0;
7482       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7483       /* PR 17531: file: 16ceda89.  */
7484       if (end > aux->info + aux->info_size)
7485         end = aux->info + aux->info_size;
7486       for (dp = head + 8; dp < end;)
7487         dp = unw_decode (dp, in_body, & in_body, end);
7488     }
7489
7490   free (aux->funtab);
7491
7492   return res;
7493 }
7494
7495 static bfd_boolean
7496 slurp_ia64_unwind_table (Filedata *                  filedata,
7497                          struct ia64_unw_aux_info *  aux,
7498                          Elf_Internal_Shdr *         sec)
7499 {
7500   unsigned long size, nrelas, i;
7501   Elf_Internal_Phdr * seg;
7502   struct ia64_unw_table_entry * tep;
7503   Elf_Internal_Shdr * relsec;
7504   Elf_Internal_Rela * rela;
7505   Elf_Internal_Rela * rp;
7506   unsigned char * table;
7507   unsigned char * tp;
7508   Elf_Internal_Sym * sym;
7509   const char * relname;
7510
7511   aux->table_len = 0;
7512
7513   /* First, find the starting address of the segment that includes
7514      this section: */
7515
7516   if (filedata->file_header.e_phnum)
7517     {
7518       if (! get_program_headers (filedata))
7519           return FALSE;
7520
7521       for (seg = filedata->program_headers;
7522            seg < filedata->program_headers + filedata->file_header.e_phnum;
7523            ++seg)
7524         {
7525           if (seg->p_type != PT_LOAD)
7526             continue;
7527
7528           if (sec->sh_addr >= seg->p_vaddr
7529               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7530             {
7531               aux->seg_base = seg->p_vaddr;
7532               break;
7533             }
7534         }
7535     }
7536
7537   /* Second, build the unwind table from the contents of the unwind section:  */
7538   size = sec->sh_size;
7539   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7540                                       _("unwind table"));
7541   if (!table)
7542     return FALSE;
7543
7544   aux->table_len = size / (3 * eh_addr_size);
7545   aux->table = (struct ia64_unw_table_entry *)
7546     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7547   tep = aux->table;
7548
7549   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7550     {
7551       tep->start.section = SHN_UNDEF;
7552       tep->end.section   = SHN_UNDEF;
7553       tep->info.section  = SHN_UNDEF;
7554       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7555       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7556       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7557       tep->start.offset += aux->seg_base;
7558       tep->end.offset   += aux->seg_base;
7559       tep->info.offset  += aux->seg_base;
7560     }
7561   free (table);
7562
7563   /* Third, apply any relocations to the unwind table:  */
7564   for (relsec = filedata->section_headers;
7565        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7566        ++relsec)
7567     {
7568       if (relsec->sh_type != SHT_RELA
7569           || relsec->sh_info >= filedata->file_header.e_shnum
7570           || filedata->section_headers + relsec->sh_info != sec)
7571         continue;
7572
7573       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7574                               & rela, & nrelas))
7575         {
7576           free (aux->table);
7577           aux->table = NULL;
7578           aux->table_len = 0;
7579           return FALSE;
7580         }
7581
7582       for (rp = rela; rp < rela + nrelas; ++rp)
7583         {
7584           relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7585           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7586
7587           /* PR 17531: file: 9fa67536.  */
7588           if (relname == NULL)
7589             {
7590               warn (_("Skipping unknown relocation type: %u\n"),
7591                     get_reloc_type (filedata, rp->r_info));
7592               continue;
7593             }
7594
7595           if (! const_strneq (relname, "R_IA64_SEGREL"))
7596             {
7597               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7598               continue;
7599             }
7600
7601           i = rp->r_offset / (3 * eh_addr_size);
7602
7603           /* PR 17531: file: 5bc8d9bf.  */
7604           if (i >= aux->table_len)
7605             {
7606               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7607               continue;
7608             }
7609
7610           switch (rp->r_offset / eh_addr_size % 3)
7611             {
7612             case 0:
7613               aux->table[i].start.section = sym->st_shndx;
7614               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7615               break;
7616             case 1:
7617               aux->table[i].end.section   = sym->st_shndx;
7618               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7619               break;
7620             case 2:
7621               aux->table[i].info.section  = sym->st_shndx;
7622               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7623               break;
7624             default:
7625               break;
7626             }
7627         }
7628
7629       free (rela);
7630     }
7631
7632   return TRUE;
7633 }
7634
7635 static bfd_boolean
7636 ia64_process_unwind (Filedata * filedata)
7637 {
7638   Elf_Internal_Shdr * sec;
7639   Elf_Internal_Shdr * unwsec = NULL;
7640   Elf_Internal_Shdr * strsec;
7641   unsigned long i, unwcount = 0, unwstart = 0;
7642   struct ia64_unw_aux_info aux;
7643   bfd_boolean res = TRUE;
7644
7645   memset (& aux, 0, sizeof (aux));
7646
7647   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7648     {
7649       if (sec->sh_type == SHT_SYMTAB
7650           && sec->sh_link < filedata->file_header.e_shnum)
7651         {
7652           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7653
7654           strsec = filedata->section_headers + sec->sh_link;
7655           if (aux.strtab != NULL)
7656             {
7657               error (_("Multiple auxillary string tables encountered\n"));
7658               free (aux.strtab);
7659               res = FALSE;
7660             }
7661           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7662                                           1, strsec->sh_size,
7663                                           _("string table"));
7664           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7665         }
7666       else if (sec->sh_type == SHT_IA_64_UNWIND)
7667         unwcount++;
7668     }
7669
7670   if (!unwcount)
7671     printf (_("\nThere are no unwind sections in this file.\n"));
7672
7673   while (unwcount-- > 0)
7674     {
7675       char * suffix;
7676       size_t len, len2;
7677
7678       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7679            i < filedata->file_header.e_shnum; ++i, ++sec)
7680         if (sec->sh_type == SHT_IA_64_UNWIND)
7681           {
7682             unwsec = sec;
7683             break;
7684           }
7685       /* We have already counted the number of SHT_IA64_UNWIND
7686          sections so the loop above should never fail.  */
7687       assert (unwsec != NULL);
7688
7689       unwstart = i + 1;
7690       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7691
7692       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7693         {
7694           /* We need to find which section group it is in.  */
7695           struct group_list * g;
7696
7697           if (section_headers_groups == NULL
7698               || section_headers_groups [i] == NULL)
7699             i = filedata->file_header.e_shnum;
7700           else
7701             {
7702               g = section_headers_groups [i]->root;
7703
7704               for (; g != NULL; g = g->next)
7705                 {
7706                   sec = filedata->section_headers + g->section_index;
7707
7708                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7709                     break;
7710                 }
7711
7712               if (g == NULL)
7713                 i = filedata->file_header.e_shnum;
7714             }
7715         }
7716       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7717         {
7718           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7719           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7720           suffix = SECTION_NAME (unwsec) + len;
7721           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7722                ++i, ++sec)
7723             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7724                 && streq (SECTION_NAME (sec) + len2, suffix))
7725               break;
7726         }
7727       else
7728         {
7729           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7730              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7731           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7732           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7733           suffix = "";
7734           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7735             suffix = SECTION_NAME (unwsec) + len;
7736           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7737                ++i, ++sec)
7738             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7739                 && streq (SECTION_NAME (sec) + len2, suffix))
7740               break;
7741         }
7742
7743       if (i == filedata->file_header.e_shnum)
7744         {
7745           printf (_("\nCould not find unwind info section for "));
7746
7747           if (filedata->string_table == NULL)
7748             printf ("%d", unwsec->sh_name);
7749           else
7750             printf ("'%s'", printable_section_name (filedata, unwsec));
7751         }
7752       else
7753         {
7754           aux.info_addr = sec->sh_addr;
7755           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7756                                                  sec->sh_size,
7757                                                  _("unwind info"));
7758           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7759
7760           printf (_("\nUnwind section "));
7761
7762           if (filedata->string_table == NULL)
7763             printf ("%d", unwsec->sh_name);
7764           else
7765             printf ("'%s'", printable_section_name (filedata, unwsec));
7766
7767           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7768                   (unsigned long) unwsec->sh_offset,
7769                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7770
7771           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7772               && aux.table_len > 0)
7773             dump_ia64_unwind (filedata, & aux);
7774
7775           if (aux.table)
7776             free ((char *) aux.table);
7777           if (aux.info)
7778             free ((char *) aux.info);
7779           aux.table = NULL;
7780           aux.info = NULL;
7781         }
7782     }
7783
7784   if (aux.symtab)
7785     free (aux.symtab);
7786   if (aux.strtab)
7787     free ((char *) aux.strtab);
7788
7789   return res;
7790 }
7791
7792 struct hppa_unw_table_entry
7793 {
7794   struct absaddr start;
7795   struct absaddr end;
7796   unsigned int Cannot_unwind:1;                 /* 0 */
7797   unsigned int Millicode:1;                     /* 1 */
7798   unsigned int Millicode_save_sr0:1;            /* 2 */
7799   unsigned int Region_description:2;            /* 3..4 */
7800   unsigned int reserved1:1;                     /* 5 */
7801   unsigned int Entry_SR:1;                      /* 6 */
7802   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7803   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7804   unsigned int Args_stored:1;                   /* 16 */
7805   unsigned int Variable_Frame:1;                /* 17 */
7806   unsigned int Separate_Package_Body:1;         /* 18 */
7807   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7808   unsigned int Stack_Overflow_Check:1;          /* 20 */
7809   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7810   unsigned int Ada_Region:1;                    /* 22 */
7811   unsigned int cxx_info:1;                      /* 23 */
7812   unsigned int cxx_try_catch:1;                 /* 24 */
7813   unsigned int sched_entry_seq:1;               /* 25 */
7814   unsigned int reserved2:1;                     /* 26 */
7815   unsigned int Save_SP:1;                       /* 27 */
7816   unsigned int Save_RP:1;                       /* 28 */
7817   unsigned int Save_MRP_in_frame:1;             /* 29 */
7818   unsigned int extn_ptr_defined:1;              /* 30 */
7819   unsigned int Cleanup_defined:1;               /* 31 */
7820
7821   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7822   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7823   unsigned int Large_frame:1;                   /* 2 */
7824   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7825   unsigned int reserved4:1;                     /* 4 */
7826   unsigned int Total_frame_size:27;             /* 5..31 */
7827 };
7828
7829 struct hppa_unw_aux_info
7830 {
7831   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7832   unsigned long                  table_len;     /* Length of unwind table.  */
7833   bfd_vma                        seg_base;      /* Starting address of segment.  */
7834   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7835   unsigned long                  nsyms;         /* Number of symbols.  */
7836   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7837   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7838   char *                         strtab;        /* The string table.  */
7839   unsigned long                  strtab_size;   /* Size of string table.  */
7840 };
7841
7842 static bfd_boolean
7843 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7844 {
7845   struct hppa_unw_table_entry * tp;
7846   unsigned long j, nfuns;
7847   bfd_boolean res = TRUE;
7848
7849   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7850   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7851     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7852       aux->funtab[nfuns++] = aux->symtab[j];
7853   aux->nfuns = nfuns;
7854   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7855
7856   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7857     {
7858       bfd_vma offset;
7859       const char * procname;
7860
7861       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7862                                aux->strtab_size, tp->start, &procname,
7863                                &offset);
7864
7865       fputs ("\n<", stdout);
7866
7867       if (procname)
7868         {
7869           fputs (procname, stdout);
7870
7871           if (offset)
7872             printf ("+%lx", (unsigned long) offset);
7873         }
7874
7875       fputs (">: [", stdout);
7876       print_vma (tp->start.offset, PREFIX_HEX);
7877       fputc ('-', stdout);
7878       print_vma (tp->end.offset, PREFIX_HEX);
7879       printf ("]\n\t");
7880
7881 #define PF(_m) if (tp->_m) printf (#_m " ");
7882 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7883       PF(Cannot_unwind);
7884       PF(Millicode);
7885       PF(Millicode_save_sr0);
7886       /* PV(Region_description);  */
7887       PF(Entry_SR);
7888       PV(Entry_FR);
7889       PV(Entry_GR);
7890       PF(Args_stored);
7891       PF(Variable_Frame);
7892       PF(Separate_Package_Body);
7893       PF(Frame_Extension_Millicode);
7894       PF(Stack_Overflow_Check);
7895       PF(Two_Instruction_SP_Increment);
7896       PF(Ada_Region);
7897       PF(cxx_info);
7898       PF(cxx_try_catch);
7899       PF(sched_entry_seq);
7900       PF(Save_SP);
7901       PF(Save_RP);
7902       PF(Save_MRP_in_frame);
7903       PF(extn_ptr_defined);
7904       PF(Cleanup_defined);
7905       PF(MPE_XL_interrupt_marker);
7906       PF(HP_UX_interrupt_marker);
7907       PF(Large_frame);
7908       PF(Pseudo_SP_Set);
7909       PV(Total_frame_size);
7910 #undef PF
7911 #undef PV
7912     }
7913
7914   printf ("\n");
7915
7916   free (aux->funtab);
7917
7918   return res;
7919 }
7920
7921 static bfd_boolean
7922 slurp_hppa_unwind_table (Filedata *                  filedata,
7923                          struct hppa_unw_aux_info *  aux,
7924                          Elf_Internal_Shdr *         sec)
7925 {
7926   unsigned long size, unw_ent_size, nentries, nrelas, i;
7927   Elf_Internal_Phdr * seg;
7928   struct hppa_unw_table_entry * tep;
7929   Elf_Internal_Shdr * relsec;
7930   Elf_Internal_Rela * rela;
7931   Elf_Internal_Rela * rp;
7932   unsigned char * table;
7933   unsigned char * tp;
7934   Elf_Internal_Sym * sym;
7935   const char * relname;
7936
7937   /* First, find the starting address of the segment that includes
7938      this section.  */
7939   if (filedata->file_header.e_phnum)
7940     {
7941       if (! get_program_headers (filedata))
7942         return FALSE;
7943
7944       for (seg = filedata->program_headers;
7945            seg < filedata->program_headers + filedata->file_header.e_phnum;
7946            ++seg)
7947         {
7948           if (seg->p_type != PT_LOAD)
7949             continue;
7950
7951           if (sec->sh_addr >= seg->p_vaddr
7952               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7953             {
7954               aux->seg_base = seg->p_vaddr;
7955               break;
7956             }
7957         }
7958     }
7959
7960   /* Second, build the unwind table from the contents of the unwind
7961      section.  */
7962   size = sec->sh_size;
7963   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7964                                       _("unwind table"));
7965   if (!table)
7966     return FALSE;
7967
7968   unw_ent_size = 16;
7969   nentries = size / unw_ent_size;
7970   size = unw_ent_size * nentries;
7971
7972   tep = aux->table = (struct hppa_unw_table_entry *)
7973       xcmalloc (nentries, sizeof (aux->table[0]));
7974
7975   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7976     {
7977       unsigned int tmp1, tmp2;
7978
7979       tep->start.section = SHN_UNDEF;
7980       tep->end.section   = SHN_UNDEF;
7981
7982       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7983       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7984       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7985       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7986
7987       tep->start.offset += aux->seg_base;
7988       tep->end.offset   += aux->seg_base;
7989
7990       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7991       tep->Millicode = (tmp1 >> 30) & 0x1;
7992       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7993       tep->Region_description = (tmp1 >> 27) & 0x3;
7994       tep->reserved1 = (tmp1 >> 26) & 0x1;
7995       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7996       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7997       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7998       tep->Args_stored = (tmp1 >> 15) & 0x1;
7999       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8000       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8001       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8002       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8003       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8004       tep->Ada_Region = (tmp1 >> 9) & 0x1;
8005       tep->cxx_info = (tmp1 >> 8) & 0x1;
8006       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8007       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8008       tep->reserved2 = (tmp1 >> 5) & 0x1;
8009       tep->Save_SP = (tmp1 >> 4) & 0x1;
8010       tep->Save_RP = (tmp1 >> 3) & 0x1;
8011       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8012       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8013       tep->Cleanup_defined = tmp1 & 0x1;
8014
8015       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8016       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8017       tep->Large_frame = (tmp2 >> 29) & 0x1;
8018       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8019       tep->reserved4 = (tmp2 >> 27) & 0x1;
8020       tep->Total_frame_size = tmp2 & 0x7ffffff;
8021     }
8022   free (table);
8023
8024   /* Third, apply any relocations to the unwind table.  */
8025   for (relsec = filedata->section_headers;
8026        relsec < filedata->section_headers + filedata->file_header.e_shnum;
8027        ++relsec)
8028     {
8029       if (relsec->sh_type != SHT_RELA
8030           || relsec->sh_info >= filedata->file_header.e_shnum
8031           || filedata->section_headers + relsec->sh_info != sec)
8032         continue;
8033
8034       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8035                               & rela, & nrelas))
8036         return FALSE;
8037
8038       for (rp = rela; rp < rela + nrelas; ++rp)
8039         {
8040           relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
8041           sym = aux->symtab + get_reloc_symindex (rp->r_info);
8042
8043           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
8044           if (! const_strneq (relname, "R_PARISC_SEGREL"))
8045             {
8046               warn (_("Skipping unexpected relocation type %s\n"), relname);
8047               continue;
8048             }
8049
8050           i = rp->r_offset / unw_ent_size;
8051
8052           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
8053             {
8054             case 0:
8055               aux->table[i].start.section = sym->st_shndx;
8056               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
8057               break;
8058             case 1:
8059               aux->table[i].end.section   = sym->st_shndx;
8060               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
8061               break;
8062             default:
8063               break;
8064             }
8065         }
8066
8067       free (rela);
8068     }
8069
8070   aux->table_len = nentries;
8071
8072   return TRUE;
8073 }
8074
8075 static bfd_boolean
8076 hppa_process_unwind (Filedata * filedata)
8077 {
8078   struct hppa_unw_aux_info aux;
8079   Elf_Internal_Shdr * unwsec = NULL;
8080   Elf_Internal_Shdr * strsec;
8081   Elf_Internal_Shdr * sec;
8082   unsigned long i;
8083   bfd_boolean res = TRUE;
8084
8085   if (filedata->string_table == NULL)
8086     return FALSE;
8087
8088   memset (& aux, 0, sizeof (aux));
8089
8090   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8091     {
8092       if (sec->sh_type == SHT_SYMTAB
8093           && sec->sh_link < filedata->file_header.e_shnum)
8094         {
8095           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8096
8097           strsec = filedata->section_headers + sec->sh_link;
8098           if (aux.strtab != NULL)
8099             {
8100               error (_("Multiple auxillary string tables encountered\n"));
8101               free (aux.strtab);
8102               res = FALSE;
8103             }
8104           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8105                                           1, strsec->sh_size,
8106                                           _("string table"));
8107           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8108         }
8109       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8110         unwsec = sec;
8111     }
8112
8113   if (!unwsec)
8114     printf (_("\nThere are no unwind sections in this file.\n"));
8115
8116   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8117     {
8118       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8119         {
8120           unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8121
8122           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8123                             "contains %lu entry:\n",
8124                             "\nUnwind section '%s' at offset 0x%lx "
8125                             "contains %lu entries:\n",
8126                             num_unwind),
8127                   printable_section_name (filedata, sec),
8128                   (unsigned long) sec->sh_offset,
8129                   num_unwind);
8130
8131           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8132             res = FALSE;
8133
8134           if (aux.table_len > 0)
8135             {
8136               if (! dump_hppa_unwind (filedata, &aux))
8137                 res = FALSE;
8138             }
8139
8140           if (aux.table)
8141             free ((char *) aux.table);
8142           aux.table = NULL;
8143         }
8144     }
8145
8146   if (aux.symtab)
8147     free (aux.symtab);
8148   if (aux.strtab)
8149     free ((char *) aux.strtab);
8150
8151   return res;
8152 }
8153
8154 struct arm_section
8155 {
8156   unsigned char *      data;            /* The unwind data.  */
8157   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8158   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8159   unsigned long        nrelas;          /* The number of relocations.  */
8160   unsigned int         rel_type;        /* REL or RELA ?  */
8161   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8162 };
8163
8164 struct arm_unw_aux_info
8165 {
8166   Filedata *          filedata;         /* The file containing the unwind sections.  */
8167   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8168   unsigned long       nsyms;            /* Number of symbols.  */
8169   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8170   unsigned long       nfuns;            /* Number of these symbols.  */
8171   char *              strtab;           /* The file's string table.  */
8172   unsigned long       strtab_size;      /* Size of string table.  */
8173 };
8174
8175 static const char *
8176 arm_print_vma_and_name (Filedata *                 filedata,
8177                         struct arm_unw_aux_info *  aux,
8178                         bfd_vma                    fn,
8179                         struct absaddr             addr)
8180 {
8181   const char *procname;
8182   bfd_vma sym_offset;
8183
8184   if (addr.section == SHN_UNDEF)
8185     addr.offset = fn;
8186
8187   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8188                            aux->strtab_size, addr, &procname,
8189                            &sym_offset);
8190
8191   print_vma (fn, PREFIX_HEX);
8192
8193   if (procname)
8194     {
8195       fputs (" <", stdout);
8196       fputs (procname, stdout);
8197
8198       if (sym_offset)
8199         printf ("+0x%lx", (unsigned long) sym_offset);
8200       fputc ('>', stdout);
8201     }
8202
8203   return procname;
8204 }
8205
8206 static void
8207 arm_free_section (struct arm_section *arm_sec)
8208 {
8209   if (arm_sec->data != NULL)
8210     free (arm_sec->data);
8211
8212   if (arm_sec->rela != NULL)
8213     free (arm_sec->rela);
8214 }
8215
8216 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8217       cached section and install SEC instead.
8218    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8219       and return its valued in * WORDP, relocating if necessary.
8220    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8221       relocation's offset in ADDR.
8222    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8223       into the string table of the symbol associated with the reloc.  If no
8224       reloc was applied store -1 there.
8225    5) Return TRUE upon success, FALSE otherwise.  */
8226
8227 static bfd_boolean
8228 get_unwind_section_word (Filedata *                 filedata,
8229                          struct arm_unw_aux_info *  aux,
8230                          struct arm_section *       arm_sec,
8231                          Elf_Internal_Shdr *        sec,
8232                          bfd_vma                    word_offset,
8233                          unsigned int *             wordp,
8234                          struct absaddr *           addr,
8235                          bfd_vma *                  sym_name)
8236 {
8237   Elf_Internal_Rela *rp;
8238   Elf_Internal_Sym *sym;
8239   const char * relname;
8240   unsigned int word;
8241   bfd_boolean wrapped;
8242
8243   if (sec == NULL || arm_sec == NULL)
8244     return FALSE;
8245
8246   addr->section = SHN_UNDEF;
8247   addr->offset = 0;
8248
8249   if (sym_name != NULL)
8250     *sym_name = (bfd_vma) -1;
8251
8252   /* If necessary, update the section cache.  */
8253   if (sec != arm_sec->sec)
8254     {
8255       Elf_Internal_Shdr *relsec;
8256
8257       arm_free_section (arm_sec);
8258
8259       arm_sec->sec = sec;
8260       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8261                                 sec->sh_size, _("unwind data"));
8262       arm_sec->rela = NULL;
8263       arm_sec->nrelas = 0;
8264
8265       for (relsec = filedata->section_headers;
8266            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8267            ++relsec)
8268         {
8269           if (relsec->sh_info >= filedata->file_header.e_shnum
8270               || filedata->section_headers + relsec->sh_info != sec
8271               /* PR 15745: Check the section type as well.  */
8272               || (relsec->sh_type != SHT_REL
8273                   && relsec->sh_type != SHT_RELA))
8274             continue;
8275
8276           arm_sec->rel_type = relsec->sh_type;
8277           if (relsec->sh_type == SHT_REL)
8278             {
8279               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8280                                      relsec->sh_size,
8281                                      & arm_sec->rela, & arm_sec->nrelas))
8282                 return FALSE;
8283             }
8284           else /* relsec->sh_type == SHT_RELA */
8285             {
8286               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8287                                       relsec->sh_size,
8288                                       & arm_sec->rela, & arm_sec->nrelas))
8289                 return FALSE;
8290             }
8291           break;
8292         }
8293
8294       arm_sec->next_rela = arm_sec->rela;
8295     }
8296
8297   /* If there is no unwind data we can do nothing.  */
8298   if (arm_sec->data == NULL)
8299     return FALSE;
8300
8301   /* If the offset is invalid then fail.  */
8302   if (/* PR 21343 *//* PR 18879 */
8303       sec->sh_size < 4
8304       || word_offset > (sec->sh_size - 4)
8305       || ((bfd_signed_vma) word_offset) < 0)
8306     return FALSE;
8307
8308   /* Get the word at the required offset.  */
8309   word = byte_get (arm_sec->data + word_offset, 4);
8310
8311   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8312   if (arm_sec->rela == NULL)
8313     {
8314       * wordp = word;
8315       return TRUE;
8316     }
8317
8318   /* Look through the relocs to find the one that applies to the provided offset.  */
8319   wrapped = FALSE;
8320   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8321     {
8322       bfd_vma prelval, offset;
8323
8324       if (rp->r_offset > word_offset && !wrapped)
8325         {
8326           rp = arm_sec->rela;
8327           wrapped = TRUE;
8328         }
8329       if (rp->r_offset > word_offset)
8330         break;
8331
8332       if (rp->r_offset & 3)
8333         {
8334           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8335                 (unsigned long) rp->r_offset);
8336           continue;
8337         }
8338
8339       if (rp->r_offset < word_offset)
8340         continue;
8341
8342       /* PR 17531: file: 027-161405-0.004  */
8343       if (aux->symtab == NULL)
8344         continue;
8345
8346       if (arm_sec->rel_type == SHT_REL)
8347         {
8348           offset = word & 0x7fffffff;
8349           if (offset & 0x40000000)
8350             offset |= ~ (bfd_vma) 0x7fffffff;
8351         }
8352       else if (arm_sec->rel_type == SHT_RELA)
8353         offset = rp->r_addend;
8354       else
8355         {
8356           error (_("Unknown section relocation type %d encountered\n"),
8357                  arm_sec->rel_type);
8358           break;
8359         }
8360
8361       /* PR 17531 file: 027-1241568-0.004.  */
8362       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8363         {
8364           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8365                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8366           break;
8367         }
8368
8369       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8370       offset += sym->st_value;
8371       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8372
8373       /* Check that we are processing the expected reloc type.  */
8374       if (filedata->file_header.e_machine == EM_ARM)
8375         {
8376           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8377           if (relname == NULL)
8378             {
8379               warn (_("Skipping unknown ARM relocation type: %d\n"),
8380                     (int) ELF32_R_TYPE (rp->r_info));
8381               continue;
8382             }
8383
8384           if (streq (relname, "R_ARM_NONE"))
8385               continue;
8386
8387           if (! streq (relname, "R_ARM_PREL31"))
8388             {
8389               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8390               continue;
8391             }
8392         }
8393       else if (filedata->file_header.e_machine == EM_TI_C6000)
8394         {
8395           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8396           if (relname == NULL)
8397             {
8398               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8399                     (int) ELF32_R_TYPE (rp->r_info));
8400               continue;
8401             }
8402
8403           if (streq (relname, "R_C6000_NONE"))
8404             continue;
8405
8406           if (! streq (relname, "R_C6000_PREL31"))
8407             {
8408               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8409               continue;
8410             }
8411
8412           prelval >>= 1;
8413         }
8414       else
8415         {
8416           /* This function currently only supports ARM and TI unwinders.  */
8417           warn (_("Only TI and ARM unwinders are currently supported\n"));
8418           break;
8419         }
8420
8421       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8422       addr->section = sym->st_shndx;
8423       addr->offset = offset;
8424
8425       if (sym_name)
8426         * sym_name = sym->st_name;
8427       break;
8428     }
8429
8430   *wordp = word;
8431   arm_sec->next_rela = rp;
8432
8433   return TRUE;
8434 }
8435
8436 static const char *tic6x_unwind_regnames[16] =
8437 {
8438   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8439   "A14", "A13", "A12", "A11", "A10",
8440   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8441 };
8442
8443 static void
8444 decode_tic6x_unwind_regmask (unsigned int mask)
8445 {
8446   int i;
8447
8448   for (i = 12; mask; mask >>= 1, i--)
8449     {
8450       if (mask & 1)
8451         {
8452           fputs (tic6x_unwind_regnames[i], stdout);
8453           if (mask > 1)
8454             fputs (", ", stdout);
8455         }
8456     }
8457 }
8458
8459 #define ADVANCE                                                 \
8460   if (remaining == 0 && more_words)                             \
8461     {                                                           \
8462       data_offset += 4;                                         \
8463       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8464                                      data_offset, & word, & addr, NULL))        \
8465         return FALSE;                                           \
8466       remaining = 4;                                            \
8467       more_words--;                                             \
8468     }                                                           \
8469
8470 #define GET_OP(OP)                      \
8471   ADVANCE;                              \
8472   if (remaining)                        \
8473     {                                   \
8474       remaining--;                      \
8475       (OP) = word >> 24;                \
8476       word <<= 8;                       \
8477     }                                   \
8478   else                                  \
8479     {                                   \
8480       printf (_("[Truncated opcode]\n"));       \
8481       return FALSE;                     \
8482     }                                   \
8483   printf ("0x%02x ", OP)
8484
8485 static bfd_boolean
8486 decode_arm_unwind_bytecode (Filedata *                 filedata,
8487                             struct arm_unw_aux_info *  aux,
8488                             unsigned int               word,
8489                             unsigned int               remaining,
8490                             unsigned int               more_words,
8491                             bfd_vma                    data_offset,
8492                             Elf_Internal_Shdr *        data_sec,
8493                             struct arm_section *       data_arm_sec)
8494 {
8495   struct absaddr addr;
8496   bfd_boolean res = TRUE;
8497
8498   /* Decode the unwinding instructions.  */
8499   while (1)
8500     {
8501       unsigned int op, op2;
8502
8503       ADVANCE;
8504       if (remaining == 0)
8505         break;
8506       remaining--;
8507       op = word >> 24;
8508       word <<= 8;
8509
8510       printf ("  0x%02x ", op);
8511
8512       if ((op & 0xc0) == 0x00)
8513         {
8514           int offset = ((op & 0x3f) << 2) + 4;
8515
8516           printf ("     vsp = vsp + %d", offset);
8517         }
8518       else if ((op & 0xc0) == 0x40)
8519         {
8520           int offset = ((op & 0x3f) << 2) + 4;
8521
8522           printf ("     vsp = vsp - %d", offset);
8523         }
8524       else if ((op & 0xf0) == 0x80)
8525         {
8526           GET_OP (op2);
8527           if (op == 0x80 && op2 == 0)
8528             printf (_("Refuse to unwind"));
8529           else
8530             {
8531               unsigned int mask = ((op & 0x0f) << 8) | op2;
8532               bfd_boolean first = TRUE;
8533               int i;
8534
8535               printf ("pop {");
8536               for (i = 0; i < 12; i++)
8537                 if (mask & (1 << i))
8538                   {
8539                     if (first)
8540                       first = FALSE;
8541                     else
8542                       printf (", ");
8543                     printf ("r%d", 4 + i);
8544                   }
8545               printf ("}");
8546             }
8547         }
8548       else if ((op & 0xf0) == 0x90)
8549         {
8550           if (op == 0x9d || op == 0x9f)
8551             printf (_("     [Reserved]"));
8552           else
8553             printf ("     vsp = r%d", op & 0x0f);
8554         }
8555       else if ((op & 0xf0) == 0xa0)
8556         {
8557           int end = 4 + (op & 0x07);
8558           bfd_boolean first = TRUE;
8559           int i;
8560
8561           printf ("     pop {");
8562           for (i = 4; i <= end; i++)
8563             {
8564               if (first)
8565                 first = FALSE;
8566               else
8567                 printf (", ");
8568               printf ("r%d", i);
8569             }
8570           if (op & 0x08)
8571             {
8572               if (!first)
8573                 printf (", ");
8574               printf ("r14");
8575             }
8576           printf ("}");
8577         }
8578       else if (op == 0xb0)
8579         printf (_("     finish"));
8580       else if (op == 0xb1)
8581         {
8582           GET_OP (op2);
8583           if (op2 == 0 || (op2 & 0xf0) != 0)
8584             printf (_("[Spare]"));
8585           else
8586             {
8587               unsigned int mask = op2 & 0x0f;
8588               bfd_boolean first = TRUE;
8589               int i;
8590
8591               printf ("pop {");
8592               for (i = 0; i < 12; i++)
8593                 if (mask & (1 << i))
8594                   {
8595                     if (first)
8596                       first = FALSE;
8597                     else
8598                       printf (", ");
8599                     printf ("r%d", i);
8600                   }
8601               printf ("}");
8602             }
8603         }
8604       else if (op == 0xb2)
8605         {
8606           unsigned char buf[9];
8607           unsigned int i, len;
8608           unsigned long offset;
8609
8610           for (i = 0; i < sizeof (buf); i++)
8611             {
8612               GET_OP (buf[i]);
8613               if ((buf[i] & 0x80) == 0)
8614                 break;
8615             }
8616           if (i == sizeof (buf))
8617             {
8618               error (_("corrupt change to vsp"));
8619               res = FALSE;
8620             }
8621           else
8622             {
8623               offset = read_uleb128 (buf, &len, buf + i + 1);
8624               assert (len == i + 1);
8625               offset = offset * 4 + 0x204;
8626               printf ("vsp = vsp + %ld", offset);
8627             }
8628         }
8629       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8630         {
8631           unsigned int first, last;
8632
8633           GET_OP (op2);
8634           first = op2 >> 4;
8635           last = op2 & 0x0f;
8636           if (op == 0xc8)
8637             first = first + 16;
8638           printf ("pop {D%d", first);
8639           if (last)
8640             printf ("-D%d", first + last);
8641           printf ("}");
8642         }
8643       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8644         {
8645           unsigned int count = op & 0x07;
8646
8647           printf ("pop {D8");
8648           if (count)
8649             printf ("-D%d", 8 + count);
8650           printf ("}");
8651         }
8652       else if (op >= 0xc0 && op <= 0xc5)
8653         {
8654           unsigned int count = op & 0x07;
8655
8656           printf ("     pop {wR10");
8657           if (count)
8658             printf ("-wR%d", 10 + count);
8659           printf ("}");
8660         }
8661       else if (op == 0xc6)
8662         {
8663           unsigned int first, last;
8664
8665           GET_OP (op2);
8666           first = op2 >> 4;
8667           last = op2 & 0x0f;
8668           printf ("pop {wR%d", first);
8669           if (last)
8670             printf ("-wR%d", first + last);
8671           printf ("}");
8672         }
8673       else if (op == 0xc7)
8674         {
8675           GET_OP (op2);
8676           if (op2 == 0 || (op2 & 0xf0) != 0)
8677             printf (_("[Spare]"));
8678           else
8679             {
8680               unsigned int mask = op2 & 0x0f;
8681               bfd_boolean first = TRUE;
8682               int i;
8683
8684               printf ("pop {");
8685               for (i = 0; i < 4; i++)
8686                 if (mask & (1 << i))
8687                   {
8688                     if (first)
8689                       first = FALSE;
8690                     else
8691                       printf (", ");
8692                     printf ("wCGR%d", i);
8693                   }
8694               printf ("}");
8695             }
8696         }
8697       else
8698         {
8699           printf (_("     [unsupported opcode]"));
8700           res = FALSE;
8701         }
8702
8703       printf ("\n");
8704     }
8705
8706   return res;
8707 }
8708
8709 static bfd_boolean
8710 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8711                               struct arm_unw_aux_info *  aux,
8712                               unsigned int               word,
8713                               unsigned int               remaining,
8714                               unsigned int               more_words,
8715                               bfd_vma                    data_offset,
8716                               Elf_Internal_Shdr *        data_sec,
8717                               struct arm_section *       data_arm_sec)
8718 {
8719   struct absaddr addr;
8720
8721   /* Decode the unwinding instructions.  */
8722   while (1)
8723     {
8724       unsigned int op, op2;
8725
8726       ADVANCE;
8727       if (remaining == 0)
8728         break;
8729       remaining--;
8730       op = word >> 24;
8731       word <<= 8;
8732
8733       printf ("  0x%02x ", op);
8734
8735       if ((op & 0xc0) == 0x00)
8736         {
8737           int offset = ((op & 0x3f) << 3) + 8;
8738           printf ("     sp = sp + %d", offset);
8739         }
8740       else if ((op & 0xc0) == 0x80)
8741         {
8742           GET_OP (op2);
8743           if (op == 0x80 && op2 == 0)
8744             printf (_("Refuse to unwind"));
8745           else
8746             {
8747               unsigned int mask = ((op & 0x1f) << 8) | op2;
8748               if (op & 0x20)
8749                 printf ("pop compact {");
8750               else
8751                 printf ("pop {");
8752
8753               decode_tic6x_unwind_regmask (mask);
8754               printf("}");
8755             }
8756         }
8757       else if ((op & 0xf0) == 0xc0)
8758         {
8759           unsigned int reg;
8760           unsigned int nregs;
8761           unsigned int i;
8762           const char *name;
8763           struct
8764           {
8765             unsigned int offset;
8766             unsigned int reg;
8767           } regpos[16];
8768
8769           /* Scan entire instruction first so that GET_OP output is not
8770              interleaved with disassembly.  */
8771           nregs = 0;
8772           for (i = 0; nregs < (op & 0xf); i++)
8773             {
8774               GET_OP (op2);
8775               reg = op2 >> 4;
8776               if (reg != 0xf)
8777                 {
8778                   regpos[nregs].offset = i * 2;
8779                   regpos[nregs].reg = reg;
8780                   nregs++;
8781                 }
8782
8783               reg = op2 & 0xf;
8784               if (reg != 0xf)
8785                 {
8786                   regpos[nregs].offset = i * 2 + 1;
8787                   regpos[nregs].reg = reg;
8788                   nregs++;
8789                 }
8790             }
8791
8792           printf (_("pop frame {"));
8793           reg = nregs - 1;
8794           for (i = i * 2; i > 0; i--)
8795             {
8796               if (regpos[reg].offset == i - 1)
8797                 {
8798                   name = tic6x_unwind_regnames[regpos[reg].reg];
8799                   if (reg > 0)
8800                     reg--;
8801                 }
8802               else
8803                 name = _("[pad]");
8804
8805               fputs (name, stdout);
8806               if (i > 1)
8807                 printf (", ");
8808             }
8809
8810           printf ("}");
8811         }
8812       else if (op == 0xd0)
8813         printf ("     MOV FP, SP");
8814       else if (op == 0xd1)
8815         printf ("     __c6xabi_pop_rts");
8816       else if (op == 0xd2)
8817         {
8818           unsigned char buf[9];
8819           unsigned int i, len;
8820           unsigned long offset;
8821
8822           for (i = 0; i < sizeof (buf); i++)
8823             {
8824               GET_OP (buf[i]);
8825               if ((buf[i] & 0x80) == 0)
8826                 break;
8827             }
8828           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8829           if (i == sizeof (buf))
8830             {
8831               warn (_("Corrupt stack pointer adjustment detected\n"));
8832               return FALSE;
8833             }
8834
8835           offset = read_uleb128 (buf, &len, buf + i + 1);
8836           assert (len == i + 1);
8837           offset = offset * 8 + 0x408;
8838           printf (_("sp = sp + %ld"), offset);
8839         }
8840       else if ((op & 0xf0) == 0xe0)
8841         {
8842           if ((op & 0x0f) == 7)
8843             printf ("     RETURN");
8844           else
8845             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8846         }
8847       else
8848         {
8849           printf (_("     [unsupported opcode]"));
8850         }
8851       putchar ('\n');
8852     }
8853
8854   return TRUE;
8855 }
8856
8857 static bfd_vma
8858 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8859 {
8860   bfd_vma offset;
8861
8862   offset = word & 0x7fffffff;
8863   if (offset & 0x40000000)
8864     offset |= ~ (bfd_vma) 0x7fffffff;
8865
8866   if (filedata->file_header.e_machine == EM_TI_C6000)
8867     offset <<= 1;
8868
8869   return offset + where;
8870 }
8871
8872 static bfd_boolean
8873 decode_arm_unwind (Filedata *                 filedata,
8874                    struct arm_unw_aux_info *  aux,
8875                    unsigned int               word,
8876                    unsigned int               remaining,
8877                    bfd_vma                    data_offset,
8878                    Elf_Internal_Shdr *        data_sec,
8879                    struct arm_section *       data_arm_sec)
8880 {
8881   int per_index;
8882   unsigned int more_words = 0;
8883   struct absaddr addr;
8884   bfd_vma sym_name = (bfd_vma) -1;
8885   bfd_boolean res = TRUE;
8886
8887   if (remaining == 0)
8888     {
8889       /* Fetch the first word.
8890          Note - when decoding an object file the address extracted
8891          here will always be 0.  So we also pass in the sym_name
8892          parameter so that we can find the symbol associated with
8893          the personality routine.  */
8894       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8895                                      & word, & addr, & sym_name))
8896         return FALSE;
8897
8898       remaining = 4;
8899     }
8900
8901   if ((word & 0x80000000) == 0)
8902     {
8903       /* Expand prel31 for personality routine.  */
8904       bfd_vma fn;
8905       const char *procname;
8906
8907       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8908       printf (_("  Personality routine: "));
8909       if (fn == 0
8910           && addr.section == SHN_UNDEF && addr.offset == 0
8911           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8912         {
8913           procname = aux->strtab + sym_name;
8914           print_vma (fn, PREFIX_HEX);
8915           if (procname)
8916             {
8917               fputs (" <", stdout);
8918               fputs (procname, stdout);
8919               fputc ('>', stdout);
8920             }
8921         }
8922       else
8923         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8924       fputc ('\n', stdout);
8925
8926       /* The GCC personality routines use the standard compact
8927          encoding, starting with one byte giving the number of
8928          words.  */
8929       if (procname != NULL
8930           && (const_strneq (procname, "__gcc_personality_v0")
8931               || const_strneq (procname, "__gxx_personality_v0")
8932               || const_strneq (procname, "__gcj_personality_v0")
8933               || const_strneq (procname, "__gnu_objc_personality_v0")))
8934         {
8935           remaining = 0;
8936           more_words = 1;
8937           ADVANCE;
8938           if (!remaining)
8939             {
8940               printf (_("  [Truncated data]\n"));
8941               return FALSE;
8942             }
8943           more_words = word >> 24;
8944           word <<= 8;
8945           remaining--;
8946           per_index = -1;
8947         }
8948       else
8949         return TRUE;
8950     }
8951   else
8952     {
8953       /* ARM EHABI Section 6.3:
8954
8955          An exception-handling table entry for the compact model looks like:
8956
8957            31 30-28 27-24 23-0
8958            -- ----- ----- ----
8959             1   0   index Data for personalityRoutine[index]    */
8960
8961       if (filedata->file_header.e_machine == EM_ARM
8962           && (word & 0x70000000))
8963         {
8964           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8965           res = FALSE;
8966         }
8967
8968       per_index = (word >> 24) & 0x7f;
8969       printf (_("  Compact model index: %d\n"), per_index);
8970       if (per_index == 0)
8971         {
8972           more_words = 0;
8973           word <<= 8;
8974           remaining--;
8975         }
8976       else if (per_index < 3)
8977         {
8978           more_words = (word >> 16) & 0xff;
8979           word <<= 16;
8980           remaining -= 2;
8981         }
8982     }
8983
8984   switch (filedata->file_header.e_machine)
8985     {
8986     case EM_ARM:
8987       if (per_index < 3)
8988         {
8989           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
8990                                             data_offset, data_sec, data_arm_sec))
8991             res = FALSE;
8992         }
8993       else
8994         {
8995           warn (_("Unknown ARM compact model index encountered\n"));
8996           printf (_("  [reserved]\n"));
8997           res = FALSE;
8998         }
8999       break;
9000
9001     case EM_TI_C6000:
9002       if (per_index < 3)
9003         {
9004           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9005                                               data_offset, data_sec, data_arm_sec))
9006             res = FALSE;
9007         }
9008       else if (per_index < 5)
9009         {
9010           if (((word >> 17) & 0x7f) == 0x7f)
9011             printf (_("  Restore stack from frame pointer\n"));
9012           else
9013             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
9014           printf (_("  Registers restored: "));
9015           if (per_index == 4)
9016             printf (" (compact) ");
9017           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9018           putchar ('\n');
9019           printf (_("  Return register: %s\n"),
9020                   tic6x_unwind_regnames[word & 0xf]);
9021         }
9022       else
9023         printf (_("  [reserved (%d)]\n"), per_index);
9024       break;
9025
9026     default:
9027       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9028              filedata->file_header.e_machine);
9029       res = FALSE;
9030     }
9031
9032   /* Decode the descriptors.  Not implemented.  */
9033
9034   return res;
9035 }
9036
9037 static bfd_boolean
9038 dump_arm_unwind (Filedata *                 filedata,
9039                  struct arm_unw_aux_info *  aux,
9040                  Elf_Internal_Shdr *        exidx_sec)
9041 {
9042   struct arm_section exidx_arm_sec, extab_arm_sec;
9043   unsigned int i, exidx_len;
9044   unsigned long j, nfuns;
9045   bfd_boolean res = TRUE;
9046
9047   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9048   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9049   exidx_len = exidx_sec->sh_size / 8;
9050
9051   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9052   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9053     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9054       aux->funtab[nfuns++] = aux->symtab[j];
9055   aux->nfuns = nfuns;
9056   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9057
9058   for (i = 0; i < exidx_len; i++)
9059     {
9060       unsigned int exidx_fn, exidx_entry;
9061       struct absaddr fn_addr, entry_addr;
9062       bfd_vma fn;
9063
9064       fputc ('\n', stdout);
9065
9066       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9067                                      8 * i, & exidx_fn, & fn_addr, NULL)
9068           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9069                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9070         {
9071           free (aux->funtab);
9072           arm_free_section (& exidx_arm_sec);
9073           arm_free_section (& extab_arm_sec);
9074           return FALSE;
9075         }
9076
9077       /* ARM EHABI, Section 5:
9078          An index table entry consists of 2 words.
9079          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9080       if (exidx_fn & 0x80000000)
9081         {
9082           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9083           res = FALSE;
9084         }
9085
9086       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9087
9088       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9089       fputs (": ", stdout);
9090
9091       if (exidx_entry == 1)
9092         {
9093           print_vma (exidx_entry, PREFIX_HEX);
9094           fputs (" [cantunwind]\n", stdout);
9095         }
9096       else if (exidx_entry & 0x80000000)
9097         {
9098           print_vma (exidx_entry, PREFIX_HEX);
9099           fputc ('\n', stdout);
9100           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9101         }
9102       else
9103         {
9104           bfd_vma table, table_offset = 0;
9105           Elf_Internal_Shdr *table_sec;
9106
9107           fputs ("@", stdout);
9108           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9109           print_vma (table, PREFIX_HEX);
9110           printf ("\n");
9111
9112           /* Locate the matching .ARM.extab.  */
9113           if (entry_addr.section != SHN_UNDEF
9114               && entry_addr.section < filedata->file_header.e_shnum)
9115             {
9116               table_sec = filedata->section_headers + entry_addr.section;
9117               table_offset = entry_addr.offset;
9118               /* PR 18879 */
9119               if (table_offset > table_sec->sh_size
9120                   || ((bfd_signed_vma) table_offset) < 0)
9121                 {
9122                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9123                         (unsigned long) table_offset,
9124                         printable_section_name (filedata, table_sec));
9125                   res = FALSE;
9126                   continue;
9127                 }
9128             }
9129           else
9130             {
9131               table_sec = find_section_by_address (filedata, table);
9132               if (table_sec != NULL)
9133                 table_offset = table - table_sec->sh_addr;
9134             }
9135
9136           if (table_sec == NULL)
9137             {
9138               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9139                     (unsigned long) table);
9140               res = FALSE;
9141               continue;
9142             }
9143
9144           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9145                                    &extab_arm_sec))
9146             res = FALSE;
9147         }
9148     }
9149
9150   printf ("\n");
9151
9152   free (aux->funtab);
9153   arm_free_section (&exidx_arm_sec);
9154   arm_free_section (&extab_arm_sec);
9155
9156   return res;
9157 }
9158
9159 /* Used for both ARM and C6X unwinding tables.  */
9160
9161 static bfd_boolean
9162 arm_process_unwind (Filedata * filedata)
9163 {
9164   struct arm_unw_aux_info aux;
9165   Elf_Internal_Shdr *unwsec = NULL;
9166   Elf_Internal_Shdr *strsec;
9167   Elf_Internal_Shdr *sec;
9168   unsigned long i;
9169   unsigned int sec_type;
9170   bfd_boolean res = TRUE;
9171
9172   switch (filedata->file_header.e_machine)
9173     {
9174     case EM_ARM:
9175       sec_type = SHT_ARM_EXIDX;
9176       break;
9177
9178     case EM_TI_C6000:
9179       sec_type = SHT_C6000_UNWIND;
9180       break;
9181
9182     default:
9183       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9184              filedata->file_header.e_machine);
9185       return FALSE;
9186     }
9187
9188   if (filedata->string_table == NULL)
9189     return FALSE;
9190
9191   memset (& aux, 0, sizeof (aux));
9192   aux.filedata = filedata;
9193
9194   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9195     {
9196       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9197         {
9198           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9199
9200           strsec = filedata->section_headers + sec->sh_link;
9201
9202           /* PR binutils/17531 file: 011-12666-0.004.  */
9203           if (aux.strtab != NULL)
9204             {
9205               error (_("Multiple string tables found in file.\n"));
9206               free (aux.strtab);
9207               res = FALSE;
9208             }
9209           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9210                                  1, strsec->sh_size, _("string table"));
9211           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9212         }
9213       else if (sec->sh_type == sec_type)
9214         unwsec = sec;
9215     }
9216
9217   if (unwsec == NULL)
9218     printf (_("\nThere are no unwind sections in this file.\n"));
9219   else
9220     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9221       {
9222         if (sec->sh_type == sec_type)
9223           {
9224             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9225             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9226                               "contains %lu entry:\n",
9227                               "\nUnwind section '%s' at offset 0x%lx "
9228                               "contains %lu entries:\n",
9229                               num_unwind),
9230                     printable_section_name (filedata, sec),
9231                     (unsigned long) sec->sh_offset,
9232                     num_unwind);
9233
9234             if (! dump_arm_unwind (filedata, &aux, sec))
9235               res = FALSE;
9236           }
9237       }
9238
9239   if (aux.symtab)
9240     free (aux.symtab);
9241   if (aux.strtab)
9242     free ((char *) aux.strtab);
9243
9244   return res;
9245 }
9246
9247 static bfd_boolean
9248 process_unwind (Filedata * filedata)
9249 {
9250   struct unwind_handler
9251   {
9252     unsigned int machtype;
9253     bfd_boolean (* handler)(Filedata *);
9254   } handlers[] =
9255   {
9256     { EM_ARM, arm_process_unwind },
9257     { EM_IA_64, ia64_process_unwind },
9258     { EM_PARISC, hppa_process_unwind },
9259     { EM_TI_C6000, arm_process_unwind },
9260     { 0, NULL }
9261   };
9262   int i;
9263
9264   if (!do_unwind)
9265     return TRUE;
9266
9267   for (i = 0; handlers[i].handler != NULL; i++)
9268     if (filedata->file_header.e_machine == handlers[i].machtype)
9269       return handlers[i].handler (filedata);
9270
9271   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9272           get_machine_name (filedata->file_header.e_machine));
9273   return TRUE;
9274 }
9275
9276 static void
9277 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9278 {
9279   switch (entry->d_tag)
9280     {
9281     case DT_MIPS_FLAGS:
9282       if (entry->d_un.d_val == 0)
9283         printf (_("NONE"));
9284       else
9285         {
9286           static const char * opts[] =
9287           {
9288             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9289             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9290             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9291             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9292             "RLD_ORDER_SAFE"
9293           };
9294           unsigned int cnt;
9295           bfd_boolean first = TRUE;
9296
9297           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9298             if (entry->d_un.d_val & (1 << cnt))
9299               {
9300                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9301                 first = FALSE;
9302               }
9303         }
9304       break;
9305
9306     case DT_MIPS_IVERSION:
9307       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9308         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9309       else
9310         {
9311           char buf[40];
9312           sprintf_vma (buf, entry->d_un.d_ptr);
9313           /* Note: coded this way so that there is a single string for translation.  */
9314           printf (_("<corrupt: %s>"), buf);
9315         }
9316       break;
9317
9318     case DT_MIPS_TIME_STAMP:
9319       {
9320         char timebuf[128];
9321         struct tm * tmp;
9322         time_t atime = entry->d_un.d_val;
9323
9324         tmp = gmtime (&atime);
9325         /* PR 17531: file: 6accc532.  */
9326         if (tmp == NULL)
9327           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9328         else
9329           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9330                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9331                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9332         printf (_("Time Stamp: %s"), timebuf);
9333       }
9334       break;
9335
9336     case DT_MIPS_RLD_VERSION:
9337     case DT_MIPS_LOCAL_GOTNO:
9338     case DT_MIPS_CONFLICTNO:
9339     case DT_MIPS_LIBLISTNO:
9340     case DT_MIPS_SYMTABNO:
9341     case DT_MIPS_UNREFEXTNO:
9342     case DT_MIPS_HIPAGENO:
9343     case DT_MIPS_DELTA_CLASS_NO:
9344     case DT_MIPS_DELTA_INSTANCE_NO:
9345     case DT_MIPS_DELTA_RELOC_NO:
9346     case DT_MIPS_DELTA_SYM_NO:
9347     case DT_MIPS_DELTA_CLASSSYM_NO:
9348     case DT_MIPS_COMPACT_SIZE:
9349       print_vma (entry->d_un.d_val, DEC);
9350       break;
9351
9352     default:
9353       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9354     }
9355     putchar ('\n');
9356 }
9357
9358 static void
9359 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9360 {
9361   switch (entry->d_tag)
9362     {
9363     case DT_HP_DLD_FLAGS:
9364       {
9365         static struct
9366         {
9367           long int bit;
9368           const char * str;
9369         }
9370         flags[] =
9371         {
9372           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9373           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9374           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9375           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9376           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9377           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9378           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9379           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9380           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9381           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9382           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9383           { DT_HP_GST, "HP_GST" },
9384           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9385           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9386           { DT_HP_NODELETE, "HP_NODELETE" },
9387           { DT_HP_GROUP, "HP_GROUP" },
9388           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9389         };
9390         bfd_boolean first = TRUE;
9391         size_t cnt;
9392         bfd_vma val = entry->d_un.d_val;
9393
9394         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9395           if (val & flags[cnt].bit)
9396             {
9397               if (! first)
9398                 putchar (' ');
9399               fputs (flags[cnt].str, stdout);
9400               first = FALSE;
9401               val ^= flags[cnt].bit;
9402             }
9403
9404         if (val != 0 || first)
9405           {
9406             if (! first)
9407               putchar (' ');
9408             print_vma (val, HEX);
9409           }
9410       }
9411       break;
9412
9413     default:
9414       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9415       break;
9416     }
9417   putchar ('\n');
9418 }
9419
9420 #ifdef BFD64
9421
9422 /* VMS vs Unix time offset and factor.  */
9423
9424 #define VMS_EPOCH_OFFSET 35067168000000000LL
9425 #define VMS_GRANULARITY_FACTOR 10000000
9426
9427 /* Display a VMS time in a human readable format.  */
9428
9429 static void
9430 print_vms_time (bfd_int64_t vmstime)
9431 {
9432   struct tm *tm;
9433   time_t unxtime;
9434
9435   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9436   tm = gmtime (&unxtime);
9437   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9438           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9439           tm->tm_hour, tm->tm_min, tm->tm_sec);
9440 }
9441 #endif /* BFD64 */
9442
9443 static void
9444 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9445 {
9446   switch (entry->d_tag)
9447     {
9448     case DT_IA_64_PLT_RESERVE:
9449       /* First 3 slots reserved.  */
9450       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9451       printf (" -- ");
9452       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9453       break;
9454
9455     case DT_IA_64_VMS_LINKTIME:
9456 #ifdef BFD64
9457       print_vms_time (entry->d_un.d_val);
9458 #endif
9459       break;
9460
9461     case DT_IA_64_VMS_LNKFLAGS:
9462       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9463       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9464         printf (" CALL_DEBUG");
9465       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9466         printf (" NOP0BUFS");
9467       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9468         printf (" P0IMAGE");
9469       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9470         printf (" MKTHREADS");
9471       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9472         printf (" UPCALLS");
9473       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9474         printf (" IMGSTA");
9475       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9476         printf (" INITIALIZE");
9477       if (entry->d_un.d_val & VMS_LF_MAIN)
9478         printf (" MAIN");
9479       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9480         printf (" EXE_INIT");
9481       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9482         printf (" TBK_IN_IMG");
9483       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9484         printf (" DBG_IN_IMG");
9485       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9486         printf (" TBK_IN_DSF");
9487       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9488         printf (" DBG_IN_DSF");
9489       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9490         printf (" SIGNATURES");
9491       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9492         printf (" REL_SEG_OFF");
9493       break;
9494
9495     default:
9496       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9497       break;
9498     }
9499   putchar ('\n');
9500 }
9501
9502 static bfd_boolean
9503 get_32bit_dynamic_section (Filedata * filedata)
9504 {
9505   Elf32_External_Dyn * edyn;
9506   Elf32_External_Dyn * ext;
9507   Elf_Internal_Dyn * entry;
9508
9509   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9510                                           dynamic_size, _("dynamic section"));
9511   if (!edyn)
9512     return FALSE;
9513
9514   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9515      might not have the luxury of section headers.  Look for the DT_NULL
9516      terminator to determine the number of entries.  */
9517   for (ext = edyn, dynamic_nent = 0;
9518        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9519        ext++)
9520     {
9521       dynamic_nent++;
9522       if (BYTE_GET (ext->d_tag) == DT_NULL)
9523         break;
9524     }
9525
9526   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9527                                                   sizeof (* entry));
9528   if (dynamic_section == NULL)
9529     {
9530       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9531              (unsigned long) dynamic_nent);
9532       free (edyn);
9533       return FALSE;
9534     }
9535
9536   for (ext = edyn, entry = dynamic_section;
9537        entry < dynamic_section + dynamic_nent;
9538        ext++, entry++)
9539     {
9540       entry->d_tag      = BYTE_GET (ext->d_tag);
9541       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9542     }
9543
9544   free (edyn);
9545
9546   return TRUE;
9547 }
9548
9549 static bfd_boolean
9550 get_64bit_dynamic_section (Filedata * filedata)
9551 {
9552   Elf64_External_Dyn * edyn;
9553   Elf64_External_Dyn * ext;
9554   Elf_Internal_Dyn * entry;
9555
9556   /* Read in the data.  */
9557   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9558                                           dynamic_size, _("dynamic section"));
9559   if (!edyn)
9560     return FALSE;
9561
9562   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9563      might not have the luxury of section headers.  Look for the DT_NULL
9564      terminator to determine the number of entries.  */
9565   for (ext = edyn, dynamic_nent = 0;
9566        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9567        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9568        ext++)
9569     {
9570       dynamic_nent++;
9571       if (BYTE_GET (ext->d_tag) == DT_NULL)
9572         break;
9573     }
9574
9575   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9576                                                   sizeof (* entry));
9577   if (dynamic_section == NULL)
9578     {
9579       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9580              (unsigned long) dynamic_nent);
9581       free (edyn);
9582       return FALSE;
9583     }
9584
9585   /* Convert from external to internal formats.  */
9586   for (ext = edyn, entry = dynamic_section;
9587        entry < dynamic_section + dynamic_nent;
9588        ext++, entry++)
9589     {
9590       entry->d_tag      = BYTE_GET (ext->d_tag);
9591       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9592     }
9593
9594   free (edyn);
9595
9596   return TRUE;
9597 }
9598
9599 static void
9600 print_dynamic_flags (bfd_vma flags)
9601 {
9602   bfd_boolean first = TRUE;
9603
9604   while (flags)
9605     {
9606       bfd_vma flag;
9607
9608       flag = flags & - flags;
9609       flags &= ~ flag;
9610
9611       if (first)
9612         first = FALSE;
9613       else
9614         putc (' ', stdout);
9615
9616       switch (flag)
9617         {
9618         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9619         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9620         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9621         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9622         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9623         default:                fputs (_("unknown"), stdout); break;
9624         }
9625     }
9626   puts ("");
9627 }
9628
9629 /* Parse and display the contents of the dynamic section.  */
9630
9631 static bfd_boolean
9632 process_dynamic_section (Filedata * filedata)
9633 {
9634   Elf_Internal_Dyn * entry;
9635
9636   if (dynamic_size == 0)
9637     {
9638       if (do_dynamic)
9639         printf (_("\nThere is no dynamic section in this file.\n"));
9640
9641       return TRUE;
9642     }
9643
9644   if (is_32bit_elf)
9645     {
9646       if (! get_32bit_dynamic_section (filedata))
9647         return FALSE;
9648     }
9649   else
9650     {
9651       if (! get_64bit_dynamic_section (filedata))
9652         return FALSE;
9653     }
9654
9655   /* Find the appropriate symbol table.  */
9656   if (dynamic_symbols == NULL)
9657     {
9658       for (entry = dynamic_section;
9659            entry < dynamic_section + dynamic_nent;
9660            ++entry)
9661         {
9662           Elf_Internal_Shdr section;
9663
9664           if (entry->d_tag != DT_SYMTAB)
9665             continue;
9666
9667           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9668
9669           /* Since we do not know how big the symbol table is,
9670              we default to reading in the entire file (!) and
9671              processing that.  This is overkill, I know, but it
9672              should work.  */
9673           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9674           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9675             {
9676               /* See PR 21379 for a reproducer.  */
9677               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9678               return FALSE;
9679             }
9680
9681           if (archive_file_offset != 0)
9682             section.sh_size = archive_file_size - section.sh_offset;
9683           else
9684             section.sh_size = filedata->file_size - section.sh_offset;
9685
9686           if (is_32bit_elf)
9687             section.sh_entsize = sizeof (Elf32_External_Sym);
9688           else
9689             section.sh_entsize = sizeof (Elf64_External_Sym);
9690           section.sh_name = filedata->string_table_length;
9691
9692           if (dynamic_symbols != NULL)
9693             {
9694               error (_("Multiple dynamic symbol table sections found\n"));
9695               free (dynamic_symbols);
9696             }
9697           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9698           if (num_dynamic_syms < 1)
9699             {
9700               error (_("Unable to determine the number of symbols to load\n"));
9701               continue;
9702             }
9703         }
9704     }
9705
9706   /* Similarly find a string table.  */
9707   if (dynamic_strings == NULL)
9708     {
9709       for (entry = dynamic_section;
9710            entry < dynamic_section + dynamic_nent;
9711            ++entry)
9712         {
9713           unsigned long offset;
9714           long str_tab_len;
9715
9716           if (entry->d_tag != DT_STRTAB)
9717             continue;
9718
9719           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9720
9721           /* Since we do not know how big the string table is,
9722              we default to reading in the entire file (!) and
9723              processing that.  This is overkill, I know, but it
9724              should work.  */
9725
9726           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9727
9728           if (archive_file_offset != 0)
9729             str_tab_len = archive_file_size - offset;
9730           else
9731             str_tab_len = filedata->file_size - offset;
9732
9733           if (str_tab_len < 1)
9734             {
9735               error
9736                 (_("Unable to determine the length of the dynamic string table\n"));
9737               continue;
9738             }
9739
9740           if (dynamic_strings != NULL)
9741             {
9742               error (_("Multiple dynamic string tables found\n"));
9743               free (dynamic_strings);
9744             }
9745
9746           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9747                                                str_tab_len,
9748                                                _("dynamic string table"));
9749           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9750         }
9751     }
9752
9753   /* And find the syminfo section if available.  */
9754   if (dynamic_syminfo == NULL)
9755     {
9756       unsigned long syminsz = 0;
9757
9758       for (entry = dynamic_section;
9759            entry < dynamic_section + dynamic_nent;
9760            ++entry)
9761         {
9762           if (entry->d_tag == DT_SYMINENT)
9763             {
9764               /* Note: these braces are necessary to avoid a syntax
9765                  error from the SunOS4 C compiler.  */
9766               /* PR binutils/17531: A corrupt file can trigger this test.
9767                  So do not use an assert, instead generate an error message.  */
9768               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9769                 error (_("Bad value (%d) for SYMINENT entry\n"),
9770                        (int) entry->d_un.d_val);
9771             }
9772           else if (entry->d_tag == DT_SYMINSZ)
9773             syminsz = entry->d_un.d_val;
9774           else if (entry->d_tag == DT_SYMINFO)
9775             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9776                                                       syminsz);
9777         }
9778
9779       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9780         {
9781           Elf_External_Syminfo * extsyminfo;
9782           Elf_External_Syminfo * extsym;
9783           Elf_Internal_Syminfo * syminfo;
9784
9785           /* There is a syminfo section.  Read the data.  */
9786           extsyminfo = (Elf_External_Syminfo *)
9787               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9788                         _("symbol information"));
9789           if (!extsyminfo)
9790             return FALSE;
9791
9792           if (dynamic_syminfo != NULL)
9793             {
9794               error (_("Multiple dynamic symbol information sections found\n"));
9795               free (dynamic_syminfo);
9796             }
9797           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9798           if (dynamic_syminfo == NULL)
9799             {
9800               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9801                      (unsigned long) syminsz);
9802               return FALSE;
9803             }
9804
9805           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9806           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9807                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9808                ++syminfo, ++extsym)
9809             {
9810               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9811               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9812             }
9813
9814           free (extsyminfo);
9815         }
9816     }
9817
9818   if (do_dynamic && dynamic_addr)
9819     printf (ngettext ("\nDynamic section at offset 0x%lx "
9820                       "contains %lu entry:\n",
9821                       "\nDynamic section at offset 0x%lx "
9822                       "contains %lu entries:\n",
9823                       dynamic_nent),
9824             dynamic_addr, (unsigned long) dynamic_nent);
9825   if (do_dynamic)
9826     printf (_("  Tag        Type                         Name/Value\n"));
9827
9828   for (entry = dynamic_section;
9829        entry < dynamic_section + dynamic_nent;
9830        entry++)
9831     {
9832       if (do_dynamic)
9833         {
9834           const char * dtype;
9835
9836           putchar (' ');
9837           print_vma (entry->d_tag, FULL_HEX);
9838           dtype = get_dynamic_type (filedata, entry->d_tag);
9839           printf (" (%s)%*s", dtype,
9840                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9841         }
9842
9843       switch (entry->d_tag)
9844         {
9845         case DT_FLAGS:
9846           if (do_dynamic)
9847             print_dynamic_flags (entry->d_un.d_val);
9848           break;
9849
9850         case DT_AUXILIARY:
9851         case DT_FILTER:
9852         case DT_CONFIG:
9853         case DT_DEPAUDIT:
9854         case DT_AUDIT:
9855           if (do_dynamic)
9856             {
9857               switch (entry->d_tag)
9858                 {
9859                 case DT_AUXILIARY:
9860                   printf (_("Auxiliary library"));
9861                   break;
9862
9863                 case DT_FILTER:
9864                   printf (_("Filter library"));
9865                   break;
9866
9867                 case DT_CONFIG:
9868                   printf (_("Configuration file"));
9869                   break;
9870
9871                 case DT_DEPAUDIT:
9872                   printf (_("Dependency audit library"));
9873                   break;
9874
9875                 case DT_AUDIT:
9876                   printf (_("Audit library"));
9877                   break;
9878                 }
9879
9880               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9881                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9882               else
9883                 {
9884                   printf (": ");
9885                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9886                   putchar ('\n');
9887                 }
9888             }
9889           break;
9890
9891         case DT_FEATURE:
9892           if (do_dynamic)
9893             {
9894               printf (_("Flags:"));
9895
9896               if (entry->d_un.d_val == 0)
9897                 printf (_(" None\n"));
9898               else
9899                 {
9900                   unsigned long int val = entry->d_un.d_val;
9901
9902                   if (val & DTF_1_PARINIT)
9903                     {
9904                       printf (" PARINIT");
9905                       val ^= DTF_1_PARINIT;
9906                     }
9907                   if (val & DTF_1_CONFEXP)
9908                     {
9909                       printf (" CONFEXP");
9910                       val ^= DTF_1_CONFEXP;
9911                     }
9912                   if (val != 0)
9913                     printf (" %lx", val);
9914                   puts ("");
9915                 }
9916             }
9917           break;
9918
9919         case DT_POSFLAG_1:
9920           if (do_dynamic)
9921             {
9922               printf (_("Flags:"));
9923
9924               if (entry->d_un.d_val == 0)
9925                 printf (_(" None\n"));
9926               else
9927                 {
9928                   unsigned long int val = entry->d_un.d_val;
9929
9930                   if (val & DF_P1_LAZYLOAD)
9931                     {
9932                       printf (" LAZYLOAD");
9933                       val ^= DF_P1_LAZYLOAD;
9934                     }
9935                   if (val & DF_P1_GROUPPERM)
9936                     {
9937                       printf (" GROUPPERM");
9938                       val ^= DF_P1_GROUPPERM;
9939                     }
9940                   if (val != 0)
9941                     printf (" %lx", val);
9942                   puts ("");
9943                 }
9944             }
9945           break;
9946
9947         case DT_FLAGS_1:
9948           if (do_dynamic)
9949             {
9950               printf (_("Flags:"));
9951               if (entry->d_un.d_val == 0)
9952                 printf (_(" None\n"));
9953               else
9954                 {
9955                   unsigned long int val = entry->d_un.d_val;
9956
9957                   if (val & DF_1_NOW)
9958                     {
9959                       printf (" NOW");
9960                       val ^= DF_1_NOW;
9961                     }
9962                   if (val & DF_1_GLOBAL)
9963                     {
9964                       printf (" GLOBAL");
9965                       val ^= DF_1_GLOBAL;
9966                     }
9967                   if (val & DF_1_GROUP)
9968                     {
9969                       printf (" GROUP");
9970                       val ^= DF_1_GROUP;
9971                     }
9972                   if (val & DF_1_NODELETE)
9973                     {
9974                       printf (" NODELETE");
9975                       val ^= DF_1_NODELETE;
9976                     }
9977                   if (val & DF_1_LOADFLTR)
9978                     {
9979                       printf (" LOADFLTR");
9980                       val ^= DF_1_LOADFLTR;
9981                     }
9982                   if (val & DF_1_INITFIRST)
9983                     {
9984                       printf (" INITFIRST");
9985                       val ^= DF_1_INITFIRST;
9986                     }
9987                   if (val & DF_1_NOOPEN)
9988                     {
9989                       printf (" NOOPEN");
9990                       val ^= DF_1_NOOPEN;
9991                     }
9992                   if (val & DF_1_ORIGIN)
9993                     {
9994                       printf (" ORIGIN");
9995                       val ^= DF_1_ORIGIN;
9996                     }
9997                   if (val & DF_1_DIRECT)
9998                     {
9999                       printf (" DIRECT");
10000                       val ^= DF_1_DIRECT;
10001                     }
10002                   if (val & DF_1_TRANS)
10003                     {
10004                       printf (" TRANS");
10005                       val ^= DF_1_TRANS;
10006                     }
10007                   if (val & DF_1_INTERPOSE)
10008                     {
10009                       printf (" INTERPOSE");
10010                       val ^= DF_1_INTERPOSE;
10011                     }
10012                   if (val & DF_1_NODEFLIB)
10013                     {
10014                       printf (" NODEFLIB");
10015                       val ^= DF_1_NODEFLIB;
10016                     }
10017                   if (val & DF_1_NODUMP)
10018                     {
10019                       printf (" NODUMP");
10020                       val ^= DF_1_NODUMP;
10021                     }
10022                   if (val & DF_1_CONFALT)
10023                     {
10024                       printf (" CONFALT");
10025                       val ^= DF_1_CONFALT;
10026                     }
10027                   if (val & DF_1_ENDFILTEE)
10028                     {
10029                       printf (" ENDFILTEE");
10030                       val ^= DF_1_ENDFILTEE;
10031                     }
10032                   if (val & DF_1_DISPRELDNE)
10033                     {
10034                       printf (" DISPRELDNE");
10035                       val ^= DF_1_DISPRELDNE;
10036                     }
10037                   if (val & DF_1_DISPRELPND)
10038                     {
10039                       printf (" DISPRELPND");
10040                       val ^= DF_1_DISPRELPND;
10041                     }
10042                   if (val & DF_1_NODIRECT)
10043                     {
10044                       printf (" NODIRECT");
10045                       val ^= DF_1_NODIRECT;
10046                     }
10047                   if (val & DF_1_IGNMULDEF)
10048                     {
10049                       printf (" IGNMULDEF");
10050                       val ^= DF_1_IGNMULDEF;
10051                     }
10052                   if (val & DF_1_NOKSYMS)
10053                     {
10054                       printf (" NOKSYMS");
10055                       val ^= DF_1_NOKSYMS;
10056                     }
10057                   if (val & DF_1_NOHDR)
10058                     {
10059                       printf (" NOHDR");
10060                       val ^= DF_1_NOHDR;
10061                     }
10062                   if (val & DF_1_EDITED)
10063                     {
10064                       printf (" EDITED");
10065                       val ^= DF_1_EDITED;
10066                     }
10067                   if (val & DF_1_NORELOC)
10068                     {
10069                       printf (" NORELOC");
10070                       val ^= DF_1_NORELOC;
10071                     }
10072                   if (val & DF_1_SYMINTPOSE)
10073                     {
10074                       printf (" SYMINTPOSE");
10075                       val ^= DF_1_SYMINTPOSE;
10076                     }
10077                   if (val & DF_1_GLOBAUDIT)
10078                     {
10079                       printf (" GLOBAUDIT");
10080                       val ^= DF_1_GLOBAUDIT;
10081                     }
10082                   if (val & DF_1_SINGLETON)
10083                     {
10084                       printf (" SINGLETON");
10085                       val ^= DF_1_SINGLETON;
10086                     }
10087                   if (val & DF_1_STUB)
10088                     {
10089                       printf (" STUB");
10090                       val ^= DF_1_STUB;
10091                     }
10092                   if (val & DF_1_PIE)
10093                     {
10094                       printf (" PIE");
10095                       val ^= DF_1_PIE;
10096                     }
10097                   if (val & DF_1_KMOD)
10098                     {
10099                       printf (" KMOD");
10100                       val ^= DF_1_KMOD;
10101                     }
10102                   if (val & DF_1_WEAKFILTER)
10103                     {
10104                       printf (" WEAKFILTER");
10105                       val ^= DF_1_WEAKFILTER;
10106                     }
10107                   if (val & DF_1_NOCOMMON)
10108                     {
10109                       printf (" NOCOMMON");
10110                       val ^= DF_1_NOCOMMON;
10111                     }
10112                   if (val != 0)
10113                     printf (" %lx", val);
10114                   puts ("");
10115                 }
10116             }
10117           break;
10118
10119         case DT_PLTREL:
10120           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10121           if (do_dynamic)
10122             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10123           break;
10124
10125         case DT_NULL    :
10126         case DT_NEEDED  :
10127         case DT_PLTGOT  :
10128         case DT_HASH    :
10129         case DT_STRTAB  :
10130         case DT_SYMTAB  :
10131         case DT_RELA    :
10132         case DT_INIT    :
10133         case DT_FINI    :
10134         case DT_SONAME  :
10135         case DT_RPATH   :
10136         case DT_SYMBOLIC:
10137         case DT_REL     :
10138         case DT_DEBUG   :
10139         case DT_TEXTREL :
10140         case DT_JMPREL  :
10141         case DT_RUNPATH :
10142           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10143
10144           if (do_dynamic)
10145             {
10146               char * name;
10147
10148               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10149                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10150               else
10151                 name = NULL;
10152
10153               if (name)
10154                 {
10155                   switch (entry->d_tag)
10156                     {
10157                     case DT_NEEDED:
10158                       printf (_("Shared library: [%s]"), name);
10159
10160                       if (streq (name, program_interpreter))
10161                         printf (_(" program interpreter"));
10162                       break;
10163
10164                     case DT_SONAME:
10165                       printf (_("Library soname: [%s]"), name);
10166                       break;
10167
10168                     case DT_RPATH:
10169                       printf (_("Library rpath: [%s]"), name);
10170                       break;
10171
10172                     case DT_RUNPATH:
10173                       printf (_("Library runpath: [%s]"), name);
10174                       break;
10175
10176                     default:
10177                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10178                       break;
10179                     }
10180                 }
10181               else
10182                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10183
10184               putchar ('\n');
10185             }
10186           break;
10187
10188         case DT_PLTRELSZ:
10189         case DT_RELASZ  :
10190         case DT_STRSZ   :
10191         case DT_RELSZ   :
10192         case DT_RELAENT :
10193         case DT_SYMENT  :
10194         case DT_RELENT  :
10195           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10196           /* Fall through.  */
10197         case DT_PLTPADSZ:
10198         case DT_MOVEENT :
10199         case DT_MOVESZ  :
10200         case DT_INIT_ARRAYSZ:
10201         case DT_FINI_ARRAYSZ:
10202         case DT_GNU_CONFLICTSZ:
10203         case DT_GNU_LIBLISTSZ:
10204           if (do_dynamic)
10205             {
10206               print_vma (entry->d_un.d_val, UNSIGNED);
10207               printf (_(" (bytes)\n"));
10208             }
10209           break;
10210
10211         case DT_VERDEFNUM:
10212         case DT_VERNEEDNUM:
10213         case DT_RELACOUNT:
10214         case DT_RELCOUNT:
10215           if (do_dynamic)
10216             {
10217               print_vma (entry->d_un.d_val, UNSIGNED);
10218               putchar ('\n');
10219             }
10220           break;
10221
10222         case DT_SYMINSZ:
10223         case DT_SYMINENT:
10224         case DT_SYMINFO:
10225         case DT_USED:
10226         case DT_INIT_ARRAY:
10227         case DT_FINI_ARRAY:
10228           if (do_dynamic)
10229             {
10230               if (entry->d_tag == DT_USED
10231                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10232                 {
10233                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10234
10235                   if (*name)
10236                     {
10237                       printf (_("Not needed object: [%s]\n"), name);
10238                       break;
10239                     }
10240                 }
10241
10242               print_vma (entry->d_un.d_val, PREFIX_HEX);
10243               putchar ('\n');
10244             }
10245           break;
10246
10247         case DT_BIND_NOW:
10248           /* The value of this entry is ignored.  */
10249           if (do_dynamic)
10250             putchar ('\n');
10251           break;
10252
10253         case DT_GNU_PRELINKED:
10254           if (do_dynamic)
10255             {
10256               struct tm * tmp;
10257               time_t atime = entry->d_un.d_val;
10258
10259               tmp = gmtime (&atime);
10260               /* PR 17533 file: 041-1244816-0.004.  */
10261               if (tmp == NULL)
10262                 printf (_("<corrupt time val: %lx"),
10263                         (unsigned long) atime);
10264               else
10265                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10266                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10267                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10268
10269             }
10270           break;
10271
10272         case DT_GNU_HASH:
10273           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10274           if (do_dynamic)
10275             {
10276               print_vma (entry->d_un.d_val, PREFIX_HEX);
10277               putchar ('\n');
10278             }
10279           break;
10280
10281         default:
10282           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10283             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10284               entry->d_un.d_val;
10285
10286           if (do_dynamic)
10287             {
10288               switch (filedata->file_header.e_machine)
10289                 {
10290                 case EM_MIPS:
10291                 case EM_MIPS_RS3_LE:
10292                   dynamic_section_mips_val (entry);
10293                   break;
10294                 case EM_PARISC:
10295                   dynamic_section_parisc_val (entry);
10296                   break;
10297                 case EM_IA_64:
10298                   dynamic_section_ia64_val (entry);
10299                   break;
10300                 default:
10301                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10302                   putchar ('\n');
10303                 }
10304             }
10305           break;
10306         }
10307     }
10308
10309   return TRUE;
10310 }
10311
10312 static char *
10313 get_ver_flags (unsigned int flags)
10314 {
10315   static char buff[128];
10316
10317   buff[0] = 0;
10318
10319   if (flags == 0)
10320     return _("none");
10321
10322   if (flags & VER_FLG_BASE)
10323     strcat (buff, "BASE");
10324
10325   if (flags & VER_FLG_WEAK)
10326     {
10327       if (flags & VER_FLG_BASE)
10328         strcat (buff, " | ");
10329
10330       strcat (buff, "WEAK");
10331     }
10332
10333   if (flags & VER_FLG_INFO)
10334     {
10335       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10336         strcat (buff, " | ");
10337
10338       strcat (buff, "INFO");
10339     }
10340
10341   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10342     {
10343       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10344         strcat (buff, " | ");
10345
10346       strcat (buff, _("<unknown>"));
10347     }
10348
10349   return buff;
10350 }
10351
10352 /* Display the contents of the version sections.  */
10353
10354 static bfd_boolean
10355 process_version_sections (Filedata * filedata)
10356 {
10357   Elf_Internal_Shdr * section;
10358   unsigned i;
10359   bfd_boolean found = FALSE;
10360
10361   if (! do_version)
10362     return TRUE;
10363
10364   for (i = 0, section = filedata->section_headers;
10365        i < filedata->file_header.e_shnum;
10366        i++, section++)
10367     {
10368       switch (section->sh_type)
10369         {
10370         case SHT_GNU_verdef:
10371           {
10372             Elf_External_Verdef * edefs;
10373             unsigned long idx;
10374             unsigned long cnt;
10375             char * endbuf;
10376
10377             found = TRUE;
10378
10379             printf (ngettext ("\nVersion definition section '%s' "
10380                               "contains %u entry:\n",
10381                               "\nVersion definition section '%s' "
10382                               "contains %u entries:\n",
10383                               section->sh_info),
10384                     printable_section_name (filedata, section),
10385                     section->sh_info);
10386
10387             printf (_("  Addr: 0x"));
10388             printf_vma (section->sh_addr);
10389             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10390                     (unsigned long) section->sh_offset, section->sh_link,
10391                     printable_section_name_from_index (filedata, section->sh_link));
10392
10393             edefs = (Elf_External_Verdef *)
10394                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10395                           _("version definition section"));
10396             if (!edefs)
10397               break;
10398             endbuf = (char *) edefs + section->sh_size;
10399
10400             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10401               {
10402                 char * vstart;
10403                 Elf_External_Verdef * edef;
10404                 Elf_Internal_Verdef ent;
10405                 Elf_External_Verdaux * eaux;
10406                 Elf_Internal_Verdaux aux;
10407                 unsigned long isum;
10408                 int j;
10409
10410                 vstart = ((char *) edefs) + idx;
10411                 if (vstart + sizeof (*edef) > endbuf)
10412                   break;
10413
10414                 edef = (Elf_External_Verdef *) vstart;
10415
10416                 ent.vd_version = BYTE_GET (edef->vd_version);
10417                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10418                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10419                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10420                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10421                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10422                 ent.vd_next    = BYTE_GET (edef->vd_next);
10423
10424                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10425                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10426
10427                 printf (_("  Index: %d  Cnt: %d  "),
10428                         ent.vd_ndx, ent.vd_cnt);
10429
10430                 /* Check for overflow.  */
10431                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10432                   break;
10433
10434                 vstart += ent.vd_aux;
10435
10436                 if (vstart + sizeof (*eaux) > endbuf)
10437                   break;
10438                 eaux = (Elf_External_Verdaux *) vstart;
10439
10440                 aux.vda_name = BYTE_GET (eaux->vda_name);
10441                 aux.vda_next = BYTE_GET (eaux->vda_next);
10442
10443                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10444                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10445                 else
10446                   printf (_("Name index: %ld\n"), aux.vda_name);
10447
10448                 isum = idx + ent.vd_aux;
10449
10450                 for (j = 1; j < ent.vd_cnt; j++)
10451                   {
10452                     if (aux.vda_next < sizeof (*eaux)
10453                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10454                       {
10455                         warn (_("Invalid vda_next field of %lx\n"),
10456                               aux.vda_next);
10457                         j = ent.vd_cnt;
10458                         break;
10459                       }
10460                     /* Check for overflow.  */
10461                     if (aux.vda_next > (size_t) (endbuf - vstart))
10462                       break;
10463
10464                     isum   += aux.vda_next;
10465                     vstart += aux.vda_next;
10466
10467                     if (vstart + sizeof (*eaux) > endbuf)
10468                       break;
10469                     eaux = (Elf_External_Verdaux *) vstart;
10470
10471                     aux.vda_name = BYTE_GET (eaux->vda_name);
10472                     aux.vda_next = BYTE_GET (eaux->vda_next);
10473
10474                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10475                       printf (_("  %#06lx: Parent %d: %s\n"),
10476                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10477                     else
10478                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10479                               isum, j, aux.vda_name);
10480                   }
10481
10482                 if (j < ent.vd_cnt)
10483                   printf (_("  Version def aux past end of section\n"));
10484
10485                 /* PR 17531:
10486                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10487                 if (ent.vd_next < sizeof (*edef)
10488                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10489                   {
10490                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10491                     cnt = section->sh_info;
10492                     break;
10493                   }
10494                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10495                   break;
10496
10497                 idx += ent.vd_next;
10498               }
10499
10500             if (cnt < section->sh_info)
10501               printf (_("  Version definition past end of section\n"));
10502
10503             free (edefs);
10504           }
10505           break;
10506
10507         case SHT_GNU_verneed:
10508           {
10509             Elf_External_Verneed * eneed;
10510             unsigned long idx;
10511             unsigned long cnt;
10512             char * endbuf;
10513
10514             found = TRUE;
10515
10516             printf (ngettext ("\nVersion needs section '%s' "
10517                               "contains %u entry:\n",
10518                               "\nVersion needs section '%s' "
10519                               "contains %u entries:\n",
10520                               section->sh_info),
10521                     printable_section_name (filedata, section), section->sh_info);
10522
10523             printf (_(" Addr: 0x"));
10524             printf_vma (section->sh_addr);
10525             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10526                     (unsigned long) section->sh_offset, section->sh_link,
10527                     printable_section_name_from_index (filedata, section->sh_link));
10528
10529             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10530                                                        section->sh_offset, 1,
10531                                                        section->sh_size,
10532                                                        _("Version Needs section"));
10533             if (!eneed)
10534               break;
10535             endbuf = (char *) eneed + section->sh_size;
10536
10537             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10538               {
10539                 Elf_External_Verneed * entry;
10540                 Elf_Internal_Verneed ent;
10541                 unsigned long isum;
10542                 int j;
10543                 char * vstart;
10544
10545                 vstart = ((char *) eneed) + idx;
10546                 if (vstart + sizeof (*entry) > endbuf)
10547                   break;
10548
10549                 entry = (Elf_External_Verneed *) vstart;
10550
10551                 ent.vn_version = BYTE_GET (entry->vn_version);
10552                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10553                 ent.vn_file    = BYTE_GET (entry->vn_file);
10554                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10555                 ent.vn_next    = BYTE_GET (entry->vn_next);
10556
10557                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10558
10559                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10560                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10561                 else
10562                   printf (_("  File: %lx"), ent.vn_file);
10563
10564                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10565
10566                 /* Check for overflow.  */
10567                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10568                   break;
10569                 vstart += ent.vn_aux;
10570
10571                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10572                   {
10573                     Elf_External_Vernaux * eaux;
10574                     Elf_Internal_Vernaux aux;
10575
10576                     if (vstart + sizeof (*eaux) > endbuf)
10577                       break;
10578                     eaux = (Elf_External_Vernaux *) vstart;
10579
10580                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10581                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10582                     aux.vna_other = BYTE_GET (eaux->vna_other);
10583                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10584                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10585
10586                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10587                       printf (_("  %#06lx:   Name: %s"),
10588                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10589                     else
10590                       printf (_("  %#06lx:   Name index: %lx"),
10591                               isum, aux.vna_name);
10592
10593                     printf (_("  Flags: %s  Version: %d\n"),
10594                             get_ver_flags (aux.vna_flags), aux.vna_other);
10595
10596                     if (aux.vna_next < sizeof (*eaux)
10597                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10598                       {
10599                         warn (_("Invalid vna_next field of %lx\n"),
10600                               aux.vna_next);
10601                         j = ent.vn_cnt;
10602                         break;
10603                       }
10604                     /* Check for overflow.  */
10605                     if (aux.vna_next > (size_t) (endbuf - vstart))
10606                       break;
10607                     isum   += aux.vna_next;
10608                     vstart += aux.vna_next;
10609                   }
10610
10611                 if (j < ent.vn_cnt)
10612                   warn (_("Missing Version Needs auxillary information\n"));
10613
10614                 if (ent.vn_next < sizeof (*entry)
10615                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10616                   {
10617                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10618                     cnt = section->sh_info;
10619                     break;
10620                   }
10621                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10622                   break;
10623                 idx += ent.vn_next;
10624               }
10625
10626             if (cnt < section->sh_info)
10627               warn (_("Missing Version Needs information\n"));
10628
10629             free (eneed);
10630           }
10631           break;
10632
10633         case SHT_GNU_versym:
10634           {
10635             Elf_Internal_Shdr * link_section;
10636             size_t total;
10637             unsigned int cnt;
10638             unsigned char * edata;
10639             unsigned short * data;
10640             char * strtab;
10641             Elf_Internal_Sym * symbols;
10642             Elf_Internal_Shdr * string_sec;
10643             unsigned long num_syms;
10644             long off;
10645
10646             if (section->sh_link >= filedata->file_header.e_shnum)
10647               break;
10648
10649             link_section = filedata->section_headers + section->sh_link;
10650             total = section->sh_size / sizeof (Elf_External_Versym);
10651
10652             if (link_section->sh_link >= filedata->file_header.e_shnum)
10653               break;
10654
10655             found = TRUE;
10656
10657             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10658             if (symbols == NULL)
10659               break;
10660
10661             string_sec = filedata->section_headers + link_section->sh_link;
10662
10663             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10664                                         string_sec->sh_size,
10665                                         _("version string table"));
10666             if (!strtab)
10667               {
10668                 free (symbols);
10669                 break;
10670               }
10671
10672             printf (ngettext ("\nVersion symbols section '%s' "
10673                               "contains %lu entry:\n",
10674                               "\nVersion symbols section '%s' "
10675                               "contains %lu entries:\n",
10676                               total),
10677                     printable_section_name (filedata, section), (unsigned long) total);
10678
10679             printf (_(" Addr: "));
10680             printf_vma (section->sh_addr);
10681             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10682                     (unsigned long) section->sh_offset, section->sh_link,
10683                     printable_section_name (filedata, link_section));
10684
10685             off = offset_from_vma (filedata,
10686                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10687                                    total * sizeof (short));
10688             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10689                                                 sizeof (short),
10690                                                 _("version symbol data"));
10691             if (!edata)
10692               {
10693                 free (strtab);
10694                 free (symbols);
10695                 break;
10696               }
10697
10698             data = (short unsigned int *) cmalloc (total, sizeof (short));
10699
10700             for (cnt = total; cnt --;)
10701               data[cnt] = byte_get (edata + cnt * sizeof (short),
10702                                     sizeof (short));
10703
10704             free (edata);
10705
10706             for (cnt = 0; cnt < total; cnt += 4)
10707               {
10708                 int j, nn;
10709                 char *name;
10710                 char *invalid = _("*invalid*");
10711
10712                 printf ("  %03x:", cnt);
10713
10714                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10715                   switch (data[cnt + j])
10716                     {
10717                     case 0:
10718                       fputs (_("   0 (*local*)    "), stdout);
10719                       break;
10720
10721                     case 1:
10722                       fputs (_("   1 (*global*)   "), stdout);
10723                       break;
10724
10725                     default:
10726                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10727                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10728
10729                       /* If this index value is greater than the size of the symbols
10730                          array, break to avoid an out-of-bounds read.  */
10731                       if ((unsigned long)(cnt + j) >= num_syms)
10732                         {
10733                           warn (_("invalid index into symbol array\n"));
10734                           break;
10735                         }
10736
10737                       name = NULL;
10738                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10739                         {
10740                           Elf_Internal_Verneed ivn;
10741                           unsigned long offset;
10742
10743                           offset = offset_from_vma
10744                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10745                              sizeof (Elf_External_Verneed));
10746
10747                           do
10748                             {
10749                               Elf_Internal_Vernaux ivna;
10750                               Elf_External_Verneed evn;
10751                               Elf_External_Vernaux evna;
10752                               unsigned long a_off;
10753
10754                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10755                                             _("version need")) == NULL)
10756                                 break;
10757
10758                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10759                               ivn.vn_next = BYTE_GET (evn.vn_next);
10760
10761                               a_off = offset + ivn.vn_aux;
10762
10763                               do
10764                                 {
10765                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10766                                                 1, _("version need aux (2)")) == NULL)
10767                                     {
10768                                       ivna.vna_next  = 0;
10769                                       ivna.vna_other = 0;
10770                                     }
10771                                   else
10772                                     {
10773                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10774                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10775                                     }
10776
10777                                   a_off += ivna.vna_next;
10778                                 }
10779                               while (ivna.vna_other != data[cnt + j]
10780                                      && ivna.vna_next != 0);
10781
10782                               if (ivna.vna_other == data[cnt + j])
10783                                 {
10784                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10785
10786                                   if (ivna.vna_name >= string_sec->sh_size)
10787                                     name = invalid;
10788                                   else
10789                                     name = strtab + ivna.vna_name;
10790                                   break;
10791                                 }
10792
10793                               offset += ivn.vn_next;
10794                             }
10795                           while (ivn.vn_next);
10796                         }
10797
10798                       if (data[cnt + j] != 0x8001
10799                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10800                         {
10801                           Elf_Internal_Verdef ivd;
10802                           Elf_External_Verdef evd;
10803                           unsigned long offset;
10804
10805                           offset = offset_from_vma
10806                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10807                              sizeof evd);
10808
10809                           do
10810                             {
10811                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10812                                             _("version def")) == NULL)
10813                                 {
10814                                   ivd.vd_next = 0;
10815                                   /* PR 17531: file: 046-1082287-0.004.  */
10816                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10817                                   break;
10818                                 }
10819                               else
10820                                 {
10821                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10822                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10823                                 }
10824
10825                               offset += ivd.vd_next;
10826                             }
10827                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10828                                  && ivd.vd_next != 0);
10829
10830                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10831                             {
10832                               Elf_External_Verdaux evda;
10833                               Elf_Internal_Verdaux ivda;
10834
10835                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10836
10837                               if (get_data (&evda, filedata,
10838                                             offset - ivd.vd_next + ivd.vd_aux,
10839                                             sizeof (evda), 1,
10840                                             _("version def aux")) == NULL)
10841                                 break;
10842
10843                               ivda.vda_name = BYTE_GET (evda.vda_name);
10844
10845                               if (ivda.vda_name >= string_sec->sh_size)
10846                                 name = invalid;
10847                               else if (name != NULL && name != invalid)
10848                                 name = _("*both*");
10849                               else
10850                                 name = strtab + ivda.vda_name;
10851                             }
10852                         }
10853                       if (name != NULL)
10854                         nn += printf ("(%s%-*s",
10855                                       name,
10856                                       12 - (int) strlen (name),
10857                                       ")");
10858
10859                       if (nn < 18)
10860                         printf ("%*c", 18 - nn, ' ');
10861                     }
10862
10863                 putchar ('\n');
10864               }
10865
10866             free (data);
10867             free (strtab);
10868             free (symbols);
10869           }
10870           break;
10871
10872         default:
10873           break;
10874         }
10875     }
10876
10877   if (! found)
10878     printf (_("\nNo version information found in this file.\n"));
10879
10880   return TRUE;
10881 }
10882
10883 static const char *
10884 get_symbol_binding (Filedata * filedata, unsigned int binding)
10885 {
10886   static char buff[32];
10887
10888   switch (binding)
10889     {
10890     case STB_LOCAL:     return "LOCAL";
10891     case STB_GLOBAL:    return "GLOBAL";
10892     case STB_WEAK:      return "WEAK";
10893     default:
10894       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10895         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10896                   binding);
10897       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10898         {
10899           if (binding == STB_GNU_UNIQUE
10900               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10901                   /* GNU is still using the default value 0.  */
10902                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10903             return "UNIQUE";
10904           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10905         }
10906       else
10907         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10908       return buff;
10909     }
10910 }
10911
10912 static const char *
10913 get_symbol_type (Filedata * filedata, unsigned int type)
10914 {
10915   static char buff[32];
10916
10917   switch (type)
10918     {
10919     case STT_NOTYPE:    return "NOTYPE";
10920     case STT_OBJECT:    return "OBJECT";
10921     case STT_FUNC:      return "FUNC";
10922     case STT_SECTION:   return "SECTION";
10923     case STT_FILE:      return "FILE";
10924     case STT_COMMON:    return "COMMON";
10925     case STT_TLS:       return "TLS";
10926     case STT_RELC:      return "RELC";
10927     case STT_SRELC:     return "SRELC";
10928     default:
10929       if (type >= STT_LOPROC && type <= STT_HIPROC)
10930         {
10931           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10932             return "THUMB_FUNC";
10933
10934           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10935             return "REGISTER";
10936
10937           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10938             return "PARISC_MILLI";
10939
10940           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10941         }
10942       else if (type >= STT_LOOS && type <= STT_HIOS)
10943         {
10944           if (filedata->file_header.e_machine == EM_PARISC)
10945             {
10946               if (type == STT_HP_OPAQUE)
10947                 return "HP_OPAQUE";
10948               if (type == STT_HP_STUB)
10949                 return "HP_STUB";
10950             }
10951
10952           if (type == STT_GNU_IFUNC
10953               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10954                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10955                   /* GNU is still using the default value 0.  */
10956                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10957             return "IFUNC";
10958
10959           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10960         }
10961       else
10962         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10963       return buff;
10964     }
10965 }
10966
10967 static const char *
10968 get_symbol_visibility (unsigned int visibility)
10969 {
10970   switch (visibility)
10971     {
10972     case STV_DEFAULT:   return "DEFAULT";
10973     case STV_INTERNAL:  return "INTERNAL";
10974     case STV_HIDDEN:    return "HIDDEN";
10975     case STV_PROTECTED: return "PROTECTED";
10976     default:
10977       error (_("Unrecognized visibility value: %u"), visibility);
10978       return _("<unknown>");
10979     }
10980 }
10981
10982 static const char *
10983 get_solaris_symbol_visibility (unsigned int visibility)
10984 {
10985   switch (visibility)
10986     {
10987     case 4: return "EXPORTED";
10988     case 5: return "SINGLETON";
10989     case 6: return "ELIMINATE";
10990     default: return get_symbol_visibility (visibility);
10991     }
10992 }
10993
10994 static const char *
10995 get_mips_symbol_other (unsigned int other)
10996 {
10997   switch (other)
10998     {
10999     case STO_OPTIONAL:      return "OPTIONAL";
11000     case STO_MIPS_PLT:      return "MIPS PLT";
11001     case STO_MIPS_PIC:      return "MIPS PIC";
11002     case STO_MICROMIPS:     return "MICROMIPS";
11003     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
11004     case STO_MIPS16:        return "MIPS16";
11005     default:                return NULL;
11006     }
11007 }
11008
11009 static const char *
11010 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11011 {
11012   if (is_ia64_vms (filedata))
11013     {
11014       static char res[32];
11015
11016       res[0] = 0;
11017
11018       /* Function types is for images and .STB files only.  */
11019       switch (filedata->file_header.e_type)
11020         {
11021         case ET_DYN:
11022         case ET_EXEC:
11023           switch (VMS_ST_FUNC_TYPE (other))
11024             {
11025             case VMS_SFT_CODE_ADDR:
11026               strcat (res, " CA");
11027               break;
11028             case VMS_SFT_SYMV_IDX:
11029               strcat (res, " VEC");
11030               break;
11031             case VMS_SFT_FD:
11032               strcat (res, " FD");
11033               break;
11034             case VMS_SFT_RESERVE:
11035               strcat (res, " RSV");
11036               break;
11037             default:
11038               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11039                     VMS_ST_FUNC_TYPE (other));
11040               strcat (res, " <unknown>");
11041               break;
11042             }
11043           break;
11044         default:
11045           break;
11046         }
11047       switch (VMS_ST_LINKAGE (other))
11048         {
11049         case VMS_STL_IGNORE:
11050           strcat (res, " IGN");
11051           break;
11052         case VMS_STL_RESERVE:
11053           strcat (res, " RSV");
11054           break;
11055         case VMS_STL_STD:
11056           strcat (res, " STD");
11057           break;
11058         case VMS_STL_LNK:
11059           strcat (res, " LNK");
11060           break;
11061         default:
11062           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11063                 VMS_ST_LINKAGE (other));
11064           strcat (res, " <unknown>");
11065           break;
11066         }
11067
11068       if (res[0] != 0)
11069         return res + 1;
11070       else
11071         return res;
11072     }
11073   return NULL;
11074 }
11075
11076 static const char *
11077 get_ppc64_symbol_other (unsigned int other)
11078 {
11079   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
11080     {
11081       static char buf[32];
11082       snprintf (buf, sizeof buf, _("<localentry>: %d"),
11083                 PPC64_LOCAL_ENTRY_OFFSET (other));
11084       return buf;
11085     }
11086   return NULL;
11087 }
11088
11089 static const char *
11090 get_symbol_other (Filedata * filedata, unsigned int other)
11091 {
11092   const char * result = NULL;
11093   static char buff [32];
11094
11095   if (other == 0)
11096     return "";
11097
11098   switch (filedata->file_header.e_machine)
11099     {
11100     case EM_MIPS:
11101       result = get_mips_symbol_other (other);
11102       break;
11103     case EM_IA_64:
11104       result = get_ia64_symbol_other (filedata, other);
11105       break;
11106     case EM_PPC64:
11107       result = get_ppc64_symbol_other (other);
11108       break;
11109     default:
11110       result = NULL;
11111       break;
11112     }
11113
11114   if (result)
11115     return result;
11116
11117   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11118   return buff;
11119 }
11120
11121 static const char *
11122 get_symbol_index_type (Filedata * filedata, unsigned int type)
11123 {
11124   static char buff[32];
11125
11126   switch (type)
11127     {
11128     case SHN_UNDEF:     return "UND";
11129     case SHN_ABS:       return "ABS";
11130     case SHN_COMMON:    return "COM";
11131     default:
11132       if (type == SHN_IA_64_ANSI_COMMON
11133           && filedata->file_header.e_machine == EM_IA_64
11134           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11135         return "ANSI_COM";
11136       else if ((filedata->file_header.e_machine == EM_X86_64
11137                 || filedata->file_header.e_machine == EM_L1OM
11138                 || filedata->file_header.e_machine == EM_K1OM)
11139                && type == SHN_X86_64_LCOMMON)
11140         return "LARGE_COM";
11141       else if ((type == SHN_MIPS_SCOMMON
11142                 && filedata->file_header.e_machine == EM_MIPS)
11143                || (type == SHN_TIC6X_SCOMMON
11144                    && filedata->file_header.e_machine == EM_TI_C6000))
11145         return "SCOM";
11146       else if (type == SHN_MIPS_SUNDEFINED
11147                && filedata->file_header.e_machine == EM_MIPS)
11148         return "SUND";
11149       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11150         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11151       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11152         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11153       else if (type >= SHN_LORESERVE)
11154         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11155       else if (type >= filedata->file_header.e_shnum)
11156         sprintf (buff, _("bad section index[%3d]"), type);
11157       else
11158         sprintf (buff, "%3d", type);
11159       break;
11160     }
11161
11162   return buff;
11163 }
11164
11165 static bfd_vma *
11166 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11167 {
11168   unsigned char * e_data;
11169   bfd_vma * i_data;
11170
11171   /* If the size_t type is smaller than the bfd_size_type, eg because
11172      you are building a 32-bit tool on a 64-bit host, then make sure
11173      that when (number) is cast to (size_t) no information is lost.  */
11174   if (sizeof (size_t) < sizeof (bfd_size_type)
11175       && (bfd_size_type) ((size_t) number) != number)
11176     {
11177       error (_("Size truncation prevents reading %s elements of size %u\n"),
11178              bfd_vmatoa ("u", number), ent_size);
11179       return NULL;
11180     }
11181
11182   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11183      attempting to allocate memory when the read is bound to fail.  */
11184   if (ent_size * number > filedata->file_size)
11185     {
11186       error (_("Invalid number of dynamic entries: %s\n"),
11187              bfd_vmatoa ("u", number));
11188       return NULL;
11189     }
11190
11191   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11192   if (e_data == NULL)
11193     {
11194       error (_("Out of memory reading %s dynamic entries\n"),
11195              bfd_vmatoa ("u", number));
11196       return NULL;
11197     }
11198
11199   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11200     {
11201       error (_("Unable to read in %s bytes of dynamic data\n"),
11202              bfd_vmatoa ("u", number * ent_size));
11203       free (e_data);
11204       return NULL;
11205     }
11206
11207   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11208   if (i_data == NULL)
11209     {
11210       error (_("Out of memory allocating space for %s dynamic entries\n"),
11211              bfd_vmatoa ("u", number));
11212       free (e_data);
11213       return NULL;
11214     }
11215
11216   while (number--)
11217     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11218
11219   free (e_data);
11220
11221   return i_data;
11222 }
11223
11224 static void
11225 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11226 {
11227   Elf_Internal_Sym * psym;
11228   int n;
11229
11230   n = print_vma (si, DEC_5);
11231   if (n < 5)
11232     fputs (&"     "[n], stdout);
11233   printf (" %3lu: ", hn);
11234
11235   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11236     {
11237       printf (_("<No info available for dynamic symbol number %lu>\n"),
11238               (unsigned long) si);
11239       return;
11240     }
11241
11242   psym = dynamic_symbols + si;
11243   print_vma (psym->st_value, LONG_HEX);
11244   putchar (' ');
11245   print_vma (psym->st_size, DEC_5);
11246
11247   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11248   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11249
11250   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11251     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11252   else
11253     {
11254       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11255
11256       printf (" %-7s",  get_symbol_visibility (vis));
11257       /* Check to see if any other bits in the st_other field are set.
11258          Note - displaying this information disrupts the layout of the
11259          table being generated, but for the moment this case is very
11260          rare.  */
11261       if (psym->st_other ^ vis)
11262         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11263     }
11264
11265   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11266   if (VALID_DYNAMIC_NAME (psym->st_name))
11267     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11268   else
11269     printf (_(" <corrupt: %14ld>"), psym->st_name);
11270   putchar ('\n');
11271 }
11272
11273 static const char *
11274 get_symbol_version_string (Filedata *                   filedata,
11275                            bfd_boolean                  is_dynsym,
11276                            const char *                 strtab,
11277                            unsigned long int            strtab_size,
11278                            unsigned int                 si,
11279                            Elf_Internal_Sym *           psym,
11280                            enum versioned_symbol_info * sym_info,
11281                            unsigned short *             vna_other)
11282 {
11283   unsigned char data[2];
11284   unsigned short vers_data;
11285   unsigned long offset;
11286
11287   if (!is_dynsym
11288       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11289     return NULL;
11290
11291   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11292                             sizeof data + si * sizeof (vers_data));
11293
11294   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11295                 sizeof (data), 1, _("version data")) == NULL)
11296     return NULL;
11297
11298   vers_data = byte_get (data, 2);
11299
11300   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11301     return NULL;
11302
11303   /* Usually we'd only see verdef for defined symbols, and verneed for
11304      undefined symbols.  However, symbols defined by the linker in
11305      .dynbss for variables copied from a shared library in order to
11306      avoid text relocations are defined yet have verneed.  We could
11307      use a heuristic to detect the special case, for example, check
11308      for verneed first on symbols defined in SHT_NOBITS sections, but
11309      it is simpler and more reliable to just look for both verdef and
11310      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11311
11312   if (psym->st_shndx != SHN_UNDEF
11313       && vers_data != 0x8001
11314       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11315     {
11316       Elf_Internal_Verdef ivd;
11317       Elf_Internal_Verdaux ivda;
11318       Elf_External_Verdaux evda;
11319       unsigned long off;
11320
11321       off = offset_from_vma (filedata,
11322                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11323                              sizeof (Elf_External_Verdef));
11324
11325       do
11326         {
11327           Elf_External_Verdef evd;
11328
11329           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11330                         _("version def")) == NULL)
11331             {
11332               ivd.vd_ndx = 0;
11333               ivd.vd_aux = 0;
11334               ivd.vd_next = 0;
11335               ivd.vd_flags = 0;
11336             }
11337           else
11338             {
11339               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11340               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11341               ivd.vd_next = BYTE_GET (evd.vd_next);
11342               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11343             }
11344
11345           off += ivd.vd_next;
11346         }
11347       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11348
11349       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11350         {
11351           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11352             return NULL;
11353
11354           off -= ivd.vd_next;
11355           off += ivd.vd_aux;
11356
11357           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11358                         _("version def aux")) != NULL)
11359             {
11360               ivda.vda_name = BYTE_GET (evda.vda_name);
11361
11362               if (psym->st_name != ivda.vda_name)
11363                 {
11364                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11365                                ? symbol_hidden : symbol_public);
11366                   return (ivda.vda_name < strtab_size
11367                           ? strtab + ivda.vda_name : _("<corrupt>"));
11368                 }
11369             }
11370         }
11371     }
11372
11373   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11374     {
11375       Elf_External_Verneed evn;
11376       Elf_Internal_Verneed ivn;
11377       Elf_Internal_Vernaux ivna;
11378
11379       offset = offset_from_vma (filedata,
11380                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11381                                 sizeof evn);
11382       do
11383         {
11384           unsigned long vna_off;
11385
11386           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11387                         _("version need")) == NULL)
11388             {
11389               ivna.vna_next = 0;
11390               ivna.vna_other = 0;
11391               ivna.vna_name = 0;
11392               break;
11393             }
11394
11395           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11396           ivn.vn_next = BYTE_GET (evn.vn_next);
11397
11398           vna_off = offset + ivn.vn_aux;
11399
11400           do
11401             {
11402               Elf_External_Vernaux evna;
11403
11404               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11405                             _("version need aux (3)")) == NULL)
11406                 {
11407                   ivna.vna_next = 0;
11408                   ivna.vna_other = 0;
11409                   ivna.vna_name = 0;
11410                 }
11411               else
11412                 {
11413                   ivna.vna_other = BYTE_GET (evna.vna_other);
11414                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11415                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11416                 }
11417
11418               vna_off += ivna.vna_next;
11419             }
11420           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11421
11422           if (ivna.vna_other == vers_data)
11423             break;
11424
11425           offset += ivn.vn_next;
11426         }
11427       while (ivn.vn_next != 0);
11428
11429       if (ivna.vna_other == vers_data)
11430         {
11431           *sym_info = symbol_undefined;
11432           *vna_other = ivna.vna_other;
11433           return (ivna.vna_name < strtab_size
11434                   ? strtab + ivna.vna_name : _("<corrupt>"));
11435         }
11436     }
11437   return NULL;
11438 }
11439
11440 /* Dump the symbol table.  */
11441 static bfd_boolean
11442 process_symbol_table (Filedata * filedata)
11443 {
11444   Elf_Internal_Shdr * section;
11445   bfd_size_type nbuckets = 0;
11446   bfd_size_type nchains = 0;
11447   bfd_vma * buckets = NULL;
11448   bfd_vma * chains = NULL;
11449   bfd_vma ngnubuckets = 0;
11450   bfd_vma * gnubuckets = NULL;
11451   bfd_vma * gnuchains = NULL;
11452   bfd_vma gnusymidx = 0;
11453   bfd_size_type ngnuchains = 0;
11454
11455   if (!do_syms && !do_dyn_syms && !do_histogram)
11456     return TRUE;
11457
11458   if (dynamic_info[DT_HASH]
11459       && (do_histogram
11460           || (do_using_dynamic
11461               && !do_dyn_syms
11462               && dynamic_strings != NULL)))
11463     {
11464       unsigned char nb[8];
11465       unsigned char nc[8];
11466       unsigned int hash_ent_size = 4;
11467
11468       if ((filedata->file_header.e_machine == EM_ALPHA
11469            || filedata->file_header.e_machine == EM_S390
11470            || filedata->file_header.e_machine == EM_S390_OLD)
11471           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11472         hash_ent_size = 8;
11473
11474       if (fseek (filedata->handle,
11475                  (archive_file_offset
11476                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11477                                      sizeof nb + sizeof nc)),
11478                  SEEK_SET))
11479         {
11480           error (_("Unable to seek to start of dynamic information\n"));
11481           goto no_hash;
11482         }
11483
11484       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11485         {
11486           error (_("Failed to read in number of buckets\n"));
11487           goto no_hash;
11488         }
11489
11490       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11491         {
11492           error (_("Failed to read in number of chains\n"));
11493           goto no_hash;
11494         }
11495
11496       nbuckets = byte_get (nb, hash_ent_size);
11497       nchains  = byte_get (nc, hash_ent_size);
11498
11499       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11500       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11501
11502     no_hash:
11503       if (buckets == NULL || chains == NULL)
11504         {
11505           if (do_using_dynamic)
11506             return FALSE;
11507           free (buckets);
11508           free (chains);
11509           buckets = NULL;
11510           chains = NULL;
11511           nbuckets = 0;
11512           nchains = 0;
11513         }
11514     }
11515
11516   if (dynamic_info_DT_GNU_HASH
11517       && (do_histogram
11518           || (do_using_dynamic
11519               && !do_dyn_syms
11520               && dynamic_strings != NULL)))
11521     {
11522       unsigned char nb[16];
11523       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11524       bfd_vma buckets_vma;
11525
11526       if (fseek (filedata->handle,
11527                  (archive_file_offset
11528                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11529                                      sizeof nb)),
11530                  SEEK_SET))
11531         {
11532           error (_("Unable to seek to start of dynamic information\n"));
11533           goto no_gnu_hash;
11534         }
11535
11536       if (fread (nb, 16, 1, filedata->handle) != 1)
11537         {
11538           error (_("Failed to read in number of buckets\n"));
11539           goto no_gnu_hash;
11540         }
11541
11542       ngnubuckets = byte_get (nb, 4);
11543       gnusymidx = byte_get (nb + 4, 4);
11544       bitmaskwords = byte_get (nb + 8, 4);
11545       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11546       if (is_32bit_elf)
11547         buckets_vma += bitmaskwords * 4;
11548       else
11549         buckets_vma += bitmaskwords * 8;
11550
11551       if (fseek (filedata->handle,
11552                  (archive_file_offset
11553                   + offset_from_vma (filedata, buckets_vma, 4)),
11554                  SEEK_SET))
11555         {
11556           error (_("Unable to seek to start of dynamic information\n"));
11557           goto no_gnu_hash;
11558         }
11559
11560       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11561
11562       if (gnubuckets == NULL)
11563         goto no_gnu_hash;
11564
11565       for (i = 0; i < ngnubuckets; i++)
11566         if (gnubuckets[i] != 0)
11567           {
11568             if (gnubuckets[i] < gnusymidx)
11569               return FALSE;
11570
11571             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11572               maxchain = gnubuckets[i];
11573           }
11574
11575       if (maxchain == 0xffffffff)
11576         goto no_gnu_hash;
11577
11578       maxchain -= gnusymidx;
11579
11580       if (fseek (filedata->handle,
11581                  (archive_file_offset
11582                   + offset_from_vma (filedata, buckets_vma
11583                                            + 4 * (ngnubuckets + maxchain), 4)),
11584                  SEEK_SET))
11585         {
11586           error (_("Unable to seek to start of dynamic information\n"));
11587           goto no_gnu_hash;
11588         }
11589
11590       do
11591         {
11592           if (fread (nb, 4, 1, filedata->handle) != 1)
11593             {
11594               error (_("Failed to determine last chain length\n"));
11595               goto no_gnu_hash;
11596             }
11597
11598           if (maxchain + 1 == 0)
11599             goto no_gnu_hash;
11600
11601           ++maxchain;
11602         }
11603       while ((byte_get (nb, 4) & 1) == 0);
11604
11605       if (fseek (filedata->handle,
11606                  (archive_file_offset
11607                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11608                  SEEK_SET))
11609         {
11610           error (_("Unable to seek to start of dynamic information\n"));
11611           goto no_gnu_hash;
11612         }
11613
11614       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11615       ngnuchains = maxchain;
11616
11617     no_gnu_hash:
11618       if (gnuchains == NULL)
11619         {
11620           free (gnubuckets);
11621           gnubuckets = NULL;
11622           ngnubuckets = 0;
11623           if (do_using_dynamic)
11624             return FALSE;
11625         }
11626     }
11627
11628   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11629       && do_syms
11630       && do_using_dynamic
11631       && dynamic_strings != NULL
11632       && dynamic_symbols != NULL)
11633     {
11634       unsigned long hn;
11635
11636       if (dynamic_info[DT_HASH])
11637         {
11638           bfd_vma si;
11639           char *visited;
11640
11641           printf (_("\nSymbol table for image:\n"));
11642           if (is_32bit_elf)
11643             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11644           else
11645             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11646
11647           visited = xcmalloc (nchains, 1);
11648           memset (visited, 0, nchains);
11649           for (hn = 0; hn < nbuckets; hn++)
11650             {
11651               for (si = buckets[hn]; si > 0; si = chains[si])
11652                 {
11653                   print_dynamic_symbol (filedata, si, hn);
11654                   if (si >= nchains || visited[si])
11655                     {
11656                       error (_("histogram chain is corrupt\n"));
11657                       break;
11658                     }
11659                   visited[si] = 1;
11660                 }
11661             }
11662           free (visited);
11663         }
11664
11665       if (dynamic_info_DT_GNU_HASH)
11666         {
11667           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11668           if (is_32bit_elf)
11669             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11670           else
11671             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11672
11673           for (hn = 0; hn < ngnubuckets; ++hn)
11674             if (gnubuckets[hn] != 0)
11675               {
11676                 bfd_vma si = gnubuckets[hn];
11677                 bfd_vma off = si - gnusymidx;
11678
11679                 do
11680                   {
11681                     print_dynamic_symbol (filedata, si, hn);
11682                     si++;
11683                   }
11684                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11685               }
11686         }
11687     }
11688   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11689            && filedata->section_headers != NULL)
11690     {
11691       unsigned int i;
11692
11693       for (i = 0, section = filedata->section_headers;
11694            i < filedata->file_header.e_shnum;
11695            i++, section++)
11696         {
11697           unsigned int si;
11698           char * strtab = NULL;
11699           unsigned long int strtab_size = 0;
11700           Elf_Internal_Sym * symtab;
11701           Elf_Internal_Sym * psym;
11702           unsigned long num_syms;
11703
11704           if ((section->sh_type != SHT_SYMTAB
11705                && section->sh_type != SHT_DYNSYM)
11706               || (!do_syms
11707                   && section->sh_type == SHT_SYMTAB))
11708             continue;
11709
11710           if (section->sh_entsize == 0)
11711             {
11712               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11713                       printable_section_name (filedata, section));
11714               continue;
11715             }
11716
11717           num_syms = section->sh_size / section->sh_entsize;
11718           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11719                             "\nSymbol table '%s' contains %lu entries:\n",
11720                             num_syms),
11721                   printable_section_name (filedata, section),
11722                   num_syms);
11723
11724           if (is_32bit_elf)
11725             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11726           else
11727             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11728
11729           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11730           if (symtab == NULL)
11731             continue;
11732
11733           if (section->sh_link == filedata->file_header.e_shstrndx)
11734             {
11735               strtab = filedata->string_table;
11736               strtab_size = filedata->string_table_length;
11737             }
11738           else if (section->sh_link < filedata->file_header.e_shnum)
11739             {
11740               Elf_Internal_Shdr * string_sec;
11741
11742               string_sec = filedata->section_headers + section->sh_link;
11743
11744               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11745                                           1, string_sec->sh_size,
11746                                           _("string table"));
11747               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11748             }
11749
11750           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11751             {
11752               const char *version_string;
11753               enum versioned_symbol_info sym_info;
11754               unsigned short vna_other;
11755
11756               printf ("%6d: ", si);
11757               print_vma (psym->st_value, LONG_HEX);
11758               putchar (' ');
11759               print_vma (psym->st_size, DEC_5);
11760               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11761               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11762               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11763                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11764               else
11765                 {
11766                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11767
11768                   printf (" %-7s", get_symbol_visibility (vis));
11769                   /* Check to see if any other bits in the st_other field are set.
11770                      Note - displaying this information disrupts the layout of the
11771                      table being generated, but for the moment this case is very rare.  */
11772                   if (psym->st_other ^ vis)
11773                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11774                 }
11775               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11776               print_symbol (25, psym->st_name < strtab_size
11777                             ? strtab + psym->st_name : _("<corrupt>"));
11778
11779               version_string
11780                 = get_symbol_version_string (filedata,
11781                                              section->sh_type == SHT_DYNSYM,
11782                                              strtab, strtab_size, si,
11783                                              psym, &sym_info, &vna_other);
11784               if (version_string)
11785                 {
11786                   if (sym_info == symbol_undefined)
11787                     printf ("@%s (%d)", version_string, vna_other);
11788                   else
11789                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11790                             version_string);
11791                 }
11792
11793               putchar ('\n');
11794
11795               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11796                   && si >= section->sh_info
11797                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11798                   && filedata->file_header.e_machine != EM_MIPS
11799                   /* Solaris binaries have been found to violate this requirement as
11800                      well.  Not sure if this is a bug or an ABI requirement.  */
11801                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11802                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11803                       si, printable_section_name (filedata, section), section->sh_info);
11804             }
11805
11806           free (symtab);
11807           if (strtab != filedata->string_table)
11808             free (strtab);
11809         }
11810     }
11811   else if (do_syms)
11812     printf
11813       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11814
11815   if (do_histogram && buckets != NULL)
11816     {
11817       unsigned long * lengths;
11818       unsigned long * counts;
11819       unsigned long hn;
11820       bfd_vma si;
11821       unsigned long maxlength = 0;
11822       unsigned long nzero_counts = 0;
11823       unsigned long nsyms = 0;
11824       char *visited;
11825
11826       printf (ngettext ("\nHistogram for bucket list length "
11827                         "(total of %lu bucket):\n",
11828                         "\nHistogram for bucket list length "
11829                         "(total of %lu buckets):\n",
11830                         (unsigned long) nbuckets),
11831               (unsigned long) nbuckets);
11832
11833       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11834       if (lengths == NULL)
11835         {
11836           error (_("Out of memory allocating space for histogram buckets\n"));
11837           return FALSE;
11838         }
11839       visited = xcmalloc (nchains, 1);
11840       memset (visited, 0, nchains);
11841
11842       printf (_(" Length  Number     %% of total  Coverage\n"));
11843       for (hn = 0; hn < nbuckets; ++hn)
11844         {
11845           for (si = buckets[hn]; si > 0; si = chains[si])
11846             {
11847               ++nsyms;
11848               if (maxlength < ++lengths[hn])
11849                 ++maxlength;
11850               if (si >= nchains || visited[si])
11851                 {
11852                   error (_("histogram chain is corrupt\n"));
11853                   break;
11854                 }
11855               visited[si] = 1;
11856             }
11857         }
11858       free (visited);
11859
11860       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11861       if (counts == NULL)
11862         {
11863           free (lengths);
11864           error (_("Out of memory allocating space for histogram counts\n"));
11865           return FALSE;
11866         }
11867
11868       for (hn = 0; hn < nbuckets; ++hn)
11869         ++counts[lengths[hn]];
11870
11871       if (nbuckets > 0)
11872         {
11873           unsigned long i;
11874           printf ("      0  %-10lu (%5.1f%%)\n",
11875                   counts[0], (counts[0] * 100.0) / nbuckets);
11876           for (i = 1; i <= maxlength; ++i)
11877             {
11878               nzero_counts += counts[i] * i;
11879               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11880                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11881                       (nzero_counts * 100.0) / nsyms);
11882             }
11883         }
11884
11885       free (counts);
11886       free (lengths);
11887     }
11888
11889   if (buckets != NULL)
11890     {
11891       free (buckets);
11892       free (chains);
11893     }
11894
11895   if (do_histogram && gnubuckets != NULL)
11896     {
11897       unsigned long * lengths;
11898       unsigned long * counts;
11899       unsigned long hn;
11900       unsigned long maxlength = 0;
11901       unsigned long nzero_counts = 0;
11902       unsigned long nsyms = 0;
11903
11904       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11905                         "(total of %lu bucket):\n",
11906                         "\nHistogram for `.gnu.hash' bucket list length "
11907                         "(total of %lu buckets):\n",
11908                         (unsigned long) ngnubuckets),
11909               (unsigned long) ngnubuckets);
11910
11911       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11912       if (lengths == NULL)
11913         {
11914           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11915           return FALSE;
11916         }
11917
11918       printf (_(" Length  Number     %% of total  Coverage\n"));
11919
11920       for (hn = 0; hn < ngnubuckets; ++hn)
11921         if (gnubuckets[hn] != 0)
11922           {
11923             bfd_vma off, length = 1;
11924
11925             for (off = gnubuckets[hn] - gnusymidx;
11926                  /* PR 17531 file: 010-77222-0.004.  */
11927                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11928                  ++off)
11929               ++length;
11930             lengths[hn] = length;
11931             if (length > maxlength)
11932               maxlength = length;
11933             nsyms += length;
11934           }
11935
11936       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11937       if (counts == NULL)
11938         {
11939           free (lengths);
11940           error (_("Out of memory allocating space for gnu histogram counts\n"));
11941           return FALSE;
11942         }
11943
11944       for (hn = 0; hn < ngnubuckets; ++hn)
11945         ++counts[lengths[hn]];
11946
11947       if (ngnubuckets > 0)
11948         {
11949           unsigned long j;
11950           printf ("      0  %-10lu (%5.1f%%)\n",
11951                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11952           for (j = 1; j <= maxlength; ++j)
11953             {
11954               nzero_counts += counts[j] * j;
11955               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11956                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11957                       (nzero_counts * 100.0) / nsyms);
11958             }
11959         }
11960
11961       free (counts);
11962       free (lengths);
11963       free (gnubuckets);
11964       free (gnuchains);
11965     }
11966
11967   return TRUE;
11968 }
11969
11970 static bfd_boolean
11971 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11972 {
11973   unsigned int i;
11974
11975   if (dynamic_syminfo == NULL
11976       || !do_dynamic)
11977     /* No syminfo, this is ok.  */
11978     return TRUE;
11979
11980   /* There better should be a dynamic symbol section.  */
11981   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11982     return FALSE;
11983
11984   if (dynamic_addr)
11985     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11986                       "contains %d entry:\n",
11987                       "\nDynamic info segment at offset 0x%lx "
11988                       "contains %d entries:\n",
11989                       dynamic_syminfo_nent),
11990             dynamic_syminfo_offset, dynamic_syminfo_nent);
11991
11992   printf (_(" Num: Name                           BoundTo     Flags\n"));
11993   for (i = 0; i < dynamic_syminfo_nent; ++i)
11994     {
11995       unsigned short int flags = dynamic_syminfo[i].si_flags;
11996
11997       printf ("%4d: ", i);
11998       if (i >= num_dynamic_syms)
11999         printf (_("<corrupt index>"));
12000       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12001         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12002       else
12003         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12004       putchar (' ');
12005
12006       switch (dynamic_syminfo[i].si_boundto)
12007         {
12008         case SYMINFO_BT_SELF:
12009           fputs ("SELF       ", stdout);
12010           break;
12011         case SYMINFO_BT_PARENT:
12012           fputs ("PARENT     ", stdout);
12013           break;
12014         default:
12015           if (dynamic_syminfo[i].si_boundto > 0
12016               && dynamic_syminfo[i].si_boundto < dynamic_nent
12017               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12018             {
12019               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12020               putchar (' ' );
12021             }
12022           else
12023             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12024           break;
12025         }
12026
12027       if (flags & SYMINFO_FLG_DIRECT)
12028         printf (" DIRECT");
12029       if (flags & SYMINFO_FLG_PASSTHRU)
12030         printf (" PASSTHRU");
12031       if (flags & SYMINFO_FLG_COPY)
12032         printf (" COPY");
12033       if (flags & SYMINFO_FLG_LAZYLOAD)
12034         printf (" LAZYLOAD");
12035
12036       puts ("");
12037     }
12038
12039   return TRUE;
12040 }
12041
12042 #define IN_RANGE(START,END,ADDR,OFF)            \
12043   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12044
12045 /* Check to see if the given reloc needs to be handled in a target specific
12046    manner.  If so then process the reloc and return TRUE otherwise return
12047    FALSE.
12048
12049    If called with reloc == NULL, then this is a signal that reloc processing
12050    for the current section has finished, and any saved state should be
12051    discarded.  */
12052
12053 static bfd_boolean
12054 target_specific_reloc_handling (Filedata *           filedata,
12055                                 Elf_Internal_Rela *  reloc,
12056                                 unsigned char *      start,
12057                                 unsigned char *      end,
12058                                 Elf_Internal_Sym *   symtab,
12059                                 unsigned long        num_syms)
12060 {
12061   unsigned int reloc_type = 0;
12062   unsigned long sym_index = 0;
12063
12064   if (reloc)
12065     {
12066       reloc_type = get_reloc_type (filedata, reloc->r_info);
12067       sym_index = get_reloc_symindex (reloc->r_info);
12068     }
12069
12070   switch (filedata->file_header.e_machine)
12071     {
12072     case EM_MSP430:
12073     case EM_MSP430_OLD:
12074       {
12075         static Elf_Internal_Sym * saved_sym = NULL;
12076
12077         if (reloc == NULL)
12078           {
12079             saved_sym = NULL;
12080             return TRUE;
12081           }
12082
12083         switch (reloc_type)
12084           {
12085           case 10: /* R_MSP430_SYM_DIFF */
12086             if (uses_msp430x_relocs (filedata))
12087               break;
12088             /* Fall through.  */
12089           case 21: /* R_MSP430X_SYM_DIFF */
12090             /* PR 21139.  */
12091             if (sym_index >= num_syms)
12092               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12093                      sym_index);
12094             else
12095               saved_sym = symtab + sym_index;
12096             return TRUE;
12097
12098           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12099           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12100             goto handle_sym_diff;
12101
12102           case 5: /* R_MSP430_16_BYTE */
12103           case 9: /* R_MSP430_8 */
12104             if (uses_msp430x_relocs (filedata))
12105               break;
12106             goto handle_sym_diff;
12107
12108           case 2: /* R_MSP430_ABS16 */
12109           case 15: /* R_MSP430X_ABS16 */
12110             if (! uses_msp430x_relocs (filedata))
12111               break;
12112             goto handle_sym_diff;
12113
12114           handle_sym_diff:
12115             if (saved_sym != NULL)
12116               {
12117                 int reloc_size = reloc_type == 1 ? 4 : 2;
12118                 bfd_vma value;
12119
12120                 if (sym_index >= num_syms)
12121                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12122                          sym_index);
12123                 else
12124                   {
12125                     value = reloc->r_addend + (symtab[sym_index].st_value
12126                                                - saved_sym->st_value);
12127
12128                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12129                       byte_put (start + reloc->r_offset, value, reloc_size);
12130                     else
12131                       /* PR 21137 */
12132                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12133                              (long) reloc->r_offset);
12134                   }
12135
12136                 saved_sym = NULL;
12137                 return TRUE;
12138               }
12139             break;
12140
12141           default:
12142             if (saved_sym != NULL)
12143               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12144             break;
12145           }
12146         break;
12147       }
12148
12149     case EM_MN10300:
12150     case EM_CYGNUS_MN10300:
12151       {
12152         static Elf_Internal_Sym * saved_sym = NULL;
12153
12154         if (reloc == NULL)
12155           {
12156             saved_sym = NULL;
12157             return TRUE;
12158           }
12159
12160         switch (reloc_type)
12161           {
12162           case 34: /* R_MN10300_ALIGN */
12163             return TRUE;
12164           case 33: /* R_MN10300_SYM_DIFF */
12165             if (sym_index >= num_syms)
12166               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12167                      sym_index);
12168             else
12169               saved_sym = symtab + sym_index;
12170             return TRUE;
12171
12172           case 1: /* R_MN10300_32 */
12173           case 2: /* R_MN10300_16 */
12174             if (saved_sym != NULL)
12175               {
12176                 int reloc_size = reloc_type == 1 ? 4 : 2;
12177                 bfd_vma value;
12178
12179                 if (sym_index >= num_syms)
12180                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12181                          sym_index);
12182                 else
12183                   {
12184                     value = reloc->r_addend + (symtab[sym_index].st_value
12185                                                - saved_sym->st_value);
12186
12187                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12188                       byte_put (start + reloc->r_offset, value, reloc_size);
12189                     else
12190                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12191                              (long) reloc->r_offset);
12192                   }
12193
12194                 saved_sym = NULL;
12195                 return TRUE;
12196               }
12197             break;
12198           default:
12199             if (saved_sym != NULL)
12200               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12201             break;
12202           }
12203         break;
12204       }
12205
12206     case EM_RL78:
12207       {
12208         static bfd_vma saved_sym1 = 0;
12209         static bfd_vma saved_sym2 = 0;
12210         static bfd_vma value;
12211
12212         if (reloc == NULL)
12213           {
12214             saved_sym1 = saved_sym2 = 0;
12215             return TRUE;
12216           }
12217
12218         switch (reloc_type)
12219           {
12220           case 0x80: /* R_RL78_SYM.  */
12221             saved_sym1 = saved_sym2;
12222             if (sym_index >= num_syms)
12223               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12224                      sym_index);
12225             else
12226               {
12227                 saved_sym2 = symtab[sym_index].st_value;
12228                 saved_sym2 += reloc->r_addend;
12229               }
12230             return TRUE;
12231
12232           case 0x83: /* R_RL78_OPsub.  */
12233             value = saved_sym1 - saved_sym2;
12234             saved_sym2 = saved_sym1 = 0;
12235             return TRUE;
12236             break;
12237
12238           case 0x41: /* R_RL78_ABS32.  */
12239             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12240               byte_put (start + reloc->r_offset, value, 4);
12241             else
12242               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12243                      (long) reloc->r_offset);
12244             value = 0;
12245             return TRUE;
12246
12247           case 0x43: /* R_RL78_ABS16.  */
12248             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12249               byte_put (start + reloc->r_offset, value, 2);
12250             else
12251               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12252                      (long) reloc->r_offset);
12253             value = 0;
12254             return TRUE;
12255
12256           default:
12257             break;
12258           }
12259         break;
12260       }
12261     }
12262
12263   return FALSE;
12264 }
12265
12266 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12267    DWARF debug sections.  This is a target specific test.  Note - we do not
12268    go through the whole including-target-headers-multiple-times route, (as
12269    we have already done with <elf/h8.h>) because this would become very
12270    messy and even then this function would have to contain target specific
12271    information (the names of the relocs instead of their numeric values).
12272    FIXME: This is not the correct way to solve this problem.  The proper way
12273    is to have target specific reloc sizing and typing functions created by
12274    the reloc-macros.h header, in the same way that it already creates the
12275    reloc naming functions.  */
12276
12277 static bfd_boolean
12278 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12279 {
12280   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12281   switch (filedata->file_header.e_machine)
12282     {
12283     case EM_386:
12284     case EM_IAMCU:
12285       return reloc_type == 1; /* R_386_32.  */
12286     case EM_68K:
12287       return reloc_type == 1; /* R_68K_32.  */
12288     case EM_860:
12289       return reloc_type == 1; /* R_860_32.  */
12290     case EM_960:
12291       return reloc_type == 2; /* R_960_32.  */
12292     case EM_AARCH64:
12293       return (reloc_type == 258
12294               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12295     case EM_ADAPTEVA_EPIPHANY:
12296       return reloc_type == 3;
12297     case EM_ALPHA:
12298       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12299     case EM_ARC:
12300       return reloc_type == 1; /* R_ARC_32.  */
12301     case EM_ARC_COMPACT:
12302     case EM_ARC_COMPACT2:
12303       return reloc_type == 4; /* R_ARC_32.  */
12304     case EM_ARM:
12305       return reloc_type == 2; /* R_ARM_ABS32 */
12306     case EM_AVR_OLD:
12307     case EM_AVR:
12308       return reloc_type == 1;
12309     case EM_BLACKFIN:
12310       return reloc_type == 0x12; /* R_byte4_data.  */
12311     case EM_CRIS:
12312       return reloc_type == 3; /* R_CRIS_32.  */
12313     case EM_CR16:
12314       return reloc_type == 3; /* R_CR16_NUM32.  */
12315     case EM_CRX:
12316       return reloc_type == 15; /* R_CRX_NUM32.  */
12317     case EM_CSKY:
12318       return reloc_type == 1; /* R_CKCORE_ADDR32.  */
12319     case EM_CYGNUS_FRV:
12320       return reloc_type == 1;
12321     case EM_CYGNUS_D10V:
12322     case EM_D10V:
12323       return reloc_type == 6; /* R_D10V_32.  */
12324     case EM_CYGNUS_D30V:
12325     case EM_D30V:
12326       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12327     case EM_DLX:
12328       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12329     case EM_CYGNUS_FR30:
12330     case EM_FR30:
12331       return reloc_type == 3; /* R_FR30_32.  */
12332     case EM_FT32:
12333       return reloc_type == 1; /* R_FT32_32.  */
12334     case EM_H8S:
12335     case EM_H8_300:
12336     case EM_H8_300H:
12337       return reloc_type == 1; /* R_H8_DIR32.  */
12338     case EM_IA_64:
12339       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12340               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12341               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12342               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12343     case EM_IP2K_OLD:
12344     case EM_IP2K:
12345       return reloc_type == 2; /* R_IP2K_32.  */
12346     case EM_IQ2000:
12347       return reloc_type == 2; /* R_IQ2000_32.  */
12348     case EM_LATTICEMICO32:
12349       return reloc_type == 3; /* R_LM32_32.  */
12350     case EM_M32C_OLD:
12351     case EM_M32C:
12352       return reloc_type == 3; /* R_M32C_32.  */
12353     case EM_M32R:
12354       return reloc_type == 34; /* R_M32R_32_RELA.  */
12355     case EM_68HC11:
12356     case EM_68HC12:
12357       return reloc_type == 6; /* R_M68HC11_32.  */
12358     case EM_S12Z:
12359       return reloc_type == 6; /* R_S12Z_EXT32.  */
12360     case EM_MCORE:
12361       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12362     case EM_CYGNUS_MEP:
12363       return reloc_type == 4; /* R_MEP_32.  */
12364     case EM_METAG:
12365       return reloc_type == 2; /* R_METAG_ADDR32.  */
12366     case EM_MICROBLAZE:
12367       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12368     case EM_MIPS:
12369       return reloc_type == 2; /* R_MIPS_32.  */
12370     case EM_MMIX:
12371       return reloc_type == 4; /* R_MMIX_32.  */
12372     case EM_CYGNUS_MN10200:
12373     case EM_MN10200:
12374       return reloc_type == 1; /* R_MN10200_32.  */
12375     case EM_CYGNUS_MN10300:
12376     case EM_MN10300:
12377       return reloc_type == 1; /* R_MN10300_32.  */
12378     case EM_MOXIE:
12379       return reloc_type == 1; /* R_MOXIE_32.  */
12380     case EM_MSP430_OLD:
12381     case EM_MSP430:
12382       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12383     case EM_MT:
12384       return reloc_type == 2; /* R_MT_32.  */
12385     case EM_NDS32:
12386       return reloc_type == 20; /* R_NDS32_RELA.  */
12387     case EM_ALTERA_NIOS2:
12388       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12389     case EM_NIOS32:
12390       return reloc_type == 1; /* R_NIOS_32.  */
12391     case EM_OR1K:
12392       return reloc_type == 1; /* R_OR1K_32.  */
12393     case EM_PARISC:
12394       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12395               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12396               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12397     case EM_PJ:
12398     case EM_PJ_OLD:
12399       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12400     case EM_PPC64:
12401       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12402     case EM_PPC:
12403       return reloc_type == 1; /* R_PPC_ADDR32.  */
12404     case EM_TI_PRU:
12405       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12406     case EM_RISCV:
12407       return reloc_type == 1; /* R_RISCV_32.  */
12408     case EM_RL78:
12409       return reloc_type == 1; /* R_RL78_DIR32.  */
12410     case EM_RX:
12411       return reloc_type == 1; /* R_RX_DIR32.  */
12412     case EM_S370:
12413       return reloc_type == 1; /* R_I370_ADDR31.  */
12414     case EM_S390_OLD:
12415     case EM_S390:
12416       return reloc_type == 4; /* R_S390_32.  */
12417     case EM_SCORE:
12418       return reloc_type == 8; /* R_SCORE_ABS32.  */
12419     case EM_SH:
12420       return reloc_type == 1; /* R_SH_DIR32.  */
12421     case EM_SPARC32PLUS:
12422     case EM_SPARCV9:
12423     case EM_SPARC:
12424       return reloc_type == 3 /* R_SPARC_32.  */
12425         || reloc_type == 23; /* R_SPARC_UA32.  */
12426     case EM_SPU:
12427       return reloc_type == 6; /* R_SPU_ADDR32 */
12428     case EM_TI_C6000:
12429       return reloc_type == 1; /* R_C6000_ABS32.  */
12430     case EM_TILEGX:
12431       return reloc_type == 2; /* R_TILEGX_32.  */
12432     case EM_TILEPRO:
12433       return reloc_type == 1; /* R_TILEPRO_32.  */
12434     case EM_CYGNUS_V850:
12435     case EM_V850:
12436       return reloc_type == 6; /* R_V850_ABS32.  */
12437     case EM_V800:
12438       return reloc_type == 0x33; /* R_V810_WORD.  */
12439     case EM_VAX:
12440       return reloc_type == 1; /* R_VAX_32.  */
12441     case EM_VISIUM:
12442       return reloc_type == 3;  /* R_VISIUM_32. */
12443     case EM_WEBASSEMBLY:
12444       return reloc_type == 1;  /* R_WASM32_32.  */
12445     case EM_X86_64:
12446     case EM_L1OM:
12447     case EM_K1OM:
12448       return reloc_type == 10; /* R_X86_64_32.  */
12449     case EM_XC16X:
12450     case EM_C166:
12451       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12452     case EM_XGATE:
12453       return reloc_type == 4; /* R_XGATE_32.  */
12454     case EM_XSTORMY16:
12455       return reloc_type == 1; /* R_XSTROMY16_32.  */
12456     case EM_XTENSA_OLD:
12457     case EM_XTENSA:
12458       return reloc_type == 1; /* R_XTENSA_32.  */
12459     default:
12460       {
12461         static unsigned int prev_warn = 0;
12462
12463         /* Avoid repeating the same warning multiple times.  */
12464         if (prev_warn != filedata->file_header.e_machine)
12465           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12466                  filedata->file_header.e_machine);
12467         prev_warn = filedata->file_header.e_machine;
12468         return FALSE;
12469       }
12470     }
12471 }
12472
12473 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12474    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12475
12476 static bfd_boolean
12477 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12478 {
12479   switch (filedata->file_header.e_machine)
12480   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12481     {
12482     case EM_386:
12483     case EM_IAMCU:
12484       return reloc_type == 2;  /* R_386_PC32.  */
12485     case EM_68K:
12486       return reloc_type == 4;  /* R_68K_PC32.  */
12487     case EM_AARCH64:
12488       return reloc_type == 261; /* R_AARCH64_PREL32 */
12489     case EM_ADAPTEVA_EPIPHANY:
12490       return reloc_type == 6;
12491     case EM_ALPHA:
12492       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12493     case EM_ARC_COMPACT:
12494     case EM_ARC_COMPACT2:
12495       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12496     case EM_ARM:
12497       return reloc_type == 3;  /* R_ARM_REL32 */
12498     case EM_AVR_OLD:
12499     case EM_AVR:
12500       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12501     case EM_MICROBLAZE:
12502       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12503     case EM_OR1K:
12504       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12505     case EM_PARISC:
12506       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12507     case EM_PPC:
12508       return reloc_type == 26; /* R_PPC_REL32.  */
12509     case EM_PPC64:
12510       return reloc_type == 26; /* R_PPC64_REL32.  */
12511     case EM_S390_OLD:
12512     case EM_S390:
12513       return reloc_type == 5;  /* R_390_PC32.  */
12514     case EM_SH:
12515       return reloc_type == 2;  /* R_SH_REL32.  */
12516     case EM_SPARC32PLUS:
12517     case EM_SPARCV9:
12518     case EM_SPARC:
12519       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12520     case EM_SPU:
12521       return reloc_type == 13; /* R_SPU_REL32.  */
12522     case EM_TILEGX:
12523       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12524     case EM_TILEPRO:
12525       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12526     case EM_VISIUM:
12527       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12528     case EM_X86_64:
12529     case EM_L1OM:
12530     case EM_K1OM:
12531       return reloc_type == 2;  /* R_X86_64_PC32.  */
12532     case EM_XTENSA_OLD:
12533     case EM_XTENSA:
12534       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12535     default:
12536       /* Do not abort or issue an error message here.  Not all targets use
12537          pc-relative 32-bit relocs in their DWARF debug information and we
12538          have already tested for target coverage in is_32bit_abs_reloc.  A
12539          more helpful warning message will be generated by apply_relocations
12540          anyway, so just return.  */
12541       return FALSE;
12542     }
12543 }
12544
12545 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12546    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12547
12548 static bfd_boolean
12549 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12550 {
12551   switch (filedata->file_header.e_machine)
12552     {
12553     case EM_AARCH64:
12554       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12555     case EM_ALPHA:
12556       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12557     case EM_IA_64:
12558       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12559               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12560     case EM_PARISC:
12561       return reloc_type == 80; /* R_PARISC_DIR64.  */
12562     case EM_PPC64:
12563       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12564     case EM_RISCV:
12565       return reloc_type == 2; /* R_RISCV_64.  */
12566     case EM_SPARC32PLUS:
12567     case EM_SPARCV9:
12568     case EM_SPARC:
12569       return reloc_type == 32 /* R_SPARC_64.  */
12570         || reloc_type == 54; /* R_SPARC_UA64.  */
12571     case EM_X86_64:
12572     case EM_L1OM:
12573     case EM_K1OM:
12574       return reloc_type == 1; /* R_X86_64_64.  */
12575     case EM_S390_OLD:
12576     case EM_S390:
12577       return reloc_type == 22;  /* R_S390_64.  */
12578     case EM_TILEGX:
12579       return reloc_type == 1; /* R_TILEGX_64.  */
12580     case EM_MIPS:
12581       return reloc_type == 18;  /* R_MIPS_64.  */
12582     default:
12583       return FALSE;
12584     }
12585 }
12586
12587 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12588    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12589
12590 static bfd_boolean
12591 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12592 {
12593   switch (filedata->file_header.e_machine)
12594     {
12595     case EM_AARCH64:
12596       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12597     case EM_ALPHA:
12598       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12599     case EM_IA_64:
12600       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12601               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12602     case EM_PARISC:
12603       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12604     case EM_PPC64:
12605       return reloc_type == 44; /* R_PPC64_REL64.  */
12606     case EM_SPARC32PLUS:
12607     case EM_SPARCV9:
12608     case EM_SPARC:
12609       return reloc_type == 46; /* R_SPARC_DISP64.  */
12610     case EM_X86_64:
12611     case EM_L1OM:
12612     case EM_K1OM:
12613       return reloc_type == 24; /* R_X86_64_PC64.  */
12614     case EM_S390_OLD:
12615     case EM_S390:
12616       return reloc_type == 23;  /* R_S390_PC64.  */
12617     case EM_TILEGX:
12618       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12619     default:
12620       return FALSE;
12621     }
12622 }
12623
12624 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12625    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12626
12627 static bfd_boolean
12628 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12629 {
12630   switch (filedata->file_header.e_machine)
12631     {
12632     case EM_CYGNUS_MN10200:
12633     case EM_MN10200:
12634       return reloc_type == 4; /* R_MN10200_24.  */
12635     case EM_FT32:
12636       return reloc_type == 5; /* R_FT32_20.  */
12637     default:
12638       return FALSE;
12639     }
12640 }
12641
12642 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12643    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12644
12645 static bfd_boolean
12646 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12647 {
12648   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12649   switch (filedata->file_header.e_machine)
12650     {
12651     case EM_ARC:
12652     case EM_ARC_COMPACT:
12653     case EM_ARC_COMPACT2:
12654       return reloc_type == 2; /* R_ARC_16.  */
12655     case EM_ADAPTEVA_EPIPHANY:
12656       return reloc_type == 5;
12657     case EM_AVR_OLD:
12658     case EM_AVR:
12659       return reloc_type == 4; /* R_AVR_16.  */
12660     case EM_CYGNUS_D10V:
12661     case EM_D10V:
12662       return reloc_type == 3; /* R_D10V_16.  */
12663     case EM_FT32:
12664       return reloc_type == 2; /* R_FT32_16.  */
12665     case EM_H8S:
12666     case EM_H8_300:
12667     case EM_H8_300H:
12668       return reloc_type == R_H8_DIR16;
12669     case EM_IP2K_OLD:
12670     case EM_IP2K:
12671       return reloc_type == 1; /* R_IP2K_16.  */
12672     case EM_M32C_OLD:
12673     case EM_M32C:
12674       return reloc_type == 1; /* R_M32C_16 */
12675     case EM_CYGNUS_MN10200:
12676     case EM_MN10200:
12677       return reloc_type == 2; /* R_MN10200_16.  */
12678     case EM_CYGNUS_MN10300:
12679     case EM_MN10300:
12680       return reloc_type == 2; /* R_MN10300_16.  */
12681     case EM_MSP430:
12682       if (uses_msp430x_relocs (filedata))
12683         return reloc_type == 2; /* R_MSP430_ABS16.  */
12684       /* Fall through.  */
12685     case EM_MSP430_OLD:
12686       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12687     case EM_NDS32:
12688       return reloc_type == 19; /* R_NDS32_RELA.  */
12689     case EM_ALTERA_NIOS2:
12690       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12691     case EM_NIOS32:
12692       return reloc_type == 9; /* R_NIOS_16.  */
12693     case EM_OR1K:
12694       return reloc_type == 2; /* R_OR1K_16.  */
12695     case EM_RISCV:
12696       return reloc_type == 55; /* R_RISCV_SET16.  */
12697     case EM_TI_PRU:
12698       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12699     case EM_TI_C6000:
12700       return reloc_type == 2; /* R_C6000_ABS16.  */
12701     case EM_VISIUM:
12702       return reloc_type == 2; /* R_VISIUM_16. */
12703     case EM_XC16X:
12704     case EM_C166:
12705       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12706     case EM_XGATE:
12707       return reloc_type == 3; /* R_XGATE_16.  */
12708     default:
12709       return FALSE;
12710     }
12711 }
12712
12713 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12714    a 8-bit absolute RELA relocation used in DWARF debug sections.  */
12715
12716 static bfd_boolean
12717 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12718 {
12719   switch (filedata->file_header.e_machine)
12720     {
12721     case EM_RISCV:
12722       return reloc_type == 54; /* R_RISCV_SET8.  */
12723     default:
12724       return FALSE;
12725     }
12726 }
12727
12728 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12729    a 6-bit absolute RELA relocation used in DWARF debug sections.  */
12730
12731 static bfd_boolean
12732 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12733 {
12734   switch (filedata->file_header.e_machine)
12735     {
12736     case EM_RISCV:
12737       return reloc_type == 53; /* R_RISCV_SET6.  */
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 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12745
12746 static bfd_boolean
12747 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12748 {
12749   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12750   switch (filedata->file_header.e_machine)
12751     {
12752     case EM_RISCV:
12753       return reloc_type == 35; /* R_RISCV_ADD32.  */
12754     default:
12755       return FALSE;
12756     }
12757 }
12758
12759 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12760    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12761
12762 static bfd_boolean
12763 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12764 {
12765   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12766   switch (filedata->file_header.e_machine)
12767     {
12768     case EM_RISCV:
12769       return reloc_type == 39; /* R_RISCV_SUB32.  */
12770     default:
12771       return FALSE;
12772     }
12773 }
12774
12775 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12776    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12777
12778 static bfd_boolean
12779 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12780 {
12781   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12782   switch (filedata->file_header.e_machine)
12783     {
12784     case EM_RISCV:
12785       return reloc_type == 36; /* R_RISCV_ADD64.  */
12786     default:
12787       return FALSE;
12788     }
12789 }
12790
12791 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12792    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12793
12794 static bfd_boolean
12795 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12796 {
12797   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12798   switch (filedata->file_header.e_machine)
12799     {
12800     case EM_RISCV:
12801       return reloc_type == 40; /* R_RISCV_SUB64.  */
12802     default:
12803       return FALSE;
12804     }
12805 }
12806
12807 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12808    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12809
12810 static bfd_boolean
12811 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12812 {
12813   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12814   switch (filedata->file_header.e_machine)
12815     {
12816     case EM_RISCV:
12817       return reloc_type == 34; /* R_RISCV_ADD16.  */
12818     default:
12819       return FALSE;
12820     }
12821 }
12822
12823 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12824    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12825
12826 static bfd_boolean
12827 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12828 {
12829   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12830   switch (filedata->file_header.e_machine)
12831     {
12832     case EM_RISCV:
12833       return reloc_type == 38; /* R_RISCV_SUB16.  */
12834     default:
12835       return FALSE;
12836     }
12837 }
12838
12839 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12840    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12841
12842 static bfd_boolean
12843 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12844 {
12845   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12846   switch (filedata->file_header.e_machine)
12847     {
12848     case EM_RISCV:
12849       return reloc_type == 33; /* R_RISCV_ADD8.  */
12850     default:
12851       return FALSE;
12852     }
12853 }
12854
12855 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12856    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12857
12858 static bfd_boolean
12859 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12860 {
12861   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12862   switch (filedata->file_header.e_machine)
12863     {
12864     case EM_RISCV:
12865       return reloc_type == 37; /* R_RISCV_SUB8.  */
12866     default:
12867       return FALSE;
12868     }
12869 }
12870
12871 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12872    a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
12873
12874 static bfd_boolean
12875 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12876 {
12877   switch (filedata->file_header.e_machine)
12878     {
12879     case EM_RISCV:
12880       return reloc_type == 52; /* R_RISCV_SUB6.  */
12881     default:
12882       return FALSE;
12883     }
12884 }
12885
12886 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12887    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12888
12889 static bfd_boolean
12890 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12891 {
12892   switch (filedata->file_header.e_machine)
12893     {
12894     case EM_386:     /* R_386_NONE.  */
12895     case EM_68K:     /* R_68K_NONE.  */
12896     case EM_ADAPTEVA_EPIPHANY:
12897     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12898     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12899     case EM_ARC:     /* R_ARC_NONE.  */
12900     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12901     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12902     case EM_ARM:     /* R_ARM_NONE.  */
12903     case EM_C166:    /* R_XC16X_NONE.  */
12904     case EM_CRIS:    /* R_CRIS_NONE.  */
12905     case EM_FT32:    /* R_FT32_NONE.  */
12906     case EM_IA_64:   /* R_IA64_NONE.  */
12907     case EM_K1OM:    /* R_X86_64_NONE.  */
12908     case EM_L1OM:    /* R_X86_64_NONE.  */
12909     case EM_M32R:    /* R_M32R_NONE.  */
12910     case EM_MIPS:    /* R_MIPS_NONE.  */
12911     case EM_MN10300: /* R_MN10300_NONE.  */
12912     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12913     case EM_NIOS32:  /* R_NIOS_NONE.  */
12914     case EM_OR1K:    /* R_OR1K_NONE. */
12915     case EM_PARISC:  /* R_PARISC_NONE.  */
12916     case EM_PPC64:   /* R_PPC64_NONE.  */
12917     case EM_PPC:     /* R_PPC_NONE.  */
12918     case EM_RISCV:   /* R_RISCV_NONE.  */
12919     case EM_S390:    /* R_390_NONE.  */
12920     case EM_S390_OLD:
12921     case EM_SH:      /* R_SH_NONE.  */
12922     case EM_SPARC32PLUS:
12923     case EM_SPARC:   /* R_SPARC_NONE.  */
12924     case EM_SPARCV9:
12925     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12926     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12927     case EM_TI_C6000:/* R_C6000_NONE.  */
12928     case EM_X86_64:  /* R_X86_64_NONE.  */
12929     case EM_XC16X:
12930     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12931       return reloc_type == 0;
12932
12933     case EM_AARCH64:
12934       return reloc_type == 0 || reloc_type == 256;
12935     case EM_AVR_OLD:
12936     case EM_AVR:
12937       return (reloc_type == 0 /* R_AVR_NONE.  */
12938               || reloc_type == 30 /* R_AVR_DIFF8.  */
12939               || reloc_type == 31 /* R_AVR_DIFF16.  */
12940               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12941     case EM_METAG:
12942       return reloc_type == 3; /* R_METAG_NONE.  */
12943     case EM_NDS32:
12944       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12945               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12946               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12947               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12948               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12949     case EM_TI_PRU:
12950       return (reloc_type == 0       /* R_PRU_NONE.  */
12951               || reloc_type == 65   /* R_PRU_DIFF8.  */
12952               || reloc_type == 66   /* R_PRU_DIFF16.  */
12953               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12954     case EM_XTENSA_OLD:
12955     case EM_XTENSA:
12956       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12957               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12958               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12959               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12960     }
12961   return FALSE;
12962 }
12963
12964 /* Returns TRUE if there is a relocation against
12965    section NAME at OFFSET bytes.  */
12966
12967 bfd_boolean
12968 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12969 {
12970   Elf_Internal_Rela * relocs;
12971   Elf_Internal_Rela * rp;
12972
12973   if (dsec == NULL || dsec->reloc_info == NULL)
12974     return FALSE;
12975
12976   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12977
12978   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12979     if (rp->r_offset == offset)
12980       return TRUE;
12981
12982    return FALSE;
12983 }
12984
12985 /* Apply relocations to a section.
12986    Returns TRUE upon success, FALSE otherwise.
12987    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12988    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12989    will be set to the number of relocs loaded.
12990
12991    Note: So far support has been added only for those relocations
12992    which can be found in debug sections. FIXME: Add support for
12993    more relocations ?  */
12994
12995 static bfd_boolean
12996 apply_relocations (Filedata *                 filedata,
12997                    const Elf_Internal_Shdr *  section,
12998                    unsigned char *            start,
12999                    bfd_size_type              size,
13000                    void **                    relocs_return,
13001                    unsigned long *            num_relocs_return)
13002 {
13003   Elf_Internal_Shdr * relsec;
13004   unsigned char * end = start + size;
13005   bfd_boolean res = TRUE;
13006
13007   if (relocs_return != NULL)
13008     {
13009       * (Elf_Internal_Rela **) relocs_return = NULL;
13010       * num_relocs_return = 0;
13011     }
13012
13013   if (filedata->file_header.e_type != ET_REL)
13014     /* No relocs to apply.  */
13015     return TRUE;
13016
13017   /* Find the reloc section associated with the section.  */
13018   for (relsec = filedata->section_headers;
13019        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13020        ++relsec)
13021     {
13022       bfd_boolean is_rela;
13023       unsigned long num_relocs;
13024       Elf_Internal_Rela * relocs;
13025       Elf_Internal_Rela * rp;
13026       Elf_Internal_Shdr * symsec;
13027       Elf_Internal_Sym * symtab;
13028       unsigned long num_syms;
13029       Elf_Internal_Sym * sym;
13030
13031       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13032           || relsec->sh_info >= filedata->file_header.e_shnum
13033           || filedata->section_headers + relsec->sh_info != section
13034           || relsec->sh_size == 0
13035           || relsec->sh_link >= filedata->file_header.e_shnum)
13036         continue;
13037
13038       is_rela = relsec->sh_type == SHT_RELA;
13039
13040       if (is_rela)
13041         {
13042           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13043                                   relsec->sh_size, & relocs, & num_relocs))
13044             return FALSE;
13045         }
13046       else
13047         {
13048           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13049                                  relsec->sh_size, & relocs, & num_relocs))
13050             return FALSE;
13051         }
13052
13053       /* SH uses RELA but uses in place value instead of the addend field.  */
13054       if (filedata->file_header.e_machine == EM_SH)
13055         is_rela = FALSE;
13056
13057       symsec = filedata->section_headers + relsec->sh_link;
13058       if (symsec->sh_type != SHT_SYMTAB
13059           && symsec->sh_type != SHT_DYNSYM)
13060         return FALSE;
13061       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13062
13063       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13064         {
13065           bfd_vma         addend;
13066           unsigned int    reloc_type;
13067           unsigned int    reloc_size;
13068           bfd_boolean     reloc_inplace = FALSE;
13069           bfd_boolean     reloc_subtract = FALSE;
13070           unsigned char * rloc;
13071           unsigned long   sym_index;
13072
13073           reloc_type = get_reloc_type (filedata, rp->r_info);
13074
13075           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13076             continue;
13077           else if (is_none_reloc (filedata, reloc_type))
13078             continue;
13079           else if (is_32bit_abs_reloc (filedata, reloc_type)
13080                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13081             reloc_size = 4;
13082           else if (is_64bit_abs_reloc (filedata, reloc_type)
13083                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13084             reloc_size = 8;
13085           else if (is_24bit_abs_reloc (filedata, reloc_type))
13086             reloc_size = 3;
13087           else if (is_16bit_abs_reloc (filedata, reloc_type))
13088             reloc_size = 2;
13089           else if (is_8bit_abs_reloc (filedata, reloc_type)
13090                    || is_6bit_abs_reloc (filedata, reloc_type))
13091             reloc_size = 1;
13092           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13093                                                                  reloc_type))
13094                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13095             {
13096               reloc_size = 4;
13097               reloc_inplace = TRUE;
13098             }
13099           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13100                                                                  reloc_type))
13101                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13102             {
13103               reloc_size = 8;
13104               reloc_inplace = TRUE;
13105             }
13106           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13107                                                                  reloc_type))
13108                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13109             {
13110               reloc_size = 2;
13111               reloc_inplace = TRUE;
13112             }
13113           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13114                                                                 reloc_type))
13115                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13116             {
13117               reloc_size = 1;
13118               reloc_inplace = TRUE;
13119             }
13120           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13121                                                                 reloc_type)))
13122             {
13123               reloc_size = 1;
13124               reloc_inplace = TRUE;
13125             }
13126           else
13127             {
13128               static unsigned int prev_reloc = 0;
13129
13130               if (reloc_type != prev_reloc)
13131                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13132                       reloc_type, printable_section_name (filedata, section));
13133               prev_reloc = reloc_type;
13134               res = FALSE;
13135               continue;
13136             }
13137
13138           rloc = start + rp->r_offset;
13139           if ((rloc + reloc_size) > end || (rloc < start))
13140             {
13141               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13142                     (unsigned long) rp->r_offset,
13143                     printable_section_name (filedata, section));
13144               res = FALSE;
13145               continue;
13146             }
13147
13148           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13149           if (sym_index >= num_syms)
13150             {
13151               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13152                     sym_index, printable_section_name (filedata, section));
13153               res = FALSE;
13154               continue;
13155             }
13156           sym = symtab + sym_index;
13157
13158           /* If the reloc has a symbol associated with it,
13159              make sure that it is of an appropriate type.
13160
13161              Relocations against symbols without type can happen.
13162              Gcc -feliminate-dwarf2-dups may generate symbols
13163              without type for debug info.
13164
13165              Icc generates relocations against function symbols
13166              instead of local labels.
13167
13168              Relocations against object symbols can happen, eg when
13169              referencing a global array.  For an example of this see
13170              the _clz.o binary in libgcc.a.  */
13171           if (sym != symtab
13172               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13173               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13174             {
13175               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13176                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13177                     printable_section_name (filedata, relsec),
13178                     (long int)(rp - relocs));
13179               res = FALSE;
13180               continue;
13181             }
13182
13183           addend = 0;
13184           if (is_rela)
13185             addend += rp->r_addend;
13186           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13187              partial_inplace.  */
13188           if (!is_rela
13189               || (filedata->file_header.e_machine == EM_XTENSA
13190                   && reloc_type == 1)
13191               || ((filedata->file_header.e_machine == EM_PJ
13192                    || filedata->file_header.e_machine == EM_PJ_OLD)
13193                   && reloc_type == 1)
13194               || ((filedata->file_header.e_machine == EM_D30V
13195                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13196                   && reloc_type == 12)
13197               || reloc_inplace)
13198             {
13199               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13200                 addend += byte_get (rloc, reloc_size) & 0x3f;
13201               else
13202                 addend += byte_get (rloc, reloc_size);
13203             }
13204
13205           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13206               || is_64bit_pcrel_reloc (filedata, reloc_type))
13207             {
13208               /* On HPPA, all pc-relative relocations are biased by 8.  */
13209               if (filedata->file_header.e_machine == EM_PARISC)
13210                 addend -= 8;
13211               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13212                         reloc_size);
13213             }
13214           else if (is_6bit_abs_reloc (filedata, reloc_type)
13215                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13216             {
13217               if (reloc_subtract)
13218                 addend -= sym->st_value;
13219               else
13220                 addend += sym->st_value;
13221               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13222               byte_put (rloc, addend, reloc_size);
13223             }
13224           else if (reloc_subtract)
13225             byte_put (rloc, addend - sym->st_value, reloc_size);
13226           else
13227             byte_put (rloc, addend + sym->st_value, reloc_size);
13228         }
13229
13230       free (symtab);
13231       /* Let the target specific reloc processing code know that
13232          we have finished with these relocs.  */
13233       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13234
13235       if (relocs_return)
13236         {
13237           * (Elf_Internal_Rela **) relocs_return = relocs;
13238           * num_relocs_return = num_relocs;
13239         }
13240       else
13241         free (relocs);
13242
13243       break;
13244     }
13245
13246   return res;
13247 }
13248
13249 #ifdef SUPPORT_DISASSEMBLY
13250 static bfd_boolean
13251 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13252 {
13253   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13254
13255   /* FIXME: XXX -- to be done --- XXX */
13256
13257   return TRUE;
13258 }
13259 #endif
13260
13261 /* Reads in the contents of SECTION from FILE, returning a pointer
13262    to a malloc'ed buffer or NULL if something went wrong.  */
13263
13264 static char *
13265 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13266 {
13267   bfd_size_type num_bytes = section->sh_size;
13268
13269   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13270     {
13271       printf (_("Section '%s' has no data to dump.\n"),
13272               printable_section_name (filedata, section));
13273       return NULL;
13274     }
13275
13276   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13277                              _("section contents"));
13278 }
13279
13280 /* Uncompresses a section that was compressed using zlib, in place.  */
13281
13282 static bfd_boolean
13283 uncompress_section_contents (unsigned char **   buffer,
13284                              dwarf_size_type    uncompressed_size,
13285                              dwarf_size_type *  size)
13286 {
13287   dwarf_size_type compressed_size = *size;
13288   unsigned char * compressed_buffer = *buffer;
13289   unsigned char * uncompressed_buffer;
13290   z_stream strm;
13291   int rc;
13292
13293   /* It is possible the section consists of several compressed
13294      buffers concatenated together, so we uncompress in a loop.  */
13295   /* PR 18313: The state field in the z_stream structure is supposed
13296      to be invisible to the user (ie us), but some compilers will
13297      still complain about it being used without initialisation.  So
13298      we first zero the entire z_stream structure and then set the fields
13299      that we need.  */
13300   memset (& strm, 0, sizeof strm);
13301   strm.avail_in = compressed_size;
13302   strm.next_in = (Bytef *) compressed_buffer;
13303   strm.avail_out = uncompressed_size;
13304   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13305
13306   rc = inflateInit (& strm);
13307   while (strm.avail_in > 0)
13308     {
13309       if (rc != Z_OK)
13310         goto fail;
13311       strm.next_out = ((Bytef *) uncompressed_buffer
13312                        + (uncompressed_size - strm.avail_out));
13313       rc = inflate (&strm, Z_FINISH);
13314       if (rc != Z_STREAM_END)
13315         goto fail;
13316       rc = inflateReset (& strm);
13317     }
13318   rc = inflateEnd (& strm);
13319   if (rc != Z_OK
13320       || strm.avail_out != 0)
13321     goto fail;
13322
13323   *buffer = uncompressed_buffer;
13324   *size = uncompressed_size;
13325   return TRUE;
13326
13327  fail:
13328   free (uncompressed_buffer);
13329   /* Indicate decompression failure.  */
13330   *buffer = NULL;
13331   return FALSE;
13332 }
13333
13334 static bfd_boolean
13335 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13336 {
13337   Elf_Internal_Shdr *  relsec;
13338   bfd_size_type        num_bytes;
13339   unsigned char *      data;
13340   unsigned char *      end;
13341   unsigned char *      real_start;
13342   unsigned char *      start;
13343   bfd_boolean          some_strings_shown;
13344
13345   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13346   if (start == NULL)
13347     /* PR 21820: Do not fail if the section was empty.  */
13348     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13349
13350   num_bytes = section->sh_size;
13351
13352   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13353
13354   if (decompress_dumps)
13355     {
13356       dwarf_size_type new_size = num_bytes;
13357       dwarf_size_type uncompressed_size = 0;
13358
13359       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13360         {
13361           Elf_Internal_Chdr chdr;
13362           unsigned int compression_header_size
13363             = get_compression_header (& chdr, (unsigned char *) start,
13364                                       num_bytes);
13365
13366           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13367             {
13368               warn (_("section '%s' has unsupported compress type: %d\n"),
13369                     printable_section_name (filedata, section), chdr.ch_type);
13370               return FALSE;
13371             }
13372           else if (chdr.ch_addralign != section->sh_addralign)
13373             {
13374               warn (_("compressed section '%s' is corrupted\n"),
13375                     printable_section_name (filedata, section));
13376               return FALSE;
13377             }
13378           uncompressed_size = chdr.ch_size;
13379           start += compression_header_size;
13380           new_size -= compression_header_size;
13381         }
13382       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13383         {
13384           /* Read the zlib header.  In this case, it should be "ZLIB"
13385              followed by the uncompressed section size, 8 bytes in
13386              big-endian order.  */
13387           uncompressed_size = start[4]; uncompressed_size <<= 8;
13388           uncompressed_size += start[5]; uncompressed_size <<= 8;
13389           uncompressed_size += start[6]; uncompressed_size <<= 8;
13390           uncompressed_size += start[7]; uncompressed_size <<= 8;
13391           uncompressed_size += start[8]; uncompressed_size <<= 8;
13392           uncompressed_size += start[9]; uncompressed_size <<= 8;
13393           uncompressed_size += start[10]; uncompressed_size <<= 8;
13394           uncompressed_size += start[11];
13395           start += 12;
13396           new_size -= 12;
13397         }
13398
13399       if (uncompressed_size)
13400         {
13401           if (uncompress_section_contents (& start,
13402                                            uncompressed_size, & new_size))
13403             num_bytes = new_size;
13404           else
13405             {
13406               error (_("Unable to decompress section %s\n"),
13407                      printable_section_name (filedata, section));
13408               return FALSE;
13409             }
13410         }
13411       else
13412         start = real_start;
13413     }
13414
13415   /* If the section being dumped has relocations against it the user might
13416      be expecting these relocations to have been applied.  Check for this
13417      case and issue a warning message in order to avoid confusion.
13418      FIXME: Maybe we ought to have an option that dumps a section with
13419      relocs applied ?  */
13420   for (relsec = filedata->section_headers;
13421        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13422        ++relsec)
13423     {
13424       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13425           || relsec->sh_info >= filedata->file_header.e_shnum
13426           || filedata->section_headers + relsec->sh_info != section
13427           || relsec->sh_size == 0
13428           || relsec->sh_link >= filedata->file_header.e_shnum)
13429         continue;
13430
13431       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13432       break;
13433     }
13434
13435   data = start;
13436   end  = start + num_bytes;
13437   some_strings_shown = FALSE;
13438
13439   while (data < end)
13440     {
13441       while (!ISPRINT (* data))
13442         if (++ data >= end)
13443           break;
13444
13445       if (data < end)
13446         {
13447           size_t maxlen = end - data;
13448
13449 #ifndef __MSVCRT__
13450           /* PR 11128: Use two separate invocations in order to work
13451              around bugs in the Solaris 8 implementation of printf.  */
13452           printf ("  [%6tx]  ", data - start);
13453 #else
13454           printf ("  [%6Ix]  ", (size_t) (data - start));
13455 #endif
13456           if (maxlen > 0)
13457             {
13458               print_symbol ((int) maxlen, (const char *) data);
13459               putchar ('\n');
13460               data += strnlen ((const char *) data, maxlen);
13461             }
13462           else
13463             {
13464               printf (_("<corrupt>\n"));
13465               data = end;
13466             }
13467           some_strings_shown = TRUE;
13468         }
13469     }
13470
13471   if (! some_strings_shown)
13472     printf (_("  No strings found in this section."));
13473
13474   free (real_start);
13475
13476   putchar ('\n');
13477   return TRUE;
13478 }
13479
13480 static bfd_boolean
13481 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13482                        Filedata *           filedata,
13483                        bfd_boolean          relocate)
13484 {
13485   Elf_Internal_Shdr * relsec;
13486   bfd_size_type       bytes;
13487   bfd_size_type       section_size;
13488   bfd_vma             addr;
13489   unsigned char *     data;
13490   unsigned char *     real_start;
13491   unsigned char *     start;
13492
13493   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13494   if (start == NULL)
13495     /* PR 21820: Do not fail if the section was empty.  */
13496     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13497
13498   section_size = section->sh_size;
13499
13500   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13501
13502   if (decompress_dumps)
13503     {
13504       dwarf_size_type new_size = section_size;
13505       dwarf_size_type uncompressed_size = 0;
13506
13507       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13508         {
13509           Elf_Internal_Chdr chdr;
13510           unsigned int compression_header_size
13511             = get_compression_header (& chdr, start, section_size);
13512
13513           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13514             {
13515               warn (_("section '%s' has unsupported compress type: %d\n"),
13516                     printable_section_name (filedata, section), chdr.ch_type);
13517               return FALSE;
13518             }
13519           else if (chdr.ch_addralign != section->sh_addralign)
13520             {
13521               warn (_("compressed section '%s' is corrupted\n"),
13522                     printable_section_name (filedata, section));
13523               return FALSE;
13524             }
13525           uncompressed_size = chdr.ch_size;
13526           start += compression_header_size;
13527           new_size -= compression_header_size;
13528         }
13529       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13530         {
13531           /* Read the zlib header.  In this case, it should be "ZLIB"
13532              followed by the uncompressed section size, 8 bytes in
13533              big-endian order.  */
13534           uncompressed_size = start[4]; uncompressed_size <<= 8;
13535           uncompressed_size += start[5]; uncompressed_size <<= 8;
13536           uncompressed_size += start[6]; uncompressed_size <<= 8;
13537           uncompressed_size += start[7]; uncompressed_size <<= 8;
13538           uncompressed_size += start[8]; uncompressed_size <<= 8;
13539           uncompressed_size += start[9]; uncompressed_size <<= 8;
13540           uncompressed_size += start[10]; uncompressed_size <<= 8;
13541           uncompressed_size += start[11];
13542           start += 12;
13543           new_size -= 12;
13544         }
13545
13546       if (uncompressed_size)
13547         {
13548           if (uncompress_section_contents (& start, uncompressed_size,
13549                                            & new_size))
13550             {
13551               section_size = new_size;
13552             }
13553           else
13554             {
13555               error (_("Unable to decompress section %s\n"),
13556                      printable_section_name (filedata, section));
13557               /* FIXME: Print the section anyway ?  */
13558               return FALSE;
13559             }
13560         }
13561       else
13562         start = real_start;
13563     }
13564
13565   if (relocate)
13566     {
13567       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13568         return FALSE;
13569     }
13570   else
13571     {
13572       /* If the section being dumped has relocations against it the user might
13573          be expecting these relocations to have been applied.  Check for this
13574          case and issue a warning message in order to avoid confusion.
13575          FIXME: Maybe we ought to have an option that dumps a section with
13576          relocs applied ?  */
13577       for (relsec = filedata->section_headers;
13578            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13579            ++relsec)
13580         {
13581           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13582               || relsec->sh_info >= filedata->file_header.e_shnum
13583               || filedata->section_headers + relsec->sh_info != section
13584               || relsec->sh_size == 0
13585               || relsec->sh_link >= filedata->file_header.e_shnum)
13586             continue;
13587
13588           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13589           break;
13590         }
13591     }
13592
13593   addr = section->sh_addr;
13594   bytes = section_size;
13595   data = start;
13596
13597   while (bytes)
13598     {
13599       int j;
13600       int k;
13601       int lbytes;
13602
13603       lbytes = (bytes > 16 ? 16 : bytes);
13604
13605       printf ("  0x%8.8lx ", (unsigned long) addr);
13606
13607       for (j = 0; j < 16; j++)
13608         {
13609           if (j < lbytes)
13610             printf ("%2.2x", data[j]);
13611           else
13612             printf ("  ");
13613
13614           if ((j & 3) == 3)
13615             printf (" ");
13616         }
13617
13618       for (j = 0; j < lbytes; j++)
13619         {
13620           k = data[j];
13621           if (k >= ' ' && k < 0x7f)
13622             printf ("%c", k);
13623           else
13624             printf (".");
13625         }
13626
13627       putchar ('\n');
13628
13629       data  += lbytes;
13630       addr  += lbytes;
13631       bytes -= lbytes;
13632     }
13633
13634   free (real_start);
13635
13636   putchar ('\n');
13637   return TRUE;
13638 }
13639
13640 static bfd_boolean
13641 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13642                              const Elf_Internal_Shdr *        sec,
13643                              void *                           data)
13644 {
13645   struct dwarf_section * section = &debug_displays [debug].section;
13646   char buf [64];
13647   Filedata * filedata = (Filedata *) data;
13648
13649   if (section->start != NULL)
13650     {
13651       /* If it is already loaded, do nothing.  */
13652       if (streq (section->filename, filedata->file_name))
13653         return TRUE;
13654       free (section->start);
13655     }
13656
13657   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13658   section->address = sec->sh_addr;
13659   section->user_data = NULL;
13660   section->filename = filedata->file_name;
13661   section->start = (unsigned char *) get_data (NULL, filedata,
13662                                                sec->sh_offset, 1,
13663                                                sec->sh_size, buf);
13664   if (section->start == NULL)
13665     section->size = 0;
13666   else
13667     {
13668       unsigned char *start = section->start;
13669       dwarf_size_type size = sec->sh_size;
13670       dwarf_size_type uncompressed_size = 0;
13671
13672       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13673         {
13674           Elf_Internal_Chdr chdr;
13675           unsigned int compression_header_size;
13676
13677           if (size < (is_32bit_elf
13678                       ? sizeof (Elf32_External_Chdr)
13679                       : sizeof (Elf64_External_Chdr)))
13680             {
13681               warn (_("compressed section %s is too small to contain a compression header"),
13682                     section->name);
13683               return FALSE;
13684             }
13685
13686           compression_header_size = get_compression_header (&chdr, start, size);
13687
13688           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13689             {
13690               warn (_("section '%s' has unsupported compress type: %d\n"),
13691                     section->name, chdr.ch_type);
13692               return FALSE;
13693             }
13694           else if (chdr.ch_addralign != sec->sh_addralign)
13695             {
13696               warn (_("compressed section '%s' is corrupted\n"),
13697                     section->name);
13698               return FALSE;
13699             }
13700           uncompressed_size = chdr.ch_size;
13701           start += compression_header_size;
13702           size -= compression_header_size;
13703         }
13704       else if (size > 12 && streq ((char *) start, "ZLIB"))
13705         {
13706           /* Read the zlib header.  In this case, it should be "ZLIB"
13707              followed by the uncompressed section size, 8 bytes in
13708              big-endian order.  */
13709           uncompressed_size = start[4]; uncompressed_size <<= 8;
13710           uncompressed_size += start[5]; uncompressed_size <<= 8;
13711           uncompressed_size += start[6]; uncompressed_size <<= 8;
13712           uncompressed_size += start[7]; uncompressed_size <<= 8;
13713           uncompressed_size += start[8]; uncompressed_size <<= 8;
13714           uncompressed_size += start[9]; uncompressed_size <<= 8;
13715           uncompressed_size += start[10]; uncompressed_size <<= 8;
13716           uncompressed_size += start[11];
13717           start += 12;
13718           size -= 12;
13719         }
13720
13721       if (uncompressed_size)
13722         {
13723           if (uncompress_section_contents (&start, uncompressed_size,
13724                                            &size))
13725             {
13726               /* Free the compressed buffer, update the section buffer
13727                  and the section size if uncompress is successful.  */
13728               free (section->start);
13729               section->start = start;
13730             }
13731           else
13732             {
13733               error (_("Unable to decompress section %s\n"),
13734                      printable_section_name (filedata, sec));
13735               return FALSE;
13736             }
13737         }
13738
13739       section->size = size;
13740     }
13741
13742   if (section->start == NULL)
13743     return FALSE;
13744
13745   if (debug_displays [debug].relocate)
13746     {
13747       if (! apply_relocations (filedata, sec, section->start, section->size,
13748                                & section->reloc_info, & section->num_relocs))
13749         return FALSE;
13750     }
13751   else
13752     {
13753       section->reloc_info = NULL;
13754       section->num_relocs = 0;
13755     }
13756
13757   return TRUE;
13758 }
13759
13760 /* If this is not NULL, load_debug_section will only look for sections
13761    within the list of sections given here.  */
13762 static unsigned int * section_subset = NULL;
13763
13764 bfd_boolean
13765 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13766 {
13767   struct dwarf_section * section = &debug_displays [debug].section;
13768   Elf_Internal_Shdr * sec;
13769   Filedata * filedata = (Filedata *) data;
13770
13771   /* Without section headers we cannot find any sections.  */
13772   if (filedata->section_headers == NULL)
13773     return FALSE;
13774
13775   if (filedata->string_table == NULL
13776       && filedata->file_header.e_shstrndx != SHN_UNDEF
13777       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13778     {
13779       Elf_Internal_Shdr * strs;
13780
13781       /* Read in the string table, so that we have section names to scan.  */
13782       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13783
13784       if (strs != NULL && strs->sh_size != 0)
13785         {
13786           filedata->string_table
13787             = (char *) get_data (NULL, filedata, strs->sh_offset,
13788                                  1, strs->sh_size, _("string table"));
13789
13790           filedata->string_table_length
13791             = filedata->string_table != NULL ? strs->sh_size : 0;
13792         }
13793     }
13794
13795   /* Locate the debug section.  */
13796   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13797   if (sec != NULL)
13798     section->name = section->uncompressed_name;
13799   else
13800     {
13801       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13802       if (sec != NULL)
13803         section->name = section->compressed_name;
13804     }
13805   if (sec == NULL)
13806     return FALSE;
13807
13808   /* If we're loading from a subset of sections, and we've loaded
13809      a section matching this name before, it's likely that it's a
13810      different one.  */
13811   if (section_subset != NULL)
13812     free_debug_section (debug);
13813
13814   return load_specific_debug_section (debug, sec, data);
13815 }
13816
13817 void
13818 free_debug_section (enum dwarf_section_display_enum debug)
13819 {
13820   struct dwarf_section * section = &debug_displays [debug].section;
13821
13822   if (section->start == NULL)
13823     return;
13824
13825   free ((char *) section->start);
13826   section->start = NULL;
13827   section->address = 0;
13828   section->size = 0;
13829 }
13830
13831 static bfd_boolean
13832 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13833 {
13834   char * name = SECTION_NAME (section);
13835   const char * print_name = printable_section_name (filedata, section);
13836   bfd_size_type length;
13837   bfd_boolean result = TRUE;
13838   int i;
13839
13840   length = section->sh_size;
13841   if (length == 0)
13842     {
13843       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13844       return TRUE;
13845     }
13846   if (section->sh_type == SHT_NOBITS)
13847     {
13848       /* There is no point in dumping the contents of a debugging section
13849          which has the NOBITS type - the bits in the file will be random.
13850          This can happen when a file containing a .eh_frame section is
13851          stripped with the --only-keep-debug command line option.  */
13852       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13853               print_name);
13854       return FALSE;
13855     }
13856
13857   if (const_strneq (name, ".gnu.linkonce.wi."))
13858     name = ".debug_info";
13859
13860   /* See if we know how to display the contents of this section.  */
13861   for (i = 0; i < max; i++)
13862     {
13863       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13864       struct dwarf_section_display *   display = debug_displays + i;
13865       struct dwarf_section *           sec = & display->section;
13866
13867       if (streq (sec->uncompressed_name, name)
13868           || (id == line && const_strneq (name, ".debug_line."))
13869           || streq (sec->compressed_name, name))
13870         {
13871           bfd_boolean secondary = (section != find_section (filedata, name));
13872
13873           if (secondary)
13874             free_debug_section (id);
13875
13876           if (i == line && const_strneq (name, ".debug_line."))
13877             sec->name = name;
13878           else if (streq (sec->uncompressed_name, name))
13879             sec->name = sec->uncompressed_name;
13880           else
13881             sec->name = sec->compressed_name;
13882
13883           if (load_specific_debug_section (id, section, filedata))
13884             {
13885               /* If this debug section is part of a CU/TU set in a .dwp file,
13886                  restrict load_debug_section to the sections in that set.  */
13887               section_subset = find_cu_tu_set (filedata, shndx);
13888
13889               result &= display->display (sec, filedata);
13890
13891               section_subset = NULL;
13892
13893               if (secondary || (id != info && id != abbrev))
13894                 free_debug_section (id);
13895             }
13896           break;
13897         }
13898     }
13899
13900   if (i == max)
13901     {
13902       printf (_("Unrecognized debug section: %s\n"), print_name);
13903       result = FALSE;
13904     }
13905
13906   return result;
13907 }
13908
13909 /* Set DUMP_SECTS for all sections where dumps were requested
13910    based on section name.  */
13911
13912 static void
13913 initialise_dumps_byname (Filedata * filedata)
13914 {
13915   struct dump_list_entry * cur;
13916
13917   for (cur = dump_sects_byname; cur; cur = cur->next)
13918     {
13919       unsigned int i;
13920       bfd_boolean any = FALSE;
13921
13922       for (i = 0; i < filedata->file_header.e_shnum; i++)
13923         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13924           {
13925             request_dump_bynumber (filedata, i, cur->type);
13926             any = TRUE;
13927           }
13928
13929       if (!any)
13930         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13931               cur->name);
13932     }
13933 }
13934
13935 static bfd_boolean
13936 process_section_contents (Filedata * filedata)
13937 {
13938   Elf_Internal_Shdr * section;
13939   unsigned int i;
13940   bfd_boolean res = TRUE;
13941
13942   if (! do_dump)
13943     return TRUE;
13944
13945   initialise_dumps_byname (filedata);
13946
13947   for (i = 0, section = filedata->section_headers;
13948        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13949        i++, section++)
13950     {
13951       dump_type dump = filedata->dump_sects[i];
13952
13953 #ifdef SUPPORT_DISASSEMBLY
13954       if (dump & DISASS_DUMP)
13955         {
13956           if (! disassemble_section (section, filedata))
13957             res = FALSE;
13958         }
13959 #endif
13960       if (dump & HEX_DUMP)
13961         {
13962           if (! dump_section_as_bytes (section, filedata, FALSE))
13963             res = FALSE;
13964         }
13965
13966       if (dump & RELOC_DUMP)
13967         {
13968           if (! dump_section_as_bytes (section, filedata, TRUE))
13969             res = FALSE;
13970         }
13971
13972       if (dump & STRING_DUMP)
13973         {
13974           if (! dump_section_as_strings (section, filedata))
13975             res = FALSE;
13976         }
13977
13978       if (dump & DEBUG_DUMP)
13979         {
13980           if (! display_debug_section (i, section, filedata))
13981             res = FALSE;
13982         }
13983     }
13984
13985   /* Check to see if the user requested a
13986      dump of a section that does not exist.  */
13987   while (i < filedata->num_dump_sects)
13988     {
13989       if (filedata->dump_sects[i])
13990         {
13991           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13992           res = FALSE;
13993         }
13994       i++;
13995     }
13996
13997   return res;
13998 }
13999
14000 static void
14001 process_mips_fpe_exception (int mask)
14002 {
14003   if (mask)
14004     {
14005       bfd_boolean first = TRUE;
14006
14007       if (mask & OEX_FPU_INEX)
14008         fputs ("INEX", stdout), first = FALSE;
14009       if (mask & OEX_FPU_UFLO)
14010         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14011       if (mask & OEX_FPU_OFLO)
14012         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14013       if (mask & OEX_FPU_DIV0)
14014         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14015       if (mask & OEX_FPU_INVAL)
14016         printf ("%sINVAL", first ? "" : "|");
14017     }
14018   else
14019     fputs ("0", stdout);
14020 }
14021
14022 /* Display's the value of TAG at location P.  If TAG is
14023    greater than 0 it is assumed to be an unknown tag, and
14024    a message is printed to this effect.  Otherwise it is
14025    assumed that a message has already been printed.
14026
14027    If the bottom bit of TAG is set it assumed to have a
14028    string value, otherwise it is assumed to have an integer
14029    value.
14030
14031    Returns an updated P pointing to the first unread byte
14032    beyond the end of TAG's value.
14033
14034    Reads at or beyond END will not be made.  */
14035
14036 static unsigned char *
14037 display_tag_value (signed int tag,
14038                    unsigned char * p,
14039                    const unsigned char * const end)
14040 {
14041   unsigned long val;
14042
14043   if (tag > 0)
14044     printf ("  Tag_unknown_%d: ", tag);
14045
14046   if (p >= end)
14047     {
14048       warn (_("<corrupt tag>\n"));
14049     }
14050   else if (tag & 1)
14051     {
14052       /* PR 17531 file: 027-19978-0.004.  */
14053       size_t maxlen = (end - p) - 1;
14054
14055       putchar ('"');
14056       if (maxlen > 0)
14057         {
14058           print_symbol ((int) maxlen, (const char *) p);
14059           p += strnlen ((char *) p, maxlen) + 1;
14060         }
14061       else
14062         {
14063           printf (_("<corrupt string tag>"));
14064           p = (unsigned char *) end;
14065         }
14066       printf ("\"\n");
14067     }
14068   else
14069     {
14070       unsigned int len;
14071
14072       val = read_uleb128 (p, &len, end);
14073       p += len;
14074       printf ("%ld (0x%lx)\n", val, val);
14075     }
14076
14077   assert (p <= end);
14078   return p;
14079 }
14080
14081 /* ARC ABI attributes section.  */
14082
14083 static unsigned char *
14084 display_arc_attribute (unsigned char * p,
14085                        const unsigned char * const end)
14086 {
14087   unsigned int tag;
14088   unsigned int len;
14089   unsigned int val;
14090
14091   tag = read_uleb128 (p, &len, end);
14092   p += len;
14093
14094   switch (tag)
14095     {
14096     case Tag_ARC_PCS_config:
14097       val = read_uleb128 (p, &len, end);
14098       p += len;
14099       printf ("  Tag_ARC_PCS_config: ");
14100       switch (val)
14101         {
14102         case 0:
14103           printf (_("Absent/Non standard\n"));
14104           break;
14105         case 1:
14106           printf (_("Bare metal/mwdt\n"));
14107           break;
14108         case 2:
14109           printf (_("Bare metal/newlib\n"));
14110           break;
14111         case 3:
14112           printf (_("Linux/uclibc\n"));
14113           break;
14114         case 4:
14115           printf (_("Linux/glibc\n"));
14116           break;
14117         default:
14118           printf (_("Unknown\n"));
14119           break;
14120         }
14121       break;
14122
14123     case Tag_ARC_CPU_base:
14124       val = read_uleb128 (p, &len, end);
14125       p += len;
14126       printf ("  Tag_ARC_CPU_base: ");
14127       switch (val)
14128         {
14129         default:
14130         case TAG_CPU_NONE:
14131           printf (_("Absent\n"));
14132           break;
14133         case TAG_CPU_ARC6xx:
14134           printf ("ARC6xx\n");
14135           break;
14136         case TAG_CPU_ARC7xx:
14137           printf ("ARC7xx\n");
14138           break;
14139         case TAG_CPU_ARCEM:
14140           printf ("ARCEM\n");
14141           break;
14142         case TAG_CPU_ARCHS:
14143           printf ("ARCHS\n");
14144           break;
14145         }
14146       break;
14147
14148     case Tag_ARC_CPU_variation:
14149       val = read_uleb128 (p, &len, end);
14150       p += len;
14151       printf ("  Tag_ARC_CPU_variation: ");
14152       switch (val)
14153         {
14154         default:
14155           if (val > 0 && val < 16)
14156               printf ("Core%d\n", val);
14157           else
14158               printf ("Unknown\n");
14159           break;
14160
14161         case 0:
14162           printf (_("Absent\n"));
14163           break;
14164         }
14165       break;
14166
14167     case Tag_ARC_CPU_name:
14168       printf ("  Tag_ARC_CPU_name: ");
14169       p = display_tag_value (-1, p, end);
14170       break;
14171
14172     case Tag_ARC_ABI_rf16:
14173       val = read_uleb128 (p, &len, end);
14174       p += len;
14175       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14176       break;
14177
14178     case Tag_ARC_ABI_osver:
14179       val = read_uleb128 (p, &len, end);
14180       p += len;
14181       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14182       break;
14183
14184     case Tag_ARC_ABI_pic:
14185     case Tag_ARC_ABI_sda:
14186       val = read_uleb128 (p, &len, end);
14187       p += len;
14188       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14189               : "  Tag_ARC_ABI_pic: ");
14190       switch (val)
14191         {
14192         case 0:
14193           printf (_("Absent\n"));
14194           break;
14195         case 1:
14196           printf ("MWDT\n");
14197           break;
14198         case 2:
14199           printf ("GNU\n");
14200           break;
14201         default:
14202           printf (_("Unknown\n"));
14203           break;
14204         }
14205       break;
14206
14207     case Tag_ARC_ABI_tls:
14208       val = read_uleb128 (p, &len, end);
14209       p += len;
14210       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14211       break;
14212
14213     case Tag_ARC_ABI_enumsize:
14214       val = read_uleb128 (p, &len, end);
14215       p += len;
14216       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14217               _("smallest"));
14218       break;
14219
14220     case Tag_ARC_ABI_exceptions:
14221       val = read_uleb128 (p, &len, end);
14222       p += len;
14223       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14224               : _("default"));
14225       break;
14226
14227     case Tag_ARC_ABI_double_size:
14228       val = read_uleb128 (p, &len, end);
14229       p += len;
14230       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14231       break;
14232
14233     case Tag_ARC_ISA_config:
14234       printf ("  Tag_ARC_ISA_config: ");
14235       p = display_tag_value (-1, p, end);
14236       break;
14237
14238     case Tag_ARC_ISA_apex:
14239       printf ("  Tag_ARC_ISA_apex: ");
14240       p = display_tag_value (-1, p, end);
14241       break;
14242
14243     case Tag_ARC_ISA_mpy_option:
14244       val = read_uleb128 (p, &len, end);
14245       p += len;
14246       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14247       break;
14248
14249     default:
14250       return display_tag_value (tag & 1, p, end);
14251     }
14252
14253   return p;
14254 }
14255
14256 /* ARM EABI attributes section.  */
14257 typedef struct
14258 {
14259   unsigned int tag;
14260   const char * name;
14261   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14262   unsigned int type;
14263   const char ** table;
14264 } arm_attr_public_tag;
14265
14266 static const char * arm_attr_tag_CPU_arch[] =
14267   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14268    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14269    "v8-M.mainline"};
14270 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14271 static const char * arm_attr_tag_THUMB_ISA_use[] =
14272   {"No", "Thumb-1", "Thumb-2", "Yes"};
14273 static const char * arm_attr_tag_FP_arch[] =
14274   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14275    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14276 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14277 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14278   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14279    "NEON for ARMv8.1"};
14280 static const char * arm_attr_tag_PCS_config[] =
14281   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14282    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14283 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14284   {"V6", "SB", "TLS", "Unused"};
14285 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14286   {"Absolute", "PC-relative", "SB-relative", "None"};
14287 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14288   {"Absolute", "PC-relative", "None"};
14289 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14290   {"None", "direct", "GOT-indirect"};
14291 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14292   {"None", "??? 1", "2", "??? 3", "4"};
14293 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14294 static const char * arm_attr_tag_ABI_FP_denormal[] =
14295   {"Unused", "Needed", "Sign only"};
14296 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14297 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14298 static const char * arm_attr_tag_ABI_FP_number_model[] =
14299   {"Unused", "Finite", "RTABI", "IEEE 754"};
14300 static const char * arm_attr_tag_ABI_enum_size[] =
14301   {"Unused", "small", "int", "forced to int"};
14302 static const char * arm_attr_tag_ABI_HardFP_use[] =
14303   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14304 static const char * arm_attr_tag_ABI_VFP_args[] =
14305   {"AAPCS", "VFP registers", "custom", "compatible"};
14306 static const char * arm_attr_tag_ABI_WMMX_args[] =
14307   {"AAPCS", "WMMX registers", "custom"};
14308 static const char * arm_attr_tag_ABI_optimization_goals[] =
14309   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14310     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14311 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14312   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14313     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14314 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14315 static const char * arm_attr_tag_FP_HP_extension[] =
14316   {"Not Allowed", "Allowed"};
14317 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14318   {"None", "IEEE 754", "Alternative Format"};
14319 static const char * arm_attr_tag_DSP_extension[] =
14320   {"Follow architecture", "Allowed"};
14321 static const char * arm_attr_tag_MPextension_use[] =
14322   {"Not Allowed", "Allowed"};
14323 static const char * arm_attr_tag_DIV_use[] =
14324   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14325     "Allowed in v7-A with integer division extension"};
14326 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14327 static const char * arm_attr_tag_Virtualization_use[] =
14328   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14329     "TrustZone and Virtualization Extensions"};
14330 static const char * arm_attr_tag_MPextension_use_legacy[] =
14331   {"Not Allowed", "Allowed"};
14332
14333 #define LOOKUP(id, name) \
14334   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14335 static arm_attr_public_tag arm_attr_public_tags[] =
14336 {
14337   {4, "CPU_raw_name", 1, NULL},
14338   {5, "CPU_name", 1, NULL},
14339   LOOKUP(6, CPU_arch),
14340   {7, "CPU_arch_profile", 0, NULL},
14341   LOOKUP(8, ARM_ISA_use),
14342   LOOKUP(9, THUMB_ISA_use),
14343   LOOKUP(10, FP_arch),
14344   LOOKUP(11, WMMX_arch),
14345   LOOKUP(12, Advanced_SIMD_arch),
14346   LOOKUP(13, PCS_config),
14347   LOOKUP(14, ABI_PCS_R9_use),
14348   LOOKUP(15, ABI_PCS_RW_data),
14349   LOOKUP(16, ABI_PCS_RO_data),
14350   LOOKUP(17, ABI_PCS_GOT_use),
14351   LOOKUP(18, ABI_PCS_wchar_t),
14352   LOOKUP(19, ABI_FP_rounding),
14353   LOOKUP(20, ABI_FP_denormal),
14354   LOOKUP(21, ABI_FP_exceptions),
14355   LOOKUP(22, ABI_FP_user_exceptions),
14356   LOOKUP(23, ABI_FP_number_model),
14357   {24, "ABI_align_needed", 0, NULL},
14358   {25, "ABI_align_preserved", 0, NULL},
14359   LOOKUP(26, ABI_enum_size),
14360   LOOKUP(27, ABI_HardFP_use),
14361   LOOKUP(28, ABI_VFP_args),
14362   LOOKUP(29, ABI_WMMX_args),
14363   LOOKUP(30, ABI_optimization_goals),
14364   LOOKUP(31, ABI_FP_optimization_goals),
14365   {32, "compatibility", 0, NULL},
14366   LOOKUP(34, CPU_unaligned_access),
14367   LOOKUP(36, FP_HP_extension),
14368   LOOKUP(38, ABI_FP_16bit_format),
14369   LOOKUP(42, MPextension_use),
14370   LOOKUP(44, DIV_use),
14371   LOOKUP(46, DSP_extension),
14372   {64, "nodefaults", 0, NULL},
14373   {65, "also_compatible_with", 0, NULL},
14374   LOOKUP(66, T2EE_use),
14375   {67, "conformance", 1, NULL},
14376   LOOKUP(68, Virtualization_use),
14377   LOOKUP(70, MPextension_use_legacy)
14378 };
14379 #undef LOOKUP
14380
14381 static unsigned char *
14382 display_arm_attribute (unsigned char * p,
14383                        const unsigned char * const end)
14384 {
14385   unsigned int tag;
14386   unsigned int len;
14387   unsigned int val;
14388   arm_attr_public_tag * attr;
14389   unsigned i;
14390   unsigned int type;
14391
14392   tag = read_uleb128 (p, &len, end);
14393   p += len;
14394   attr = NULL;
14395   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14396     {
14397       if (arm_attr_public_tags[i].tag == tag)
14398         {
14399           attr = &arm_attr_public_tags[i];
14400           break;
14401         }
14402     }
14403
14404   if (attr)
14405     {
14406       printf ("  Tag_%s: ", attr->name);
14407       switch (attr->type)
14408         {
14409         case 0:
14410           switch (tag)
14411             {
14412             case 7: /* Tag_CPU_arch_profile.  */
14413               val = read_uleb128 (p, &len, end);
14414               p += len;
14415               switch (val)
14416                 {
14417                 case 0: printf (_("None\n")); break;
14418                 case 'A': printf (_("Application\n")); break;
14419                 case 'R': printf (_("Realtime\n")); break;
14420                 case 'M': printf (_("Microcontroller\n")); break;
14421                 case 'S': printf (_("Application or Realtime\n")); break;
14422                 default: printf ("??? (%d)\n", val); break;
14423                 }
14424               break;
14425
14426             case 24: /* Tag_align_needed.  */
14427               val = read_uleb128 (p, &len, end);
14428               p += len;
14429               switch (val)
14430                 {
14431                 case 0: printf (_("None\n")); break;
14432                 case 1: printf (_("8-byte\n")); break;
14433                 case 2: printf (_("4-byte\n")); break;
14434                 case 3: printf ("??? 3\n"); break;
14435                 default:
14436                   if (val <= 12)
14437                     printf (_("8-byte and up to %d-byte extended\n"),
14438                             1 << val);
14439                   else
14440                     printf ("??? (%d)\n", val);
14441                   break;
14442                 }
14443               break;
14444
14445             case 25: /* Tag_align_preserved.  */
14446               val = read_uleb128 (p, &len, end);
14447               p += len;
14448               switch (val)
14449                 {
14450                 case 0: printf (_("None\n")); break;
14451                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14452                 case 2: printf (_("8-byte\n")); break;
14453                 case 3: printf ("??? 3\n"); break;
14454                 default:
14455                   if (val <= 12)
14456                     printf (_("8-byte and up to %d-byte extended\n"),
14457                             1 << val);
14458                   else
14459                     printf ("??? (%d)\n", val);
14460                   break;
14461                 }
14462               break;
14463
14464             case 32: /* Tag_compatibility.  */
14465               {
14466                 val = read_uleb128 (p, &len, end);
14467                 p += len;
14468                 printf (_("flag = %d, vendor = "), val);
14469                 if (p < end - 1)
14470                   {
14471                     size_t maxlen = (end - p) - 1;
14472
14473                     print_symbol ((int) maxlen, (const char *) p);
14474                     p += strnlen ((char *) p, maxlen) + 1;
14475                   }
14476                 else
14477                   {
14478                     printf (_("<corrupt>"));
14479                     p = (unsigned char *) end;
14480                   }
14481                 putchar ('\n');
14482               }
14483               break;
14484
14485             case 64: /* Tag_nodefaults.  */
14486               /* PR 17531: file: 001-505008-0.01.  */
14487               if (p < end)
14488                 p++;
14489               printf (_("True\n"));
14490               break;
14491
14492             case 65: /* Tag_also_compatible_with.  */
14493               val = read_uleb128 (p, &len, end);
14494               p += len;
14495               if (val == 6 /* Tag_CPU_arch.  */)
14496                 {
14497                   val = read_uleb128 (p, &len, end);
14498                   p += len;
14499                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14500                     printf ("??? (%d)\n", val);
14501                   else
14502                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14503                 }
14504               else
14505                 printf ("???\n");
14506               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14507                 ;
14508               break;
14509
14510             default:
14511               printf (_("<unknown: %d>\n"), tag);
14512               break;
14513             }
14514           return p;
14515
14516         case 1:
14517           return display_tag_value (-1, p, end);
14518         case 2:
14519           return display_tag_value (0, p, end);
14520
14521         default:
14522           assert (attr->type & 0x80);
14523           val = read_uleb128 (p, &len, end);
14524           p += len;
14525           type = attr->type & 0x7f;
14526           if (val >= type)
14527             printf ("??? (%d)\n", val);
14528           else
14529             printf ("%s\n", attr->table[val]);
14530           return p;
14531         }
14532     }
14533
14534   return display_tag_value (tag, p, end);
14535 }
14536
14537 static unsigned char *
14538 display_gnu_attribute (unsigned char * p,
14539                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14540                        const unsigned char * const end)
14541 {
14542   int tag;
14543   unsigned int len;
14544   unsigned int val;
14545
14546   tag = read_uleb128 (p, &len, end);
14547   p += len;
14548
14549   /* Tag_compatibility is the only generic GNU attribute defined at
14550      present.  */
14551   if (tag == 32)
14552     {
14553       val = read_uleb128 (p, &len, end);
14554       p += len;
14555
14556       printf (_("flag = %d, vendor = "), val);
14557       if (p == end)
14558         {
14559           printf (_("<corrupt>\n"));
14560           warn (_("corrupt vendor attribute\n"));
14561         }
14562       else
14563         {
14564           if (p < end - 1)
14565             {
14566               size_t maxlen = (end - p) - 1;
14567
14568               print_symbol ((int) maxlen, (const char *) p);
14569               p += strnlen ((char *) p, maxlen) + 1;
14570             }
14571           else
14572             {
14573               printf (_("<corrupt>"));
14574               p = (unsigned char *) end;
14575             }
14576           putchar ('\n');
14577         }
14578       return p;
14579     }
14580
14581   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14582     return display_proc_gnu_attribute (p, tag, end);
14583
14584   return display_tag_value (tag, p, end);
14585 }
14586
14587 static unsigned char *
14588 display_power_gnu_attribute (unsigned char * p,
14589                              unsigned int tag,
14590                              const unsigned char * const end)
14591 {
14592   unsigned int len;
14593   unsigned int val;
14594
14595   if (tag == Tag_GNU_Power_ABI_FP)
14596     {
14597       val = read_uleb128 (p, &len, end);
14598       p += len;
14599       printf ("  Tag_GNU_Power_ABI_FP: ");
14600       if (len == 0)
14601         {
14602           printf (_("<corrupt>\n"));
14603           return p;
14604         }
14605
14606       if (val > 15)
14607         printf ("(%#x), ", val);
14608
14609       switch (val & 3)
14610         {
14611         case 0:
14612           printf (_("unspecified hard/soft float, "));
14613           break;
14614         case 1:
14615           printf (_("hard float, "));
14616           break;
14617         case 2:
14618           printf (_("soft float, "));
14619           break;
14620         case 3:
14621           printf (_("single-precision hard float, "));
14622           break;
14623         }
14624
14625       switch (val & 0xC)
14626         {
14627         case 0:
14628           printf (_("unspecified long double\n"));
14629           break;
14630         case 4:
14631           printf (_("128-bit IBM long double\n"));
14632           break;
14633         case 8:
14634           printf (_("64-bit long double\n"));
14635           break;
14636         case 12:
14637           printf (_("128-bit IEEE long double\n"));
14638           break;
14639         }
14640       return p;
14641     }
14642
14643   if (tag == Tag_GNU_Power_ABI_Vector)
14644     {
14645       val = read_uleb128 (p, &len, end);
14646       p += len;
14647       printf ("  Tag_GNU_Power_ABI_Vector: ");
14648       if (len == 0)
14649         {
14650           printf (_("<corrupt>\n"));
14651           return p;
14652         }
14653
14654       if (val > 3)
14655         printf ("(%#x), ", val);
14656
14657       switch (val & 3)
14658         {
14659         case 0:
14660           printf (_("unspecified\n"));
14661           break;
14662         case 1:
14663           printf (_("generic\n"));
14664           break;
14665         case 2:
14666           printf ("AltiVec\n");
14667           break;
14668         case 3:
14669           printf ("SPE\n");
14670           break;
14671         }
14672       return p;
14673     }
14674
14675   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14676     {
14677       val = read_uleb128 (p, &len, end);
14678       p += len;
14679       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14680       if (len == 0)
14681         {
14682           printf (_("<corrupt>\n"));
14683           return p;
14684         }
14685
14686       if (val > 2)
14687         printf ("(%#x), ", val);
14688
14689       switch (val & 3)
14690         {
14691         case 0:
14692           printf (_("unspecified\n"));
14693           break;
14694         case 1:
14695           printf ("r3/r4\n");
14696           break;
14697         case 2:
14698           printf (_("memory\n"));
14699           break;
14700         case 3:
14701           printf ("???\n");
14702           break;
14703         }
14704       return p;
14705     }
14706
14707   return display_tag_value (tag & 1, p, end);
14708 }
14709
14710 static unsigned char *
14711 display_s390_gnu_attribute (unsigned char * p,
14712                             unsigned int tag,
14713                             const unsigned char * const end)
14714 {
14715   unsigned int len;
14716   int val;
14717
14718   if (tag == Tag_GNU_S390_ABI_Vector)
14719     {
14720       val = read_uleb128 (p, &len, end);
14721       p += len;
14722       printf ("  Tag_GNU_S390_ABI_Vector: ");
14723
14724       switch (val)
14725         {
14726         case 0:
14727           printf (_("any\n"));
14728           break;
14729         case 1:
14730           printf (_("software\n"));
14731           break;
14732         case 2:
14733           printf (_("hardware\n"));
14734           break;
14735         default:
14736           printf ("??? (%d)\n", val);
14737           break;
14738         }
14739       return p;
14740    }
14741
14742   return display_tag_value (tag & 1, p, end);
14743 }
14744
14745 static void
14746 display_sparc_hwcaps (unsigned int mask)
14747 {
14748   if (mask)
14749     {
14750       bfd_boolean first = TRUE;
14751
14752       if (mask & ELF_SPARC_HWCAP_MUL32)
14753         fputs ("mul32", stdout), first = FALSE;
14754       if (mask & ELF_SPARC_HWCAP_DIV32)
14755         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14756       if (mask & ELF_SPARC_HWCAP_FSMULD)
14757         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14758       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14759         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14760       if (mask & ELF_SPARC_HWCAP_POPC)
14761         printf ("%spopc", first ? "" : "|"), first = FALSE;
14762       if (mask & ELF_SPARC_HWCAP_VIS)
14763         printf ("%svis", first ? "" : "|"), first = FALSE;
14764       if (mask & ELF_SPARC_HWCAP_VIS2)
14765         printf ("%svis2", first ? "" : "|"), first = FALSE;
14766       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14767         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14768       if (mask & ELF_SPARC_HWCAP_FMAF)
14769         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14770       if (mask & ELF_SPARC_HWCAP_VIS3)
14771         printf ("%svis3", first ? "" : "|"), first = FALSE;
14772       if (mask & ELF_SPARC_HWCAP_HPC)
14773         printf ("%shpc", first ? "" : "|"), first = FALSE;
14774       if (mask & ELF_SPARC_HWCAP_RANDOM)
14775         printf ("%srandom", first ? "" : "|"), first = FALSE;
14776       if (mask & ELF_SPARC_HWCAP_TRANS)
14777         printf ("%strans", first ? "" : "|"), first = FALSE;
14778       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14779         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14780       if (mask & ELF_SPARC_HWCAP_IMA)
14781         printf ("%sima", first ? "" : "|"), first = FALSE;
14782       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14783         printf ("%scspare", first ? "" : "|"), first = FALSE;
14784     }
14785   else
14786     fputc ('0', stdout);
14787   fputc ('\n', stdout);
14788 }
14789
14790 static void
14791 display_sparc_hwcaps2 (unsigned int mask)
14792 {
14793   if (mask)
14794     {
14795       bfd_boolean first = TRUE;
14796
14797       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14798         fputs ("fjathplus", stdout), first = FALSE;
14799       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14800         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14801       if (mask & ELF_SPARC_HWCAP2_ADP)
14802         printf ("%sadp", first ? "" : "|"), first = FALSE;
14803       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14804         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14805       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14806         printf ("%smwait", first ? "" : "|"), first = FALSE;
14807       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14808         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14809       if (mask & ELF_SPARC_HWCAP2_XMONT)
14810         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14811       if (mask & ELF_SPARC_HWCAP2_NSEC)
14812         printf ("%snsec", first ? "" : "|"), first = FALSE;
14813       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14814         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14815       if (mask & ELF_SPARC_HWCAP2_FJDES)
14816         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14817       if (mask & ELF_SPARC_HWCAP2_FJAES)
14818         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14819     }
14820   else
14821     fputc ('0', stdout);
14822   fputc ('\n', stdout);
14823 }
14824
14825 static unsigned char *
14826 display_sparc_gnu_attribute (unsigned char * p,
14827                              unsigned int tag,
14828                              const unsigned char * const end)
14829 {
14830   unsigned int len;
14831   int val;
14832
14833   if (tag == Tag_GNU_Sparc_HWCAPS)
14834     {
14835       val = read_uleb128 (p, &len, end);
14836       p += len;
14837       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14838       display_sparc_hwcaps (val);
14839       return p;
14840     }
14841   if (tag == Tag_GNU_Sparc_HWCAPS2)
14842     {
14843       val = read_uleb128 (p, &len, end);
14844       p += len;
14845       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14846       display_sparc_hwcaps2 (val);
14847       return p;
14848     }
14849
14850   return display_tag_value (tag, p, end);
14851 }
14852
14853 static void
14854 print_mips_fp_abi_value (unsigned int val)
14855 {
14856   switch (val)
14857     {
14858     case Val_GNU_MIPS_ABI_FP_ANY:
14859       printf (_("Hard or soft float\n"));
14860       break;
14861     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14862       printf (_("Hard float (double precision)\n"));
14863       break;
14864     case Val_GNU_MIPS_ABI_FP_SINGLE:
14865       printf (_("Hard float (single precision)\n"));
14866       break;
14867     case Val_GNU_MIPS_ABI_FP_SOFT:
14868       printf (_("Soft float\n"));
14869       break;
14870     case Val_GNU_MIPS_ABI_FP_OLD_64:
14871       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14872       break;
14873     case Val_GNU_MIPS_ABI_FP_XX:
14874       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14875       break;
14876     case Val_GNU_MIPS_ABI_FP_64:
14877       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14878       break;
14879     case Val_GNU_MIPS_ABI_FP_64A:
14880       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14881       break;
14882     case Val_GNU_MIPS_ABI_FP_NAN2008:
14883       printf (_("NaN 2008 compatibility\n"));
14884       break;
14885     default:
14886       printf ("??? (%d)\n", val);
14887       break;
14888     }
14889 }
14890
14891 static unsigned char *
14892 display_mips_gnu_attribute (unsigned char * p,
14893                             unsigned int tag,
14894                             const unsigned char * const end)
14895 {
14896   if (tag == Tag_GNU_MIPS_ABI_FP)
14897     {
14898       unsigned int len;
14899       unsigned int val;
14900
14901       val = read_uleb128 (p, &len, end);
14902       p += len;
14903       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14904
14905       print_mips_fp_abi_value (val);
14906
14907       return p;
14908    }
14909
14910   if (tag == Tag_GNU_MIPS_ABI_MSA)
14911     {
14912       unsigned int len;
14913       unsigned int val;
14914
14915       val = read_uleb128 (p, &len, end);
14916       p += len;
14917       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14918
14919       switch (val)
14920         {
14921         case Val_GNU_MIPS_ABI_MSA_ANY:
14922           printf (_("Any MSA or not\n"));
14923           break;
14924         case Val_GNU_MIPS_ABI_MSA_128:
14925           printf (_("128-bit MSA\n"));
14926           break;
14927         default:
14928           printf ("??? (%d)\n", val);
14929           break;
14930         }
14931       return p;
14932     }
14933
14934   return display_tag_value (tag & 1, p, end);
14935 }
14936
14937 static unsigned char *
14938 display_tic6x_attribute (unsigned char * p,
14939                          const unsigned char * const end)
14940 {
14941   unsigned int tag;
14942   unsigned int len;
14943   int val;
14944
14945   tag = read_uleb128 (p, &len, end);
14946   p += len;
14947
14948   switch (tag)
14949     {
14950     case Tag_ISA:
14951       val = read_uleb128 (p, &len, end);
14952       p += len;
14953       printf ("  Tag_ISA: ");
14954
14955       switch (val)
14956         {
14957         case C6XABI_Tag_ISA_none:
14958           printf (_("None\n"));
14959           break;
14960         case C6XABI_Tag_ISA_C62X:
14961           printf ("C62x\n");
14962           break;
14963         case C6XABI_Tag_ISA_C67X:
14964           printf ("C67x\n");
14965           break;
14966         case C6XABI_Tag_ISA_C67XP:
14967           printf ("C67x+\n");
14968           break;
14969         case C6XABI_Tag_ISA_C64X:
14970           printf ("C64x\n");
14971           break;
14972         case C6XABI_Tag_ISA_C64XP:
14973           printf ("C64x+\n");
14974           break;
14975         case C6XABI_Tag_ISA_C674X:
14976           printf ("C674x\n");
14977           break;
14978         default:
14979           printf ("??? (%d)\n", val);
14980           break;
14981         }
14982       return p;
14983
14984     case Tag_ABI_wchar_t:
14985       val = read_uleb128 (p, &len, end);
14986       p += len;
14987       printf ("  Tag_ABI_wchar_t: ");
14988       switch (val)
14989         {
14990         case 0:
14991           printf (_("Not used\n"));
14992           break;
14993         case 1:
14994           printf (_("2 bytes\n"));
14995           break;
14996         case 2:
14997           printf (_("4 bytes\n"));
14998           break;
14999         default:
15000           printf ("??? (%d)\n", val);
15001           break;
15002         }
15003       return p;
15004
15005     case Tag_ABI_stack_align_needed:
15006       val = read_uleb128 (p, &len, end);
15007       p += len;
15008       printf ("  Tag_ABI_stack_align_needed: ");
15009       switch (val)
15010         {
15011         case 0:
15012           printf (_("8-byte\n"));
15013           break;
15014         case 1:
15015           printf (_("16-byte\n"));
15016           break;
15017         default:
15018           printf ("??? (%d)\n", val);
15019           break;
15020         }
15021       return p;
15022
15023     case Tag_ABI_stack_align_preserved:
15024       val = read_uleb128 (p, &len, end);
15025       p += len;
15026       printf ("  Tag_ABI_stack_align_preserved: ");
15027       switch (val)
15028         {
15029         case 0:
15030           printf (_("8-byte\n"));
15031           break;
15032         case 1:
15033           printf (_("16-byte\n"));
15034           break;
15035         default:
15036           printf ("??? (%d)\n", val);
15037           break;
15038         }
15039       return p;
15040
15041     case Tag_ABI_DSBT:
15042       val = read_uleb128 (p, &len, end);
15043       p += len;
15044       printf ("  Tag_ABI_DSBT: ");
15045       switch (val)
15046         {
15047         case 0:
15048           printf (_("DSBT addressing not used\n"));
15049           break;
15050         case 1:
15051           printf (_("DSBT addressing used\n"));
15052           break;
15053         default:
15054           printf ("??? (%d)\n", val);
15055           break;
15056         }
15057       return p;
15058
15059     case Tag_ABI_PID:
15060       val = read_uleb128 (p, &len, end);
15061       p += len;
15062       printf ("  Tag_ABI_PID: ");
15063       switch (val)
15064         {
15065         case 0:
15066           printf (_("Data addressing position-dependent\n"));
15067           break;
15068         case 1:
15069           printf (_("Data addressing position-independent, GOT near DP\n"));
15070           break;
15071         case 2:
15072           printf (_("Data addressing position-independent, GOT far from DP\n"));
15073           break;
15074         default:
15075           printf ("??? (%d)\n", val);
15076           break;
15077         }
15078       return p;
15079
15080     case Tag_ABI_PIC:
15081       val = read_uleb128 (p, &len, end);
15082       p += len;
15083       printf ("  Tag_ABI_PIC: ");
15084       switch (val)
15085         {
15086         case 0:
15087           printf (_("Code addressing position-dependent\n"));
15088           break;
15089         case 1:
15090           printf (_("Code addressing position-independent\n"));
15091           break;
15092         default:
15093           printf ("??? (%d)\n", val);
15094           break;
15095         }
15096       return p;
15097
15098     case Tag_ABI_array_object_alignment:
15099       val = read_uleb128 (p, &len, end);
15100       p += len;
15101       printf ("  Tag_ABI_array_object_alignment: ");
15102       switch (val)
15103         {
15104         case 0:
15105           printf (_("8-byte\n"));
15106           break;
15107         case 1:
15108           printf (_("4-byte\n"));
15109           break;
15110         case 2:
15111           printf (_("16-byte\n"));
15112           break;
15113         default:
15114           printf ("??? (%d)\n", val);
15115           break;
15116         }
15117       return p;
15118
15119     case Tag_ABI_array_object_align_expected:
15120       val = read_uleb128 (p, &len, end);
15121       p += len;
15122       printf ("  Tag_ABI_array_object_align_expected: ");
15123       switch (val)
15124         {
15125         case 0:
15126           printf (_("8-byte\n"));
15127           break;
15128         case 1:
15129           printf (_("4-byte\n"));
15130           break;
15131         case 2:
15132           printf (_("16-byte\n"));
15133           break;
15134         default:
15135           printf ("??? (%d)\n", val);
15136           break;
15137         }
15138       return p;
15139
15140     case Tag_ABI_compatibility:
15141       {
15142         val = read_uleb128 (p, &len, end);
15143         p += len;
15144         printf ("  Tag_ABI_compatibility: ");
15145         printf (_("flag = %d, vendor = "), val);
15146         if (p < end - 1)
15147           {
15148             size_t maxlen = (end - p) - 1;
15149
15150             print_symbol ((int) maxlen, (const char *) p);
15151             p += strnlen ((char *) p, maxlen) + 1;
15152           }
15153         else
15154           {
15155             printf (_("<corrupt>"));
15156             p = (unsigned char *) end;
15157           }
15158         putchar ('\n');
15159         return p;
15160       }
15161
15162     case Tag_ABI_conformance:
15163       {
15164         printf ("  Tag_ABI_conformance: \"");
15165         if (p < end - 1)
15166           {
15167             size_t maxlen = (end - p) - 1;
15168
15169             print_symbol ((int) maxlen, (const char *) p);
15170             p += strnlen ((char *) p, maxlen) + 1;
15171           }
15172         else
15173           {
15174             printf (_("<corrupt>"));
15175             p = (unsigned char *) end;
15176           }
15177         printf ("\"\n");
15178         return p;
15179       }
15180     }
15181
15182   return display_tag_value (tag, p, end);
15183 }
15184
15185 static void
15186 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15187 {
15188   unsigned long addr = 0;
15189   size_t bytes = end - p;
15190
15191   assert (end > p);
15192   while (bytes)
15193     {
15194       int j;
15195       int k;
15196       int lbytes = (bytes > 16 ? 16 : bytes);
15197
15198       printf ("  0x%8.8lx ", addr);
15199
15200       for (j = 0; j < 16; j++)
15201         {
15202           if (j < lbytes)
15203             printf ("%2.2x", p[j]);
15204           else
15205             printf ("  ");
15206
15207           if ((j & 3) == 3)
15208             printf (" ");
15209         }
15210
15211       for (j = 0; j < lbytes; j++)
15212         {
15213           k = p[j];
15214           if (k >= ' ' && k < 0x7f)
15215             printf ("%c", k);
15216           else
15217             printf (".");
15218         }
15219
15220       putchar ('\n');
15221
15222       p  += lbytes;
15223       bytes -= lbytes;
15224       addr += lbytes;
15225     }
15226
15227   putchar ('\n');
15228 }
15229
15230 static unsigned char *
15231 display_msp430x_attribute (unsigned char * p,
15232                            const unsigned char * const end)
15233 {
15234   unsigned int len;
15235   unsigned int val;
15236   unsigned int tag;
15237
15238   tag = read_uleb128 (p, & len, end);
15239   p += len;
15240
15241   switch (tag)
15242     {
15243     case OFBA_MSPABI_Tag_ISA:
15244       val = read_uleb128 (p, &len, end);
15245       p += len;
15246       printf ("  Tag_ISA: ");
15247       switch (val)
15248         {
15249         case 0: printf (_("None\n")); break;
15250         case 1: printf (_("MSP430\n")); break;
15251         case 2: printf (_("MSP430X\n")); break;
15252         default: printf ("??? (%d)\n", val); break;
15253         }
15254       break;
15255
15256     case OFBA_MSPABI_Tag_Code_Model:
15257       val = read_uleb128 (p, &len, end);
15258       p += len;
15259       printf ("  Tag_Code_Model: ");
15260       switch (val)
15261         {
15262         case 0: printf (_("None\n")); break;
15263         case 1: printf (_("Small\n")); break;
15264         case 2: printf (_("Large\n")); break;
15265         default: printf ("??? (%d)\n", val); break;
15266         }
15267       break;
15268
15269     case OFBA_MSPABI_Tag_Data_Model:
15270       val = read_uleb128 (p, &len, end);
15271       p += len;
15272       printf ("  Tag_Data_Model: ");
15273       switch (val)
15274         {
15275         case 0: printf (_("None\n")); break;
15276         case 1: printf (_("Small\n")); break;
15277         case 2: printf (_("Large\n")); break;
15278         case 3: printf (_("Restricted Large\n")); break;
15279         default: printf ("??? (%d)\n", val); break;
15280         }
15281       break;
15282
15283     default:
15284       printf (_("  <unknown tag %d>: "), tag);
15285
15286       if (tag & 1)
15287         {
15288           putchar ('"');
15289           if (p < end - 1)
15290             {
15291               size_t maxlen = (end - p) - 1;
15292
15293               print_symbol ((int) maxlen, (const char *) p);
15294               p += strnlen ((char *) p, maxlen) + 1;
15295             }
15296           else
15297             {
15298               printf (_("<corrupt>"));
15299               p = (unsigned char *) end;
15300             }
15301           printf ("\"\n");
15302         }
15303       else
15304         {
15305           val = read_uleb128 (p, &len, end);
15306           p += len;
15307           printf ("%d (0x%x)\n", val, val);
15308         }
15309       break;
15310    }
15311
15312   assert (p <= end);
15313   return p;
15314 }
15315
15316 static bfd_boolean
15317 process_attributes (Filedata * filedata,
15318                     const char * public_name,
15319                     unsigned int proc_type,
15320                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15321                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15322 {
15323   Elf_Internal_Shdr * sect;
15324   unsigned i;
15325   bfd_boolean res = TRUE;
15326
15327   /* Find the section header so that we get the size.  */
15328   for (i = 0, sect = filedata->section_headers;
15329        i < filedata->file_header.e_shnum;
15330        i++, sect++)
15331     {
15332       unsigned char * contents;
15333       unsigned char * p;
15334
15335       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15336         continue;
15337
15338       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15339                                              sect->sh_size, _("attributes"));
15340       if (contents == NULL)
15341         {
15342           res = FALSE;
15343           continue;
15344         }
15345
15346       p = contents;
15347       /* The first character is the version of the attributes.
15348          Currently only version 1, (aka 'A') is recognised here.  */
15349       if (*p != 'A')
15350         {
15351           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15352           res = FALSE;
15353         }
15354       else
15355         {
15356           bfd_vma section_len;
15357
15358           section_len = sect->sh_size - 1;
15359           p++;
15360
15361           while (section_len > 0)
15362             {
15363               bfd_vma attr_len;
15364               unsigned int namelen;
15365               bfd_boolean public_section;
15366               bfd_boolean gnu_section;
15367
15368               if (section_len <= 4)
15369                 {
15370                   error (_("Tag section ends prematurely\n"));
15371                   res = FALSE;
15372                   break;
15373                 }
15374               attr_len = byte_get (p, 4);
15375               p += 4;
15376
15377               if (attr_len > section_len)
15378                 {
15379                   error (_("Bad attribute length (%u > %u)\n"),
15380                           (unsigned) attr_len, (unsigned) section_len);
15381                   attr_len = section_len;
15382                   res = FALSE;
15383                 }
15384               /* PR 17531: file: 001-101425-0.004  */
15385               else if (attr_len < 5)
15386                 {
15387                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15388                   res = FALSE;
15389                   break;
15390                 }
15391
15392               section_len -= attr_len;
15393               attr_len -= 4;
15394
15395               namelen = strnlen ((char *) p, attr_len) + 1;
15396               if (namelen == 0 || namelen >= attr_len)
15397                 {
15398                   error (_("Corrupt attribute section name\n"));
15399                   res = FALSE;
15400                   break;
15401                 }
15402
15403               printf (_("Attribute Section: "));
15404               print_symbol (INT_MAX, (const char *) p);
15405               putchar ('\n');
15406
15407               if (public_name && streq ((char *) p, public_name))
15408                 public_section = TRUE;
15409               else
15410                 public_section = FALSE;
15411
15412               if (streq ((char *) p, "gnu"))
15413                 gnu_section = TRUE;
15414               else
15415                 gnu_section = FALSE;
15416
15417               p += namelen;
15418               attr_len -= namelen;
15419
15420               while (attr_len > 0 && p < contents + sect->sh_size)
15421                 {
15422                   int tag;
15423                   int val;
15424                   bfd_vma size;
15425                   unsigned char * end;
15426
15427                   /* PR binutils/17531: Safe handling of corrupt files.  */
15428                   if (attr_len < 6)
15429                     {
15430                       error (_("Unused bytes at end of section\n"));
15431                       res = FALSE;
15432                       section_len = 0;
15433                       break;
15434                     }
15435
15436                   tag = *(p++);
15437                   size = byte_get (p, 4);
15438                   if (size > attr_len)
15439                     {
15440                       error (_("Bad subsection length (%u > %u)\n"),
15441                               (unsigned) size, (unsigned) attr_len);
15442                       res = FALSE;
15443                       size = attr_len;
15444                     }
15445                   /* PR binutils/17531: Safe handling of corrupt files.  */
15446                   if (size < 6)
15447                     {
15448                       error (_("Bad subsection length (%u < 6)\n"),
15449                               (unsigned) size);
15450                       res = FALSE;
15451                       section_len = 0;
15452                       break;
15453                     }
15454
15455                   attr_len -= size;
15456                   end = p + size - 1;
15457                   assert (end <= contents + sect->sh_size);
15458                   p += 4;
15459
15460                   switch (tag)
15461                     {
15462                     case 1:
15463                       printf (_("File Attributes\n"));
15464                       break;
15465                     case 2:
15466                       printf (_("Section Attributes:"));
15467                       goto do_numlist;
15468                     case 3:
15469                       printf (_("Symbol Attributes:"));
15470                       /* Fall through.  */
15471                     do_numlist:
15472                       for (;;)
15473                         {
15474                           unsigned int j;
15475
15476                           val = read_uleb128 (p, &j, end);
15477                           p += j;
15478                           if (val == 0)
15479                             break;
15480                           printf (" %d", val);
15481                         }
15482                       printf ("\n");
15483                       break;
15484                     default:
15485                       printf (_("Unknown tag: %d\n"), tag);
15486                       public_section = FALSE;
15487                       break;
15488                     }
15489
15490                   if (public_section && display_pub_attribute != NULL)
15491                     {
15492                       while (p < end)
15493                         p = display_pub_attribute (p, end);
15494                       assert (p == end);
15495                     }
15496                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15497                     {
15498                       while (p < end)
15499                         p = display_gnu_attribute (p,
15500                                                    display_proc_gnu_attribute,
15501                                                    end);
15502                       assert (p == end);
15503                     }
15504                   else if (p < end)
15505                     {
15506                       printf (_("  Unknown attribute:\n"));
15507                       display_raw_attribute (p, end);
15508                       p = end;
15509                     }
15510                   else
15511                     attr_len = 0;
15512                 }
15513             }
15514         }
15515
15516       free (contents);
15517     }
15518
15519   return res;
15520 }
15521
15522 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15523    Print the Address, Access and Initial fields of an entry at VMA ADDR
15524    and return the VMA of the next entry, or -1 if there was a problem.
15525    Does not read from DATA_END or beyond.  */
15526
15527 static bfd_vma
15528 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15529                       unsigned char * data_end)
15530 {
15531   printf ("  ");
15532   print_vma (addr, LONG_HEX);
15533   printf (" ");
15534   if (addr < pltgot + 0xfff0)
15535     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15536   else
15537     printf ("%10s", "");
15538   printf (" ");
15539   if (data == NULL)
15540     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15541   else
15542     {
15543       bfd_vma entry;
15544       unsigned char * from = data + addr - pltgot;
15545
15546       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15547         {
15548           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15549           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15550           return (bfd_vma) -1;
15551         }
15552       else
15553         {
15554           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15555           print_vma (entry, LONG_HEX);
15556         }
15557     }
15558   return addr + (is_32bit_elf ? 4 : 8);
15559 }
15560
15561 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15562    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15563    ADDR and return the VMA of the next entry.  */
15564
15565 static bfd_vma
15566 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15567 {
15568   printf ("  ");
15569   print_vma (addr, LONG_HEX);
15570   printf (" ");
15571   if (data == NULL)
15572     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15573   else
15574     {
15575       bfd_vma entry;
15576
15577       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15578       print_vma (entry, LONG_HEX);
15579     }
15580   return addr + (is_32bit_elf ? 4 : 8);
15581 }
15582
15583 static void
15584 print_mips_ases (unsigned int mask)
15585 {
15586   if (mask & AFL_ASE_DSP)
15587     fputs ("\n\tDSP ASE", stdout);
15588   if (mask & AFL_ASE_DSPR2)
15589     fputs ("\n\tDSP R2 ASE", stdout);
15590   if (mask & AFL_ASE_DSPR3)
15591     fputs ("\n\tDSP R3 ASE", stdout);
15592   if (mask & AFL_ASE_EVA)
15593     fputs ("\n\tEnhanced VA Scheme", stdout);
15594   if (mask & AFL_ASE_MCU)
15595     fputs ("\n\tMCU (MicroController) ASE", stdout);
15596   if (mask & AFL_ASE_MDMX)
15597     fputs ("\n\tMDMX ASE", stdout);
15598   if (mask & AFL_ASE_MIPS3D)
15599     fputs ("\n\tMIPS-3D ASE", stdout);
15600   if (mask & AFL_ASE_MT)
15601     fputs ("\n\tMT ASE", stdout);
15602   if (mask & AFL_ASE_SMARTMIPS)
15603     fputs ("\n\tSmartMIPS ASE", stdout);
15604   if (mask & AFL_ASE_VIRT)
15605     fputs ("\n\tVZ ASE", stdout);
15606   if (mask & AFL_ASE_MSA)
15607     fputs ("\n\tMSA ASE", stdout);
15608   if (mask & AFL_ASE_MIPS16)
15609     fputs ("\n\tMIPS16 ASE", stdout);
15610   if (mask & AFL_ASE_MICROMIPS)
15611     fputs ("\n\tMICROMIPS ASE", stdout);
15612   if (mask & AFL_ASE_XPA)
15613     fputs ("\n\tXPA ASE", stdout);
15614   if (mask & AFL_ASE_MIPS16E2)
15615     fputs ("\n\tMIPS16e2 ASE", stdout);
15616   if (mask & AFL_ASE_CRC)
15617     fputs ("\n\tCRC ASE", stdout);
15618   if (mask & AFL_ASE_GINV)
15619     fputs ("\n\tGINV ASE", stdout);
15620   if (mask & AFL_ASE_LOONGSON_MMI)
15621     fputs ("\n\tLoongson MMI ASE", stdout);
15622   if (mask == 0)
15623     fprintf (stdout, "\n\t%s", _("None"));
15624   else if ((mask & ~AFL_ASE_MASK) != 0)
15625     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15626 }
15627
15628 static void
15629 print_mips_isa_ext (unsigned int isa_ext)
15630 {
15631   switch (isa_ext)
15632     {
15633     case 0:
15634       fputs (_("None"), stdout);
15635       break;
15636     case AFL_EXT_XLR:
15637       fputs ("RMI XLR", stdout);
15638       break;
15639     case AFL_EXT_OCTEON3:
15640       fputs ("Cavium Networks Octeon3", stdout);
15641       break;
15642     case AFL_EXT_OCTEON2:
15643       fputs ("Cavium Networks Octeon2", stdout);
15644       break;
15645     case AFL_EXT_OCTEONP:
15646       fputs ("Cavium Networks OcteonP", stdout);
15647       break;
15648     case AFL_EXT_LOONGSON_3A:
15649       fputs ("Loongson 3A", stdout);
15650       break;
15651     case AFL_EXT_OCTEON:
15652       fputs ("Cavium Networks Octeon", stdout);
15653       break;
15654     case AFL_EXT_5900:
15655       fputs ("Toshiba R5900", stdout);
15656       break;
15657     case AFL_EXT_4650:
15658       fputs ("MIPS R4650", stdout);
15659       break;
15660     case AFL_EXT_4010:
15661       fputs ("LSI R4010", stdout);
15662       break;
15663     case AFL_EXT_4100:
15664       fputs ("NEC VR4100", stdout);
15665       break;
15666     case AFL_EXT_3900:
15667       fputs ("Toshiba R3900", stdout);
15668       break;
15669     case AFL_EXT_10000:
15670       fputs ("MIPS R10000", stdout);
15671       break;
15672     case AFL_EXT_SB1:
15673       fputs ("Broadcom SB-1", stdout);
15674       break;
15675     case AFL_EXT_4111:
15676       fputs ("NEC VR4111/VR4181", stdout);
15677       break;
15678     case AFL_EXT_4120:
15679       fputs ("NEC VR4120", stdout);
15680       break;
15681     case AFL_EXT_5400:
15682       fputs ("NEC VR5400", stdout);
15683       break;
15684     case AFL_EXT_5500:
15685       fputs ("NEC VR5500", stdout);
15686       break;
15687     case AFL_EXT_LOONGSON_2E:
15688       fputs ("ST Microelectronics Loongson 2E", stdout);
15689       break;
15690     case AFL_EXT_LOONGSON_2F:
15691       fputs ("ST Microelectronics Loongson 2F", stdout);
15692       break;
15693     case AFL_EXT_INTERAPTIV_MR2:
15694       fputs ("Imagination interAptiv MR2", stdout);
15695       break;
15696     default:
15697       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15698     }
15699 }
15700
15701 static signed int
15702 get_mips_reg_size (int reg_size)
15703 {
15704   return (reg_size == AFL_REG_NONE) ? 0
15705          : (reg_size == AFL_REG_32) ? 32
15706          : (reg_size == AFL_REG_64) ? 64
15707          : (reg_size == AFL_REG_128) ? 128
15708          : -1;
15709 }
15710
15711 static bfd_boolean
15712 process_mips_specific (Filedata * filedata)
15713 {
15714   Elf_Internal_Dyn * entry;
15715   Elf_Internal_Shdr *sect = NULL;
15716   size_t liblist_offset = 0;
15717   size_t liblistno = 0;
15718   size_t conflictsno = 0;
15719   size_t options_offset = 0;
15720   size_t conflicts_offset = 0;
15721   size_t pltrelsz = 0;
15722   size_t pltrel = 0;
15723   bfd_vma pltgot = 0;
15724   bfd_vma mips_pltgot = 0;
15725   bfd_vma jmprel = 0;
15726   bfd_vma local_gotno = 0;
15727   bfd_vma gotsym = 0;
15728   bfd_vma symtabno = 0;
15729   bfd_boolean res = TRUE;
15730
15731   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15732                             display_mips_gnu_attribute))
15733     res = FALSE;
15734
15735   sect = find_section (filedata, ".MIPS.abiflags");
15736
15737   if (sect != NULL)
15738     {
15739       Elf_External_ABIFlags_v0 *abiflags_ext;
15740       Elf_Internal_ABIFlags_v0 abiflags_in;
15741
15742       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15743         {
15744           error (_("Corrupt MIPS ABI Flags section.\n"));
15745           res = FALSE;
15746         }
15747       else
15748         {
15749           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15750                                    sect->sh_size, _("MIPS ABI Flags section"));
15751           if (abiflags_ext)
15752             {
15753               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15754               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15755               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15756               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15757               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15758               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15759               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15760               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15761               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15762               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15763               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15764
15765               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15766               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15767               if (abiflags_in.isa_rev > 1)
15768                 printf ("r%d", abiflags_in.isa_rev);
15769               printf ("\nGPR size: %d",
15770                       get_mips_reg_size (abiflags_in.gpr_size));
15771               printf ("\nCPR1 size: %d",
15772                       get_mips_reg_size (abiflags_in.cpr1_size));
15773               printf ("\nCPR2 size: %d",
15774                       get_mips_reg_size (abiflags_in.cpr2_size));
15775               fputs ("\nFP ABI: ", stdout);
15776               print_mips_fp_abi_value (abiflags_in.fp_abi);
15777               fputs ("ISA Extension: ", stdout);
15778               print_mips_isa_ext (abiflags_in.isa_ext);
15779               fputs ("\nASEs:", stdout);
15780               print_mips_ases (abiflags_in.ases);
15781               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15782               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15783               fputc ('\n', stdout);
15784               free (abiflags_ext);
15785             }
15786         }
15787     }
15788
15789   /* We have a lot of special sections.  Thanks SGI!  */
15790   if (dynamic_section == NULL)
15791     {
15792       /* No dynamic information available.  See if there is static GOT.  */
15793       sect = find_section (filedata, ".got");
15794       if (sect != NULL)
15795         {
15796           unsigned char *data_end;
15797           unsigned char *data;
15798           bfd_vma ent, end;
15799           int addr_size;
15800
15801           pltgot = sect->sh_addr;
15802
15803           ent = pltgot;
15804           addr_size = (is_32bit_elf ? 4 : 8);
15805           end = pltgot + sect->sh_size;
15806
15807           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15808                                              end - pltgot, 1,
15809                                              _("Global Offset Table data"));
15810           /* PR 12855: Null data is handled gracefully throughout.  */
15811           data_end = data + (end - pltgot);
15812
15813           printf (_("\nStatic GOT:\n"));
15814           printf (_(" Canonical gp value: "));
15815           print_vma (ent + 0x7ff0, LONG_HEX);
15816           printf ("\n\n");
15817
15818           /* In a dynamic binary GOT[0] is reserved for the dynamic
15819              loader to store the lazy resolver pointer, however in
15820              a static binary it may well have been omitted and GOT
15821              reduced to a table of addresses.
15822              PR 21344: Check for the entry being fully available
15823              before fetching it.  */
15824           if (data
15825               && data + ent - pltgot + addr_size <= data_end
15826               && byte_get (data + ent - pltgot, addr_size) == 0)
15827             {
15828               printf (_(" Reserved entries:\n"));
15829               printf (_("  %*s %10s %*s\n"),
15830                       addr_size * 2, _("Address"), _("Access"),
15831                       addr_size * 2, _("Value"));
15832               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15833               printf ("\n");
15834               if (ent == (bfd_vma) -1)
15835                 goto sgot_print_fail;
15836
15837               /* Check for the MSB of GOT[1] being set, identifying a
15838                  GNU object.  This entry will be used by some runtime
15839                  loaders, to store the module pointer.  Otherwise this
15840                  is an ordinary local entry.
15841                  PR 21344: Check for the entry being fully available
15842                  before fetching it.  */
15843               if (data
15844                   && data + ent - pltgot + addr_size <= data_end
15845                   && (byte_get (data + ent - pltgot, addr_size)
15846                       >> (addr_size * 8 - 1)) != 0)
15847                 {
15848                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15849                   printf ("\n");
15850                   if (ent == (bfd_vma) -1)
15851                     goto sgot_print_fail;
15852                 }
15853               printf ("\n");
15854             }
15855
15856           if (data != NULL && ent < end)
15857             {
15858               printf (_(" Local entries:\n"));
15859               printf ("  %*s %10s %*s\n",
15860                       addr_size * 2, _("Address"), _("Access"),
15861                       addr_size * 2, _("Value"));
15862               while (ent < end)
15863                 {
15864                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15865                   printf ("\n");
15866                   if (ent == (bfd_vma) -1)
15867                     goto sgot_print_fail;
15868                 }
15869               printf ("\n");
15870             }
15871
15872         sgot_print_fail:
15873           if (data)
15874             free (data);
15875         }
15876       return res;
15877     }
15878
15879   for (entry = dynamic_section;
15880        /* PR 17531 file: 012-50589-0.004.  */
15881        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15882        ++entry)
15883     switch (entry->d_tag)
15884       {
15885       case DT_MIPS_LIBLIST:
15886         liblist_offset
15887           = offset_from_vma (filedata, entry->d_un.d_val,
15888                              liblistno * sizeof (Elf32_External_Lib));
15889         break;
15890       case DT_MIPS_LIBLISTNO:
15891         liblistno = entry->d_un.d_val;
15892         break;
15893       case DT_MIPS_OPTIONS:
15894         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15895         break;
15896       case DT_MIPS_CONFLICT:
15897         conflicts_offset
15898           = offset_from_vma (filedata, entry->d_un.d_val,
15899                              conflictsno * sizeof (Elf32_External_Conflict));
15900         break;
15901       case DT_MIPS_CONFLICTNO:
15902         conflictsno = entry->d_un.d_val;
15903         break;
15904       case DT_PLTGOT:
15905         pltgot = entry->d_un.d_ptr;
15906         break;
15907       case DT_MIPS_LOCAL_GOTNO:
15908         local_gotno = entry->d_un.d_val;
15909         break;
15910       case DT_MIPS_GOTSYM:
15911         gotsym = entry->d_un.d_val;
15912         break;
15913       case DT_MIPS_SYMTABNO:
15914         symtabno = entry->d_un.d_val;
15915         break;
15916       case DT_MIPS_PLTGOT:
15917         mips_pltgot = entry->d_un.d_ptr;
15918         break;
15919       case DT_PLTREL:
15920         pltrel = entry->d_un.d_val;
15921         break;
15922       case DT_PLTRELSZ:
15923         pltrelsz = entry->d_un.d_val;
15924         break;
15925       case DT_JMPREL:
15926         jmprel = entry->d_un.d_ptr;
15927         break;
15928       default:
15929         break;
15930       }
15931
15932   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15933     {
15934       Elf32_External_Lib * elib;
15935       size_t cnt;
15936
15937       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15938                                               liblistno,
15939                                               sizeof (Elf32_External_Lib),
15940                                               _("liblist section data"));
15941       if (elib)
15942         {
15943           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15944                             "\nSection '.liblist' contains %lu entries:\n",
15945                             (unsigned long) liblistno),
15946                   (unsigned long) liblistno);
15947           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15948                  stdout);
15949
15950           for (cnt = 0; cnt < liblistno; ++cnt)
15951             {
15952               Elf32_Lib liblist;
15953               time_t atime;
15954               char timebuf[128];
15955               struct tm * tmp;
15956
15957               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15958               atime = BYTE_GET (elib[cnt].l_time_stamp);
15959               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15960               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15961               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15962
15963               tmp = gmtime (&atime);
15964               snprintf (timebuf, sizeof (timebuf),
15965                         "%04u-%02u-%02uT%02u:%02u:%02u",
15966                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15967                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15968
15969               printf ("%3lu: ", (unsigned long) cnt);
15970               if (VALID_DYNAMIC_NAME (liblist.l_name))
15971                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15972               else
15973                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15974               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15975                       liblist.l_version);
15976
15977               if (liblist.l_flags == 0)
15978                 puts (_(" NONE"));
15979               else
15980                 {
15981                   static const struct
15982                   {
15983                     const char * name;
15984                     int bit;
15985                   }
15986                   l_flags_vals[] =
15987                   {
15988                     { " EXACT_MATCH", LL_EXACT_MATCH },
15989                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15990                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15991                     { " EXPORTS", LL_EXPORTS },
15992                     { " DELAY_LOAD", LL_DELAY_LOAD },
15993                     { " DELTA", LL_DELTA }
15994                   };
15995                   int flags = liblist.l_flags;
15996                   size_t fcnt;
15997
15998                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15999                     if ((flags & l_flags_vals[fcnt].bit) != 0)
16000                       {
16001                         fputs (l_flags_vals[fcnt].name, stdout);
16002                         flags ^= l_flags_vals[fcnt].bit;
16003                       }
16004                   if (flags != 0)
16005                     printf (" %#x", (unsigned int) flags);
16006
16007                   puts ("");
16008                 }
16009             }
16010
16011           free (elib);
16012         }
16013       else
16014         res = FALSE;
16015     }
16016
16017   if (options_offset != 0)
16018     {
16019       Elf_External_Options * eopt;
16020       Elf_Internal_Options * iopt;
16021       Elf_Internal_Options * option;
16022       size_t offset;
16023       int cnt;
16024       sect = filedata->section_headers;
16025
16026       /* Find the section header so that we get the size.  */
16027       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16028       /* PR 17533 file: 012-277276-0.004.  */
16029       if (sect == NULL)
16030         {
16031           error (_("No MIPS_OPTIONS header found\n"));
16032           return FALSE;
16033         }
16034
16035       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16036                                                 sect->sh_size, _("options"));
16037       if (eopt)
16038         {
16039           iopt = (Elf_Internal_Options *)
16040               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16041           if (iopt == NULL)
16042             {
16043               error (_("Out of memory allocating space for MIPS options\n"));
16044               return FALSE;
16045             }
16046
16047           offset = cnt = 0;
16048           option = iopt;
16049
16050           while (offset <= sect->sh_size - sizeof (* eopt))
16051             {
16052               Elf_External_Options * eoption;
16053
16054               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16055
16056               option->kind = BYTE_GET (eoption->kind);
16057               option->size = BYTE_GET (eoption->size);
16058               option->section = BYTE_GET (eoption->section);
16059               option->info = BYTE_GET (eoption->info);
16060
16061               /* PR 17531: file: ffa0fa3b.  */
16062               if (option->size < sizeof (* eopt)
16063                   || offset + option->size > sect->sh_size)
16064                 {
16065                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
16066                   return FALSE;
16067                 }
16068               offset += option->size;
16069
16070               ++option;
16071               ++cnt;
16072             }
16073
16074           printf (ngettext ("\nSection '%s' contains %d entry:\n",
16075                             "\nSection '%s' contains %d entries:\n",
16076                             cnt),
16077                   printable_section_name (filedata, sect), cnt);
16078
16079           option = iopt;
16080           offset = 0;
16081
16082           while (cnt-- > 0)
16083             {
16084               size_t len;
16085
16086               switch (option->kind)
16087                 {
16088                 case ODK_NULL:
16089                   /* This shouldn't happen.  */
16090                   printf (" NULL       %d %lx", option->section, option->info);
16091                   break;
16092                 case ODK_REGINFO:
16093                   printf (" REGINFO    ");
16094                   if (filedata->file_header.e_machine == EM_MIPS)
16095                     {
16096                       /* 32bit form.  */
16097                       Elf32_External_RegInfo * ereg;
16098                       Elf32_RegInfo reginfo;
16099
16100                       ereg = (Elf32_External_RegInfo *) (option + 1);
16101                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16102                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16103                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16104                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16105                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16106                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16107
16108                       printf ("GPR %08lx  GP 0x%lx\n",
16109                               reginfo.ri_gprmask,
16110                               (unsigned long) reginfo.ri_gp_value);
16111                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16112                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16113                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16114                     }
16115                   else
16116                     {
16117                       /* 64 bit form.  */
16118                       Elf64_External_RegInfo * ereg;
16119                       Elf64_Internal_RegInfo reginfo;
16120
16121                       ereg = (Elf64_External_RegInfo *) (option + 1);
16122                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
16123                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16124                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16125                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16126                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16127                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16128
16129                       printf ("GPR %08lx  GP 0x",
16130                               reginfo.ri_gprmask);
16131                       printf_vma (reginfo.ri_gp_value);
16132                       printf ("\n");
16133
16134                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16135                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16136                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16137                     }
16138                   ++option;
16139                   continue;
16140                 case ODK_EXCEPTIONS:
16141                   fputs (" EXCEPTIONS fpe_min(", stdout);
16142                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16143                   fputs (") fpe_max(", stdout);
16144                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16145                   fputs (")", stdout);
16146
16147                   if (option->info & OEX_PAGE0)
16148                     fputs (" PAGE0", stdout);
16149                   if (option->info & OEX_SMM)
16150                     fputs (" SMM", stdout);
16151                   if (option->info & OEX_FPDBUG)
16152                     fputs (" FPDBUG", stdout);
16153                   if (option->info & OEX_DISMISS)
16154                     fputs (" DISMISS", stdout);
16155                   break;
16156                 case ODK_PAD:
16157                   fputs (" PAD       ", stdout);
16158                   if (option->info & OPAD_PREFIX)
16159                     fputs (" PREFIX", stdout);
16160                   if (option->info & OPAD_POSTFIX)
16161                     fputs (" POSTFIX", stdout);
16162                   if (option->info & OPAD_SYMBOL)
16163                     fputs (" SYMBOL", stdout);
16164                   break;
16165                 case ODK_HWPATCH:
16166                   fputs (" HWPATCH   ", stdout);
16167                   if (option->info & OHW_R4KEOP)
16168                     fputs (" R4KEOP", stdout);
16169                   if (option->info & OHW_R8KPFETCH)
16170                     fputs (" R8KPFETCH", stdout);
16171                   if (option->info & OHW_R5KEOP)
16172                     fputs (" R5KEOP", stdout);
16173                   if (option->info & OHW_R5KCVTL)
16174                     fputs (" R5KCVTL", stdout);
16175                   break;
16176                 case ODK_FILL:
16177                   fputs (" FILL       ", stdout);
16178                   /* XXX Print content of info word?  */
16179                   break;
16180                 case ODK_TAGS:
16181                   fputs (" TAGS       ", stdout);
16182                   /* XXX Print content of info word?  */
16183                   break;
16184                 case ODK_HWAND:
16185                   fputs (" HWAND     ", stdout);
16186                   if (option->info & OHWA0_R4KEOP_CHECKED)
16187                     fputs (" R4KEOP_CHECKED", stdout);
16188                   if (option->info & OHWA0_R4KEOP_CLEAN)
16189                     fputs (" R4KEOP_CLEAN", stdout);
16190                   break;
16191                 case ODK_HWOR:
16192                   fputs (" HWOR      ", stdout);
16193                   if (option->info & OHWA0_R4KEOP_CHECKED)
16194                     fputs (" R4KEOP_CHECKED", stdout);
16195                   if (option->info & OHWA0_R4KEOP_CLEAN)
16196                     fputs (" R4KEOP_CLEAN", stdout);
16197                   break;
16198                 case ODK_GP_GROUP:
16199                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16200                           option->info & OGP_GROUP,
16201                           (option->info & OGP_SELF) >> 16);
16202                   break;
16203                 case ODK_IDENT:
16204                   printf (" IDENT     %#06lx  self-contained %#06lx",
16205                           option->info & OGP_GROUP,
16206                           (option->info & OGP_SELF) >> 16);
16207                   break;
16208                 default:
16209                   /* This shouldn't happen.  */
16210                   printf (" %3d ???     %d %lx",
16211                           option->kind, option->section, option->info);
16212                   break;
16213                 }
16214
16215               len = sizeof (* eopt);
16216               while (len < option->size)
16217                 {
16218                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16219
16220                   if (ISPRINT (datum))
16221                     printf ("%c", datum);
16222                   else
16223                     printf ("\\%03o", datum);
16224                   len ++;
16225                 }
16226               fputs ("\n", stdout);
16227
16228               offset += option->size;
16229               ++option;
16230             }
16231
16232           free (eopt);
16233         }
16234       else
16235         res = FALSE;
16236     }
16237
16238   if (conflicts_offset != 0 && conflictsno != 0)
16239     {
16240       Elf32_Conflict * iconf;
16241       size_t cnt;
16242
16243       if (dynamic_symbols == NULL)
16244         {
16245           error (_("conflict list found without a dynamic symbol table\n"));
16246           return FALSE;
16247         }
16248
16249       /* PR 21345 - print a slightly more helpful error message
16250          if we are sure that the cmalloc will fail.  */
16251       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16252         {
16253           error (_("Overlarge number of conflicts detected: %lx\n"),
16254                  (long) conflictsno);
16255           return FALSE;
16256         }
16257
16258       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16259       if (iconf == NULL)
16260         {
16261           error (_("Out of memory allocating space for dynamic conflicts\n"));
16262           return FALSE;
16263         }
16264
16265       if (is_32bit_elf)
16266         {
16267           Elf32_External_Conflict * econf32;
16268
16269           econf32 = (Elf32_External_Conflict *)
16270               get_data (NULL, filedata, conflicts_offset, conflictsno,
16271                         sizeof (* econf32), _("conflict"));
16272           if (!econf32)
16273             return FALSE;
16274
16275           for (cnt = 0; cnt < conflictsno; ++cnt)
16276             iconf[cnt] = BYTE_GET (econf32[cnt]);
16277
16278           free (econf32);
16279         }
16280       else
16281         {
16282           Elf64_External_Conflict * econf64;
16283
16284           econf64 = (Elf64_External_Conflict *)
16285               get_data (NULL, filedata, conflicts_offset, conflictsno,
16286                         sizeof (* econf64), _("conflict"));
16287           if (!econf64)
16288             return FALSE;
16289
16290           for (cnt = 0; cnt < conflictsno; ++cnt)
16291             iconf[cnt] = BYTE_GET (econf64[cnt]);
16292
16293           free (econf64);
16294         }
16295
16296       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16297                         "\nSection '.conflict' contains %lu entries:\n",
16298                         (unsigned long) conflictsno),
16299               (unsigned long) conflictsno);
16300       puts (_("  Num:    Index       Value  Name"));
16301
16302       for (cnt = 0; cnt < conflictsno; ++cnt)
16303         {
16304           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16305
16306           if (iconf[cnt] >= num_dynamic_syms)
16307             printf (_("<corrupt symbol index>"));
16308           else
16309             {
16310               Elf_Internal_Sym * psym;
16311
16312               psym = & dynamic_symbols[iconf[cnt]];
16313               print_vma (psym->st_value, FULL_HEX);
16314               putchar (' ');
16315               if (VALID_DYNAMIC_NAME (psym->st_name))
16316                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16317               else
16318                 printf (_("<corrupt: %14ld>"), psym->st_name);
16319             }
16320           putchar ('\n');
16321         }
16322
16323       free (iconf);
16324     }
16325
16326   if (pltgot != 0 && local_gotno != 0)
16327     {
16328       bfd_vma ent, local_end, global_end;
16329       size_t i, offset;
16330       unsigned char * data;
16331       unsigned char * data_end;
16332       int addr_size;
16333
16334       ent = pltgot;
16335       addr_size = (is_32bit_elf ? 4 : 8);
16336       local_end = pltgot + local_gotno * addr_size;
16337
16338       /* PR binutils/17533 file: 012-111227-0.004  */
16339       if (symtabno < gotsym)
16340         {
16341           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16342                  (unsigned long) gotsym, (unsigned long) symtabno);
16343           return FALSE;
16344         }
16345
16346       global_end = local_end + (symtabno - gotsym) * addr_size;
16347       /* PR 17531: file: 54c91a34.  */
16348       if (global_end < local_end)
16349         {
16350           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16351           return FALSE;
16352         }
16353
16354       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16355       data = (unsigned char *) get_data (NULL, filedata, offset,
16356                                          global_end - pltgot, 1,
16357                                          _("Global Offset Table data"));
16358       /* PR 12855: Null data is handled gracefully throughout.  */
16359       data_end = data + (global_end - pltgot);
16360
16361       printf (_("\nPrimary GOT:\n"));
16362       printf (_(" Canonical gp value: "));
16363       print_vma (pltgot + 0x7ff0, LONG_HEX);
16364       printf ("\n\n");
16365
16366       printf (_(" Reserved entries:\n"));
16367       printf (_("  %*s %10s %*s Purpose\n"),
16368               addr_size * 2, _("Address"), _("Access"),
16369               addr_size * 2, _("Initial"));
16370       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16371       printf (_(" Lazy resolver\n"));
16372       if (ent == (bfd_vma) -1)
16373         goto got_print_fail;
16374
16375       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16376          This entry will be used by some runtime loaders, to store the
16377          module pointer.  Otherwise this is an ordinary local entry.
16378          PR 21344: Check for the entry being fully available before
16379          fetching it.  */
16380       if (data
16381           && data + ent - pltgot + addr_size <= data_end
16382           && (byte_get (data + ent - pltgot, addr_size)
16383               >> (addr_size * 8 - 1)) != 0)
16384         {
16385           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16386           printf (_(" Module pointer (GNU extension)\n"));
16387           if (ent == (bfd_vma) -1)
16388             goto got_print_fail;
16389         }
16390       printf ("\n");
16391
16392       if (data != NULL && ent < local_end)
16393         {
16394           printf (_(" Local entries:\n"));
16395           printf ("  %*s %10s %*s\n",
16396                   addr_size * 2, _("Address"), _("Access"),
16397                   addr_size * 2, _("Initial"));
16398           while (ent < local_end)
16399             {
16400               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16401               printf ("\n");
16402               if (ent == (bfd_vma) -1)
16403                 goto got_print_fail;
16404             }
16405           printf ("\n");
16406         }
16407
16408       if (data != NULL && gotsym < symtabno)
16409         {
16410           int sym_width;
16411
16412           printf (_(" Global entries:\n"));
16413           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16414                   addr_size * 2, _("Address"),
16415                   _("Access"),
16416                   addr_size * 2, _("Initial"),
16417                   addr_size * 2, _("Sym.Val."),
16418                   _("Type"),
16419                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16420                   _("Ndx"), _("Name"));
16421
16422           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16423
16424           for (i = gotsym; i < symtabno; i++)
16425             {
16426               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16427               printf (" ");
16428
16429               if (dynamic_symbols == NULL)
16430                 printf (_("<no dynamic symbols>"));
16431               else if (i < num_dynamic_syms)
16432                 {
16433                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16434
16435                   print_vma (psym->st_value, LONG_HEX);
16436                   printf (" %-7s %3s ",
16437                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16438                           get_symbol_index_type (filedata, psym->st_shndx));
16439
16440                   if (VALID_DYNAMIC_NAME (psym->st_name))
16441                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16442                   else
16443                     printf (_("<corrupt: %14ld>"), psym->st_name);
16444                 }
16445               else
16446                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16447                         (unsigned long) i);
16448
16449               printf ("\n");
16450               if (ent == (bfd_vma) -1)
16451                 break;
16452             }
16453           printf ("\n");
16454         }
16455
16456     got_print_fail:
16457       if (data)
16458         free (data);
16459     }
16460
16461   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16462     {
16463       bfd_vma ent, end;
16464       size_t offset, rel_offset;
16465       unsigned long count, i;
16466       unsigned char * data;
16467       int addr_size, sym_width;
16468       Elf_Internal_Rela * rels;
16469
16470       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16471       if (pltrel == DT_RELA)
16472         {
16473           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16474             return FALSE;
16475         }
16476       else
16477         {
16478           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16479             return FALSE;
16480         }
16481
16482       ent = mips_pltgot;
16483       addr_size = (is_32bit_elf ? 4 : 8);
16484       end = mips_pltgot + (2 + count) * addr_size;
16485
16486       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16487       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16488                                          1, _("Procedure Linkage Table data"));
16489       if (data == NULL)
16490         return FALSE;
16491
16492       printf ("\nPLT GOT:\n\n");
16493       printf (_(" Reserved entries:\n"));
16494       printf (_("  %*s %*s Purpose\n"),
16495               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16496       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16497       printf (_(" PLT lazy resolver\n"));
16498       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16499       printf (_(" Module pointer\n"));
16500       printf ("\n");
16501
16502       printf (_(" Entries:\n"));
16503       printf ("  %*s %*s %*s %-7s %3s %s\n",
16504               addr_size * 2, _("Address"),
16505               addr_size * 2, _("Initial"),
16506               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16507       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16508       for (i = 0; i < count; i++)
16509         {
16510           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16511
16512           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16513           printf (" ");
16514
16515           if (idx >= num_dynamic_syms)
16516             printf (_("<corrupt symbol index: %lu>"), idx);
16517           else
16518             {
16519               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16520
16521               print_vma (psym->st_value, LONG_HEX);
16522               printf (" %-7s %3s ",
16523                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16524                       get_symbol_index_type (filedata, psym->st_shndx));
16525               if (VALID_DYNAMIC_NAME (psym->st_name))
16526                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16527               else
16528                 printf (_("<corrupt: %14ld>"), psym->st_name);
16529             }
16530           printf ("\n");
16531         }
16532       printf ("\n");
16533
16534       if (data)
16535         free (data);
16536       free (rels);
16537     }
16538
16539   return res;
16540 }
16541
16542 static bfd_boolean
16543 process_nds32_specific (Filedata * filedata)
16544 {
16545   Elf_Internal_Shdr *sect = NULL;
16546
16547   sect = find_section (filedata, ".nds32_e_flags");
16548   if (sect != NULL)
16549     {
16550       unsigned int *flag;
16551
16552       printf ("\nNDS32 elf flags section:\n");
16553       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16554                        sect->sh_size, _("NDS32 elf flags section"));
16555
16556       if (! flag)
16557         return FALSE;
16558
16559       switch ((*flag) & 0x3)
16560         {
16561         case 0:
16562           printf ("(VEC_SIZE):\tNo entry.\n");
16563           break;
16564         case 1:
16565           printf ("(VEC_SIZE):\t4 bytes\n");
16566           break;
16567         case 2:
16568           printf ("(VEC_SIZE):\t16 bytes\n");
16569           break;
16570         case 3:
16571           printf ("(VEC_SIZE):\treserved\n");
16572           break;
16573         }
16574     }
16575
16576   return TRUE;
16577 }
16578
16579 static bfd_boolean
16580 process_gnu_liblist (Filedata * filedata)
16581 {
16582   Elf_Internal_Shdr * section;
16583   Elf_Internal_Shdr * string_sec;
16584   Elf32_External_Lib * elib;
16585   char * strtab;
16586   size_t strtab_size;
16587   size_t cnt;
16588   unsigned long num_liblist;
16589   unsigned i;
16590   bfd_boolean res = TRUE;
16591
16592   if (! do_arch)
16593     return TRUE;
16594
16595   for (i = 0, section = filedata->section_headers;
16596        i < filedata->file_header.e_shnum;
16597        i++, section++)
16598     {
16599       switch (section->sh_type)
16600         {
16601         case SHT_GNU_LIBLIST:
16602           if (section->sh_link >= filedata->file_header.e_shnum)
16603             break;
16604
16605           elib = (Elf32_External_Lib *)
16606               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16607                         _("liblist section data"));
16608
16609           if (elib == NULL)
16610             {
16611               res = FALSE;
16612               break;
16613             }
16614
16615           string_sec = filedata->section_headers + section->sh_link;
16616           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16617                                       string_sec->sh_size,
16618                                       _("liblist string table"));
16619           if (strtab == NULL
16620               || section->sh_entsize != sizeof (Elf32_External_Lib))
16621             {
16622               free (elib);
16623               free (strtab);
16624               res = FALSE;
16625               break;
16626             }
16627           strtab_size = string_sec->sh_size;
16628
16629           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16630           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16631                             "\nLibrary list section '%s' contains %lu entries:\n",
16632                             num_liblist),
16633                   printable_section_name (filedata, section),
16634                   num_liblist);
16635
16636           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16637
16638           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16639                ++cnt)
16640             {
16641               Elf32_Lib liblist;
16642               time_t atime;
16643               char timebuf[128];
16644               struct tm * tmp;
16645
16646               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16647               atime = BYTE_GET (elib[cnt].l_time_stamp);
16648               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16649               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16650               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16651
16652               tmp = gmtime (&atime);
16653               snprintf (timebuf, sizeof (timebuf),
16654                         "%04u-%02u-%02uT%02u:%02u:%02u",
16655                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16656                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16657
16658               printf ("%3lu: ", (unsigned long) cnt);
16659               if (do_wide)
16660                 printf ("%-20s", liblist.l_name < strtab_size
16661                         ? strtab + liblist.l_name : _("<corrupt>"));
16662               else
16663                 printf ("%-20.20s", liblist.l_name < strtab_size
16664                         ? strtab + liblist.l_name : _("<corrupt>"));
16665               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16666                       liblist.l_version, liblist.l_flags);
16667             }
16668
16669           free (elib);
16670           free (strtab);
16671         }
16672     }
16673
16674   return res;
16675 }
16676
16677 static const char *
16678 get_note_type (Filedata * filedata, unsigned e_type)
16679 {
16680   static char buff[64];
16681
16682   if (filedata->file_header.e_type == ET_CORE)
16683     switch (e_type)
16684       {
16685       case NT_AUXV:
16686         return _("NT_AUXV (auxiliary vector)");
16687       case NT_PRSTATUS:
16688         return _("NT_PRSTATUS (prstatus structure)");
16689       case NT_FPREGSET:
16690         return _("NT_FPREGSET (floating point registers)");
16691       case NT_PRPSINFO:
16692         return _("NT_PRPSINFO (prpsinfo structure)");
16693       case NT_TASKSTRUCT:
16694         return _("NT_TASKSTRUCT (task structure)");
16695       case NT_PRXFPREG:
16696         return _("NT_PRXFPREG (user_xfpregs structure)");
16697       case NT_PPC_VMX:
16698         return _("NT_PPC_VMX (ppc Altivec registers)");
16699       case NT_PPC_VSX:
16700         return _("NT_PPC_VSX (ppc VSX registers)");
16701       case NT_PPC_TAR:
16702         return _("NT_PPC_TAR (ppc TAR register)");
16703       case NT_PPC_PPR:
16704         return _("NT_PPC_PPR (ppc PPR register)");
16705       case NT_PPC_DSCR:
16706         return _("NT_PPC_DSCR (ppc DSCR register)");
16707       case NT_PPC_EBB:
16708         return _("NT_PPC_EBB (ppc EBB registers)");
16709       case NT_PPC_PMU:
16710         return _("NT_PPC_PMU (ppc PMU registers)");
16711       case NT_PPC_TM_CGPR:
16712         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16713       case NT_PPC_TM_CFPR:
16714         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16715       case NT_PPC_TM_CVMX:
16716         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16717       case NT_PPC_TM_CVSX:
16718         return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16719       case NT_PPC_TM_SPR:
16720         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16721       case NT_PPC_TM_CTAR:
16722         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16723       case NT_PPC_TM_CPPR:
16724         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16725       case NT_PPC_TM_CDSCR:
16726         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16727       case NT_386_TLS:
16728         return _("NT_386_TLS (x86 TLS information)");
16729       case NT_386_IOPERM:
16730         return _("NT_386_IOPERM (x86 I/O permissions)");
16731       case NT_X86_XSTATE:
16732         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16733       case NT_S390_HIGH_GPRS:
16734         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16735       case NT_S390_TIMER:
16736         return _("NT_S390_TIMER (s390 timer register)");
16737       case NT_S390_TODCMP:
16738         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16739       case NT_S390_TODPREG:
16740         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16741       case NT_S390_CTRS:
16742         return _("NT_S390_CTRS (s390 control registers)");
16743       case NT_S390_PREFIX:
16744         return _("NT_S390_PREFIX (s390 prefix register)");
16745       case NT_S390_LAST_BREAK:
16746         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16747       case NT_S390_SYSTEM_CALL:
16748         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16749       case NT_S390_TDB:
16750         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16751       case NT_S390_VXRS_LOW:
16752         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16753       case NT_S390_VXRS_HIGH:
16754         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16755       case NT_S390_GS_CB:
16756         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16757       case NT_S390_GS_BC:
16758         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16759       case NT_ARM_VFP:
16760         return _("NT_ARM_VFP (arm VFP registers)");
16761       case NT_ARM_TLS:
16762         return _("NT_ARM_TLS (AArch TLS registers)");
16763       case NT_ARM_HW_BREAK:
16764         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16765       case NT_ARM_HW_WATCH:
16766         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16767       case NT_PSTATUS:
16768         return _("NT_PSTATUS (pstatus structure)");
16769       case NT_FPREGS:
16770         return _("NT_FPREGS (floating point registers)");
16771       case NT_PSINFO:
16772         return _("NT_PSINFO (psinfo structure)");
16773       case NT_LWPSTATUS:
16774         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16775       case NT_LWPSINFO:
16776         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16777       case NT_WIN32PSTATUS:
16778         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16779       case NT_SIGINFO:
16780         return _("NT_SIGINFO (siginfo_t data)");
16781       case NT_FILE:
16782         return _("NT_FILE (mapped files)");
16783       default:
16784         break;
16785       }
16786   else
16787     switch (e_type)
16788       {
16789       case NT_VERSION:
16790         return _("NT_VERSION (version)");
16791       case NT_ARCH:
16792         return _("NT_ARCH (architecture)");
16793       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16794         return _("OPEN");
16795       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16796         return _("func");
16797       default:
16798         break;
16799       }
16800
16801   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16802   return buff;
16803 }
16804
16805 static bfd_boolean
16806 print_core_note (Elf_Internal_Note *pnote)
16807 {
16808   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16809   bfd_vma count, page_size;
16810   unsigned char *descdata, *filenames, *descend;
16811
16812   if (pnote->type != NT_FILE)
16813     {
16814       if (do_wide)
16815         printf ("\n");
16816       return TRUE;
16817     }
16818
16819 #ifndef BFD64
16820   if (!is_32bit_elf)
16821     {
16822       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16823       /* Still "successful".  */
16824       return TRUE;
16825     }
16826 #endif
16827
16828   if (pnote->descsz < 2 * addr_size)
16829     {
16830       error (_("    Malformed note - too short for header\n"));
16831       return FALSE;
16832     }
16833
16834   descdata = (unsigned char *) pnote->descdata;
16835   descend = descdata + pnote->descsz;
16836
16837   if (descdata[pnote->descsz - 1] != '\0')
16838     {
16839       error (_("    Malformed note - does not end with \\0\n"));
16840       return FALSE;
16841     }
16842
16843   count = byte_get (descdata, addr_size);
16844   descdata += addr_size;
16845
16846   page_size = byte_get (descdata, addr_size);
16847   descdata += addr_size;
16848
16849   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16850       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16851     {
16852       error (_("    Malformed note - too short for supplied file count\n"));
16853       return FALSE;
16854     }
16855
16856   printf (_("    Page size: "));
16857   print_vma (page_size, DEC);
16858   printf ("\n");
16859
16860   printf (_("    %*s%*s%*s\n"),
16861           (int) (2 + 2 * addr_size), _("Start"),
16862           (int) (4 + 2 * addr_size), _("End"),
16863           (int) (4 + 2 * addr_size), _("Page Offset"));
16864   filenames = descdata + count * 3 * addr_size;
16865   while (count-- > 0)
16866     {
16867       bfd_vma start, end, file_ofs;
16868
16869       if (filenames == descend)
16870         {
16871           error (_("    Malformed note - filenames end too early\n"));
16872           return FALSE;
16873         }
16874
16875       start = byte_get (descdata, addr_size);
16876       descdata += addr_size;
16877       end = byte_get (descdata, addr_size);
16878       descdata += addr_size;
16879       file_ofs = byte_get (descdata, addr_size);
16880       descdata += addr_size;
16881
16882       printf ("    ");
16883       print_vma (start, FULL_HEX);
16884       printf ("  ");
16885       print_vma (end, FULL_HEX);
16886       printf ("  ");
16887       print_vma (file_ofs, FULL_HEX);
16888       printf ("\n        %s\n", filenames);
16889
16890       filenames += 1 + strlen ((char *) filenames);
16891     }
16892
16893   return TRUE;
16894 }
16895
16896 static const char *
16897 get_gnu_elf_note_type (unsigned e_type)
16898 {
16899   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16900   switch (e_type)
16901     {
16902     case NT_GNU_ABI_TAG:
16903       return _("NT_GNU_ABI_TAG (ABI version tag)");
16904     case NT_GNU_HWCAP:
16905       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16906     case NT_GNU_BUILD_ID:
16907       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16908     case NT_GNU_GOLD_VERSION:
16909       return _("NT_GNU_GOLD_VERSION (gold version)");
16910     case NT_GNU_PROPERTY_TYPE_0:
16911       return _("NT_GNU_PROPERTY_TYPE_0");
16912     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16913       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16914     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16915       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16916     default:
16917       {
16918         static char buff[64];
16919
16920         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16921         return buff;
16922       }
16923     }
16924 }
16925
16926 static void
16927 decode_x86_isa (unsigned int bitmask)
16928 {
16929   while (bitmask)
16930     {
16931       unsigned int bit = bitmask & (- bitmask);
16932
16933       bitmask &= ~ bit;
16934       switch (bit)
16935         {
16936         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16937         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16938         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16939         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16940         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16941         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16942         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16943         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16944         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16945         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16946         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16947         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16948         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16949         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16950         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16951         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16952         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16953         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16954         default: printf (_("<unknown: %x>"), bit); break;
16955         }
16956       if (bitmask)
16957         printf (", ");
16958     }
16959 }
16960
16961 static void
16962 decode_x86_feature (unsigned int type, unsigned int bitmask)
16963 {
16964   while (bitmask)
16965     {
16966       unsigned int bit = bitmask & (- bitmask);
16967
16968       bitmask &= ~ bit;
16969       switch (bit)
16970         {
16971         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16972           switch (type)
16973             {
16974             case GNU_PROPERTY_X86_FEATURE_1_AND:
16975               printf ("IBT");
16976               break;
16977             default:
16978               /* This should never happen.  */
16979               abort ();
16980             }
16981           break;
16982         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16983           switch (type)
16984             {
16985             case GNU_PROPERTY_X86_FEATURE_1_AND:
16986               printf ("SHSTK");
16987               break;
16988             default:
16989               /* This should never happen.  */
16990               abort ();
16991             }
16992           break;
16993         default:
16994           printf (_("<unknown: %x>"), bit);
16995           break;
16996         }
16997       if (bitmask)
16998         printf (", ");
16999     }
17000 }
17001
17002 static void
17003 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17004 {
17005   unsigned char * ptr = (unsigned char *) pnote->descdata;
17006   unsigned char * ptr_end = ptr + pnote->descsz;
17007   unsigned int    size = is_32bit_elf ? 4 : 8;
17008
17009   printf (_("      Properties: "));
17010
17011   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17012     {
17013       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17014       return;
17015     }
17016
17017   while (ptr < ptr_end)
17018     {
17019       unsigned int j;
17020       unsigned int type;
17021       unsigned int datasz;
17022
17023       if ((size_t) (ptr_end - ptr) < 8)
17024         {
17025           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17026           break;
17027         }
17028
17029       type = byte_get (ptr, 4);
17030       datasz = byte_get (ptr + 4, 4);
17031
17032       ptr += 8;
17033
17034       if (datasz > (size_t) (ptr_end - ptr))
17035         {
17036           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17037                   type, datasz);
17038           break;
17039         }
17040
17041       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17042         {
17043           if (filedata->file_header.e_machine == EM_X86_64
17044               || filedata->file_header.e_machine == EM_IAMCU
17045               || filedata->file_header.e_machine == EM_386)
17046             {
17047               switch (type)
17048                 {
17049                 case GNU_PROPERTY_X86_ISA_1_USED:
17050                   printf ("x86 ISA used: ");
17051                   if (datasz != 4)
17052                     printf (_("<corrupt length: %#x> "), datasz);
17053                   else
17054                     decode_x86_isa (byte_get (ptr, 4));
17055                   goto next;
17056
17057                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17058                   printf ("x86 ISA needed: ");
17059                   if (datasz != 4)
17060                     printf (_("<corrupt length: %#x> "), datasz);
17061                   else
17062                     decode_x86_isa (byte_get (ptr, 4));
17063                   goto next;
17064
17065                 case GNU_PROPERTY_X86_FEATURE_1_AND:
17066                   printf ("x86 feature: ");
17067                   if (datasz != 4)
17068                     printf (_("<corrupt length: %#x> "), datasz);
17069                   else
17070                     decode_x86_feature (type, byte_get (ptr, 4));
17071                   goto next;
17072
17073                 default:
17074                   break;
17075                 }
17076             }
17077         }
17078       else
17079         {
17080           switch (type)
17081             {
17082             case GNU_PROPERTY_STACK_SIZE:
17083               printf (_("stack size: "));
17084               if (datasz != size)
17085                 printf (_("<corrupt length: %#x> "), datasz);
17086               else
17087                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17088               goto next;
17089
17090             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17091               printf ("no copy on protected ");
17092               if (datasz)
17093                 printf (_("<corrupt length: %#x> "), datasz);
17094               goto next;
17095
17096             default:
17097               break;
17098             }
17099         }
17100
17101       if (type < GNU_PROPERTY_LOPROC)
17102         printf (_("<unknown type %#x data: "), type);
17103       else if (type < GNU_PROPERTY_LOUSER)
17104         printf (_("<procesor-specific type %#x data: "), type);
17105       else
17106         printf (_("<application-specific type %#x data: "), type);
17107       for (j = 0; j < datasz; ++j)
17108         printf ("%02x ", ptr[j] & 0xff);
17109       printf (">");
17110
17111 next:
17112       ptr += ((datasz + (size - 1)) & ~ (size - 1));
17113       if (ptr == ptr_end)
17114         break;
17115
17116       if (do_wide)
17117         printf (", ");
17118       else
17119         printf ("\n\t");
17120     }
17121
17122   printf ("\n");
17123 }
17124
17125 static bfd_boolean
17126 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17127 {
17128   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17129   switch (pnote->type)
17130     {
17131     case NT_GNU_BUILD_ID:
17132       {
17133         unsigned long i;
17134
17135         printf (_("    Build ID: "));
17136         for (i = 0; i < pnote->descsz; ++i)
17137           printf ("%02x", pnote->descdata[i] & 0xff);
17138         printf ("\n");
17139       }
17140       break;
17141
17142     case NT_GNU_ABI_TAG:
17143       {
17144         unsigned long os, major, minor, subminor;
17145         const char *osname;
17146
17147         /* PR 17531: file: 030-599401-0.004.  */
17148         if (pnote->descsz < 16)
17149           {
17150             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17151             break;
17152           }
17153
17154         os = byte_get ((unsigned char *) pnote->descdata, 4);
17155         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17156         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17157         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17158
17159         switch (os)
17160           {
17161           case GNU_ABI_TAG_LINUX:
17162             osname = "Linux";
17163             break;
17164           case GNU_ABI_TAG_HURD:
17165             osname = "Hurd";
17166             break;
17167           case GNU_ABI_TAG_SOLARIS:
17168             osname = "Solaris";
17169             break;
17170           case GNU_ABI_TAG_FREEBSD:
17171             osname = "FreeBSD";
17172             break;
17173           case GNU_ABI_TAG_NETBSD:
17174             osname = "NetBSD";
17175             break;
17176           case GNU_ABI_TAG_SYLLABLE:
17177             osname = "Syllable";
17178             break;
17179           case GNU_ABI_TAG_NACL:
17180             osname = "NaCl";
17181             break;
17182           default:
17183             osname = "Unknown";
17184             break;
17185           }
17186
17187         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17188                 major, minor, subminor);
17189       }
17190       break;
17191
17192     case NT_GNU_GOLD_VERSION:
17193       {
17194         unsigned long i;
17195
17196         printf (_("    Version: "));
17197         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17198           printf ("%c", pnote->descdata[i]);
17199         printf ("\n");
17200       }
17201       break;
17202
17203     case NT_GNU_HWCAP:
17204       {
17205         unsigned long num_entries, mask;
17206
17207         /* Hardware capabilities information.  Word 0 is the number of entries.
17208            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17209            is a series of entries, where each entry is a single byte followed
17210            by a nul terminated string.  The byte gives the bit number to test
17211            if enabled in the bitmask.  */
17212         printf (_("      Hardware Capabilities: "));
17213         if (pnote->descsz < 8)
17214           {
17215             error (_("<corrupt GNU_HWCAP>\n"));
17216             return FALSE;
17217           }
17218         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17219         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17220         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17221         /* FIXME: Add code to display the entries... */
17222       }
17223       break;
17224
17225     case NT_GNU_PROPERTY_TYPE_0:
17226       print_gnu_property_note (filedata, pnote);
17227       break;
17228
17229     default:
17230       /* Handle unrecognised types.  An error message should have already been
17231          created by get_gnu_elf_note_type(), so all that we need to do is to
17232          display the data.  */
17233       {
17234         unsigned long i;
17235
17236         printf (_("    Description data: "));
17237         for (i = 0; i < pnote->descsz; ++i)
17238           printf ("%02x ", pnote->descdata[i] & 0xff);
17239         printf ("\n");
17240       }
17241       break;
17242     }
17243
17244   return TRUE;
17245 }
17246
17247 static const char *
17248 get_v850_elf_note_type (enum v850_notes n_type)
17249 {
17250   static char buff[64];
17251
17252   switch (n_type)
17253     {
17254     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17255     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17256     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17257     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17258     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17259     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17260     default:
17261       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17262       return buff;
17263     }
17264 }
17265
17266 static bfd_boolean
17267 print_v850_note (Elf_Internal_Note * pnote)
17268 {
17269   unsigned int val;
17270
17271   if (pnote->descsz != 4)
17272     return FALSE;
17273
17274   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17275
17276   if (val == 0)
17277     {
17278       printf (_("not set\n"));
17279       return TRUE;
17280     }
17281
17282   switch (pnote->type)
17283     {
17284     case V850_NOTE_ALIGNMENT:
17285       switch (val)
17286         {
17287         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17288         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17289         }
17290       break;
17291
17292     case V850_NOTE_DATA_SIZE:
17293       switch (val)
17294         {
17295         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17296         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17297         }
17298       break;
17299
17300     case V850_NOTE_FPU_INFO:
17301       switch (val)
17302         {
17303         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17304         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17305         }
17306       break;
17307
17308     case V850_NOTE_MMU_INFO:
17309     case V850_NOTE_CACHE_INFO:
17310     case V850_NOTE_SIMD_INFO:
17311       if (val == EF_RH850_SIMD)
17312         {
17313           printf (_("yes\n"));
17314           return TRUE;
17315         }
17316       break;
17317
17318     default:
17319       /* An 'unknown note type' message will already have been displayed.  */
17320       break;
17321     }
17322
17323   printf (_("unknown value: %x\n"), val);
17324   return FALSE;
17325 }
17326
17327 static bfd_boolean
17328 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17329 {
17330   unsigned int version;
17331
17332   switch (pnote->type)
17333     {
17334     case NT_NETBSD_IDENT:
17335       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17336       if ((version / 10000) % 100)
17337         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17338                 version, version / 100000000, (version / 1000000) % 100,
17339                 (version / 10000) % 100 > 26 ? "Z" : "",
17340                 'A' + (version / 10000) % 26);
17341       else
17342         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17343                 version, version / 100000000, (version / 1000000) % 100,
17344                 (version / 100) % 100);
17345       return TRUE;
17346
17347     case NT_NETBSD_MARCH:
17348       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17349               pnote->descdata);
17350       return TRUE;
17351
17352     default:
17353       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17354               pnote->type);
17355       return FALSE;
17356     }
17357 }
17358
17359 static const char *
17360 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17361 {
17362   switch (e_type)
17363     {
17364     case NT_FREEBSD_THRMISC:
17365       return _("NT_THRMISC (thrmisc structure)");
17366     case NT_FREEBSD_PROCSTAT_PROC:
17367       return _("NT_PROCSTAT_PROC (proc data)");
17368     case NT_FREEBSD_PROCSTAT_FILES:
17369       return _("NT_PROCSTAT_FILES (files data)");
17370     case NT_FREEBSD_PROCSTAT_VMMAP:
17371       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17372     case NT_FREEBSD_PROCSTAT_GROUPS:
17373       return _("NT_PROCSTAT_GROUPS (groups data)");
17374     case NT_FREEBSD_PROCSTAT_UMASK:
17375       return _("NT_PROCSTAT_UMASK (umask data)");
17376     case NT_FREEBSD_PROCSTAT_RLIMIT:
17377       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17378     case NT_FREEBSD_PROCSTAT_OSREL:
17379       return _("NT_PROCSTAT_OSREL (osreldate data)");
17380     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17381       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17382     case NT_FREEBSD_PROCSTAT_AUXV:
17383       return _("NT_PROCSTAT_AUXV (auxv data)");
17384     case NT_FREEBSD_PTLWPINFO:
17385       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17386     }
17387   return get_note_type (filedata, e_type);
17388 }
17389
17390 static const char *
17391 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17392 {
17393   static char buff[64];
17394
17395   if (e_type == NT_NETBSDCORE_PROCINFO)
17396     return _("NetBSD procinfo structure");
17397
17398   /* As of Jan 2002 there are no other machine-independent notes
17399      defined for NetBSD core files.  If the note type is less
17400      than the start of the machine-dependent note types, we don't
17401      understand it.  */
17402
17403   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17404     {
17405       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17406       return buff;
17407     }
17408
17409   switch (filedata->file_header.e_machine)
17410     {
17411     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17412        and PT_GETFPREGS == mach+2.  */
17413
17414     case EM_OLD_ALPHA:
17415     case EM_ALPHA:
17416     case EM_SPARC:
17417     case EM_SPARC32PLUS:
17418     case EM_SPARCV9:
17419       switch (e_type)
17420         {
17421         case NT_NETBSDCORE_FIRSTMACH + 0:
17422           return _("PT_GETREGS (reg structure)");
17423         case NT_NETBSDCORE_FIRSTMACH + 2:
17424           return _("PT_GETFPREGS (fpreg structure)");
17425         default:
17426           break;
17427         }
17428       break;
17429
17430     /* On all other arch's, PT_GETREGS == mach+1 and
17431        PT_GETFPREGS == mach+3.  */
17432     default:
17433       switch (e_type)
17434         {
17435         case NT_NETBSDCORE_FIRSTMACH + 1:
17436           return _("PT_GETREGS (reg structure)");
17437         case NT_NETBSDCORE_FIRSTMACH + 3:
17438           return _("PT_GETFPREGS (fpreg structure)");
17439         default:
17440           break;
17441         }
17442     }
17443
17444   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17445             e_type - NT_NETBSDCORE_FIRSTMACH);
17446   return buff;
17447 }
17448
17449 static const char *
17450 get_stapsdt_note_type (unsigned e_type)
17451 {
17452   static char buff[64];
17453
17454   switch (e_type)
17455     {
17456     case NT_STAPSDT:
17457       return _("NT_STAPSDT (SystemTap probe descriptors)");
17458
17459     default:
17460       break;
17461     }
17462
17463   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17464   return buff;
17465 }
17466
17467 static bfd_boolean
17468 print_stapsdt_note (Elf_Internal_Note *pnote)
17469 {
17470   int addr_size = is_32bit_elf ? 4 : 8;
17471   char *data = pnote->descdata;
17472   char *data_end = pnote->descdata + pnote->descsz;
17473   bfd_vma pc, base_addr, semaphore;
17474   char *provider, *probe, *arg_fmt;
17475
17476   pc = byte_get ((unsigned char *) data, addr_size);
17477   data += addr_size;
17478   base_addr = byte_get ((unsigned char *) data, addr_size);
17479   data += addr_size;
17480   semaphore = byte_get ((unsigned char *) data, addr_size);
17481   data += addr_size;
17482
17483   provider = data;
17484   data += strlen (data) + 1;
17485   probe = data;
17486   data += strlen (data) + 1;
17487   arg_fmt = data;
17488   data += strlen (data) + 1;
17489
17490   printf (_("    Provider: %s\n"), provider);
17491   printf (_("    Name: %s\n"), probe);
17492   printf (_("    Location: "));
17493   print_vma (pc, FULL_HEX);
17494   printf (_(", Base: "));
17495   print_vma (base_addr, FULL_HEX);
17496   printf (_(", Semaphore: "));
17497   print_vma (semaphore, FULL_HEX);
17498   printf ("\n");
17499   printf (_("    Arguments: %s\n"), arg_fmt);
17500
17501   return data == data_end;
17502 }
17503
17504 static const char *
17505 get_ia64_vms_note_type (unsigned e_type)
17506 {
17507   static char buff[64];
17508
17509   switch (e_type)
17510     {
17511     case NT_VMS_MHD:
17512       return _("NT_VMS_MHD (module header)");
17513     case NT_VMS_LNM:
17514       return _("NT_VMS_LNM (language name)");
17515     case NT_VMS_SRC:
17516       return _("NT_VMS_SRC (source files)");
17517     case NT_VMS_TITLE:
17518       return "NT_VMS_TITLE";
17519     case NT_VMS_EIDC:
17520       return _("NT_VMS_EIDC (consistency check)");
17521     case NT_VMS_FPMODE:
17522       return _("NT_VMS_FPMODE (FP mode)");
17523     case NT_VMS_LINKTIME:
17524       return "NT_VMS_LINKTIME";
17525     case NT_VMS_IMGNAM:
17526       return _("NT_VMS_IMGNAM (image name)");
17527     case NT_VMS_IMGID:
17528       return _("NT_VMS_IMGID (image id)");
17529     case NT_VMS_LINKID:
17530       return _("NT_VMS_LINKID (link id)");
17531     case NT_VMS_IMGBID:
17532       return _("NT_VMS_IMGBID (build id)");
17533     case NT_VMS_GSTNAM:
17534       return _("NT_VMS_GSTNAM (sym table name)");
17535     case NT_VMS_ORIG_DYN:
17536       return "NT_VMS_ORIG_DYN";
17537     case NT_VMS_PATCHTIME:
17538       return "NT_VMS_PATCHTIME";
17539     default:
17540       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17541       return buff;
17542     }
17543 }
17544
17545 static bfd_boolean
17546 print_ia64_vms_note (Elf_Internal_Note * pnote)
17547 {
17548   switch (pnote->type)
17549     {
17550     case NT_VMS_MHD:
17551       if (pnote->descsz > 36)
17552         {
17553           size_t l = strlen (pnote->descdata + 34);
17554           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17555           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17556           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17557           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17558         }
17559       else
17560         printf (_("    Invalid size\n"));
17561       break;
17562     case NT_VMS_LNM:
17563       printf (_("   Language: %s\n"), pnote->descdata);
17564       break;
17565 #ifdef BFD64
17566     case NT_VMS_FPMODE:
17567       printf (_("   Floating Point mode: "));
17568       printf ("0x%016" BFD_VMA_FMT "x\n",
17569               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17570       break;
17571     case NT_VMS_LINKTIME:
17572       printf (_("   Link time: "));
17573       print_vms_time
17574         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17575       printf ("\n");
17576       break;
17577     case NT_VMS_PATCHTIME:
17578       printf (_("   Patch time: "));
17579       print_vms_time
17580         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17581       printf ("\n");
17582       break;
17583     case NT_VMS_ORIG_DYN:
17584       printf (_("   Major id: %u,  minor id: %u\n"),
17585               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17586               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17587       printf (_("   Last modified  : "));
17588       print_vms_time
17589         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17590       printf (_("\n   Link flags  : "));
17591       printf ("0x%016" BFD_VMA_FMT "x\n",
17592               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17593       printf (_("   Header flags: 0x%08x\n"),
17594               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17595       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17596       break;
17597 #endif
17598     case NT_VMS_IMGNAM:
17599       printf (_("    Image name: %s\n"), pnote->descdata);
17600       break;
17601     case NT_VMS_GSTNAM:
17602       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17603       break;
17604     case NT_VMS_IMGID:
17605       printf (_("    Image id: %s\n"), pnote->descdata);
17606       break;
17607     case NT_VMS_LINKID:
17608       printf (_("    Linker id: %s\n"), pnote->descdata);
17609       break;
17610     default:
17611       return FALSE;
17612     }
17613   return TRUE;
17614 }
17615
17616 /* Find the symbol associated with a build attribute that is attached
17617    to address OFFSET.  If PNAME is non-NULL then store the name of
17618    the symbol (if found) in the provided pointer,  Returns NULL if a
17619    symbol could not be found.  */
17620
17621 static Elf_Internal_Sym *
17622 get_symbol_for_build_attribute (Filedata *       filedata,
17623                                 unsigned long    offset,
17624                                 bfd_boolean      is_open_attr,
17625                                 const char **    pname)
17626 {
17627   static Filedata *         saved_filedata = NULL;
17628   static char *             strtab;
17629   static unsigned long      strtablen;
17630   static Elf_Internal_Sym * symtab;
17631   static unsigned long      nsyms;
17632   Elf_Internal_Sym *        saved_sym = NULL;
17633   Elf_Internal_Sym *        sym;
17634
17635   if (filedata->section_headers != NULL
17636       && (saved_filedata == NULL || filedata != saved_filedata))
17637     {
17638       Elf_Internal_Shdr * symsec;
17639
17640       /* Load the symbol and string sections.  */
17641       for (symsec = filedata->section_headers;
17642            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17643            symsec ++)
17644         {
17645           if (symsec->sh_type == SHT_SYMTAB)
17646             {
17647               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17648
17649               if (symsec->sh_link < filedata->file_header.e_shnum)
17650                 {
17651                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17652
17653                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17654                                               1, strtab_sec->sh_size,
17655                                               _("string table"));
17656                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17657                 }
17658             }
17659         }
17660       saved_filedata = filedata;
17661     }
17662
17663   if (symtab == NULL || strtab == NULL)
17664     return NULL;
17665
17666   /* Find a symbol whose value matches offset.  */
17667   for (sym = symtab; sym < symtab + nsyms; sym ++)
17668     if (sym->st_value == offset)
17669       {
17670         if (sym->st_name >= strtablen)
17671           /* Huh ?  This should not happen.  */
17672           continue;
17673
17674         if (strtab[sym->st_name] == 0)
17675           continue;
17676
17677         /* The AArch64 and ARM architectures define mapping symbols
17678            (eg $d, $x, $t) which we want to ignore.  */
17679         if (strtab[sym->st_name] == '$'
17680             && strtab[sym->st_name + 1] != 0
17681             && strtab[sym->st_name + 2] == 0)
17682           continue;
17683
17684         if (is_open_attr)
17685           {
17686             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17687                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17688                FUNC symbols entirely.  */
17689             switch (ELF_ST_TYPE (sym->st_info))
17690               {
17691               case STT_OBJECT:
17692               case STT_FILE:
17693                 saved_sym = sym;
17694                 if (sym->st_size)
17695                   {
17696                     /* If the symbol has a size associated
17697                        with it then we can stop searching.  */
17698                     sym = symtab + nsyms;
17699                   }
17700                 continue;
17701
17702               case STT_FUNC:
17703                 /* Ignore function symbols.  */
17704                 continue;
17705
17706               default:
17707                 break;
17708               }
17709
17710             switch (ELF_ST_BIND (sym->st_info))
17711               {
17712               case STB_GLOBAL:
17713                 if (saved_sym == NULL
17714                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17715                   saved_sym = sym;
17716                 break;
17717
17718               case STB_LOCAL:
17719                 if (saved_sym == NULL)
17720                   saved_sym = sym;
17721                 break;
17722
17723               default:
17724                 break;
17725               }
17726           }
17727         else
17728           {
17729             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17730               continue;
17731
17732             saved_sym = sym;
17733             break;
17734           }
17735       }
17736
17737   if (saved_sym && pname)
17738     * pname = strtab + saved_sym->st_name;
17739
17740   return saved_sym;
17741 }
17742
17743 /* Returns true iff addr1 and addr2 are in the same section.  */
17744
17745 static bfd_boolean
17746 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
17747 {
17748   Elf_Internal_Shdr * a1;
17749   Elf_Internal_Shdr * a2;
17750
17751   a1 = find_section_by_address (filedata, addr1);
17752   a2 = find_section_by_address (filedata, addr2);
17753
17754   return a1 == a2 && a1 != NULL;
17755 }
17756
17757 static bfd_boolean
17758 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
17759                                        Filedata *           filedata)
17760 {
17761   static unsigned long  global_offset = 0;
17762   static unsigned long  global_end = 0;
17763   static unsigned long  func_offset = 0;
17764   static unsigned long  func_end = 0;
17765
17766   Elf_Internal_Sym *    sym;
17767   const char *          name;
17768   unsigned long         start;
17769   unsigned long         end;
17770   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17771
17772   switch (pnote->descsz)
17773     {
17774     case 0:
17775       /* A zero-length description means that the range of
17776          the previous note of the same type should be used.  */
17777       if (is_open_attr)
17778         {
17779           if (global_end > global_offset)
17780             printf (_("    Applies to region from %#lx to %#lx\n"),
17781                     global_offset, global_end);
17782           else
17783             printf (_("    Applies to region from %#lx\n"), global_offset);
17784         }
17785       else
17786         {
17787           if (func_end > func_offset)
17788             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
17789           else
17790             printf (_("    Applies to region from %#lx\n"), func_offset);
17791         }
17792       return TRUE;
17793
17794     case 4:
17795       start = byte_get ((unsigned char *) pnote->descdata, 4);
17796       end = 0;
17797       break;
17798
17799     case 8:
17800       if (is_32bit_elf)
17801         {
17802           /* FIXME: We should check that version 3+ notes are being used here...  */
17803           start = byte_get ((unsigned char *) pnote->descdata, 4);
17804           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17805         }
17806       else
17807         {
17808           start = byte_get ((unsigned char *) pnote->descdata, 8);
17809           end = 0;
17810         }
17811       break;
17812
17813     case 16:
17814       start = byte_get ((unsigned char *) pnote->descdata, 8);
17815       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
17816       break;
17817
17818     default:
17819       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17820       printf (_("    <invalid descsz>"));
17821       return FALSE;
17822     }
17823
17824   name = NULL;
17825   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
17826   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17827      in order to avoid them being confused with the start address of the
17828      first function in the file...  */
17829   if (sym == NULL && is_open_attr)
17830     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
17831                                           & name);
17832
17833   if (end == 0 && sym != NULL && sym->st_size > 0)
17834     end = start + sym->st_size;
17835
17836   if (is_open_attr)
17837     {
17838       /* FIXME: Need to properly allow for section alignment.
17839          16 is just the alignment used on x86_64.  */
17840       if (global_end > 0
17841           && start > BFD_ALIGN (global_end, 16)
17842           /* Build notes are not guaranteed to be organised in order of
17843              increasing address, but we should find the all of the notes
17844              for one section in the same place.  */
17845           && same_section (filedata, start, global_end))
17846         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17847               global_end + 1, start - 1);
17848
17849       printf (_("    Applies to region from %#lx"), start);
17850       global_offset = start;
17851
17852       if (end)
17853         {
17854           printf (_(" to %#lx"), end);
17855           global_end = end;
17856         }
17857     }
17858   else
17859     {
17860       printf (_("    Applies to region from %#lx"), start);
17861       func_offset = start;
17862
17863       if (end)
17864         {
17865           printf (_(" to %#lx"), end);
17866           func_end = end;
17867         }
17868     }
17869
17870   if (sym && name)
17871     printf (_(" (%s)"), name);
17872
17873   printf ("\n");
17874   return TRUE;
17875 }
17876
17877 static bfd_boolean
17878 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17879 {
17880   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17881   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17882   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17883   char         name_type;
17884   char         name_attribute;
17885   const char * expected_types;
17886   const char * name = pnote->namedata;
17887   const char * text;
17888   signed int   left;
17889
17890   if (name == NULL || pnote->namesz < 2)
17891     {
17892       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17893       print_symbol (-20, _("  <corrupt name>"));
17894       return FALSE;
17895     }
17896
17897   if (do_wide)
17898     left = 28;
17899   else
17900     left = 20;
17901
17902   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17903   if (name[0] == 'G' && name[1] == 'A')
17904     {
17905       if (pnote->namesz < 4)
17906         {
17907           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17908           print_symbol (-20, _("  <corrupt name>"));
17909           return FALSE;
17910         }
17911
17912       printf ("GA");
17913       name += 2;
17914       left -= 2;
17915     }
17916
17917   switch ((name_type = * name))
17918     {
17919     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17920     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17921     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17922     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17923       printf ("%c", * name);
17924       left --;
17925       break;
17926     default:
17927       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17928       print_symbol (-20, _("<unknown name type>"));
17929       return FALSE;
17930     }
17931
17932   ++ name;
17933   text = NULL;
17934
17935   switch ((name_attribute = * name))
17936     {
17937     case GNU_BUILD_ATTRIBUTE_VERSION:
17938       text = _("<version>");
17939       expected_types = string_expected;
17940       ++ name;
17941       break;
17942     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17943       text = _("<stack prot>");
17944       expected_types = "!+*";
17945       ++ name;
17946       break;
17947     case GNU_BUILD_ATTRIBUTE_RELRO:
17948       text = _("<relro>");
17949       expected_types = bool_expected;
17950       ++ name;
17951       break;
17952     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17953       text = _("<stack size>");
17954       expected_types = number_expected;
17955       ++ name;
17956       break;
17957     case GNU_BUILD_ATTRIBUTE_TOOL:
17958       text = _("<tool>");
17959       expected_types = string_expected;
17960       ++ name;
17961       break;
17962     case GNU_BUILD_ATTRIBUTE_ABI:
17963       text = _("<ABI>");
17964       expected_types = "$*";
17965       ++ name;
17966       break;
17967     case GNU_BUILD_ATTRIBUTE_PIC:
17968       text = _("<PIC>");
17969       expected_types = number_expected;
17970       ++ name;
17971       break;
17972     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17973       text = _("<short enum>");
17974       expected_types = bool_expected;
17975       ++ name;
17976       break;
17977     default:
17978       if (ISPRINT (* name))
17979         {
17980           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17981
17982           if (len > left && ! do_wide)
17983             len = left;
17984           printf ("%.*s:", len, name);
17985           left -= len;
17986           name += len;
17987         }
17988       else
17989         {
17990           static char tmpbuf [128];
17991
17992           error (_("unrecognised byte in name field: %d\n"), * name);
17993           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17994           text = tmpbuf;
17995           name ++;
17996         }
17997       expected_types = "*$!+";
17998       break;
17999     }
18000
18001   if (text)
18002     left -= printf ("%s", text);
18003
18004   if (strchr (expected_types, name_type) == NULL)
18005     warn (_("attribute does not have an expected type (%c)\n"), name_type);
18006
18007   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18008     {
18009       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18010              (unsigned long) pnote->namesz,
18011              (long) (name - pnote->namedata));
18012       return FALSE;
18013     }
18014
18015   if (left < 1 && ! do_wide)
18016     return TRUE;
18017
18018   switch (name_type)
18019     {
18020     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18021       {
18022         unsigned int        bytes;
18023         unsigned long long  val = 0;
18024         unsigned int        shift = 0;
18025         char *              decoded = NULL;
18026
18027         bytes = pnote->namesz - (name - pnote->namedata);
18028         if (bytes > 0)
18029           /* The -1 is because the name field is always 0 terminated, and we
18030              want to be able to ensure that the shift in the while loop below
18031              will not overflow.  */
18032           -- bytes;
18033
18034         if (bytes > sizeof (val))
18035           {
18036             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18037                    bytes);
18038             bytes = sizeof (val);
18039           }
18040         /* We do not bother to warn if bytes == 0 as this can
18041            happen with some early versions of the gcc plugin.  */
18042
18043         while (bytes --)
18044           {
18045             unsigned long byte = (* name ++) & 0xff;
18046
18047             val |= byte << shift;
18048             shift += 8;
18049           }
18050
18051         switch (name_attribute)
18052           {
18053           case GNU_BUILD_ATTRIBUTE_PIC:
18054             switch (val)
18055               {
18056               case 0: decoded = "static"; break;
18057               case 1: decoded = "pic"; break;
18058               case 2: decoded = "PIC"; break;
18059               case 3: decoded = "pie"; break;
18060               case 4: decoded = "PIE"; break;
18061               default: break;
18062               }
18063             break;
18064           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18065             switch (val)
18066               {
18067                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
18068               case 0: decoded = "off"; break;
18069               case 1: decoded = "on"; break;
18070               case 2: decoded = "all"; break;
18071               case 3: decoded = "strong"; break;
18072               case 4: decoded = "explicit"; break;
18073               default: break;
18074               }
18075             break;
18076           default:
18077             break;
18078           }
18079
18080         if (decoded != NULL)
18081           {
18082             print_symbol (-left, decoded);
18083             left = 0;
18084           }
18085         else if (val == 0)
18086           {
18087             printf ("0x0");
18088             left -= 3;
18089           }
18090         else
18091           {
18092             if (do_wide)
18093               left -= printf ("0x%llx", val);
18094             else
18095               left -= printf ("0x%-.*llx", left, val);
18096           }
18097       }
18098       break;
18099     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18100       left -= print_symbol (- left, name);
18101       break;
18102     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18103       left -= print_symbol (- left, "true");
18104       break;
18105     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18106       left -= print_symbol (- left, "false");
18107       break;
18108     }
18109
18110   if (do_wide && left > 0)
18111     printf ("%-*s", left, " ");
18112
18113   return TRUE;
18114 }
18115
18116 /* Note that by the ELF standard, the name field is already null byte
18117    terminated, and namesz includes the terminating null byte.
18118    I.E. the value of namesz for the name "FSF" is 4.
18119
18120    If the value of namesz is zero, there is no name present.  */
18121
18122 static bfd_boolean
18123 process_note (Elf_Internal_Note *  pnote,
18124               Filedata *           filedata)
18125 {
18126   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18127   const char * nt;
18128
18129   if (pnote->namesz == 0)
18130     /* If there is no note name, then use the default set of
18131        note type strings.  */
18132     nt = get_note_type (filedata, pnote->type);
18133
18134   else if (const_strneq (pnote->namedata, "GNU"))
18135     /* GNU-specific object file notes.  */
18136     nt = get_gnu_elf_note_type (pnote->type);
18137
18138   else if (const_strneq (pnote->namedata, "FreeBSD"))
18139     /* FreeBSD-specific core file notes.  */
18140     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18141
18142   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18143     /* NetBSD-specific core file notes.  */
18144     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18145
18146   else if (const_strneq (pnote->namedata, "NetBSD"))
18147     /* NetBSD-specific core file notes.  */
18148     return process_netbsd_elf_note (pnote);
18149
18150   else if (strneq (pnote->namedata, "SPU/", 4))
18151     {
18152       /* SPU-specific core file notes.  */
18153       nt = pnote->namedata + 4;
18154       name = "SPU";
18155     }
18156
18157   else if (const_strneq (pnote->namedata, "IPF/VMS"))
18158     /* VMS/ia64-specific file notes.  */
18159     nt = get_ia64_vms_note_type (pnote->type);
18160
18161   else if (const_strneq (pnote->namedata, "stapsdt"))
18162     nt = get_stapsdt_note_type (pnote->type);
18163
18164   else
18165     /* Don't recognize this note name; just use the default set of
18166        note type strings.  */
18167     nt = get_note_type (filedata, pnote->type);
18168
18169   printf ("  ");
18170
18171   if (((const_strneq (pnote->namedata, "GA")
18172         && strchr ("*$!+", pnote->namedata[2]) != NULL)
18173        || strchr ("*$!+", pnote->namedata[0]) != NULL)
18174       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18175           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18176     print_gnu_build_attribute_name (pnote);
18177   else
18178     print_symbol (-20, name);
18179
18180   if (do_wide)
18181     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18182   else
18183     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18184
18185   if (const_strneq (pnote->namedata, "IPF/VMS"))
18186     return print_ia64_vms_note (pnote);
18187   else if (const_strneq (pnote->namedata, "GNU"))
18188     return print_gnu_note (filedata, pnote);
18189   else if (const_strneq (pnote->namedata, "stapsdt"))
18190     return print_stapsdt_note (pnote);
18191   else if (const_strneq (pnote->namedata, "CORE"))
18192     return print_core_note (pnote);
18193   else if (((const_strneq (pnote->namedata, "GA")
18194              && strchr ("*$!+", pnote->namedata[2]) != NULL)
18195             || strchr ("*$!+", pnote->namedata[0]) != NULL)
18196            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18197                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18198     return print_gnu_build_attribute_description (pnote, filedata);
18199
18200   if (pnote->descsz)
18201     {
18202       unsigned long i;
18203
18204       printf (_("   description data: "));
18205       for (i = 0; i < pnote->descsz; i++)
18206         printf ("%02x ", pnote->descdata[i]);
18207       if (!do_wide)
18208         printf ("\n");
18209     }
18210
18211   if (do_wide)
18212     printf ("\n");
18213
18214   return TRUE;
18215 }
18216
18217 static bfd_boolean
18218 process_notes_at (Filedata *           filedata,
18219                   Elf_Internal_Shdr *  section,
18220                   bfd_vma              offset,
18221                   bfd_vma              length,
18222                   bfd_vma              align)
18223 {
18224   Elf_External_Note * pnotes;
18225   Elf_External_Note * external;
18226   char *              end;
18227   bfd_boolean         res = TRUE;
18228
18229   if (length <= 0)
18230     return FALSE;
18231
18232   if (section)
18233     {
18234       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18235       if (pnotes)
18236         {
18237           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18238             return FALSE;
18239         }
18240     }
18241   else
18242     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18243                                              _("notes"));
18244
18245   if (pnotes == NULL)
18246     return FALSE;
18247
18248   external = pnotes;
18249
18250   if (section)
18251     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18252   else
18253     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18254             (unsigned long) offset, (unsigned long) length);
18255
18256   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18257      specifies that notes should be aligned to 4 bytes in 32-bit
18258      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18259      we also support 4 byte alignment in 64-bit objects.  If section
18260      alignment is less than 4, we treate alignment as 4 bytes.   */
18261   if (align < 4)
18262     align = 4;
18263   else if (align != 4 && align != 8)
18264     {
18265       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18266             (long) align);
18267       return FALSE;
18268     }
18269
18270   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18271
18272   end = (char *) pnotes + length;
18273   while ((char *) external < end)
18274     {
18275       Elf_Internal_Note inote;
18276       size_t min_notesz;
18277       char * next;
18278       char * temp = NULL;
18279       size_t data_remaining = end - (char *) external;
18280
18281       if (!is_ia64_vms (filedata))
18282         {
18283           /* PR binutils/15191
18284              Make sure that there is enough data to read.  */
18285           min_notesz = offsetof (Elf_External_Note, name);
18286           if (data_remaining < min_notesz)
18287             {
18288               warn (ngettext ("Corrupt note: only %ld byte remains, "
18289                               "not enough for a full note\n",
18290                               "Corrupt note: only %ld bytes remain, "
18291                               "not enough for a full note\n",
18292                               data_remaining),
18293                     (long) data_remaining);
18294               break;
18295             }
18296           data_remaining -= min_notesz;
18297
18298           inote.type     = BYTE_GET (external->type);
18299           inote.namesz   = BYTE_GET (external->namesz);
18300           inote.namedata = external->name;
18301           inote.descsz   = BYTE_GET (external->descsz);
18302           inote.descdata = ((char *) external
18303                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18304           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18305           next = ((char *) external
18306                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18307         }
18308       else
18309         {
18310           Elf64_External_VMS_Note *vms_external;
18311
18312           /* PR binutils/15191
18313              Make sure that there is enough data to read.  */
18314           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18315           if (data_remaining < min_notesz)
18316             {
18317               warn (ngettext ("Corrupt note: only %ld byte remains, "
18318                               "not enough for a full note\n",
18319                               "Corrupt note: only %ld bytes remain, "
18320                               "not enough for a full note\n",
18321                               data_remaining),
18322                     (long) data_remaining);
18323               break;
18324             }
18325           data_remaining -= min_notesz;
18326
18327           vms_external = (Elf64_External_VMS_Note *) external;
18328           inote.type     = BYTE_GET (vms_external->type);
18329           inote.namesz   = BYTE_GET (vms_external->namesz);
18330           inote.namedata = vms_external->name;
18331           inote.descsz   = BYTE_GET (vms_external->descsz);
18332           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18333           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18334           next = inote.descdata + align_power (inote.descsz, 3);
18335         }
18336
18337       /* PR 17531: file: 3443835e.  */
18338       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18339       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18340           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18341           || (size_t) (next - inote.descdata) < inote.descsz
18342           || ((size_t) (next - inote.descdata)
18343               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18344         {
18345           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18346                 (unsigned long) ((char *) external - (char *) pnotes));
18347           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18348                 inote.type, inote.namesz, inote.descsz, (int) align);
18349           break;
18350         }
18351
18352       external = (Elf_External_Note *) next;
18353
18354       /* Verify that name is null terminated.  It appears that at least
18355          one version of Linux (RedHat 6.0) generates corefiles that don't
18356          comply with the ELF spec by failing to include the null byte in
18357          namesz.  */
18358       if (inote.namedata[inote.namesz - 1] != '\0')
18359         {
18360           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18361             {
18362               temp = (char *) malloc (inote.namesz + 1);
18363               if (temp == NULL)
18364                 {
18365                   error (_("Out of memory allocating space for inote name\n"));
18366                   res = FALSE;
18367                   break;
18368                 }
18369
18370               memcpy (temp, inote.namedata, inote.namesz);
18371               inote.namedata = temp;
18372             }
18373           inote.namedata[inote.namesz] = 0;
18374         }
18375
18376       if (! process_note (& inote, filedata))
18377         res = FALSE;
18378
18379       if (temp != NULL)
18380         {
18381           free (temp);
18382           temp = NULL;
18383         }
18384     }
18385
18386   free (pnotes);
18387
18388   return res;
18389 }
18390
18391 static bfd_boolean
18392 process_corefile_note_segments (Filedata * filedata)
18393 {
18394   Elf_Internal_Phdr * segment;
18395   unsigned int i;
18396   bfd_boolean res = TRUE;
18397
18398   if (! get_program_headers (filedata))
18399     return TRUE;
18400
18401   for (i = 0, segment = filedata->program_headers;
18402        i < filedata->file_header.e_phnum;
18403        i++, segment++)
18404     {
18405       if (segment->p_type == PT_NOTE)
18406         if (! process_notes_at (filedata, NULL,
18407                                 (bfd_vma) segment->p_offset,
18408                                 (bfd_vma) segment->p_filesz,
18409                                 (bfd_vma) segment->p_align))
18410           res = FALSE;
18411     }
18412
18413   return res;
18414 }
18415
18416 static bfd_boolean
18417 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18418 {
18419   Elf_External_Note * pnotes;
18420   Elf_External_Note * external;
18421   char * end;
18422   bfd_boolean res = TRUE;
18423
18424   if (length <= 0)
18425     return FALSE;
18426
18427   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18428                                            _("v850 notes"));
18429   if (pnotes == NULL)
18430     return FALSE;
18431
18432   external = pnotes;
18433   end = (char*) pnotes + length;
18434
18435   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18436           (unsigned long) offset, (unsigned long) length);
18437
18438   while ((char *) external + sizeof (Elf_External_Note) < end)
18439     {
18440       Elf_External_Note * next;
18441       Elf_Internal_Note inote;
18442
18443       inote.type     = BYTE_GET (external->type);
18444       inote.namesz   = BYTE_GET (external->namesz);
18445       inote.namedata = external->name;
18446       inote.descsz   = BYTE_GET (external->descsz);
18447       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18448       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18449
18450       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18451         {
18452           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18453           inote.descdata = inote.namedata;
18454           inote.namesz   = 0;
18455         }
18456
18457       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18458
18459       if (   ((char *) next > end)
18460           || ((char *) next <  (char *) pnotes))
18461         {
18462           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18463                 (unsigned long) ((char *) external - (char *) pnotes));
18464           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18465                 inote.type, inote.namesz, inote.descsz);
18466           break;
18467         }
18468
18469       external = next;
18470
18471       /* Prevent out-of-bounds indexing.  */
18472       if (   inote.namedata + inote.namesz > end
18473           || inote.namedata + inote.namesz < inote.namedata)
18474         {
18475           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18476                 (unsigned long) ((char *) external - (char *) pnotes));
18477           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18478                 inote.type, inote.namesz, inote.descsz);
18479           break;
18480         }
18481
18482       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18483
18484       if (! print_v850_note (& inote))
18485         {
18486           res = FALSE;
18487           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18488                   inote.namesz, inote.descsz);
18489         }
18490     }
18491
18492   free (pnotes);
18493
18494   return res;
18495 }
18496
18497 static bfd_boolean
18498 process_note_sections (Filedata * filedata)
18499 {
18500   Elf_Internal_Shdr * section;
18501   unsigned long i;
18502   unsigned int n = 0;
18503   bfd_boolean res = TRUE;
18504
18505   for (i = 0, section = filedata->section_headers;
18506        i < filedata->file_header.e_shnum && section != NULL;
18507        i++, section++)
18508     {
18509       if (section->sh_type == SHT_NOTE)
18510         {
18511           if (! process_notes_at (filedata, section,
18512                                   (bfd_vma) section->sh_offset,
18513                                   (bfd_vma) section->sh_size,
18514                                   (bfd_vma) section->sh_addralign))
18515             res = FALSE;
18516           n++;
18517         }
18518
18519       if ((   filedata->file_header.e_machine == EM_V800
18520            || filedata->file_header.e_machine == EM_V850
18521            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18522           && section->sh_type == SHT_RENESAS_INFO)
18523         {
18524           if (! process_v850_notes (filedata,
18525                                     (bfd_vma) section->sh_offset,
18526                                     (bfd_vma) section->sh_size))
18527             res = FALSE;
18528           n++;
18529         }
18530     }
18531
18532   if (n == 0)
18533     /* Try processing NOTE segments instead.  */
18534     return process_corefile_note_segments (filedata);
18535
18536   return res;
18537 }
18538
18539 static bfd_boolean
18540 process_notes (Filedata * filedata)
18541 {
18542   /* If we have not been asked to display the notes then do nothing.  */
18543   if (! do_notes)
18544     return TRUE;
18545
18546   if (filedata->file_header.e_type != ET_CORE)
18547     return process_note_sections (filedata);
18548
18549   /* No program headers means no NOTE segment.  */
18550   if (filedata->file_header.e_phnum > 0)
18551     return process_corefile_note_segments (filedata);
18552
18553   printf (_("No note segments present in the core file.\n"));
18554   return TRUE;
18555 }
18556
18557 static unsigned char *
18558 display_public_gnu_attributes (unsigned char * start,
18559                                const unsigned char * const end)
18560 {
18561   printf (_("  Unknown GNU attribute: %s\n"), start);
18562
18563   start += strnlen ((char *) start, end - start);
18564   display_raw_attribute (start, end);
18565
18566   return (unsigned char *) end;
18567 }
18568
18569 static unsigned char *
18570 display_generic_attribute (unsigned char * start,
18571                            unsigned int tag,
18572                            const unsigned char * const end)
18573 {
18574   if (tag == 0)
18575     return (unsigned char *) end;
18576
18577   return display_tag_value (tag, start, end);
18578 }
18579
18580 static bfd_boolean
18581 process_arch_specific (Filedata * filedata)
18582 {
18583   if (! do_arch)
18584     return TRUE;
18585
18586   switch (filedata->file_header.e_machine)
18587     {
18588     case EM_ARC:
18589     case EM_ARC_COMPACT:
18590     case EM_ARC_COMPACT2:
18591       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18592                                  display_arc_attribute,
18593                                  display_generic_attribute);
18594     case EM_ARM:
18595       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18596                                  display_arm_attribute,
18597                                  display_generic_attribute);
18598
18599     case EM_MIPS:
18600     case EM_MIPS_RS3_LE:
18601       return process_mips_specific (filedata);
18602
18603     case EM_MSP430:
18604      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18605                                 display_msp430x_attribute,
18606                                 display_generic_attribute);
18607
18608     case EM_NDS32:
18609       return process_nds32_specific (filedata);
18610
18611     case EM_PPC:
18612     case EM_PPC64:
18613       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18614                                  display_power_gnu_attribute);
18615
18616     case EM_S390:
18617     case EM_S390_OLD:
18618       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18619                                  display_s390_gnu_attribute);
18620
18621     case EM_SPARC:
18622     case EM_SPARC32PLUS:
18623     case EM_SPARCV9:
18624       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18625                                  display_sparc_gnu_attribute);
18626
18627     case EM_TI_C6000:
18628       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18629                                  display_tic6x_attribute,
18630                                  display_generic_attribute);
18631
18632     default:
18633       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18634                                  display_public_gnu_attributes,
18635                                  display_generic_attribute);
18636     }
18637 }
18638
18639 static bfd_boolean
18640 get_file_header (Filedata * filedata)
18641 {
18642   /* Read in the identity array.  */
18643   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18644     return FALSE;
18645
18646   /* Determine how to read the rest of the header.  */
18647   switch (filedata->file_header.e_ident[EI_DATA])
18648     {
18649     default:
18650     case ELFDATANONE:
18651     case ELFDATA2LSB:
18652       byte_get = byte_get_little_endian;
18653       byte_put = byte_put_little_endian;
18654       break;
18655     case ELFDATA2MSB:
18656       byte_get = byte_get_big_endian;
18657       byte_put = byte_put_big_endian;
18658       break;
18659     }
18660
18661   /* For now we only support 32 bit and 64 bit ELF files.  */
18662   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18663
18664   /* Read in the rest of the header.  */
18665   if (is_32bit_elf)
18666     {
18667       Elf32_External_Ehdr ehdr32;
18668
18669       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18670         return FALSE;
18671
18672       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18673       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18674       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18675       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18676       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18677       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18678       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18679       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18680       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18681       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18682       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18683       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18684       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18685     }
18686   else
18687     {
18688       Elf64_External_Ehdr ehdr64;
18689
18690       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18691          we will not be able to cope with the 64bit data found in
18692          64 ELF files.  Detect this now and abort before we start
18693          overwriting things.  */
18694       if (sizeof (bfd_vma) < 8)
18695         {
18696           error (_("This instance of readelf has been built without support for a\n\
18697 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18698           return FALSE;
18699         }
18700
18701       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18702         return FALSE;
18703
18704       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18705       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18706       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18707       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18708       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18709       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18710       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18711       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18712       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18713       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18714       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18715       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18716       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18717     }
18718
18719   if (filedata->file_header.e_shoff)
18720     {
18721       /* There may be some extensions in the first section header.  Don't
18722          bomb if we can't read it.  */
18723       if (is_32bit_elf)
18724         get_32bit_section_headers (filedata, TRUE);
18725       else
18726         get_64bit_section_headers (filedata, TRUE);
18727     }
18728
18729   return TRUE;
18730 }
18731
18732 static void
18733 close_file (Filedata * filedata)
18734 {
18735   if (filedata)
18736     {
18737       if (filedata->handle)
18738         fclose (filedata->handle);
18739       free (filedata);
18740     }
18741 }
18742
18743 void
18744 close_debug_file (void * data)
18745 {
18746   close_file ((Filedata *) data);
18747 }
18748
18749 static Filedata *
18750 open_file (const char * pathname)
18751 {
18752   struct stat  statbuf;
18753   Filedata *   filedata = NULL;
18754
18755   if (stat (pathname, & statbuf) < 0
18756       || ! S_ISREG (statbuf.st_mode))
18757     goto fail;
18758
18759   filedata = calloc (1, sizeof * filedata);
18760   if (filedata == NULL)
18761     goto fail;
18762
18763   filedata->handle = fopen (pathname, "rb");
18764   if (filedata->handle == NULL)
18765     goto fail;
18766
18767   filedata->file_size = (bfd_size_type) statbuf.st_size;
18768   filedata->file_name = pathname;
18769
18770   if (! get_file_header (filedata))
18771     goto fail;
18772
18773   if (filedata->file_header.e_shoff)
18774     {
18775       bfd_boolean res;
18776
18777       /* Read the section headers again, this time for real.  */
18778       if (is_32bit_elf)
18779         res = get_32bit_section_headers (filedata, FALSE);
18780       else
18781         res = get_64bit_section_headers (filedata, FALSE);
18782
18783       if (!res)
18784         goto fail;
18785     }
18786
18787   return filedata;
18788
18789  fail:
18790   if (filedata)
18791     {
18792       if (filedata->handle)
18793         fclose (filedata->handle);
18794       free (filedata);
18795     }
18796   return NULL;
18797 }
18798
18799 void *
18800 open_debug_file (const char * pathname)
18801 {
18802   return open_file (pathname);
18803 }
18804
18805 /* Process one ELF object file according to the command line options.
18806    This file may actually be stored in an archive.  The file is
18807    positioned at the start of the ELF object.  Returns TRUE if no
18808    problems were encountered, FALSE otherwise.  */
18809
18810 static bfd_boolean
18811 process_object (Filedata * filedata)
18812 {
18813   Filedata * separates;
18814   unsigned int i;
18815   bfd_boolean res = TRUE;
18816
18817   if (! get_file_header (filedata))
18818     {
18819       error (_("%s: Failed to read file header\n"), filedata->file_name);
18820       return FALSE;
18821     }
18822
18823   /* Initialise per file variables.  */
18824   for (i = ARRAY_SIZE (version_info); i--;)
18825     version_info[i] = 0;
18826
18827   for (i = ARRAY_SIZE (dynamic_info); i--;)
18828     dynamic_info[i] = 0;
18829   dynamic_info_DT_GNU_HASH = 0;
18830
18831   /* Process the file.  */
18832   if (show_name)
18833     printf (_("\nFile: %s\n"), filedata->file_name);
18834
18835   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18836      Note we do this even if cmdline_dump_sects is empty because we
18837      must make sure that the dump_sets array is zeroed out before each
18838      object file is processed.  */
18839   if (filedata->num_dump_sects > cmdline.num_dump_sects)
18840     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
18841
18842   if (cmdline.num_dump_sects > 0)
18843     {
18844       if (filedata->num_dump_sects == 0)
18845         /* A sneaky way of allocating the dump_sects array.  */
18846         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
18847
18848       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
18849       memcpy (filedata->dump_sects, cmdline.dump_sects,
18850               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
18851     }
18852
18853   if (! process_file_header (filedata))
18854     return FALSE;
18855
18856   if (! process_section_headers (filedata))
18857     {
18858       /* Without loaded section headers we cannot process lots of things.  */
18859       do_unwind = do_version = do_dump = do_arch = FALSE;
18860
18861       if (! do_using_dynamic)
18862         do_syms = do_dyn_syms = do_reloc = FALSE;
18863     }
18864
18865   if (! process_section_groups (filedata))
18866     /* Without loaded section groups we cannot process unwind.  */
18867     do_unwind = FALSE;
18868
18869   if (process_program_headers (filedata))
18870     process_dynamic_section (filedata);
18871   else
18872     res = FALSE;
18873
18874   if (! process_relocs (filedata))
18875     res = FALSE;
18876
18877   if (! process_unwind (filedata))
18878     res = FALSE;
18879
18880   if (! process_symbol_table (filedata))
18881     res = FALSE;
18882
18883   if (! process_syminfo (filedata))
18884     res = FALSE;
18885
18886   if (! process_version_sections (filedata))
18887     res = FALSE;
18888
18889   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
18890     separates = load_separate_debug_file (filedata, filedata->file_name);
18891   else
18892     separates = NULL;
18893
18894   if (! process_section_contents (filedata))
18895     res = FALSE;
18896
18897   if (separates)
18898     {
18899       if (! process_section_headers (separates))
18900         res = FALSE;
18901       else if (! process_section_contents (separates))
18902         res = FALSE;
18903     }
18904
18905   if (! process_notes (filedata))
18906     res = FALSE;
18907
18908   if (! process_gnu_liblist (filedata))
18909     res = FALSE;
18910
18911   if (! process_arch_specific (filedata))
18912     res = FALSE;
18913
18914   free (filedata->program_headers);
18915   filedata->program_headers = NULL;
18916
18917   free (filedata->section_headers);
18918   filedata->section_headers = NULL;
18919
18920   free (filedata->string_table);
18921   filedata->string_table = NULL;
18922   filedata->string_table_length = 0;
18923
18924   if (dynamic_strings)
18925     {
18926       free (dynamic_strings);
18927       dynamic_strings = NULL;
18928       dynamic_strings_length = 0;
18929     }
18930
18931   if (dynamic_symbols)
18932     {
18933       free (dynamic_symbols);
18934       dynamic_symbols = NULL;
18935       num_dynamic_syms = 0;
18936     }
18937
18938   if (dynamic_syminfo)
18939     {
18940       free (dynamic_syminfo);
18941       dynamic_syminfo = NULL;
18942     }
18943
18944   if (dynamic_section)
18945     {
18946       free (dynamic_section);
18947       dynamic_section = NULL;
18948     }
18949
18950   if (section_headers_groups)
18951     {
18952       free (section_headers_groups);
18953       section_headers_groups = NULL;
18954     }
18955
18956   if (section_groups)
18957     {
18958       struct group_list * g;
18959       struct group_list * next;
18960
18961       for (i = 0; i < group_count; i++)
18962         {
18963           for (g = section_groups [i].root; g != NULL; g = next)
18964             {
18965               next = g->next;
18966               free (g);
18967             }
18968         }
18969
18970       free (section_groups);
18971       section_groups = NULL;
18972     }
18973
18974   free_debug_memory ();
18975
18976   return res;
18977 }
18978
18979 /* Process an ELF archive.
18980    On entry the file is positioned just after the ARMAG string.
18981    Returns TRUE upon success, FALSE otherwise.  */
18982
18983 static bfd_boolean
18984 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
18985 {
18986   struct archive_info arch;
18987   struct archive_info nested_arch;
18988   size_t got;
18989   bfd_boolean ret = TRUE;
18990
18991   show_name = TRUE;
18992
18993   /* The ARCH structure is used to hold information about this archive.  */
18994   arch.file_name = NULL;
18995   arch.file = NULL;
18996   arch.index_array = NULL;
18997   arch.sym_table = NULL;
18998   arch.longnames = NULL;
18999
19000   /* The NESTED_ARCH structure is used as a single-item cache of information
19001      about a nested archive (when members of a thin archive reside within
19002      another regular archive file).  */
19003   nested_arch.file_name = NULL;
19004   nested_arch.file = NULL;
19005   nested_arch.index_array = NULL;
19006   nested_arch.sym_table = NULL;
19007   nested_arch.longnames = NULL;
19008
19009   if (setup_archive (&arch, filedata->file_name, filedata->handle,
19010                      is_thin_archive, do_archive_index) != 0)
19011     {
19012       ret = FALSE;
19013       goto out;
19014     }
19015
19016   if (do_archive_index)
19017     {
19018       if (arch.sym_table == NULL)
19019         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19020       else
19021         {
19022           unsigned long i, l;
19023           unsigned long current_pos;
19024
19025           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19026                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19027
19028           current_pos = ftell (filedata->handle);
19029
19030           for (i = l = 0; i < arch.index_num; i++)
19031             {
19032               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19033                 {
19034                   char * member_name;
19035
19036                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19037
19038                   if (member_name != NULL)
19039                     {
19040                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19041
19042                       if (qualified_name != NULL)
19043                         {
19044                           printf (_("Contents of binary %s at offset "), qualified_name);
19045                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
19046                           putchar ('\n');
19047                           free (qualified_name);
19048                         }
19049                     }
19050                 }
19051
19052               if (l >= arch.sym_size)
19053                 {
19054                   error (_("%s: end of the symbol table reached before the end of the index\n"),
19055                          filedata->file_name);
19056                   ret = FALSE;
19057                   break;
19058                 }
19059               /* PR 17531: file: 0b6630b2.  */
19060               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19061               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19062             }
19063
19064           if (arch.uses_64bit_indices)
19065             l = (l + 7) & ~ 7;
19066           else
19067             l += l & 1;
19068
19069           if (l < arch.sym_size)
19070             {
19071               error (ngettext ("%s: %ld byte remains in the symbol table, "
19072                                "but without corresponding entries in "
19073                                "the index table\n",
19074                                "%s: %ld bytes remain in the symbol table, "
19075                                "but without corresponding entries in "
19076                                "the index table\n",
19077                                arch.sym_size - l),
19078                      filedata->file_name, arch.sym_size - l);
19079               ret = FALSE;
19080             }
19081
19082           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19083             {
19084               error (_("%s: failed to seek back to start of object files in the archive\n"),
19085                      filedata->file_name);
19086               ret = FALSE;
19087               goto out;
19088             }
19089         }
19090
19091       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19092           && !do_segments && !do_header && !do_dump && !do_version
19093           && !do_histogram && !do_debugging && !do_arch && !do_notes
19094           && !do_section_groups && !do_dyn_syms)
19095         {
19096           ret = TRUE; /* Archive index only.  */
19097           goto out;
19098         }
19099     }
19100
19101   while (1)
19102     {
19103       char * name;
19104       size_t namelen;
19105       char * qualified_name;
19106
19107       /* Read the next archive header.  */
19108       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19109         {
19110           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
19111           return FALSE;
19112         }
19113       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19114       if (got != sizeof arch.arhdr)
19115         {
19116           if (got == 0)
19117             break;
19118           error (_("%s: failed to read archive header\n"), filedata->file_name);
19119           ret = FALSE;
19120           break;
19121         }
19122       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19123         {
19124           error (_("%s: did not find a valid archive header\n"), arch.file_name);
19125           ret = FALSE;
19126           break;
19127         }
19128
19129       arch.next_arhdr_offset += sizeof arch.arhdr;
19130
19131       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19132       if (archive_file_size & 01)
19133         ++archive_file_size;
19134
19135       name = get_archive_member_name (&arch, &nested_arch);
19136       if (name == NULL)
19137         {
19138           error (_("%s: bad archive file name\n"), filedata->file_name);
19139           ret = FALSE;
19140           break;
19141         }
19142       namelen = strlen (name);
19143
19144       qualified_name = make_qualified_name (&arch, &nested_arch, name);
19145       if (qualified_name == NULL)
19146         {
19147           error (_("%s: bad archive file name\n"), filedata->file_name);
19148           ret = FALSE;
19149           break;
19150         }
19151
19152       if (is_thin_archive && arch.nested_member_origin == 0)
19153         {
19154           /* This is a proxy for an external member of a thin archive.  */
19155           Filedata * member_filedata;
19156           char * member_file_name = adjust_relative_path
19157             (filedata->file_name, name, namelen);
19158
19159           if (member_file_name == NULL)
19160             {
19161               ret = FALSE;
19162               break;
19163             }
19164
19165           member_filedata = open_file (member_file_name);
19166           if (member_filedata == NULL)
19167             {
19168               error (_("Input file '%s' is not readable.\n"), member_file_name);
19169               free (member_file_name);
19170               ret = FALSE;
19171               break;
19172             }
19173
19174           archive_file_offset = arch.nested_member_origin;
19175           member_filedata->file_name = qualified_name;
19176
19177           if (! process_object (member_filedata))
19178             ret = FALSE;
19179
19180           close_file (member_filedata);
19181           free (member_file_name);
19182         }
19183       else if (is_thin_archive)
19184         {
19185           Filedata thin_filedata;
19186
19187           memset (&thin_filedata, 0, sizeof (thin_filedata));
19188
19189           /* PR 15140: Allow for corrupt thin archives.  */
19190           if (nested_arch.file == NULL)
19191             {
19192               error (_("%s: contains corrupt thin archive: %s\n"),
19193                      filedata->file_name, name);
19194               ret = FALSE;
19195               break;
19196             }
19197
19198           /* This is a proxy for a member of a nested archive.  */
19199           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19200
19201           /* The nested archive file will have been opened and setup by
19202              get_archive_member_name.  */
19203           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19204             {
19205               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19206               ret = FALSE;
19207               break;
19208             }
19209
19210           thin_filedata.handle = nested_arch.file;
19211           thin_filedata.file_name = qualified_name;
19212
19213           if (! process_object (& thin_filedata))
19214             ret = FALSE;
19215         }
19216       else
19217         {
19218           archive_file_offset = arch.next_arhdr_offset;
19219           arch.next_arhdr_offset += archive_file_size;
19220
19221           filedata->file_name = qualified_name;
19222           if (! process_object (filedata))
19223             ret = FALSE;
19224         }
19225
19226       if (filedata->dump_sects != NULL)
19227         {
19228           free (filedata->dump_sects);
19229           filedata->dump_sects = NULL;
19230           filedata->num_dump_sects = 0;
19231         }
19232
19233       free (qualified_name);
19234     }
19235
19236  out:
19237   if (nested_arch.file != NULL)
19238     fclose (nested_arch.file);
19239   release_archive (&nested_arch);
19240   release_archive (&arch);
19241
19242   return ret;
19243 }
19244
19245 static bfd_boolean
19246 process_file (char * file_name)
19247 {
19248   Filedata * filedata = NULL;
19249   struct stat statbuf;
19250   char armag[SARMAG];
19251   bfd_boolean ret = TRUE;
19252
19253   if (stat (file_name, &statbuf) < 0)
19254     {
19255       if (errno == ENOENT)
19256         error (_("'%s': No such file\n"), file_name);
19257       else
19258         error (_("Could not locate '%s'.  System error message: %s\n"),
19259                file_name, strerror (errno));
19260       return FALSE;
19261     }
19262
19263   if (! S_ISREG (statbuf.st_mode))
19264     {
19265       error (_("'%s' is not an ordinary file\n"), file_name);
19266       return FALSE;
19267     }
19268
19269   filedata = calloc (1, sizeof * filedata);
19270   if (filedata == NULL)
19271     {
19272       error (_("Out of memory allocating file data structure\n"));
19273       return FALSE;
19274     }
19275
19276   filedata->file_name = file_name;
19277   filedata->handle = fopen (file_name, "rb");
19278   if (filedata->handle == NULL)
19279     {
19280       error (_("Input file '%s' is not readable.\n"), file_name);
19281       free (filedata);
19282       return FALSE;
19283     }
19284
19285   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19286     {
19287       error (_("%s: Failed to read file's magic number\n"), file_name);
19288       fclose (filedata->handle);
19289       free (filedata);
19290       return FALSE;
19291     }
19292
19293   filedata->file_size = (bfd_size_type) statbuf.st_size;
19294
19295   if (memcmp (armag, ARMAG, SARMAG) == 0)
19296     {
19297       if (! process_archive (filedata, FALSE))
19298         ret = FALSE;
19299     }
19300   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19301     {
19302       if ( ! process_archive (filedata, TRUE))
19303         ret = FALSE;
19304     }
19305   else
19306     {
19307       if (do_archive_index)
19308         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19309                file_name);
19310
19311       rewind (filedata->handle);
19312       archive_file_size = archive_file_offset = 0;
19313
19314       if (! process_object (filedata))
19315         ret = FALSE;
19316     }
19317
19318   fclose (filedata->handle);
19319   free (filedata);
19320
19321   return ret;
19322 }
19323
19324 #ifdef SUPPORT_DISASSEMBLY
19325 /* Needed by the i386 disassembler.  For extra credit, someone could
19326    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19327    symbols.  */
19328
19329 void
19330 print_address (unsigned int addr, FILE * outfile)
19331 {
19332   fprintf (outfile,"0x%8.8x", addr);
19333 }
19334
19335 /* Needed by the i386 disassembler.  */
19336
19337 void
19338 db_task_printsym (unsigned int addr)
19339 {
19340   print_address (addr, stderr);
19341 }
19342 #endif
19343
19344 int
19345 main (int argc, char ** argv)
19346 {
19347   int err;
19348
19349 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19350   setlocale (LC_MESSAGES, "");
19351 #endif
19352 #if defined (HAVE_SETLOCALE)
19353   setlocale (LC_CTYPE, "");
19354 #endif
19355   bindtextdomain (PACKAGE, LOCALEDIR);
19356   textdomain (PACKAGE);
19357
19358   expandargv (&argc, &argv);
19359
19360   cmdline.file_name = "<cmdline>";
19361   parse_args (& cmdline, argc, argv);
19362
19363   if (optind < (argc - 1))
19364     show_name = TRUE;
19365   else if (optind >= argc)
19366     {
19367       warn (_("Nothing to do.\n"));
19368       usage (stderr);
19369     }
19370
19371   err = FALSE;
19372   while (optind < argc)
19373     if (! process_file (argv[optind++]))
19374       err = TRUE;
19375
19376   if (cmdline.dump_sects != NULL)
19377     free (cmdline.dump_sects);
19378
19379   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19380 }