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>")
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               header->e_version);
4785
4786       printf (_("  Entry point address:               "));
4787       print_vma (header->e_entry, PREFIX_HEX);
4788       printf (_("\n  Start of program headers:          "));
4789       print_vma (header->e_phoff, DEC);
4790       printf (_(" (bytes into file)\n  Start of section headers:          "));
4791       print_vma (header->e_shoff, DEC);
4792       printf (_(" (bytes into file)\n"));
4793
4794       printf (_("  Flags:                             0x%lx%s\n"),
4795               header->e_flags,
4796               get_machine_flags (filedata, header->e_flags, header->e_machine));
4797       printf (_("  Size of this header:               %u (bytes)\n"),
4798               header->e_ehsize);
4799       printf (_("  Size of program headers:           %u (bytes)\n"),
4800               header->e_phentsize);
4801       printf (_("  Number of program headers:         %u"),
4802               header->e_phnum);
4803       if (filedata->section_headers != NULL
4804           && header->e_phnum == PN_XNUM
4805           && filedata->section_headers[0].sh_info != 0)
4806         {
4807           header->e_phnum = filedata->section_headers[0].sh_info;
4808           printf (" (%u)", header->e_phnum);
4809         }
4810       putc ('\n', stdout);
4811       printf (_("  Size of section headers:           %u (bytes)\n"),
4812               header->e_shentsize);
4813       printf (_("  Number of section headers:         %u"),
4814               header->e_shnum);
4815       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4816         {
4817           header->e_shnum = filedata->section_headers[0].sh_size;
4818           printf (" (%u)", header->e_shnum);
4819         }
4820       putc ('\n', stdout);
4821       printf (_("  Section header string table index: %u"),
4822               header->e_shstrndx);
4823       if (filedata->section_headers != NULL
4824           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4825         {
4826           header->e_shstrndx = filedata->section_headers[0].sh_link;
4827           printf (" (%u)", header->e_shstrndx);
4828         }
4829       if (header->e_shstrndx != SHN_UNDEF
4830           && header->e_shstrndx >= header->e_shnum)
4831         {
4832           header->e_shstrndx = SHN_UNDEF;
4833           printf (_(" <corrupt: out of range>"));
4834         }
4835       putc ('\n', stdout);
4836     }
4837
4838   if (filedata->section_headers != NULL)
4839     {
4840       if (header->e_phnum == PN_XNUM
4841           && filedata->section_headers[0].sh_info != 0)
4842         header->e_phnum = filedata->section_headers[0].sh_info;
4843       if (header->e_shnum == SHN_UNDEF)
4844         header->e_shnum = filedata->section_headers[0].sh_size;
4845       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4846         header->e_shstrndx = filedata->section_headers[0].sh_link;
4847       if (header->e_shstrndx >= header->e_shnum)
4848         header->e_shstrndx = SHN_UNDEF;
4849       free (filedata->section_headers);
4850       filedata->section_headers = NULL;
4851     }
4852
4853   return TRUE;
4854 }
4855
4856 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4857    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4858
4859 static bfd_boolean
4860 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4861 {
4862   Elf32_External_Phdr * phdrs;
4863   Elf32_External_Phdr * external;
4864   Elf_Internal_Phdr *   internal;
4865   unsigned int i;
4866   unsigned int size = filedata->file_header.e_phentsize;
4867   unsigned int num  = filedata->file_header.e_phnum;
4868
4869   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4870   if (size == 0 || num == 0)
4871     return FALSE;
4872   if (size < sizeof * phdrs)
4873     {
4874       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4875       return FALSE;
4876     }
4877   if (size > sizeof * phdrs)
4878     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4879
4880   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4881                                             size, num, _("program headers"));
4882   if (phdrs == NULL)
4883     return FALSE;
4884
4885   for (i = 0, internal = pheaders, external = phdrs;
4886        i < filedata->file_header.e_phnum;
4887        i++, internal++, external++)
4888     {
4889       internal->p_type   = BYTE_GET (external->p_type);
4890       internal->p_offset = BYTE_GET (external->p_offset);
4891       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4892       internal->p_paddr  = BYTE_GET (external->p_paddr);
4893       internal->p_filesz = BYTE_GET (external->p_filesz);
4894       internal->p_memsz  = BYTE_GET (external->p_memsz);
4895       internal->p_flags  = BYTE_GET (external->p_flags);
4896       internal->p_align  = BYTE_GET (external->p_align);
4897     }
4898
4899   free (phdrs);
4900   return TRUE;
4901 }
4902
4903 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4904    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4905
4906 static bfd_boolean
4907 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4908 {
4909   Elf64_External_Phdr * phdrs;
4910   Elf64_External_Phdr * external;
4911   Elf_Internal_Phdr *   internal;
4912   unsigned int i;
4913   unsigned int size = filedata->file_header.e_phentsize;
4914   unsigned int num  = filedata->file_header.e_phnum;
4915
4916   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4917   if (size == 0 || num == 0)
4918     return FALSE;
4919   if (size < sizeof * phdrs)
4920     {
4921       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4922       return FALSE;
4923     }
4924   if (size > sizeof * phdrs)
4925     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4926
4927   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4928                                             size, num, _("program headers"));
4929   if (!phdrs)
4930     return FALSE;
4931
4932   for (i = 0, internal = pheaders, external = phdrs;
4933        i < filedata->file_header.e_phnum;
4934        i++, internal++, external++)
4935     {
4936       internal->p_type   = BYTE_GET (external->p_type);
4937       internal->p_flags  = BYTE_GET (external->p_flags);
4938       internal->p_offset = BYTE_GET (external->p_offset);
4939       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4940       internal->p_paddr  = BYTE_GET (external->p_paddr);
4941       internal->p_filesz = BYTE_GET (external->p_filesz);
4942       internal->p_memsz  = BYTE_GET (external->p_memsz);
4943       internal->p_align  = BYTE_GET (external->p_align);
4944     }
4945
4946   free (phdrs);
4947   return TRUE;
4948 }
4949
4950 /* Returns TRUE if the program headers were read into `program_headers'.  */
4951
4952 static bfd_boolean
4953 get_program_headers (Filedata * filedata)
4954 {
4955   Elf_Internal_Phdr * phdrs;
4956
4957   /* Check cache of prior read.  */
4958   if (filedata->program_headers != NULL)
4959     return TRUE;
4960
4961   /* Be kind to memory checkers by looking for
4962      e_phnum values which we know must be invalid.  */
4963   if (filedata->file_header.e_phnum
4964       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4965       >= filedata->file_size)
4966     {
4967       error (_("Too many program headers - %#x - the file is not that big\n"),
4968              filedata->file_header.e_phnum);
4969       return FALSE;
4970     }
4971
4972   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4973                                          sizeof (Elf_Internal_Phdr));
4974   if (phdrs == NULL)
4975     {
4976       error (_("Out of memory reading %u program headers\n"),
4977              filedata->file_header.e_phnum);
4978       return FALSE;
4979     }
4980
4981   if (is_32bit_elf
4982       ? get_32bit_program_headers (filedata, phdrs)
4983       : get_64bit_program_headers (filedata, phdrs))
4984     {
4985       filedata->program_headers = phdrs;
4986       return TRUE;
4987     }
4988
4989   free (phdrs);
4990   return FALSE;
4991 }
4992
4993 /* Returns TRUE if the program headers were loaded.  */
4994
4995 static bfd_boolean
4996 process_program_headers (Filedata * filedata)
4997 {
4998   Elf_Internal_Phdr * segment;
4999   unsigned int i;
5000   Elf_Internal_Phdr * previous_load = NULL;
5001
5002   if (filedata->file_header.e_phnum == 0)
5003     {
5004       /* PR binutils/12467.  */
5005       if (filedata->file_header.e_phoff != 0)
5006         {
5007           warn (_("possibly corrupt ELF header - it has a non-zero program"
5008                   " header offset, but no program headers\n"));
5009           return FALSE;
5010         }
5011       else if (do_segments)
5012         printf (_("\nThere are no program headers in this file.\n"));
5013       return TRUE;
5014     }
5015
5016   if (do_segments && !do_header)
5017     {
5018       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5019       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5020       printf (ngettext ("There is %d program header, starting at offset %s\n",
5021                         "There are %d program headers, starting at offset %s\n",
5022                         filedata->file_header.e_phnum),
5023               filedata->file_header.e_phnum,
5024               bfd_vmatoa ("u", filedata->file_header.e_phoff));
5025     }
5026
5027   if (! get_program_headers (filedata))
5028     return TRUE;
5029
5030   if (do_segments)
5031     {
5032       if (filedata->file_header.e_phnum > 1)
5033         printf (_("\nProgram Headers:\n"));
5034       else
5035         printf (_("\nProgram Headers:\n"));
5036
5037       if (is_32bit_elf)
5038         printf
5039           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
5040       else if (do_wide)
5041         printf
5042           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
5043       else
5044         {
5045           printf
5046             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
5047           printf
5048             (_("                 FileSiz            MemSiz              Flags  Align\n"));
5049         }
5050     }
5051
5052   dynamic_addr = 0;
5053   dynamic_size = 0;
5054
5055   for (i = 0, segment = filedata->program_headers;
5056        i < filedata->file_header.e_phnum;
5057        i++, segment++)
5058     {
5059       if (do_segments)
5060         {
5061           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
5062
5063           if (is_32bit_elf)
5064             {
5065               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5066               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5067               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5068               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5069               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5070               printf ("%c%c%c ",
5071                       (segment->p_flags & PF_R ? 'R' : ' '),
5072                       (segment->p_flags & PF_W ? 'W' : ' '),
5073                       (segment->p_flags & PF_X ? 'E' : ' '));
5074               printf ("%#lx", (unsigned long) segment->p_align);
5075             }
5076           else if (do_wide)
5077             {
5078               if ((unsigned long) segment->p_offset == segment->p_offset)
5079                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5080               else
5081                 {
5082                   print_vma (segment->p_offset, FULL_HEX);
5083                   putchar (' ');
5084                 }
5085
5086               print_vma (segment->p_vaddr, FULL_HEX);
5087               putchar (' ');
5088               print_vma (segment->p_paddr, FULL_HEX);
5089               putchar (' ');
5090
5091               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5092                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5093               else
5094                 {
5095                   print_vma (segment->p_filesz, FULL_HEX);
5096                   putchar (' ');
5097                 }
5098
5099               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5100                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5101               else
5102                 {
5103                   print_vma (segment->p_memsz, FULL_HEX);
5104                 }
5105
5106               printf (" %c%c%c ",
5107                       (segment->p_flags & PF_R ? 'R' : ' '),
5108                       (segment->p_flags & PF_W ? 'W' : ' '),
5109                       (segment->p_flags & PF_X ? 'E' : ' '));
5110
5111               if ((unsigned long) segment->p_align == segment->p_align)
5112                 printf ("%#lx", (unsigned long) segment->p_align);
5113               else
5114                 {
5115                   print_vma (segment->p_align, PREFIX_HEX);
5116                 }
5117             }
5118           else
5119             {
5120               print_vma (segment->p_offset, FULL_HEX);
5121               putchar (' ');
5122               print_vma (segment->p_vaddr, FULL_HEX);
5123               putchar (' ');
5124               print_vma (segment->p_paddr, FULL_HEX);
5125               printf ("\n                 ");
5126               print_vma (segment->p_filesz, FULL_HEX);
5127               putchar (' ');
5128               print_vma (segment->p_memsz, FULL_HEX);
5129               printf ("  %c%c%c    ",
5130                       (segment->p_flags & PF_R ? 'R' : ' '),
5131                       (segment->p_flags & PF_W ? 'W' : ' '),
5132                       (segment->p_flags & PF_X ? 'E' : ' '));
5133               print_vma (segment->p_align, PREFIX_HEX);
5134             }
5135
5136           putc ('\n', stdout);
5137         }
5138
5139       switch (segment->p_type)
5140         {
5141         case PT_LOAD:
5142 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5143          required by the ELF standard, several programs, including the Linux
5144          kernel, make use of non-ordered segments.  */
5145           if (previous_load
5146               && previous_load->p_vaddr > segment->p_vaddr)
5147             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5148 #endif
5149           if (segment->p_memsz < segment->p_filesz)
5150             error (_("the segment's file size is larger than its memory size\n"));
5151           previous_load = segment;
5152           break;
5153
5154         case PT_PHDR:
5155           /* PR 20815 - Verify that the program header is loaded into memory.  */
5156           if (i > 0 && previous_load != NULL)
5157             error (_("the PHDR segment must occur before any LOAD segment\n"));
5158           if (filedata->file_header.e_machine != EM_PARISC)
5159             {
5160               unsigned int j;
5161
5162               for (j = 1; j < filedata->file_header.e_phnum; j++)
5163                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5164                     && (filedata->program_headers[j].p_vaddr
5165                         + filedata->program_headers[j].p_memsz)
5166                     >= (segment->p_vaddr + segment->p_filesz))
5167                   break;
5168               if (j == filedata->file_header.e_phnum)
5169                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5170             }
5171           break;
5172
5173         case PT_DYNAMIC:
5174           if (dynamic_addr)
5175             error (_("more than one dynamic segment\n"));
5176
5177           /* By default, assume that the .dynamic section is the first
5178              section in the DYNAMIC segment.  */
5179           dynamic_addr = segment->p_offset;
5180           dynamic_size = segment->p_filesz;
5181
5182           /* Try to locate the .dynamic section. If there is
5183              a section header table, we can easily locate it.  */
5184           if (filedata->section_headers != NULL)
5185             {
5186               Elf_Internal_Shdr * sec;
5187
5188               sec = find_section (filedata, ".dynamic");
5189               if (sec == NULL || sec->sh_size == 0)
5190                 {
5191                   /* A corresponding .dynamic section is expected, but on
5192                      IA-64/OpenVMS it is OK for it to be missing.  */
5193                   if (!is_ia64_vms (filedata))
5194                     error (_("no .dynamic section in the dynamic segment\n"));
5195                   break;
5196                 }
5197
5198               if (sec->sh_type == SHT_NOBITS)
5199                 {
5200                   dynamic_size = 0;
5201                   break;
5202                 }
5203
5204               dynamic_addr = sec->sh_offset;
5205               dynamic_size = sec->sh_size;
5206
5207               if (dynamic_addr < segment->p_offset
5208                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5209                 warn (_("the .dynamic section is not contained"
5210                         " within the dynamic segment\n"));
5211               else if (dynamic_addr > segment->p_offset)
5212                 warn (_("the .dynamic section is not the first section"
5213                         " in the dynamic segment.\n"));
5214             }
5215
5216           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5217              segment.  Check this after matching against the section headers
5218              so we don't warn on debuginfo file (which have NOBITS .dynamic
5219              sections).  */
5220           if (dynamic_addr + dynamic_size >= filedata->file_size)
5221             {
5222               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5223               dynamic_addr = dynamic_size = 0;
5224             }
5225           break;
5226
5227         case PT_INTERP:
5228           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5229                      SEEK_SET))
5230             error (_("Unable to find program interpreter name\n"));
5231           else
5232             {
5233               char fmt [32];
5234               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5235
5236               if (ret >= (int) sizeof (fmt) || ret < 0)
5237                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5238
5239               program_interpreter[0] = 0;
5240               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5241                 error (_("Unable to read program interpreter name\n"));
5242
5243               if (do_segments)
5244                 printf (_("      [Requesting program interpreter: %s]\n"),
5245                     program_interpreter);
5246             }
5247           break;
5248         }
5249     }
5250
5251   if (do_segments
5252       && filedata->section_headers != NULL
5253       && filedata->string_table != NULL)
5254     {
5255       printf (_("\n Section to Segment mapping:\n"));
5256       printf (_("  Segment Sections...\n"));
5257
5258       for (i = 0; i < filedata->file_header.e_phnum; i++)
5259         {
5260           unsigned int j;
5261           Elf_Internal_Shdr * section;
5262
5263           segment = filedata->program_headers + i;
5264           section = filedata->section_headers + 1;
5265
5266           printf ("   %2.2d     ", i);
5267
5268           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5269             {
5270               if (!ELF_TBSS_SPECIAL (section, segment)
5271                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5272                 printf ("%s ", printable_section_name (filedata, section));
5273             }
5274
5275           putc ('\n',stdout);
5276         }
5277     }
5278
5279   return TRUE;
5280 }
5281
5282
5283 /* Find the file offset corresponding to VMA by using the program headers.  */
5284
5285 static long
5286 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5287 {
5288   Elf_Internal_Phdr * seg;
5289
5290   if (! get_program_headers (filedata))
5291     {
5292       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5293       return (long) vma;
5294     }
5295
5296   for (seg = filedata->program_headers;
5297        seg < filedata->program_headers + filedata->file_header.e_phnum;
5298        ++seg)
5299     {
5300       if (seg->p_type != PT_LOAD)
5301         continue;
5302
5303       if (vma >= (seg->p_vaddr & -seg->p_align)
5304           && vma + size <= seg->p_vaddr + seg->p_filesz)
5305         return vma - seg->p_vaddr + seg->p_offset;
5306     }
5307
5308   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5309         (unsigned long) vma);
5310   return (long) vma;
5311 }
5312
5313
5314 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5315    If PROBE is true, this is just a probe and we do not generate any error
5316    messages if the load fails.  */
5317
5318 static bfd_boolean
5319 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5320 {
5321   Elf32_External_Shdr * shdrs;
5322   Elf_Internal_Shdr *   internal;
5323   unsigned int          i;
5324   unsigned int          size = filedata->file_header.e_shentsize;
5325   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5326
5327   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5328   if (size == 0 || num == 0)
5329     return FALSE;
5330   if (size < sizeof * shdrs)
5331     {
5332       if (! probe)
5333         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5334       return FALSE;
5335     }
5336   if (!probe && size > sizeof * shdrs)
5337     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5338
5339   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5340                                             size, num,
5341                                             probe ? NULL : _("section headers"));
5342   if (shdrs == NULL)
5343     return FALSE;
5344
5345   free (filedata->section_headers);
5346   filedata->section_headers = (Elf_Internal_Shdr *)
5347     cmalloc (num, sizeof (Elf_Internal_Shdr));
5348   if (filedata->section_headers == NULL)
5349     {
5350       if (!probe)
5351         error (_("Out of memory reading %u section headers\n"), num);
5352       free (shdrs);
5353       return FALSE;
5354     }
5355
5356   for (i = 0, internal = filedata->section_headers;
5357        i < num;
5358        i++, internal++)
5359     {
5360       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5361       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5362       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5363       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5364       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5365       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5366       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5367       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5368       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5369       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5370       if (!probe && internal->sh_link > num)
5371         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5372       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5373         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5374     }
5375
5376   free (shdrs);
5377   return TRUE;
5378 }
5379
5380 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5381
5382 static bfd_boolean
5383 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5384 {
5385   Elf64_External_Shdr *  shdrs;
5386   Elf_Internal_Shdr *    internal;
5387   unsigned int           i;
5388   unsigned int           size = filedata->file_header.e_shentsize;
5389   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5390
5391   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5392   if (size == 0 || num == 0)
5393     return FALSE;
5394
5395   if (size < sizeof * shdrs)
5396     {
5397       if (! probe)
5398         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5399       return FALSE;
5400     }
5401
5402   if (! probe && size > sizeof * shdrs)
5403     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5404
5405   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5406                                             filedata->file_header.e_shoff,
5407                                             size, num,
5408                                             probe ? NULL : _("section headers"));
5409   if (shdrs == NULL)
5410     return FALSE;
5411
5412   free (filedata->section_headers);
5413   filedata->section_headers = (Elf_Internal_Shdr *)
5414     cmalloc (num, sizeof (Elf_Internal_Shdr));
5415   if (filedata->section_headers == NULL)
5416     {
5417       if (! probe)
5418         error (_("Out of memory reading %u section headers\n"), num);
5419       free (shdrs);
5420       return FALSE;
5421     }
5422
5423   for (i = 0, internal = filedata->section_headers;
5424        i < num;
5425        i++, internal++)
5426     {
5427       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5428       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5429       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5430       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5431       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5432       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5433       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5434       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5435       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5436       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5437       if (!probe && internal->sh_link > num)
5438         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5439       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5440         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5441     }
5442
5443   free (shdrs);
5444   return TRUE;
5445 }
5446
5447 static Elf_Internal_Sym *
5448 get_32bit_elf_symbols (Filedata *           filedata,
5449                        Elf_Internal_Shdr *  section,
5450                        unsigned long *      num_syms_return)
5451 {
5452   unsigned long number = 0;
5453   Elf32_External_Sym * esyms = NULL;
5454   Elf_External_Sym_Shndx * shndx = NULL;
5455   Elf_Internal_Sym * isyms = NULL;
5456   Elf_Internal_Sym * psym;
5457   unsigned int j;
5458   elf_section_list * entry;
5459
5460   if (section->sh_size == 0)
5461     {
5462       if (num_syms_return != NULL)
5463         * num_syms_return = 0;
5464       return NULL;
5465     }
5466
5467   /* Run some sanity checks first.  */
5468   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5469     {
5470       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5471              printable_section_name (filedata, section),
5472              (unsigned long) section->sh_entsize);
5473       goto exit_point;
5474     }
5475
5476   if (section->sh_size > filedata->file_size)
5477     {
5478       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5479              printable_section_name (filedata, section),
5480              (unsigned long) section->sh_size);
5481       goto exit_point;
5482     }
5483
5484   number = section->sh_size / section->sh_entsize;
5485
5486   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5487     {
5488       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5489              (unsigned long) section->sh_size,
5490              printable_section_name (filedata, section),
5491              (unsigned long) section->sh_entsize);
5492       goto exit_point;
5493     }
5494
5495   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5496                                            section->sh_size, _("symbols"));
5497   if (esyms == NULL)
5498     goto exit_point;
5499
5500   shndx = NULL;
5501   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5502     {
5503       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5504         continue;
5505
5506       if (shndx != NULL)
5507         {
5508           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5509           free (shndx);
5510         }
5511
5512       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5513                                                    entry->hdr->sh_offset,
5514                                                    1, entry->hdr->sh_size,
5515                                                    _("symbol table section indices"));
5516       if (shndx == NULL)
5517         goto exit_point;
5518
5519       /* PR17531: file: heap-buffer-overflow */
5520       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5521         {
5522           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5523                  printable_section_name (filedata, entry->hdr),
5524                  (unsigned long) entry->hdr->sh_size,
5525                  (unsigned long) section->sh_size);
5526           goto exit_point;
5527         }
5528     }
5529
5530   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5531
5532   if (isyms == NULL)
5533     {
5534       error (_("Out of memory reading %lu symbols\n"),
5535              (unsigned long) number);
5536       goto exit_point;
5537     }
5538
5539   for (j = 0, psym = isyms; j < number; j++, psym++)
5540     {
5541       psym->st_name  = BYTE_GET (esyms[j].st_name);
5542       psym->st_value = BYTE_GET (esyms[j].st_value);
5543       psym->st_size  = BYTE_GET (esyms[j].st_size);
5544       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5545       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5546         psym->st_shndx
5547           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5548       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5549         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5550       psym->st_info  = BYTE_GET (esyms[j].st_info);
5551       psym->st_other = BYTE_GET (esyms[j].st_other);
5552     }
5553
5554  exit_point:
5555   free (shndx);
5556   free (esyms);
5557
5558   if (num_syms_return != NULL)
5559     * num_syms_return = isyms == NULL ? 0 : number;
5560
5561   return isyms;
5562 }
5563
5564 static Elf_Internal_Sym *
5565 get_64bit_elf_symbols (Filedata *           filedata,
5566                        Elf_Internal_Shdr *  section,
5567                        unsigned long *      num_syms_return)
5568 {
5569   unsigned long number = 0;
5570   Elf64_External_Sym * esyms = NULL;
5571   Elf_External_Sym_Shndx * shndx = NULL;
5572   Elf_Internal_Sym * isyms = NULL;
5573   Elf_Internal_Sym * psym;
5574   unsigned int j;
5575   elf_section_list * entry;
5576
5577   if (section->sh_size == 0)
5578     {
5579       if (num_syms_return != NULL)
5580         * num_syms_return = 0;
5581       return NULL;
5582     }
5583
5584   /* Run some sanity checks first.  */
5585   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5586     {
5587       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5588              printable_section_name (filedata, section),
5589              (unsigned long) section->sh_entsize);
5590       goto exit_point;
5591     }
5592
5593   if (section->sh_size > filedata->file_size)
5594     {
5595       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5596              printable_section_name (filedata, section),
5597              (unsigned long) section->sh_size);
5598       goto exit_point;
5599     }
5600
5601   number = section->sh_size / section->sh_entsize;
5602
5603   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5604     {
5605       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5606              (unsigned long) section->sh_size,
5607              printable_section_name (filedata, section),
5608              (unsigned long) section->sh_entsize);
5609       goto exit_point;
5610     }
5611
5612   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5613                                            section->sh_size, _("symbols"));
5614   if (!esyms)
5615     goto exit_point;
5616
5617   shndx = NULL;
5618   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5619     {
5620       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5621         continue;
5622
5623       if (shndx != NULL)
5624         {
5625           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5626           free (shndx);
5627         }
5628
5629       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5630                                                    entry->hdr->sh_offset,
5631                                                    1, entry->hdr->sh_size,
5632                                                    _("symbol table section indices"));
5633       if (shndx == NULL)
5634         goto exit_point;
5635
5636       /* PR17531: file: heap-buffer-overflow */
5637       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5638         {
5639           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5640                  printable_section_name (filedata, entry->hdr),
5641                  (unsigned long) entry->hdr->sh_size,
5642                  (unsigned long) section->sh_size);
5643           goto exit_point;
5644         }
5645     }
5646
5647   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5648
5649   if (isyms == NULL)
5650     {
5651       error (_("Out of memory reading %lu symbols\n"),
5652              (unsigned long) number);
5653       goto exit_point;
5654     }
5655
5656   for (j = 0, psym = isyms; j < number; j++, psym++)
5657     {
5658       psym->st_name  = BYTE_GET (esyms[j].st_name);
5659       psym->st_info  = BYTE_GET (esyms[j].st_info);
5660       psym->st_other = BYTE_GET (esyms[j].st_other);
5661       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5662
5663       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5664         psym->st_shndx
5665           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5666       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5667         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5668
5669       psym->st_value = BYTE_GET (esyms[j].st_value);
5670       psym->st_size  = BYTE_GET (esyms[j].st_size);
5671     }
5672
5673  exit_point:
5674   free (shndx);
5675   free (esyms);
5676
5677   if (num_syms_return != NULL)
5678     * num_syms_return = isyms == NULL ? 0 : number;
5679
5680   return isyms;
5681 }
5682
5683 static const char *
5684 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5685 {
5686   static char buff[1024];
5687   char * p = buff;
5688   unsigned int field_size = is_32bit_elf ? 8 : 16;
5689   signed int sindex;
5690   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5691   bfd_vma os_flags = 0;
5692   bfd_vma proc_flags = 0;
5693   bfd_vma unknown_flags = 0;
5694   static const struct
5695     {
5696       const char * str;
5697       unsigned int len;
5698     }
5699   flags [] =
5700     {
5701       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5702       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5703       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5704       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5705       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5706       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5707       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5708       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5709       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5710       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5711       /* IA-64 specific.  */
5712       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5713       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5714       /* IA-64 OpenVMS specific.  */
5715       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5716       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5717       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5718       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5719       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5720       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5721       /* Generic.  */
5722       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5723       /* SPARC specific.  */
5724       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5725       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5726       /* ARM specific.  */
5727       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5728       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5729       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5730       /* GNU specific.  */
5731       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5732       /* VLE specific.  */
5733       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5734     };
5735
5736   if (do_section_details)
5737     {
5738       sprintf (buff, "[%*.*lx]: ",
5739                field_size, field_size, (unsigned long) sh_flags);
5740       p += field_size + 4;
5741     }
5742
5743   while (sh_flags)
5744     {
5745       bfd_vma flag;
5746
5747       flag = sh_flags & - sh_flags;
5748       sh_flags &= ~ flag;
5749
5750       if (do_section_details)
5751         {
5752           switch (flag)
5753             {
5754             case SHF_WRITE:             sindex = 0; break;
5755             case SHF_ALLOC:             sindex = 1; break;
5756             case SHF_EXECINSTR:         sindex = 2; break;
5757             case SHF_MERGE:             sindex = 3; break;
5758             case SHF_STRINGS:           sindex = 4; break;
5759             case SHF_INFO_LINK:         sindex = 5; break;
5760             case SHF_LINK_ORDER:        sindex = 6; break;
5761             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5762             case SHF_GROUP:             sindex = 8; break;
5763             case SHF_TLS:               sindex = 9; break;
5764             case SHF_EXCLUDE:           sindex = 18; break;
5765             case SHF_COMPRESSED:        sindex = 20; break;
5766             case SHF_GNU_MBIND:         sindex = 24; break;
5767
5768             default:
5769               sindex = -1;
5770               switch (filedata->file_header.e_machine)
5771                 {
5772                 case EM_IA_64:
5773                   if (flag == SHF_IA_64_SHORT)
5774                     sindex = 10;
5775                   else if (flag == SHF_IA_64_NORECOV)
5776                     sindex = 11;
5777 #ifdef BFD64
5778                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5779                     switch (flag)
5780                       {
5781                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5782                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5783                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5784                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5785                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5786                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5787                       default:                        break;
5788                       }
5789 #endif
5790                   break;
5791
5792                 case EM_386:
5793                 case EM_IAMCU:
5794                 case EM_X86_64:
5795                 case EM_L1OM:
5796                 case EM_K1OM:
5797                 case EM_OLD_SPARCV9:
5798                 case EM_SPARC32PLUS:
5799                 case EM_SPARCV9:
5800                 case EM_SPARC:
5801                   if (flag == SHF_ORDERED)
5802                     sindex = 19;
5803                   break;
5804
5805                 case EM_ARM:
5806                   switch (flag)
5807                     {
5808                     case SHF_ENTRYSECT: sindex = 21; break;
5809                     case SHF_ARM_PURECODE: sindex = 22; break;
5810                     case SHF_COMDEF: sindex = 23; break;
5811                     default: break;
5812                     }
5813                   break;
5814                 case EM_PPC:
5815                   if (flag == SHF_PPC_VLE)
5816                     sindex = 25;
5817                   break;
5818
5819                 default:
5820                   break;
5821                 }
5822             }
5823
5824           if (sindex != -1)
5825             {
5826               if (p != buff + field_size + 4)
5827                 {
5828                   if (size < (10 + 2))
5829                     {
5830                       warn (_("Internal error: not enough buffer room for section flag info"));
5831                       return _("<unknown>");
5832                     }
5833                   size -= 2;
5834                   *p++ = ',';
5835                   *p++ = ' ';
5836                 }
5837
5838               size -= flags [sindex].len;
5839               p = stpcpy (p, flags [sindex].str);
5840             }
5841           else if (flag & SHF_MASKOS)
5842             os_flags |= flag;
5843           else if (flag & SHF_MASKPROC)
5844             proc_flags |= flag;
5845           else
5846             unknown_flags |= flag;
5847         }
5848       else
5849         {
5850           switch (flag)
5851             {
5852             case SHF_WRITE:             *p = 'W'; break;
5853             case SHF_ALLOC:             *p = 'A'; break;
5854             case SHF_EXECINSTR:         *p = 'X'; break;
5855             case SHF_MERGE:             *p = 'M'; break;
5856             case SHF_STRINGS:           *p = 'S'; break;
5857             case SHF_INFO_LINK:         *p = 'I'; break;
5858             case SHF_LINK_ORDER:        *p = 'L'; break;
5859             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5860             case SHF_GROUP:             *p = 'G'; break;
5861             case SHF_TLS:               *p = 'T'; break;
5862             case SHF_EXCLUDE:           *p = 'E'; break;
5863             case SHF_COMPRESSED:        *p = 'C'; break;
5864             case SHF_GNU_MBIND:         *p = 'D'; break;
5865
5866             default:
5867               if ((filedata->file_header.e_machine == EM_X86_64
5868                    || filedata->file_header.e_machine == EM_L1OM
5869                    || filedata->file_header.e_machine == EM_K1OM)
5870                   && flag == SHF_X86_64_LARGE)
5871                 *p = 'l';
5872               else if (filedata->file_header.e_machine == EM_ARM
5873                        && flag == SHF_ARM_PURECODE)
5874                   *p = 'y';
5875               else if (filedata->file_header.e_machine == EM_PPC
5876                        && flag == SHF_PPC_VLE)
5877                   *p = 'v';
5878               else if (flag & SHF_MASKOS)
5879                 {
5880                   *p = 'o';
5881                   sh_flags &= ~ SHF_MASKOS;
5882                 }
5883               else if (flag & SHF_MASKPROC)
5884                 {
5885                   *p = 'p';
5886                   sh_flags &= ~ SHF_MASKPROC;
5887                 }
5888               else
5889                 *p = 'x';
5890               break;
5891             }
5892           p++;
5893         }
5894     }
5895
5896   if (do_section_details)
5897     {
5898       if (os_flags)
5899         {
5900           size -= 5 + field_size;
5901           if (p != buff + field_size + 4)
5902             {
5903               if (size < (2 + 1))
5904                 {
5905                   warn (_("Internal error: not enough buffer room for section flag info"));
5906                   return _("<unknown>");
5907                 }
5908               size -= 2;
5909               *p++ = ',';
5910               *p++ = ' ';
5911             }
5912           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5913                    (unsigned long) os_flags);
5914           p += 5 + field_size;
5915         }
5916       if (proc_flags)
5917         {
5918           size -= 7 + field_size;
5919           if (p != buff + field_size + 4)
5920             {
5921               if (size < (2 + 1))
5922                 {
5923                   warn (_("Internal error: not enough buffer room for section flag info"));
5924                   return _("<unknown>");
5925                 }
5926               size -= 2;
5927               *p++ = ',';
5928               *p++ = ' ';
5929             }
5930           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5931                    (unsigned long) proc_flags);
5932           p += 7 + field_size;
5933         }
5934       if (unknown_flags)
5935         {
5936           size -= 10 + field_size;
5937           if (p != buff + field_size + 4)
5938             {
5939               if (size < (2 + 1))
5940                 {
5941                   warn (_("Internal error: not enough buffer room for section flag info"));
5942                   return _("<unknown>");
5943                 }
5944               size -= 2;
5945               *p++ = ',';
5946               *p++ = ' ';
5947             }
5948           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5949                    (unsigned long) unknown_flags);
5950           p += 10 + field_size;
5951         }
5952     }
5953
5954   *p = '\0';
5955   return buff;
5956 }
5957
5958 static unsigned int
5959 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5960 {
5961   if (is_32bit_elf)
5962     {
5963       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5964
5965       if (size < sizeof (* echdr))
5966         {
5967           error (_("Compressed section is too small even for a compression header\n"));
5968           return 0;
5969         }
5970
5971       chdr->ch_type = BYTE_GET (echdr->ch_type);
5972       chdr->ch_size = BYTE_GET (echdr->ch_size);
5973       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5974       return sizeof (*echdr);
5975     }
5976   else
5977     {
5978       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5979
5980       if (size < sizeof (* echdr))
5981         {
5982           error (_("Compressed section is too small even for a compression header\n"));
5983           return 0;
5984         }
5985
5986       chdr->ch_type = BYTE_GET (echdr->ch_type);
5987       chdr->ch_size = BYTE_GET (echdr->ch_size);
5988       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5989       return sizeof (*echdr);
5990     }
5991 }
5992
5993 static bfd_boolean
5994 process_section_headers (Filedata * filedata)
5995 {
5996   Elf_Internal_Shdr * section;
5997   unsigned int i;
5998
5999   filedata->section_headers = NULL;
6000
6001   if (filedata->file_header.e_shnum == 0)
6002     {
6003       /* PR binutils/12467.  */
6004       if (filedata->file_header.e_shoff != 0)
6005         {
6006           warn (_("possibly corrupt ELF file header - it has a non-zero"
6007                   " section header offset, but no section headers\n"));
6008           return FALSE;
6009         }
6010       else if (do_sections)
6011         printf (_("\nThere are no sections in this file.\n"));
6012
6013       return TRUE;
6014     }
6015
6016   if (do_sections && !do_header)
6017     printf (ngettext ("There is %d section header, "
6018                       "starting at offset 0x%lx:\n",
6019                       "There are %d section headers, "
6020                       "starting at offset 0x%lx:\n",
6021                       filedata->file_header.e_shnum),
6022             filedata->file_header.e_shnum,
6023             (unsigned long) filedata->file_header.e_shoff);
6024
6025   if (is_32bit_elf)
6026     {
6027       if (! get_32bit_section_headers (filedata, FALSE))
6028         return FALSE;
6029     }
6030   else
6031     {
6032       if (! get_64bit_section_headers (filedata, FALSE))
6033         return FALSE;
6034     }
6035
6036   /* Read in the string table, so that we have names to display.  */
6037   if (filedata->file_header.e_shstrndx != SHN_UNDEF
6038        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6039     {
6040       section = filedata->section_headers + filedata->file_header.e_shstrndx;
6041
6042       if (section->sh_size != 0)
6043         {
6044           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6045                                                       1, section->sh_size,
6046                                                       _("string table"));
6047
6048           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6049         }
6050     }
6051
6052   /* Scan the sections for the dynamic symbol table
6053      and dynamic string table and debug sections.  */
6054   dynamic_symbols = NULL;
6055   dynamic_strings = NULL;
6056   dynamic_syminfo = NULL;
6057   symtab_shndx_list = NULL;
6058
6059   eh_addr_size = is_32bit_elf ? 4 : 8;
6060   switch (filedata->file_header.e_machine)
6061     {
6062     case EM_MIPS:
6063     case EM_MIPS_RS3_LE:
6064       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6065          FDE addresses.  However, the ABI also has a semi-official ILP32
6066          variant for which the normal FDE address size rules apply.
6067
6068          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6069          section, where XX is the size of longs in bits.  Unfortunately,
6070          earlier compilers provided no way of distinguishing ILP32 objects
6071          from LP64 objects, so if there's any doubt, we should assume that
6072          the official LP64 form is being used.  */
6073       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6074           && find_section (filedata, ".gcc_compiled_long32") == NULL)
6075         eh_addr_size = 8;
6076       break;
6077
6078     case EM_H8_300:
6079     case EM_H8_300H:
6080       switch (filedata->file_header.e_flags & EF_H8_MACH)
6081         {
6082         case E_H8_MACH_H8300:
6083         case E_H8_MACH_H8300HN:
6084         case E_H8_MACH_H8300SN:
6085         case E_H8_MACH_H8300SXN:
6086           eh_addr_size = 2;
6087           break;
6088         case E_H8_MACH_H8300H:
6089         case E_H8_MACH_H8300S:
6090         case E_H8_MACH_H8300SX:
6091           eh_addr_size = 4;
6092           break;
6093         }
6094       break;
6095
6096     case EM_M32C_OLD:
6097     case EM_M32C:
6098       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6099         {
6100         case EF_M32C_CPU_M16C:
6101           eh_addr_size = 2;
6102           break;
6103         }
6104       break;
6105     }
6106
6107 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6108   do                                                                    \
6109     {                                                                   \
6110       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6111       if (section->sh_entsize != expected_entsize)                      \
6112         {                                                               \
6113           char buf[40];                                                 \
6114           sprintf_vma (buf, section->sh_entsize);                       \
6115           /* Note: coded this way so that there is a single string for  \
6116              translation.  */ \
6117           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6118           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6119                    (unsigned) expected_entsize);                        \
6120           section->sh_entsize = expected_entsize;                       \
6121         }                                                               \
6122     }                                                                   \
6123   while (0)
6124
6125 #define CHECK_ENTSIZE(section, i, type)                                 \
6126   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6127                         sizeof (Elf64_External_##type))
6128
6129   for (i = 0, section = filedata->section_headers;
6130        i < filedata->file_header.e_shnum;
6131        i++, section++)
6132     {
6133       char * name = SECTION_NAME (section);
6134
6135       if (section->sh_type == SHT_DYNSYM)
6136         {
6137           if (dynamic_symbols != NULL)
6138             {
6139               error (_("File contains multiple dynamic symbol tables\n"));
6140               continue;
6141             }
6142
6143           CHECK_ENTSIZE (section, i, Sym);
6144           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6145         }
6146       else if (section->sh_type == SHT_STRTAB
6147                && streq (name, ".dynstr"))
6148         {
6149           if (dynamic_strings != NULL)
6150             {
6151               error (_("File contains multiple dynamic string tables\n"));
6152               continue;
6153             }
6154
6155           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6156                                                1, section->sh_size,
6157                                                _("dynamic strings"));
6158           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6159         }
6160       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6161         {
6162           elf_section_list * entry = xmalloc (sizeof * entry);
6163
6164           entry->hdr = section;
6165           entry->next = symtab_shndx_list;
6166           symtab_shndx_list = entry;
6167         }
6168       else if (section->sh_type == SHT_SYMTAB)
6169         CHECK_ENTSIZE (section, i, Sym);
6170       else if (section->sh_type == SHT_GROUP)
6171         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6172       else if (section->sh_type == SHT_REL)
6173         CHECK_ENTSIZE (section, i, Rel);
6174       else if (section->sh_type == SHT_RELA)
6175         CHECK_ENTSIZE (section, i, Rela);
6176       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6177                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6178                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6179                 || do_debug_str || do_debug_loc || do_debug_ranges
6180                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6181                && (const_strneq (name, ".debug_")
6182                    || const_strneq (name, ".zdebug_")))
6183         {
6184           if (name[1] == 'z')
6185             name += sizeof (".zdebug_") - 1;
6186           else
6187             name += sizeof (".debug_") - 1;
6188
6189           if (do_debugging
6190               || (do_debug_info     && const_strneq (name, "info"))
6191               || (do_debug_info     && const_strneq (name, "types"))
6192               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6193               || (do_debug_lines    && strcmp (name, "line") == 0)
6194               || (do_debug_lines    && const_strneq (name, "line."))
6195               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6196               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6197               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6198               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6199               || (do_debug_aranges  && const_strneq (name, "aranges"))
6200               || (do_debug_ranges   && const_strneq (name, "ranges"))
6201               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6202               || (do_debug_frames   && const_strneq (name, "frame"))
6203               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6204               || (do_debug_macinfo  && const_strneq (name, "macro"))
6205               || (do_debug_str      && const_strneq (name, "str"))
6206               || (do_debug_loc      && const_strneq (name, "loc"))
6207               || (do_debug_loc      && const_strneq (name, "loclists"))
6208               || (do_debug_addr     && const_strneq (name, "addr"))
6209               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6210               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6211               )
6212             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6213         }
6214       /* Linkonce section to be combined with .debug_info at link time.  */
6215       else if ((do_debugging || do_debug_info)
6216                && const_strneq (name, ".gnu.linkonce.wi."))
6217         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6218       else if (do_debug_frames && streq (name, ".eh_frame"))
6219         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6220       else if (do_gdb_index && (streq (name, ".gdb_index")
6221                                 || streq (name, ".debug_names")))
6222         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6223       /* Trace sections for Itanium VMS.  */
6224       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6225                 || do_trace_aranges)
6226                && const_strneq (name, ".trace_"))
6227         {
6228           name += sizeof (".trace_") - 1;
6229
6230           if (do_debugging
6231               || (do_trace_info     && streq (name, "info"))
6232               || (do_trace_abbrevs  && streq (name, "abbrev"))
6233               || (do_trace_aranges  && streq (name, "aranges"))
6234               )
6235             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6236         }
6237       else if ((do_debugging || do_debug_links)
6238                && (const_strneq (name, ".gnu_debuglink")
6239                    || const_strneq (name, ".gnu_debugaltlink")))
6240         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6241     }
6242
6243   if (! do_sections)
6244     return TRUE;
6245
6246   if (filedata->file_header.e_shnum > 1)
6247     printf (_("\nSection Headers:\n"));
6248   else
6249     printf (_("\nSection Header:\n"));
6250
6251   if (is_32bit_elf)
6252     {
6253       if (do_section_details)
6254         {
6255           printf (_("  [Nr] Name\n"));
6256           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6257         }
6258       else
6259         printf
6260           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6261     }
6262   else if (do_wide)
6263     {
6264       if (do_section_details)
6265         {
6266           printf (_("  [Nr] Name\n"));
6267           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6268         }
6269       else
6270         printf
6271           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6272     }
6273   else
6274     {
6275       if (do_section_details)
6276         {
6277           printf (_("  [Nr] Name\n"));
6278           printf (_("       Type              Address          Offset            Link\n"));
6279           printf (_("       Size              EntSize          Info              Align\n"));
6280         }
6281       else
6282         {
6283           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6284           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6285         }
6286     }
6287
6288   if (do_section_details)
6289     printf (_("       Flags\n"));
6290
6291   for (i = 0, section = filedata->section_headers;
6292        i < filedata->file_header.e_shnum;
6293        i++, section++)
6294     {
6295       /* Run some sanity checks on the section header.  */
6296
6297       /* Check the sh_link field.  */
6298       switch (section->sh_type)
6299         {
6300         case SHT_SYMTAB_SHNDX:
6301         case SHT_GROUP:
6302         case SHT_HASH:
6303         case SHT_GNU_HASH:
6304         case SHT_GNU_versym:
6305         case SHT_REL:
6306         case SHT_RELA:
6307           if (section->sh_link < 1
6308               || section->sh_link >= filedata->file_header.e_shnum
6309               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6310                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6311             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6312                   i, section->sh_link);
6313           break;
6314
6315         case SHT_DYNAMIC:
6316         case SHT_SYMTAB:
6317         case SHT_DYNSYM:
6318         case SHT_GNU_verneed:
6319         case SHT_GNU_verdef:
6320         case SHT_GNU_LIBLIST:
6321           if (section->sh_link < 1
6322               || section->sh_link >= filedata->file_header.e_shnum
6323               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6324             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6325                   i, section->sh_link);
6326           break;
6327
6328         case SHT_INIT_ARRAY:
6329         case SHT_FINI_ARRAY:
6330         case SHT_PREINIT_ARRAY:
6331           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6332             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6333                   i, section->sh_link);
6334           break;
6335
6336         default:
6337           /* FIXME: Add support for target specific section types.  */
6338 #if 0     /* Currently we do not check other section types as there are too
6339              many special cases.  Stab sections for example have a type
6340              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6341              section.  */
6342           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6343             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6344                   i, section->sh_link);
6345 #endif
6346           break;
6347         }
6348
6349       /* Check the sh_info field.  */
6350       switch (section->sh_type)
6351         {
6352         case SHT_REL:
6353         case SHT_RELA:
6354           if (section->sh_info < 1
6355               || section->sh_info >= filedata->file_header.e_shnum
6356               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6357                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6358                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6359                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6360                   /* FIXME: Are other section types valid ?  */
6361                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6362             {
6363               if (section->sh_info == 0
6364                   && (filedata->file_header.e_type == ET_EXEC
6365                       || filedata->file_header.e_type == ET_DYN
6366                       /* These next two tests may be redundant, but
6367                          they have been left in for paranoia's sake.  */
6368                       || streq (SECTION_NAME (section), ".rel.dyn")
6369                       || streq (SECTION_NAME (section), ".rela.dyn")))
6370                 /* Dynamic relocations apply to segments, not sections, so
6371                    they do not need an sh_info value.  */
6372                 ;
6373               else
6374                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6375                       i, section->sh_info);
6376             }
6377           break;
6378
6379         case SHT_DYNAMIC:
6380         case SHT_HASH:
6381         case SHT_SYMTAB_SHNDX:
6382         case SHT_INIT_ARRAY:
6383         case SHT_FINI_ARRAY:
6384         case SHT_PREINIT_ARRAY:
6385           if (section->sh_info != 0)
6386             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6387                   i, section->sh_info);
6388           break;
6389
6390         case SHT_GROUP:
6391         case SHT_SYMTAB:
6392         case SHT_DYNSYM:
6393           /* A symbol index - we assume that it is valid.  */
6394           break;
6395
6396         default:
6397           /* FIXME: Add support for target specific section types.  */
6398           if (section->sh_type == SHT_NOBITS)
6399             /* NOBITS section headers with non-zero sh_info fields can be
6400                created when a binary is stripped of everything but its debug
6401                information.  The stripped sections have their headers
6402                preserved but their types set to SHT_NOBITS.  So do not check
6403                this type of section.  */
6404             ;
6405           else if (section->sh_flags & SHF_INFO_LINK)
6406             {
6407               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6408                 warn (_("[%2u]: Expected link to another section in info field"), i);
6409             }
6410           else if (section->sh_type < SHT_LOOS
6411                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6412                    && section->sh_info != 0)
6413             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6414                   i, section->sh_info);
6415           break;
6416         }
6417
6418       /* Check the sh_size field.  */
6419       if (section->sh_size > filedata->file_size
6420           && section->sh_type != SHT_NOBITS
6421           && section->sh_type != SHT_NULL
6422           && section->sh_type < SHT_LOOS)
6423         warn (_("Size of section %u is larger than the entire file!\n"), i);
6424
6425       printf ("  [%2u] ", i);
6426       if (do_section_details)
6427         printf ("%s\n      ", printable_section_name (filedata, section));
6428       else
6429         print_symbol (-17, SECTION_NAME (section));
6430
6431       printf (do_wide ? " %-15s " : " %-15.15s ",
6432               get_section_type_name (filedata, section->sh_type));
6433
6434       if (is_32bit_elf)
6435         {
6436           const char * link_too_big = NULL;
6437
6438           print_vma (section->sh_addr, LONG_HEX);
6439
6440           printf ( " %6.6lx %6.6lx %2.2lx",
6441                    (unsigned long) section->sh_offset,
6442                    (unsigned long) section->sh_size,
6443                    (unsigned long) section->sh_entsize);
6444
6445           if (do_section_details)
6446             fputs ("  ", stdout);
6447           else
6448             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6449
6450           if (section->sh_link >= filedata->file_header.e_shnum)
6451             {
6452               link_too_big = "";
6453               /* The sh_link value is out of range.  Normally this indicates
6454                  an error but it can have special values in Solaris binaries.  */
6455               switch (filedata->file_header.e_machine)
6456                 {
6457                 case EM_386:
6458                 case EM_IAMCU:
6459                 case EM_X86_64:
6460                 case EM_L1OM:
6461                 case EM_K1OM:
6462                 case EM_OLD_SPARCV9:
6463                 case EM_SPARC32PLUS:
6464                 case EM_SPARCV9:
6465                 case EM_SPARC:
6466                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6467                     link_too_big = "BEFORE";
6468                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6469                     link_too_big = "AFTER";
6470                   break;
6471                 default:
6472                   break;
6473                 }
6474             }
6475
6476           if (do_section_details)
6477             {
6478               if (link_too_big != NULL && * link_too_big)
6479                 printf ("<%s> ", link_too_big);
6480               else
6481                 printf ("%2u ", section->sh_link);
6482               printf ("%3u %2lu\n", section->sh_info,
6483                       (unsigned long) section->sh_addralign);
6484             }
6485           else
6486             printf ("%2u %3u %2lu\n",
6487                     section->sh_link,
6488                     section->sh_info,
6489                     (unsigned long) section->sh_addralign);
6490
6491           if (link_too_big && ! * link_too_big)
6492             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6493                   i, section->sh_link);
6494         }
6495       else if (do_wide)
6496         {
6497           print_vma (section->sh_addr, LONG_HEX);
6498
6499           if ((long) section->sh_offset == section->sh_offset)
6500             printf (" %6.6lx", (unsigned long) section->sh_offset);
6501           else
6502             {
6503               putchar (' ');
6504               print_vma (section->sh_offset, LONG_HEX);
6505             }
6506
6507           if ((unsigned long) section->sh_size == section->sh_size)
6508             printf (" %6.6lx", (unsigned long) section->sh_size);
6509           else
6510             {
6511               putchar (' ');
6512               print_vma (section->sh_size, LONG_HEX);
6513             }
6514
6515           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6516             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6517           else
6518             {
6519               putchar (' ');
6520               print_vma (section->sh_entsize, LONG_HEX);
6521             }
6522
6523           if (do_section_details)
6524             fputs ("  ", stdout);
6525           else
6526             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6527
6528           printf ("%2u %3u ", section->sh_link, section->sh_info);
6529
6530           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6531             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6532           else
6533             {
6534               print_vma (section->sh_addralign, DEC);
6535               putchar ('\n');
6536             }
6537         }
6538       else if (do_section_details)
6539         {
6540           putchar (' ');
6541           print_vma (section->sh_addr, LONG_HEX);
6542           if ((long) section->sh_offset == section->sh_offset)
6543             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6544           else
6545             {
6546               printf ("  ");
6547               print_vma (section->sh_offset, LONG_HEX);
6548             }
6549           printf ("  %u\n       ", section->sh_link);
6550           print_vma (section->sh_size, LONG_HEX);
6551           putchar (' ');
6552           print_vma (section->sh_entsize, LONG_HEX);
6553
6554           printf ("  %-16u  %lu\n",
6555                   section->sh_info,
6556                   (unsigned long) section->sh_addralign);
6557         }
6558       else
6559         {
6560           putchar (' ');
6561           print_vma (section->sh_addr, LONG_HEX);
6562           if ((long) section->sh_offset == section->sh_offset)
6563             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6564           else
6565             {
6566               printf ("  ");
6567               print_vma (section->sh_offset, LONG_HEX);
6568             }
6569           printf ("\n       ");
6570           print_vma (section->sh_size, LONG_HEX);
6571           printf ("  ");
6572           print_vma (section->sh_entsize, LONG_HEX);
6573
6574           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6575
6576           printf ("     %2u   %3u     %lu\n",
6577                   section->sh_link,
6578                   section->sh_info,
6579                   (unsigned long) section->sh_addralign);
6580         }
6581
6582       if (do_section_details)
6583         {
6584           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6585           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6586             {
6587               /* Minimum section size is 12 bytes for 32-bit compression
6588                  header + 12 bytes for compressed data header.  */
6589               unsigned char buf[24];
6590
6591               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6592               if (get_data (&buf, filedata, section->sh_offset, 1,
6593                             sizeof (buf), _("compression header")))
6594                 {
6595                   Elf_Internal_Chdr chdr;
6596
6597                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6598
6599                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6600                     printf ("       ZLIB, ");
6601                   else
6602                     printf (_("       [<unknown>: 0x%x], "),
6603                             chdr.ch_type);
6604                   print_vma (chdr.ch_size, LONG_HEX);
6605                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6606                 }
6607             }
6608         }
6609     }
6610
6611   if (!do_section_details)
6612     {
6613       /* The ordering of the letters shown here matches the ordering of the
6614          corresponding SHF_xxx values, and hence the order in which these
6615          letters will be displayed to the user.  */
6616       printf (_("Key to Flags:\n\
6617   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6618   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6619   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6620       if (filedata->file_header.e_machine == EM_X86_64
6621           || filedata->file_header.e_machine == EM_L1OM
6622           || filedata->file_header.e_machine == EM_K1OM)
6623         printf (_("l (large), "));
6624       else if (filedata->file_header.e_machine == EM_ARM)
6625         printf (_("y (purecode), "));
6626       else if (filedata->file_header.e_machine == EM_PPC)
6627         printf (_("v (VLE), "));
6628       printf ("p (processor specific)\n");
6629     }
6630
6631   return TRUE;
6632 }
6633
6634 static const char *
6635 get_group_flags (unsigned int flags)
6636 {
6637   static char buff[128];
6638
6639   if (flags == 0)
6640     return "";
6641   else if (flags == GRP_COMDAT)
6642     return "COMDAT ";
6643
6644   snprintf (buff, 14, _("[0x%x: "), flags);
6645
6646   flags &= ~ GRP_COMDAT;
6647   if (flags & GRP_MASKOS)
6648     {
6649       strcat (buff, "<OS specific>");
6650       flags &= ~ GRP_MASKOS;
6651     }
6652
6653   if (flags & GRP_MASKPROC)
6654     {
6655       strcat (buff, "<PROC specific>");
6656       flags &= ~ GRP_MASKPROC;
6657     }
6658
6659   if (flags)
6660     strcat (buff, "<unknown>");
6661
6662   strcat (buff, "]");
6663   return buff;
6664 }
6665
6666 static bfd_boolean
6667 process_section_groups (Filedata * filedata)
6668 {
6669   Elf_Internal_Shdr * section;
6670   unsigned int i;
6671   struct group * group;
6672   Elf_Internal_Shdr * symtab_sec;
6673   Elf_Internal_Shdr * strtab_sec;
6674   Elf_Internal_Sym * symtab;
6675   unsigned long num_syms;
6676   char * strtab;
6677   size_t strtab_size;
6678
6679   /* Don't process section groups unless needed.  */
6680   if (!do_unwind && !do_section_groups)
6681     return TRUE;
6682
6683   if (filedata->file_header.e_shnum == 0)
6684     {
6685       if (do_section_groups)
6686         printf (_("\nThere are no sections to group in this file.\n"));
6687
6688       return TRUE;
6689     }
6690
6691   if (filedata->section_headers == NULL)
6692     {
6693       error (_("Section headers are not available!\n"));
6694       /* PR 13622: This can happen with a corrupt ELF header.  */
6695       return FALSE;
6696     }
6697
6698   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6699                                                      sizeof (struct group *));
6700
6701   if (section_headers_groups == NULL)
6702     {
6703       error (_("Out of memory reading %u section group headers\n"),
6704              filedata->file_header.e_shnum);
6705       return FALSE;
6706     }
6707
6708   /* Scan the sections for the group section.  */
6709   group_count = 0;
6710   for (i = 0, section = filedata->section_headers;
6711        i < filedata->file_header.e_shnum;
6712        i++, section++)
6713     if (section->sh_type == SHT_GROUP)
6714       group_count++;
6715
6716   if (group_count == 0)
6717     {
6718       if (do_section_groups)
6719         printf (_("\nThere are no section groups in this file.\n"));
6720
6721       return TRUE;
6722     }
6723
6724   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6725
6726   if (section_groups == NULL)
6727     {
6728       error (_("Out of memory reading %lu groups\n"),
6729              (unsigned long) group_count);
6730       return FALSE;
6731     }
6732
6733   symtab_sec = NULL;
6734   strtab_sec = NULL;
6735   symtab = NULL;
6736   num_syms = 0;
6737   strtab = NULL;
6738   strtab_size = 0;
6739   for (i = 0, section = filedata->section_headers, group = section_groups;
6740        i < filedata->file_header.e_shnum;
6741        i++, section++)
6742     {
6743       if (section->sh_type == SHT_GROUP)
6744         {
6745           const char * name = printable_section_name (filedata, section);
6746           const char * group_name;
6747           unsigned char * start;
6748           unsigned char * indices;
6749           unsigned int entry, j, size;
6750           Elf_Internal_Shdr * sec;
6751           Elf_Internal_Sym * sym;
6752
6753           /* Get the symbol table.  */
6754           if (section->sh_link >= filedata->file_header.e_shnum
6755               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6756                   != SHT_SYMTAB))
6757             {
6758               error (_("Bad sh_link in group section `%s'\n"), name);
6759               continue;
6760             }
6761
6762           if (symtab_sec != sec)
6763             {
6764               symtab_sec = sec;
6765               if (symtab)
6766                 free (symtab);
6767               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6768             }
6769
6770           if (symtab == NULL)
6771             {
6772               error (_("Corrupt header in group section `%s'\n"), name);
6773               continue;
6774             }
6775
6776           if (section->sh_info >= num_syms)
6777             {
6778               error (_("Bad sh_info in group section `%s'\n"), name);
6779               continue;
6780             }
6781
6782           sym = symtab + section->sh_info;
6783
6784           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6785             {
6786               if (sym->st_shndx == 0
6787                   || sym->st_shndx >= filedata->file_header.e_shnum)
6788                 {
6789                   error (_("Bad sh_info in group section `%s'\n"), name);
6790                   continue;
6791                 }
6792
6793               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6794               strtab_sec = NULL;
6795               if (strtab)
6796                 free (strtab);
6797               strtab = NULL;
6798               strtab_size = 0;
6799             }
6800           else
6801             {
6802               /* Get the string table.  */
6803               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6804                 {
6805                   strtab_sec = NULL;
6806                   if (strtab)
6807                     free (strtab);
6808                   strtab = NULL;
6809                   strtab_size = 0;
6810                 }
6811               else if (strtab_sec
6812                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6813                 {
6814                   strtab_sec = sec;
6815                   if (strtab)
6816                     free (strtab);
6817
6818                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6819                                               1, strtab_sec->sh_size,
6820                                               _("string table"));
6821                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6822                 }
6823               group_name = sym->st_name < strtab_size
6824                 ? strtab + sym->st_name : _("<corrupt>");
6825             }
6826
6827           /* PR 17531: file: loop.  */
6828           if (section->sh_entsize > section->sh_size)
6829             {
6830               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6831                      printable_section_name (filedata, section),
6832                      (unsigned long) section->sh_entsize,
6833                      (unsigned long) section->sh_size);
6834               break;
6835             }
6836
6837           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6838                                               1, section->sh_size,
6839                                               _("section data"));
6840           if (start == NULL)
6841             continue;
6842
6843           indices = start;
6844           size = (section->sh_size / section->sh_entsize) - 1;
6845           entry = byte_get (indices, 4);
6846           indices += 4;
6847
6848           if (do_section_groups)
6849             {
6850               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6851                       get_group_flags (entry), i, name, group_name, size);
6852
6853               printf (_("   [Index]    Name\n"));
6854             }
6855
6856           group->group_index = i;
6857
6858           for (j = 0; j < size; j++)
6859             {
6860               struct group_list * g;
6861
6862               entry = byte_get (indices, 4);
6863               indices += 4;
6864
6865               if (entry >= filedata->file_header.e_shnum)
6866                 {
6867                   static unsigned num_group_errors = 0;
6868
6869                   if (num_group_errors ++ < 10)
6870                     {
6871                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6872                              entry, i, filedata->file_header.e_shnum - 1);
6873                       if (num_group_errors == 10)
6874                         warn (_("Further error messages about overlarge group section indices suppressed\n"));
6875                     }
6876                   continue;
6877                 }
6878
6879               if (section_headers_groups [entry] != NULL)
6880                 {
6881                   if (entry)
6882                     {
6883                       static unsigned num_errs = 0;
6884
6885                       if (num_errs ++ < 10)
6886                         {
6887                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6888                                  entry, i,
6889                                  section_headers_groups [entry]->group_index);
6890                           if (num_errs == 10)
6891                             warn (_("Further error messages about already contained group sections suppressed\n"));
6892                         }
6893                       continue;
6894                     }
6895                   else
6896                     {
6897                       /* Intel C/C++ compiler may put section 0 in a
6898                          section group.  We just warn it the first time
6899                          and ignore it afterwards.  */
6900                       static bfd_boolean warned = FALSE;
6901                       if (!warned)
6902                         {
6903                           error (_("section 0 in group section [%5u]\n"),
6904                                  section_headers_groups [entry]->group_index);
6905                           warned = TRUE;
6906                         }
6907                     }
6908                 }
6909
6910               section_headers_groups [entry] = group;
6911
6912               if (do_section_groups)
6913                 {
6914                   sec = filedata->section_headers + entry;
6915                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6916                 }
6917
6918               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6919               g->section_index = entry;
6920               g->next = group->root;
6921               group->root = g;
6922             }
6923
6924           if (start)
6925             free (start);
6926
6927           group++;
6928         }
6929     }
6930
6931   if (symtab)
6932     free (symtab);
6933   if (strtab)
6934     free (strtab);
6935   return TRUE;
6936 }
6937
6938 /* Data used to display dynamic fixups.  */
6939
6940 struct ia64_vms_dynfixup
6941 {
6942   bfd_vma needed_ident;         /* Library ident number.  */
6943   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6944   bfd_vma fixup_needed;         /* Index of the library.  */
6945   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6946   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6947 };
6948
6949 /* Data used to display dynamic relocations.  */
6950
6951 struct ia64_vms_dynimgrela
6952 {
6953   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6954   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6955 };
6956
6957 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6958    library).  */
6959
6960 static bfd_boolean
6961 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6962                               struct ia64_vms_dynfixup *  fixup,
6963                               const char *                strtab,
6964                               unsigned int                strtab_sz)
6965 {
6966   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6967   long i;
6968   const char * lib_name;
6969
6970   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6971                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6972                    _("dynamic section image fixups"));
6973   if (!imfs)
6974     return FALSE;
6975
6976   if (fixup->needed < strtab_sz)
6977     lib_name = strtab + fixup->needed;
6978   else
6979     {
6980       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6981             (unsigned long) fixup->needed);
6982       lib_name = "???";
6983     }
6984   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6985           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6986   printf
6987     (_("Seg Offset           Type                             SymVec DataType\n"));
6988
6989   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6990     {
6991       unsigned int type;
6992       const char *rtype;
6993
6994       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6995       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6996       type = BYTE_GET (imfs [i].type);
6997       rtype = elf_ia64_reloc_type (type);
6998       if (rtype == NULL)
6999         printf (" 0x%08x                       ", type);
7000       else
7001         printf (" %-32s ", rtype);
7002       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7003       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7004     }
7005
7006   free (imfs);
7007   return TRUE;
7008 }
7009
7010 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
7011
7012 static bfd_boolean
7013 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7014 {
7015   Elf64_External_VMS_IMAGE_RELA *imrs;
7016   long i;
7017
7018   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7019                    1, imgrela->img_rela_cnt * sizeof (*imrs),
7020                    _("dynamic section image relocations"));
7021   if (!imrs)
7022     return FALSE;
7023
7024   printf (_("\nImage relocs\n"));
7025   printf
7026     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
7027
7028   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7029     {
7030       unsigned int type;
7031       const char *rtype;
7032
7033       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7034       printf ("%08" BFD_VMA_FMT "x ",
7035               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7036       type = BYTE_GET (imrs [i].type);
7037       rtype = elf_ia64_reloc_type (type);
7038       if (rtype == NULL)
7039         printf ("0x%08x                      ", type);
7040       else
7041         printf ("%-31s ", rtype);
7042       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7043       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7044       printf ("%08" BFD_VMA_FMT "x\n",
7045               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7046     }
7047
7048   free (imrs);
7049   return TRUE;
7050 }
7051
7052 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
7053
7054 static bfd_boolean
7055 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7056 {
7057   struct ia64_vms_dynfixup fixup;
7058   struct ia64_vms_dynimgrela imgrela;
7059   Elf_Internal_Dyn *entry;
7060   bfd_vma strtab_off = 0;
7061   bfd_vma strtab_sz = 0;
7062   char *strtab = NULL;
7063   bfd_boolean res = TRUE;
7064
7065   memset (&fixup, 0, sizeof (fixup));
7066   memset (&imgrela, 0, sizeof (imgrela));
7067
7068   /* Note: the order of the entries is specified by the OpenVMS specs.  */
7069   for (entry = dynamic_section;
7070        entry < dynamic_section + dynamic_nent;
7071        entry++)
7072     {
7073       switch (entry->d_tag)
7074         {
7075         case DT_IA_64_VMS_STRTAB_OFFSET:
7076           strtab_off = entry->d_un.d_val;
7077           break;
7078         case DT_STRSZ:
7079           strtab_sz = entry->d_un.d_val;
7080           if (strtab == NULL)
7081             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7082                                1, strtab_sz, _("dynamic string section"));
7083           break;
7084
7085         case DT_IA_64_VMS_NEEDED_IDENT:
7086           fixup.needed_ident = entry->d_un.d_val;
7087           break;
7088         case DT_NEEDED:
7089           fixup.needed = entry->d_un.d_val;
7090           break;
7091         case DT_IA_64_VMS_FIXUP_NEEDED:
7092           fixup.fixup_needed = entry->d_un.d_val;
7093           break;
7094         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7095           fixup.fixup_rela_cnt = entry->d_un.d_val;
7096           break;
7097         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7098           fixup.fixup_rela_off = entry->d_un.d_val;
7099           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7100             res = FALSE;
7101           break;
7102         case DT_IA_64_VMS_IMG_RELA_CNT:
7103           imgrela.img_rela_cnt = entry->d_un.d_val;
7104           break;
7105         case DT_IA_64_VMS_IMG_RELA_OFF:
7106           imgrela.img_rela_off = entry->d_un.d_val;
7107           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7108             res = FALSE;
7109           break;
7110
7111         default:
7112           break;
7113         }
7114     }
7115
7116   if (strtab != NULL)
7117     free (strtab);
7118
7119   return res;
7120 }
7121
7122 static struct
7123 {
7124   const char * name;
7125   int reloc;
7126   int size;
7127   int rela;
7128 }
7129   dynamic_relocations [] =
7130 {
7131   { "REL", DT_REL, DT_RELSZ, FALSE },
7132   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7133   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7134 };
7135
7136 /* Process the reloc section.  */
7137
7138 static bfd_boolean
7139 process_relocs (Filedata * filedata)
7140 {
7141   unsigned long rel_size;
7142   unsigned long rel_offset;
7143
7144   if (!do_reloc)
7145     return TRUE;
7146
7147   if (do_using_dynamic)
7148     {
7149       int          is_rela;
7150       const char * name;
7151       bfd_boolean  has_dynamic_reloc;
7152       unsigned int i;
7153
7154       has_dynamic_reloc = FALSE;
7155
7156       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7157         {
7158           is_rela = dynamic_relocations [i].rela;
7159           name = dynamic_relocations [i].name;
7160           rel_size = dynamic_info [dynamic_relocations [i].size];
7161           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7162
7163           if (rel_size)
7164             has_dynamic_reloc = TRUE;
7165
7166           if (is_rela == UNKNOWN)
7167             {
7168               if (dynamic_relocations [i].reloc == DT_JMPREL)
7169                 switch (dynamic_info[DT_PLTREL])
7170                   {
7171                   case DT_REL:
7172                     is_rela = FALSE;
7173                     break;
7174                   case DT_RELA:
7175                     is_rela = TRUE;
7176                     break;
7177                   }
7178             }
7179
7180           if (rel_size)
7181             {
7182               printf
7183                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7184                  name, rel_offset, rel_size);
7185
7186               dump_relocations (filedata,
7187                                 offset_from_vma (filedata, rel_offset, rel_size),
7188                                 rel_size,
7189                                 dynamic_symbols, num_dynamic_syms,
7190                                 dynamic_strings, dynamic_strings_length,
7191                                 is_rela, TRUE /* is_dynamic */);
7192             }
7193         }
7194
7195       if (is_ia64_vms (filedata))
7196         if (process_ia64_vms_dynamic_relocs (filedata))
7197           has_dynamic_reloc = TRUE;
7198
7199       if (! has_dynamic_reloc)
7200         printf (_("\nThere are no dynamic relocations in this file.\n"));
7201     }
7202   else
7203     {
7204       Elf_Internal_Shdr * section;
7205       unsigned long i;
7206       bfd_boolean found = FALSE;
7207
7208       for (i = 0, section = filedata->section_headers;
7209            i < filedata->file_header.e_shnum;
7210            i++, section++)
7211         {
7212           if (   section->sh_type != SHT_RELA
7213               && section->sh_type != SHT_REL)
7214             continue;
7215
7216           rel_offset = section->sh_offset;
7217           rel_size   = section->sh_size;
7218
7219           if (rel_size)
7220             {
7221               Elf_Internal_Shdr * strsec;
7222               int is_rela;
7223               unsigned long num_rela;
7224
7225               printf (_("\nRelocation section "));
7226
7227               if (filedata->string_table == NULL)
7228                 printf ("%d", section->sh_name);
7229               else
7230                 printf ("'%s'", printable_section_name (filedata, section));
7231
7232               num_rela = rel_size / section->sh_entsize;
7233               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7234                                 " at offset 0x%lx contains %lu entries:\n",
7235                                 num_rela),
7236                       rel_offset, num_rela);
7237
7238               is_rela = section->sh_type == SHT_RELA;
7239
7240               if (section->sh_link != 0
7241                   && section->sh_link < filedata->file_header.e_shnum)
7242                 {
7243                   Elf_Internal_Shdr * symsec;
7244                   Elf_Internal_Sym *  symtab;
7245                   unsigned long nsyms;
7246                   unsigned long strtablen = 0;
7247                   char * strtab = NULL;
7248
7249                   symsec = filedata->section_headers + section->sh_link;
7250                   if (symsec->sh_type != SHT_SYMTAB
7251                       && symsec->sh_type != SHT_DYNSYM)
7252                     continue;
7253
7254                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7255
7256                   if (symtab == NULL)
7257                     continue;
7258
7259                   if (symsec->sh_link != 0
7260                       && symsec->sh_link < filedata->file_header.e_shnum)
7261                     {
7262                       strsec = filedata->section_headers + symsec->sh_link;
7263
7264                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7265                                                   1, strsec->sh_size,
7266                                                   _("string table"));
7267                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7268                     }
7269
7270                   dump_relocations (filedata, rel_offset, rel_size,
7271                                     symtab, nsyms, strtab, strtablen,
7272                                     is_rela,
7273                                     symsec->sh_type == SHT_DYNSYM);
7274                   if (strtab)
7275                     free (strtab);
7276                   free (symtab);
7277                 }
7278               else
7279                 dump_relocations (filedata, rel_offset, rel_size,
7280                                   NULL, 0, NULL, 0, is_rela,
7281                                   FALSE /* is_dynamic */);
7282
7283               found = TRUE;
7284             }
7285         }
7286
7287       if (! found)
7288         {
7289           /* Users sometimes forget the -D option, so try to be helpful.  */
7290           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7291             {
7292               if (dynamic_info [dynamic_relocations [i].size])
7293                 {
7294                   printf (_("\nThere are no static relocations in this file."));
7295                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7296
7297                   break;
7298                 }
7299             }
7300           if (i == ARRAY_SIZE (dynamic_relocations))
7301             printf (_("\nThere are no relocations in this file.\n"));
7302         }
7303     }
7304
7305   return TRUE;
7306 }
7307
7308 /* An absolute address consists of a section and an offset.  If the
7309    section is NULL, the offset itself is the address, otherwise, the
7310    address equals to LOAD_ADDRESS(section) + offset.  */
7311
7312 struct absaddr
7313 {
7314   unsigned short section;
7315   bfd_vma offset;
7316 };
7317
7318 #define ABSADDR(a) \
7319   ((a).section \
7320    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7321    : (a).offset)
7322
7323 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7324    name, if found, and the offset from the symbol to ADDR.  */
7325
7326 static void
7327 find_symbol_for_address (Filedata *          filedata,
7328                          Elf_Internal_Sym *  symtab,
7329                          unsigned long       nsyms,
7330                          const char *        strtab,
7331                          unsigned long       strtab_size,
7332                          struct absaddr      addr,
7333                          const char **       symname,
7334                          bfd_vma *           offset)
7335 {
7336   bfd_vma dist = 0x100000;
7337   Elf_Internal_Sym * sym;
7338   Elf_Internal_Sym * beg;
7339   Elf_Internal_Sym * end;
7340   Elf_Internal_Sym * best = NULL;
7341
7342   REMOVE_ARCH_BITS (addr.offset);
7343   beg = symtab;
7344   end = symtab + nsyms;
7345
7346   while (beg < end)
7347     {
7348       bfd_vma value;
7349
7350       sym = beg + (end - beg) / 2;
7351
7352       value = sym->st_value;
7353       REMOVE_ARCH_BITS (value);
7354
7355       if (sym->st_name != 0
7356           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7357           && addr.offset >= value
7358           && addr.offset - value < dist)
7359         {
7360           best = sym;
7361           dist = addr.offset - value;
7362           if (!dist)
7363             break;
7364         }
7365
7366       if (addr.offset < value)
7367         end = sym;
7368       else
7369         beg = sym + 1;
7370     }
7371
7372   if (best)
7373     {
7374       *symname = (best->st_name >= strtab_size
7375                   ? _("<corrupt>") : strtab + best->st_name);
7376       *offset = dist;
7377       return;
7378     }
7379
7380   *symname = NULL;
7381   *offset = addr.offset;
7382 }
7383
7384 static /* signed */ int
7385 symcmp (const void *p, const void *q)
7386 {
7387   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7388   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7389
7390   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7391 }
7392
7393 /* Process the unwind section.  */
7394
7395 #include "unwind-ia64.h"
7396
7397 struct ia64_unw_table_entry
7398 {
7399   struct absaddr start;
7400   struct absaddr end;
7401   struct absaddr info;
7402 };
7403
7404 struct ia64_unw_aux_info
7405 {
7406   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7407   unsigned long                 table_len;      /* Length of unwind table.  */
7408   unsigned char *               info;           /* Unwind info.  */
7409   unsigned long                 info_size;      /* Size of unwind info.  */
7410   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7411   bfd_vma                       seg_base;       /* Starting address of segment.  */
7412   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7413   unsigned long                 nsyms;          /* Number of symbols.  */
7414   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7415   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7416   char *                        strtab;         /* The string table.  */
7417   unsigned long                 strtab_size;    /* Size of string table.  */
7418 };
7419
7420 static bfd_boolean
7421 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7422 {
7423   struct ia64_unw_table_entry * tp;
7424   unsigned long j, nfuns;
7425   int in_body;
7426   bfd_boolean res = TRUE;
7427
7428   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7429   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7430     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7431       aux->funtab[nfuns++] = aux->symtab[j];
7432   aux->nfuns = nfuns;
7433   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7434
7435   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7436     {
7437       bfd_vma stamp;
7438       bfd_vma offset;
7439       const unsigned char * dp;
7440       const unsigned char * head;
7441       const unsigned char * end;
7442       const char * procname;
7443
7444       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7445                                aux->strtab_size, tp->start, &procname, &offset);
7446
7447       fputs ("\n<", stdout);
7448
7449       if (procname)
7450         {
7451           fputs (procname, stdout);
7452
7453           if (offset)
7454             printf ("+%lx", (unsigned long) offset);
7455         }
7456
7457       fputs (">: [", stdout);
7458       print_vma (tp->start.offset, PREFIX_HEX);
7459       fputc ('-', stdout);
7460       print_vma (tp->end.offset, PREFIX_HEX);
7461       printf ("], info at +0x%lx\n",
7462               (unsigned long) (tp->info.offset - aux->seg_base));
7463
7464       /* PR 17531: file: 86232b32.  */
7465       if (aux->info == NULL)
7466         continue;
7467
7468       /* PR 17531: file: 0997b4d1.  */
7469       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7470         {
7471           warn (_("Invalid offset %lx in table entry %ld\n"),
7472                 (long) tp->info.offset, (long) (tp - aux->table));
7473           res = FALSE;
7474           continue;
7475         }
7476
7477       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7478       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7479
7480       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7481               (unsigned) UNW_VER (stamp),
7482               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7483               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7484               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7485               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7486
7487       if (UNW_VER (stamp) != 1)
7488         {
7489           printf (_("\tUnknown version.\n"));
7490           continue;
7491         }
7492
7493       in_body = 0;
7494       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7495       /* PR 17531: file: 16ceda89.  */
7496       if (end > aux->info + aux->info_size)
7497         end = aux->info + aux->info_size;
7498       for (dp = head + 8; dp < end;)
7499         dp = unw_decode (dp, in_body, & in_body, end);
7500     }
7501
7502   free (aux->funtab);
7503
7504   return res;
7505 }
7506
7507 static bfd_boolean
7508 slurp_ia64_unwind_table (Filedata *                  filedata,
7509                          struct ia64_unw_aux_info *  aux,
7510                          Elf_Internal_Shdr *         sec)
7511 {
7512   unsigned long size, nrelas, i;
7513   Elf_Internal_Phdr * seg;
7514   struct ia64_unw_table_entry * tep;
7515   Elf_Internal_Shdr * relsec;
7516   Elf_Internal_Rela * rela;
7517   Elf_Internal_Rela * rp;
7518   unsigned char * table;
7519   unsigned char * tp;
7520   Elf_Internal_Sym * sym;
7521   const char * relname;
7522
7523   aux->table_len = 0;
7524
7525   /* First, find the starting address of the segment that includes
7526      this section: */
7527
7528   if (filedata->file_header.e_phnum)
7529     {
7530       if (! get_program_headers (filedata))
7531           return FALSE;
7532
7533       for (seg = filedata->program_headers;
7534            seg < filedata->program_headers + filedata->file_header.e_phnum;
7535            ++seg)
7536         {
7537           if (seg->p_type != PT_LOAD)
7538             continue;
7539
7540           if (sec->sh_addr >= seg->p_vaddr
7541               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7542             {
7543               aux->seg_base = seg->p_vaddr;
7544               break;
7545             }
7546         }
7547     }
7548
7549   /* Second, build the unwind table from the contents of the unwind section:  */
7550   size = sec->sh_size;
7551   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7552                                       _("unwind table"));
7553   if (!table)
7554     return FALSE;
7555
7556   aux->table_len = size / (3 * eh_addr_size);
7557   aux->table = (struct ia64_unw_table_entry *)
7558     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7559   tep = aux->table;
7560
7561   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7562     {
7563       tep->start.section = SHN_UNDEF;
7564       tep->end.section   = SHN_UNDEF;
7565       tep->info.section  = SHN_UNDEF;
7566       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7567       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7568       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7569       tep->start.offset += aux->seg_base;
7570       tep->end.offset   += aux->seg_base;
7571       tep->info.offset  += aux->seg_base;
7572     }
7573   free (table);
7574
7575   /* Third, apply any relocations to the unwind table:  */
7576   for (relsec = filedata->section_headers;
7577        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7578        ++relsec)
7579     {
7580       if (relsec->sh_type != SHT_RELA
7581           || relsec->sh_info >= filedata->file_header.e_shnum
7582           || filedata->section_headers + relsec->sh_info != sec)
7583         continue;
7584
7585       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7586                               & rela, & nrelas))
7587         {
7588           free (aux->table);
7589           aux->table = NULL;
7590           aux->table_len = 0;
7591           return FALSE;
7592         }
7593
7594       for (rp = rela; rp < rela + nrelas; ++rp)
7595         {
7596           relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7597           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7598
7599           /* PR 17531: file: 9fa67536.  */
7600           if (relname == NULL)
7601             {
7602               warn (_("Skipping unknown relocation type: %u\n"),
7603                     get_reloc_type (filedata, rp->r_info));
7604               continue;
7605             }
7606
7607           if (! const_strneq (relname, "R_IA64_SEGREL"))
7608             {
7609               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7610               continue;
7611             }
7612
7613           i = rp->r_offset / (3 * eh_addr_size);
7614
7615           /* PR 17531: file: 5bc8d9bf.  */
7616           if (i >= aux->table_len)
7617             {
7618               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7619               continue;
7620             }
7621
7622           switch (rp->r_offset / eh_addr_size % 3)
7623             {
7624             case 0:
7625               aux->table[i].start.section = sym->st_shndx;
7626               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7627               break;
7628             case 1:
7629               aux->table[i].end.section   = sym->st_shndx;
7630               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7631               break;
7632             case 2:
7633               aux->table[i].info.section  = sym->st_shndx;
7634               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7635               break;
7636             default:
7637               break;
7638             }
7639         }
7640
7641       free (rela);
7642     }
7643
7644   return TRUE;
7645 }
7646
7647 static bfd_boolean
7648 ia64_process_unwind (Filedata * filedata)
7649 {
7650   Elf_Internal_Shdr * sec;
7651   Elf_Internal_Shdr * unwsec = NULL;
7652   Elf_Internal_Shdr * strsec;
7653   unsigned long i, unwcount = 0, unwstart = 0;
7654   struct ia64_unw_aux_info aux;
7655   bfd_boolean res = TRUE;
7656
7657   memset (& aux, 0, sizeof (aux));
7658
7659   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7660     {
7661       if (sec->sh_type == SHT_SYMTAB
7662           && sec->sh_link < filedata->file_header.e_shnum)
7663         {
7664           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7665
7666           strsec = filedata->section_headers + sec->sh_link;
7667           if (aux.strtab != NULL)
7668             {
7669               error (_("Multiple auxillary string tables encountered\n"));
7670               free (aux.strtab);
7671               res = FALSE;
7672             }
7673           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7674                                           1, strsec->sh_size,
7675                                           _("string table"));
7676           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7677         }
7678       else if (sec->sh_type == SHT_IA_64_UNWIND)
7679         unwcount++;
7680     }
7681
7682   if (!unwcount)
7683     printf (_("\nThere are no unwind sections in this file.\n"));
7684
7685   while (unwcount-- > 0)
7686     {
7687       char * suffix;
7688       size_t len, len2;
7689
7690       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7691            i < filedata->file_header.e_shnum; ++i, ++sec)
7692         if (sec->sh_type == SHT_IA_64_UNWIND)
7693           {
7694             unwsec = sec;
7695             break;
7696           }
7697       /* We have already counted the number of SHT_IA64_UNWIND
7698          sections so the loop above should never fail.  */
7699       assert (unwsec != NULL);
7700
7701       unwstart = i + 1;
7702       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7703
7704       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7705         {
7706           /* We need to find which section group it is in.  */
7707           struct group_list * g;
7708
7709           if (section_headers_groups == NULL
7710               || section_headers_groups [i] == NULL)
7711             i = filedata->file_header.e_shnum;
7712           else
7713             {
7714               g = section_headers_groups [i]->root;
7715
7716               for (; g != NULL; g = g->next)
7717                 {
7718                   sec = filedata->section_headers + g->section_index;
7719
7720                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7721                     break;
7722                 }
7723
7724               if (g == NULL)
7725                 i = filedata->file_header.e_shnum;
7726             }
7727         }
7728       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7729         {
7730           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7731           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7732           suffix = SECTION_NAME (unwsec) + len;
7733           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7734                ++i, ++sec)
7735             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7736                 && streq (SECTION_NAME (sec) + len2, suffix))
7737               break;
7738         }
7739       else
7740         {
7741           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7742              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7743           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7744           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7745           suffix = "";
7746           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7747             suffix = SECTION_NAME (unwsec) + len;
7748           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7749                ++i, ++sec)
7750             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7751                 && streq (SECTION_NAME (sec) + len2, suffix))
7752               break;
7753         }
7754
7755       if (i == filedata->file_header.e_shnum)
7756         {
7757           printf (_("\nCould not find unwind info section for "));
7758
7759           if (filedata->string_table == NULL)
7760             printf ("%d", unwsec->sh_name);
7761           else
7762             printf ("'%s'", printable_section_name (filedata, unwsec));
7763         }
7764       else
7765         {
7766           aux.info_addr = sec->sh_addr;
7767           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7768                                                  sec->sh_size,
7769                                                  _("unwind info"));
7770           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7771
7772           printf (_("\nUnwind section "));
7773
7774           if (filedata->string_table == NULL)
7775             printf ("%d", unwsec->sh_name);
7776           else
7777             printf ("'%s'", printable_section_name (filedata, unwsec));
7778
7779           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7780                   (unsigned long) unwsec->sh_offset,
7781                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7782
7783           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7784               && aux.table_len > 0)
7785             dump_ia64_unwind (filedata, & aux);
7786
7787           if (aux.table)
7788             free ((char *) aux.table);
7789           if (aux.info)
7790             free ((char *) aux.info);
7791           aux.table = NULL;
7792           aux.info = NULL;
7793         }
7794     }
7795
7796   if (aux.symtab)
7797     free (aux.symtab);
7798   if (aux.strtab)
7799     free ((char *) aux.strtab);
7800
7801   return res;
7802 }
7803
7804 struct hppa_unw_table_entry
7805 {
7806   struct absaddr start;
7807   struct absaddr end;
7808   unsigned int Cannot_unwind:1;                 /* 0 */
7809   unsigned int Millicode:1;                     /* 1 */
7810   unsigned int Millicode_save_sr0:1;            /* 2 */
7811   unsigned int Region_description:2;            /* 3..4 */
7812   unsigned int reserved1:1;                     /* 5 */
7813   unsigned int Entry_SR:1;                      /* 6 */
7814   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7815   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7816   unsigned int Args_stored:1;                   /* 16 */
7817   unsigned int Variable_Frame:1;                /* 17 */
7818   unsigned int Separate_Package_Body:1;         /* 18 */
7819   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7820   unsigned int Stack_Overflow_Check:1;          /* 20 */
7821   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7822   unsigned int Ada_Region:1;                    /* 22 */
7823   unsigned int cxx_info:1;                      /* 23 */
7824   unsigned int cxx_try_catch:1;                 /* 24 */
7825   unsigned int sched_entry_seq:1;               /* 25 */
7826   unsigned int reserved2:1;                     /* 26 */
7827   unsigned int Save_SP:1;                       /* 27 */
7828   unsigned int Save_RP:1;                       /* 28 */
7829   unsigned int Save_MRP_in_frame:1;             /* 29 */
7830   unsigned int extn_ptr_defined:1;              /* 30 */
7831   unsigned int Cleanup_defined:1;               /* 31 */
7832
7833   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7834   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7835   unsigned int Large_frame:1;                   /* 2 */
7836   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7837   unsigned int reserved4:1;                     /* 4 */
7838   unsigned int Total_frame_size:27;             /* 5..31 */
7839 };
7840
7841 struct hppa_unw_aux_info
7842 {
7843   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7844   unsigned long                  table_len;     /* Length of unwind table.  */
7845   bfd_vma                        seg_base;      /* Starting address of segment.  */
7846   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7847   unsigned long                  nsyms;         /* Number of symbols.  */
7848   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7849   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7850   char *                         strtab;        /* The string table.  */
7851   unsigned long                  strtab_size;   /* Size of string table.  */
7852 };
7853
7854 static bfd_boolean
7855 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7856 {
7857   struct hppa_unw_table_entry * tp;
7858   unsigned long j, nfuns;
7859   bfd_boolean res = TRUE;
7860
7861   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7862   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7863     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7864       aux->funtab[nfuns++] = aux->symtab[j];
7865   aux->nfuns = nfuns;
7866   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7867
7868   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7869     {
7870       bfd_vma offset;
7871       const char * procname;
7872
7873       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7874                                aux->strtab_size, tp->start, &procname,
7875                                &offset);
7876
7877       fputs ("\n<", stdout);
7878
7879       if (procname)
7880         {
7881           fputs (procname, stdout);
7882
7883           if (offset)
7884             printf ("+%lx", (unsigned long) offset);
7885         }
7886
7887       fputs (">: [", stdout);
7888       print_vma (tp->start.offset, PREFIX_HEX);
7889       fputc ('-', stdout);
7890       print_vma (tp->end.offset, PREFIX_HEX);
7891       printf ("]\n\t");
7892
7893 #define PF(_m) if (tp->_m) printf (#_m " ");
7894 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7895       PF(Cannot_unwind);
7896       PF(Millicode);
7897       PF(Millicode_save_sr0);
7898       /* PV(Region_description);  */
7899       PF(Entry_SR);
7900       PV(Entry_FR);
7901       PV(Entry_GR);
7902       PF(Args_stored);
7903       PF(Variable_Frame);
7904       PF(Separate_Package_Body);
7905       PF(Frame_Extension_Millicode);
7906       PF(Stack_Overflow_Check);
7907       PF(Two_Instruction_SP_Increment);
7908       PF(Ada_Region);
7909       PF(cxx_info);
7910       PF(cxx_try_catch);
7911       PF(sched_entry_seq);
7912       PF(Save_SP);
7913       PF(Save_RP);
7914       PF(Save_MRP_in_frame);
7915       PF(extn_ptr_defined);
7916       PF(Cleanup_defined);
7917       PF(MPE_XL_interrupt_marker);
7918       PF(HP_UX_interrupt_marker);
7919       PF(Large_frame);
7920       PF(Pseudo_SP_Set);
7921       PV(Total_frame_size);
7922 #undef PF
7923 #undef PV
7924     }
7925
7926   printf ("\n");
7927
7928   free (aux->funtab);
7929
7930   return res;
7931 }
7932
7933 static bfd_boolean
7934 slurp_hppa_unwind_table (Filedata *                  filedata,
7935                          struct hppa_unw_aux_info *  aux,
7936                          Elf_Internal_Shdr *         sec)
7937 {
7938   unsigned long size, unw_ent_size, nentries, nrelas, i;
7939   Elf_Internal_Phdr * seg;
7940   struct hppa_unw_table_entry * tep;
7941   Elf_Internal_Shdr * relsec;
7942   Elf_Internal_Rela * rela;
7943   Elf_Internal_Rela * rp;
7944   unsigned char * table;
7945   unsigned char * tp;
7946   Elf_Internal_Sym * sym;
7947   const char * relname;
7948
7949   /* First, find the starting address of the segment that includes
7950      this section.  */
7951   if (filedata->file_header.e_phnum)
7952     {
7953       if (! get_program_headers (filedata))
7954         return FALSE;
7955
7956       for (seg = filedata->program_headers;
7957            seg < filedata->program_headers + filedata->file_header.e_phnum;
7958            ++seg)
7959         {
7960           if (seg->p_type != PT_LOAD)
7961             continue;
7962
7963           if (sec->sh_addr >= seg->p_vaddr
7964               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7965             {
7966               aux->seg_base = seg->p_vaddr;
7967               break;
7968             }
7969         }
7970     }
7971
7972   /* Second, build the unwind table from the contents of the unwind
7973      section.  */
7974   size = sec->sh_size;
7975   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7976                                       _("unwind table"));
7977   if (!table)
7978     return FALSE;
7979
7980   unw_ent_size = 16;
7981   nentries = size / unw_ent_size;
7982   size = unw_ent_size * nentries;
7983
7984   tep = aux->table = (struct hppa_unw_table_entry *)
7985       xcmalloc (nentries, sizeof (aux->table[0]));
7986
7987   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7988     {
7989       unsigned int tmp1, tmp2;
7990
7991       tep->start.section = SHN_UNDEF;
7992       tep->end.section   = SHN_UNDEF;
7993
7994       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7995       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7996       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7997       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7998
7999       tep->start.offset += aux->seg_base;
8000       tep->end.offset   += aux->seg_base;
8001
8002       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8003       tep->Millicode = (tmp1 >> 30) & 0x1;
8004       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8005       tep->Region_description = (tmp1 >> 27) & 0x3;
8006       tep->reserved1 = (tmp1 >> 26) & 0x1;
8007       tep->Entry_SR = (tmp1 >> 25) & 0x1;
8008       tep->Entry_FR = (tmp1 >> 21) & 0xf;
8009       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8010       tep->Args_stored = (tmp1 >> 15) & 0x1;
8011       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8012       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8013       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8014       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8015       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8016       tep->Ada_Region = (tmp1 >> 9) & 0x1;
8017       tep->cxx_info = (tmp1 >> 8) & 0x1;
8018       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8019       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8020       tep->reserved2 = (tmp1 >> 5) & 0x1;
8021       tep->Save_SP = (tmp1 >> 4) & 0x1;
8022       tep->Save_RP = (tmp1 >> 3) & 0x1;
8023       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8024       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8025       tep->Cleanup_defined = tmp1 & 0x1;
8026
8027       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8028       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8029       tep->Large_frame = (tmp2 >> 29) & 0x1;
8030       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8031       tep->reserved4 = (tmp2 >> 27) & 0x1;
8032       tep->Total_frame_size = tmp2 & 0x7ffffff;
8033     }
8034   free (table);
8035
8036   /* Third, apply any relocations to the unwind table.  */
8037   for (relsec = filedata->section_headers;
8038        relsec < filedata->section_headers + filedata->file_header.e_shnum;
8039        ++relsec)
8040     {
8041       if (relsec->sh_type != SHT_RELA
8042           || relsec->sh_info >= filedata->file_header.e_shnum
8043           || filedata->section_headers + relsec->sh_info != sec)
8044         continue;
8045
8046       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8047                               & rela, & nrelas))
8048         return FALSE;
8049
8050       for (rp = rela; rp < rela + nrelas; ++rp)
8051         {
8052           relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
8053           sym = aux->symtab + get_reloc_symindex (rp->r_info);
8054
8055           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
8056           if (! const_strneq (relname, "R_PARISC_SEGREL"))
8057             {
8058               warn (_("Skipping unexpected relocation type %s\n"), relname);
8059               continue;
8060             }
8061
8062           i = rp->r_offset / unw_ent_size;
8063
8064           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
8065             {
8066             case 0:
8067               aux->table[i].start.section = sym->st_shndx;
8068               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
8069               break;
8070             case 1:
8071               aux->table[i].end.section   = sym->st_shndx;
8072               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
8073               break;
8074             default:
8075               break;
8076             }
8077         }
8078
8079       free (rela);
8080     }
8081
8082   aux->table_len = nentries;
8083
8084   return TRUE;
8085 }
8086
8087 static bfd_boolean
8088 hppa_process_unwind (Filedata * filedata)
8089 {
8090   struct hppa_unw_aux_info aux;
8091   Elf_Internal_Shdr * unwsec = NULL;
8092   Elf_Internal_Shdr * strsec;
8093   Elf_Internal_Shdr * sec;
8094   unsigned long i;
8095   bfd_boolean res = TRUE;
8096
8097   if (filedata->string_table == NULL)
8098     return FALSE;
8099
8100   memset (& aux, 0, sizeof (aux));
8101
8102   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8103     {
8104       if (sec->sh_type == SHT_SYMTAB
8105           && sec->sh_link < filedata->file_header.e_shnum)
8106         {
8107           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8108
8109           strsec = filedata->section_headers + sec->sh_link;
8110           if (aux.strtab != NULL)
8111             {
8112               error (_("Multiple auxillary string tables encountered\n"));
8113               free (aux.strtab);
8114               res = FALSE;
8115             }
8116           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8117                                           1, strsec->sh_size,
8118                                           _("string table"));
8119           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8120         }
8121       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8122         unwsec = sec;
8123     }
8124
8125   if (!unwsec)
8126     printf (_("\nThere are no unwind sections in this file.\n"));
8127
8128   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8129     {
8130       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8131         {
8132           unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8133
8134           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8135                             "contains %lu entry:\n",
8136                             "\nUnwind section '%s' at offset 0x%lx "
8137                             "contains %lu entries:\n",
8138                             num_unwind),
8139                   printable_section_name (filedata, sec),
8140                   (unsigned long) sec->sh_offset,
8141                   num_unwind);
8142
8143           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8144             res = FALSE;
8145
8146           if (res && aux.table_len > 0)
8147             {
8148               if (! dump_hppa_unwind (filedata, &aux))
8149                 res = FALSE;
8150             }
8151
8152           if (aux.table)
8153             free ((char *) aux.table);
8154           aux.table = NULL;
8155         }
8156     }
8157
8158   if (aux.symtab)
8159     free (aux.symtab);
8160   if (aux.strtab)
8161     free ((char *) aux.strtab);
8162
8163   return res;
8164 }
8165
8166 struct arm_section
8167 {
8168   unsigned char *      data;            /* The unwind data.  */
8169   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8170   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8171   unsigned long        nrelas;          /* The number of relocations.  */
8172   unsigned int         rel_type;        /* REL or RELA ?  */
8173   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8174 };
8175
8176 struct arm_unw_aux_info
8177 {
8178   Filedata *          filedata;         /* The file containing the unwind sections.  */
8179   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8180   unsigned long       nsyms;            /* Number of symbols.  */
8181   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8182   unsigned long       nfuns;            /* Number of these symbols.  */
8183   char *              strtab;           /* The file's string table.  */
8184   unsigned long       strtab_size;      /* Size of string table.  */
8185 };
8186
8187 static const char *
8188 arm_print_vma_and_name (Filedata *                 filedata,
8189                         struct arm_unw_aux_info *  aux,
8190                         bfd_vma                    fn,
8191                         struct absaddr             addr)
8192 {
8193   const char *procname;
8194   bfd_vma sym_offset;
8195
8196   if (addr.section == SHN_UNDEF)
8197     addr.offset = fn;
8198
8199   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8200                            aux->strtab_size, addr, &procname,
8201                            &sym_offset);
8202
8203   print_vma (fn, PREFIX_HEX);
8204
8205   if (procname)
8206     {
8207       fputs (" <", stdout);
8208       fputs (procname, stdout);
8209
8210       if (sym_offset)
8211         printf ("+0x%lx", (unsigned long) sym_offset);
8212       fputc ('>', stdout);
8213     }
8214
8215   return procname;
8216 }
8217
8218 static void
8219 arm_free_section (struct arm_section *arm_sec)
8220 {
8221   if (arm_sec->data != NULL)
8222     free (arm_sec->data);
8223
8224   if (arm_sec->rela != NULL)
8225     free (arm_sec->rela);
8226 }
8227
8228 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8229       cached section and install SEC instead.
8230    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8231       and return its valued in * WORDP, relocating if necessary.
8232    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8233       relocation's offset in ADDR.
8234    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8235       into the string table of the symbol associated with the reloc.  If no
8236       reloc was applied store -1 there.
8237    5) Return TRUE upon success, FALSE otherwise.  */
8238
8239 static bfd_boolean
8240 get_unwind_section_word (Filedata *                 filedata,
8241                          struct arm_unw_aux_info *  aux,
8242                          struct arm_section *       arm_sec,
8243                          Elf_Internal_Shdr *        sec,
8244                          bfd_vma                    word_offset,
8245                          unsigned int *             wordp,
8246                          struct absaddr *           addr,
8247                          bfd_vma *                  sym_name)
8248 {
8249   Elf_Internal_Rela *rp;
8250   Elf_Internal_Sym *sym;
8251   const char * relname;
8252   unsigned int word;
8253   bfd_boolean wrapped;
8254
8255   if (sec == NULL || arm_sec == NULL)
8256     return FALSE;
8257
8258   addr->section = SHN_UNDEF;
8259   addr->offset = 0;
8260
8261   if (sym_name != NULL)
8262     *sym_name = (bfd_vma) -1;
8263
8264   /* If necessary, update the section cache.  */
8265   if (sec != arm_sec->sec)
8266     {
8267       Elf_Internal_Shdr *relsec;
8268
8269       arm_free_section (arm_sec);
8270
8271       arm_sec->sec = sec;
8272       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8273                                 sec->sh_size, _("unwind data"));
8274       arm_sec->rela = NULL;
8275       arm_sec->nrelas = 0;
8276
8277       for (relsec = filedata->section_headers;
8278            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8279            ++relsec)
8280         {
8281           if (relsec->sh_info >= filedata->file_header.e_shnum
8282               || filedata->section_headers + relsec->sh_info != sec
8283               /* PR 15745: Check the section type as well.  */
8284               || (relsec->sh_type != SHT_REL
8285                   && relsec->sh_type != SHT_RELA))
8286             continue;
8287
8288           arm_sec->rel_type = relsec->sh_type;
8289           if (relsec->sh_type == SHT_REL)
8290             {
8291               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8292                                      relsec->sh_size,
8293                                      & arm_sec->rela, & arm_sec->nrelas))
8294                 return FALSE;
8295             }
8296           else /* relsec->sh_type == SHT_RELA */
8297             {
8298               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8299                                       relsec->sh_size,
8300                                       & arm_sec->rela, & arm_sec->nrelas))
8301                 return FALSE;
8302             }
8303           break;
8304         }
8305
8306       arm_sec->next_rela = arm_sec->rela;
8307     }
8308
8309   /* If there is no unwind data we can do nothing.  */
8310   if (arm_sec->data == NULL)
8311     return FALSE;
8312
8313   /* If the offset is invalid then fail.  */
8314   if (/* PR 21343 *//* PR 18879 */
8315       sec->sh_size < 4
8316       || word_offset > (sec->sh_size - 4)
8317       || ((bfd_signed_vma) word_offset) < 0)
8318     return FALSE;
8319
8320   /* Get the word at the required offset.  */
8321   word = byte_get (arm_sec->data + word_offset, 4);
8322
8323   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8324   if (arm_sec->rela == NULL)
8325     {
8326       * wordp = word;
8327       return TRUE;
8328     }
8329
8330   /* Look through the relocs to find the one that applies to the provided offset.  */
8331   wrapped = FALSE;
8332   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8333     {
8334       bfd_vma prelval, offset;
8335
8336       if (rp->r_offset > word_offset && !wrapped)
8337         {
8338           rp = arm_sec->rela;
8339           wrapped = TRUE;
8340         }
8341       if (rp->r_offset > word_offset)
8342         break;
8343
8344       if (rp->r_offset & 3)
8345         {
8346           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8347                 (unsigned long) rp->r_offset);
8348           continue;
8349         }
8350
8351       if (rp->r_offset < word_offset)
8352         continue;
8353
8354       /* PR 17531: file: 027-161405-0.004  */
8355       if (aux->symtab == NULL)
8356         continue;
8357
8358       if (arm_sec->rel_type == SHT_REL)
8359         {
8360           offset = word & 0x7fffffff;
8361           if (offset & 0x40000000)
8362             offset |= ~ (bfd_vma) 0x7fffffff;
8363         }
8364       else if (arm_sec->rel_type == SHT_RELA)
8365         offset = rp->r_addend;
8366       else
8367         {
8368           error (_("Unknown section relocation type %d encountered\n"),
8369                  arm_sec->rel_type);
8370           break;
8371         }
8372
8373       /* PR 17531 file: 027-1241568-0.004.  */
8374       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8375         {
8376           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8377                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8378           break;
8379         }
8380
8381       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8382       offset += sym->st_value;
8383       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8384
8385       /* Check that we are processing the expected reloc type.  */
8386       if (filedata->file_header.e_machine == EM_ARM)
8387         {
8388           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8389           if (relname == NULL)
8390             {
8391               warn (_("Skipping unknown ARM relocation type: %d\n"),
8392                     (int) ELF32_R_TYPE (rp->r_info));
8393               continue;
8394             }
8395
8396           if (streq (relname, "R_ARM_NONE"))
8397               continue;
8398
8399           if (! streq (relname, "R_ARM_PREL31"))
8400             {
8401               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8402               continue;
8403             }
8404         }
8405       else if (filedata->file_header.e_machine == EM_TI_C6000)
8406         {
8407           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8408           if (relname == NULL)
8409             {
8410               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8411                     (int) ELF32_R_TYPE (rp->r_info));
8412               continue;
8413             }
8414
8415           if (streq (relname, "R_C6000_NONE"))
8416             continue;
8417
8418           if (! streq (relname, "R_C6000_PREL31"))
8419             {
8420               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8421               continue;
8422             }
8423
8424           prelval >>= 1;
8425         }
8426       else
8427         {
8428           /* This function currently only supports ARM and TI unwinders.  */
8429           warn (_("Only TI and ARM unwinders are currently supported\n"));
8430           break;
8431         }
8432
8433       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8434       addr->section = sym->st_shndx;
8435       addr->offset = offset;
8436
8437       if (sym_name)
8438         * sym_name = sym->st_name;
8439       break;
8440     }
8441
8442   *wordp = word;
8443   arm_sec->next_rela = rp;
8444
8445   return TRUE;
8446 }
8447
8448 static const char *tic6x_unwind_regnames[16] =
8449 {
8450   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8451   "A14", "A13", "A12", "A11", "A10",
8452   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8453 };
8454
8455 static void
8456 decode_tic6x_unwind_regmask (unsigned int mask)
8457 {
8458   int i;
8459
8460   for (i = 12; mask; mask >>= 1, i--)
8461     {
8462       if (mask & 1)
8463         {
8464           fputs (tic6x_unwind_regnames[i], stdout);
8465           if (mask > 1)
8466             fputs (", ", stdout);
8467         }
8468     }
8469 }
8470
8471 #define ADVANCE                                                 \
8472   if (remaining == 0 && more_words)                             \
8473     {                                                           \
8474       data_offset += 4;                                         \
8475       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8476                                      data_offset, & word, & addr, NULL))        \
8477         return FALSE;                                           \
8478       remaining = 4;                                            \
8479       more_words--;                                             \
8480     }                                                           \
8481
8482 #define GET_OP(OP)                      \
8483   ADVANCE;                              \
8484   if (remaining)                        \
8485     {                                   \
8486       remaining--;                      \
8487       (OP) = word >> 24;                \
8488       word <<= 8;                       \
8489     }                                   \
8490   else                                  \
8491     {                                   \
8492       printf (_("[Truncated opcode]\n"));       \
8493       return FALSE;                     \
8494     }                                   \
8495   printf ("0x%02x ", OP)
8496
8497 static bfd_boolean
8498 decode_arm_unwind_bytecode (Filedata *                 filedata,
8499                             struct arm_unw_aux_info *  aux,
8500                             unsigned int               word,
8501                             unsigned int               remaining,
8502                             unsigned int               more_words,
8503                             bfd_vma                    data_offset,
8504                             Elf_Internal_Shdr *        data_sec,
8505                             struct arm_section *       data_arm_sec)
8506 {
8507   struct absaddr addr;
8508   bfd_boolean res = TRUE;
8509
8510   /* Decode the unwinding instructions.  */
8511   while (1)
8512     {
8513       unsigned int op, op2;
8514
8515       ADVANCE;
8516       if (remaining == 0)
8517         break;
8518       remaining--;
8519       op = word >> 24;
8520       word <<= 8;
8521
8522       printf ("  0x%02x ", op);
8523
8524       if ((op & 0xc0) == 0x00)
8525         {
8526           int offset = ((op & 0x3f) << 2) + 4;
8527
8528           printf ("     vsp = vsp + %d", offset);
8529         }
8530       else if ((op & 0xc0) == 0x40)
8531         {
8532           int offset = ((op & 0x3f) << 2) + 4;
8533
8534           printf ("     vsp = vsp - %d", offset);
8535         }
8536       else if ((op & 0xf0) == 0x80)
8537         {
8538           GET_OP (op2);
8539           if (op == 0x80 && op2 == 0)
8540             printf (_("Refuse to unwind"));
8541           else
8542             {
8543               unsigned int mask = ((op & 0x0f) << 8) | op2;
8544               bfd_boolean first = TRUE;
8545               int i;
8546
8547               printf ("pop {");
8548               for (i = 0; i < 12; i++)
8549                 if (mask & (1 << i))
8550                   {
8551                     if (first)
8552                       first = FALSE;
8553                     else
8554                       printf (", ");
8555                     printf ("r%d", 4 + i);
8556                   }
8557               printf ("}");
8558             }
8559         }
8560       else if ((op & 0xf0) == 0x90)
8561         {
8562           if (op == 0x9d || op == 0x9f)
8563             printf (_("     [Reserved]"));
8564           else
8565             printf ("     vsp = r%d", op & 0x0f);
8566         }
8567       else if ((op & 0xf0) == 0xa0)
8568         {
8569           int end = 4 + (op & 0x07);
8570           bfd_boolean first = TRUE;
8571           int i;
8572
8573           printf ("     pop {");
8574           for (i = 4; i <= end; i++)
8575             {
8576               if (first)
8577                 first = FALSE;
8578               else
8579                 printf (", ");
8580               printf ("r%d", i);
8581             }
8582           if (op & 0x08)
8583             {
8584               if (!first)
8585                 printf (", ");
8586               printf ("r14");
8587             }
8588           printf ("}");
8589         }
8590       else if (op == 0xb0)
8591         printf (_("     finish"));
8592       else if (op == 0xb1)
8593         {
8594           GET_OP (op2);
8595           if (op2 == 0 || (op2 & 0xf0) != 0)
8596             printf (_("[Spare]"));
8597           else
8598             {
8599               unsigned int mask = op2 & 0x0f;
8600               bfd_boolean first = TRUE;
8601               int i;
8602
8603               printf ("pop {");
8604               for (i = 0; i < 12; i++)
8605                 if (mask & (1 << i))
8606                   {
8607                     if (first)
8608                       first = FALSE;
8609                     else
8610                       printf (", ");
8611                     printf ("r%d", i);
8612                   }
8613               printf ("}");
8614             }
8615         }
8616       else if (op == 0xb2)
8617         {
8618           unsigned char buf[9];
8619           unsigned int i, len;
8620           unsigned long offset;
8621
8622           for (i = 0; i < sizeof (buf); i++)
8623             {
8624               GET_OP (buf[i]);
8625               if ((buf[i] & 0x80) == 0)
8626                 break;
8627             }
8628           if (i == sizeof (buf))
8629             {
8630               error (_("corrupt change to vsp"));
8631               res = FALSE;
8632             }
8633           else
8634             {
8635               offset = read_uleb128 (buf, &len, buf + i + 1);
8636               assert (len == i + 1);
8637               offset = offset * 4 + 0x204;
8638               printf ("vsp = vsp + %ld", offset);
8639             }
8640         }
8641       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8642         {
8643           unsigned int first, last;
8644
8645           GET_OP (op2);
8646           first = op2 >> 4;
8647           last = op2 & 0x0f;
8648           if (op == 0xc8)
8649             first = first + 16;
8650           printf ("pop {D%d", first);
8651           if (last)
8652             printf ("-D%d", first + last);
8653           printf ("}");
8654         }
8655       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8656         {
8657           unsigned int count = op & 0x07;
8658
8659           printf ("pop {D8");
8660           if (count)
8661             printf ("-D%d", 8 + count);
8662           printf ("}");
8663         }
8664       else if (op >= 0xc0 && op <= 0xc5)
8665         {
8666           unsigned int count = op & 0x07;
8667
8668           printf ("     pop {wR10");
8669           if (count)
8670             printf ("-wR%d", 10 + count);
8671           printf ("}");
8672         }
8673       else if (op == 0xc6)
8674         {
8675           unsigned int first, last;
8676
8677           GET_OP (op2);
8678           first = op2 >> 4;
8679           last = op2 & 0x0f;
8680           printf ("pop {wR%d", first);
8681           if (last)
8682             printf ("-wR%d", first + last);
8683           printf ("}");
8684         }
8685       else if (op == 0xc7)
8686         {
8687           GET_OP (op2);
8688           if (op2 == 0 || (op2 & 0xf0) != 0)
8689             printf (_("[Spare]"));
8690           else
8691             {
8692               unsigned int mask = op2 & 0x0f;
8693               bfd_boolean first = TRUE;
8694               int i;
8695
8696               printf ("pop {");
8697               for (i = 0; i < 4; i++)
8698                 if (mask & (1 << i))
8699                   {
8700                     if (first)
8701                       first = FALSE;
8702                     else
8703                       printf (", ");
8704                     printf ("wCGR%d", i);
8705                   }
8706               printf ("}");
8707             }
8708         }
8709       else
8710         {
8711           printf (_("     [unsupported opcode]"));
8712           res = FALSE;
8713         }
8714
8715       printf ("\n");
8716     }
8717
8718   return res;
8719 }
8720
8721 static bfd_boolean
8722 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8723                               struct arm_unw_aux_info *  aux,
8724                               unsigned int               word,
8725                               unsigned int               remaining,
8726                               unsigned int               more_words,
8727                               bfd_vma                    data_offset,
8728                               Elf_Internal_Shdr *        data_sec,
8729                               struct arm_section *       data_arm_sec)
8730 {
8731   struct absaddr addr;
8732
8733   /* Decode the unwinding instructions.  */
8734   while (1)
8735     {
8736       unsigned int op, op2;
8737
8738       ADVANCE;
8739       if (remaining == 0)
8740         break;
8741       remaining--;
8742       op = word >> 24;
8743       word <<= 8;
8744
8745       printf ("  0x%02x ", op);
8746
8747       if ((op & 0xc0) == 0x00)
8748         {
8749           int offset = ((op & 0x3f) << 3) + 8;
8750           printf ("     sp = sp + %d", offset);
8751         }
8752       else if ((op & 0xc0) == 0x80)
8753         {
8754           GET_OP (op2);
8755           if (op == 0x80 && op2 == 0)
8756             printf (_("Refuse to unwind"));
8757           else
8758             {
8759               unsigned int mask = ((op & 0x1f) << 8) | op2;
8760               if (op & 0x20)
8761                 printf ("pop compact {");
8762               else
8763                 printf ("pop {");
8764
8765               decode_tic6x_unwind_regmask (mask);
8766               printf("}");
8767             }
8768         }
8769       else if ((op & 0xf0) == 0xc0)
8770         {
8771           unsigned int reg;
8772           unsigned int nregs;
8773           unsigned int i;
8774           const char *name;
8775           struct
8776           {
8777             unsigned int offset;
8778             unsigned int reg;
8779           } regpos[16];
8780
8781           /* Scan entire instruction first so that GET_OP output is not
8782              interleaved with disassembly.  */
8783           nregs = 0;
8784           for (i = 0; nregs < (op & 0xf); i++)
8785             {
8786               GET_OP (op2);
8787               reg = op2 >> 4;
8788               if (reg != 0xf)
8789                 {
8790                   regpos[nregs].offset = i * 2;
8791                   regpos[nregs].reg = reg;
8792                   nregs++;
8793                 }
8794
8795               reg = op2 & 0xf;
8796               if (reg != 0xf)
8797                 {
8798                   regpos[nregs].offset = i * 2 + 1;
8799                   regpos[nregs].reg = reg;
8800                   nregs++;
8801                 }
8802             }
8803
8804           printf (_("pop frame {"));
8805           reg = nregs - 1;
8806           for (i = i * 2; i > 0; i--)
8807             {
8808               if (regpos[reg].offset == i - 1)
8809                 {
8810                   name = tic6x_unwind_regnames[regpos[reg].reg];
8811                   if (reg > 0)
8812                     reg--;
8813                 }
8814               else
8815                 name = _("[pad]");
8816
8817               fputs (name, stdout);
8818               if (i > 1)
8819                 printf (", ");
8820             }
8821
8822           printf ("}");
8823         }
8824       else if (op == 0xd0)
8825         printf ("     MOV FP, SP");
8826       else if (op == 0xd1)
8827         printf ("     __c6xabi_pop_rts");
8828       else if (op == 0xd2)
8829         {
8830           unsigned char buf[9];
8831           unsigned int i, len;
8832           unsigned long offset;
8833
8834           for (i = 0; i < sizeof (buf); i++)
8835             {
8836               GET_OP (buf[i]);
8837               if ((buf[i] & 0x80) == 0)
8838                 break;
8839             }
8840           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8841           if (i == sizeof (buf))
8842             {
8843               warn (_("Corrupt stack pointer adjustment detected\n"));
8844               return FALSE;
8845             }
8846
8847           offset = read_uleb128 (buf, &len, buf + i + 1);
8848           assert (len == i + 1);
8849           offset = offset * 8 + 0x408;
8850           printf (_("sp = sp + %ld"), offset);
8851         }
8852       else if ((op & 0xf0) == 0xe0)
8853         {
8854           if ((op & 0x0f) == 7)
8855             printf ("     RETURN");
8856           else
8857             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8858         }
8859       else
8860         {
8861           printf (_("     [unsupported opcode]"));
8862         }
8863       putchar ('\n');
8864     }
8865
8866   return TRUE;
8867 }
8868
8869 static bfd_vma
8870 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8871 {
8872   bfd_vma offset;
8873
8874   offset = word & 0x7fffffff;
8875   if (offset & 0x40000000)
8876     offset |= ~ (bfd_vma) 0x7fffffff;
8877
8878   if (filedata->file_header.e_machine == EM_TI_C6000)
8879     offset <<= 1;
8880
8881   return offset + where;
8882 }
8883
8884 static bfd_boolean
8885 decode_arm_unwind (Filedata *                 filedata,
8886                    struct arm_unw_aux_info *  aux,
8887                    unsigned int               word,
8888                    unsigned int               remaining,
8889                    bfd_vma                    data_offset,
8890                    Elf_Internal_Shdr *        data_sec,
8891                    struct arm_section *       data_arm_sec)
8892 {
8893   int per_index;
8894   unsigned int more_words = 0;
8895   struct absaddr addr;
8896   bfd_vma sym_name = (bfd_vma) -1;
8897   bfd_boolean res = TRUE;
8898
8899   if (remaining == 0)
8900     {
8901       /* Fetch the first word.
8902          Note - when decoding an object file the address extracted
8903          here will always be 0.  So we also pass in the sym_name
8904          parameter so that we can find the symbol associated with
8905          the personality routine.  */
8906       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8907                                      & word, & addr, & sym_name))
8908         return FALSE;
8909
8910       remaining = 4;
8911     }
8912
8913   if ((word & 0x80000000) == 0)
8914     {
8915       /* Expand prel31 for personality routine.  */
8916       bfd_vma fn;
8917       const char *procname;
8918
8919       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8920       printf (_("  Personality routine: "));
8921       if (fn == 0
8922           && addr.section == SHN_UNDEF && addr.offset == 0
8923           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8924         {
8925           procname = aux->strtab + sym_name;
8926           print_vma (fn, PREFIX_HEX);
8927           if (procname)
8928             {
8929               fputs (" <", stdout);
8930               fputs (procname, stdout);
8931               fputc ('>', stdout);
8932             }
8933         }
8934       else
8935         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8936       fputc ('\n', stdout);
8937
8938       /* The GCC personality routines use the standard compact
8939          encoding, starting with one byte giving the number of
8940          words.  */
8941       if (procname != NULL
8942           && (const_strneq (procname, "__gcc_personality_v0")
8943               || const_strneq (procname, "__gxx_personality_v0")
8944               || const_strneq (procname, "__gcj_personality_v0")
8945               || const_strneq (procname, "__gnu_objc_personality_v0")))
8946         {
8947           remaining = 0;
8948           more_words = 1;
8949           ADVANCE;
8950           if (!remaining)
8951             {
8952               printf (_("  [Truncated data]\n"));
8953               return FALSE;
8954             }
8955           more_words = word >> 24;
8956           word <<= 8;
8957           remaining--;
8958           per_index = -1;
8959         }
8960       else
8961         return TRUE;
8962     }
8963   else
8964     {
8965       /* ARM EHABI Section 6.3:
8966
8967          An exception-handling table entry for the compact model looks like:
8968
8969            31 30-28 27-24 23-0
8970            -- ----- ----- ----
8971             1   0   index Data for personalityRoutine[index]    */
8972
8973       if (filedata->file_header.e_machine == EM_ARM
8974           && (word & 0x70000000))
8975         {
8976           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8977           res = FALSE;
8978         }
8979
8980       per_index = (word >> 24) & 0x7f;
8981       printf (_("  Compact model index: %d\n"), per_index);
8982       if (per_index == 0)
8983         {
8984           more_words = 0;
8985           word <<= 8;
8986           remaining--;
8987         }
8988       else if (per_index < 3)
8989         {
8990           more_words = (word >> 16) & 0xff;
8991           word <<= 16;
8992           remaining -= 2;
8993         }
8994     }
8995
8996   switch (filedata->file_header.e_machine)
8997     {
8998     case EM_ARM:
8999       if (per_index < 3)
9000         {
9001           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9002                                             data_offset, data_sec, data_arm_sec))
9003             res = FALSE;
9004         }
9005       else
9006         {
9007           warn (_("Unknown ARM compact model index encountered\n"));
9008           printf (_("  [reserved]\n"));
9009           res = FALSE;
9010         }
9011       break;
9012
9013     case EM_TI_C6000:
9014       if (per_index < 3)
9015         {
9016           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9017                                               data_offset, data_sec, data_arm_sec))
9018             res = FALSE;
9019         }
9020       else if (per_index < 5)
9021         {
9022           if (((word >> 17) & 0x7f) == 0x7f)
9023             printf (_("  Restore stack from frame pointer\n"));
9024           else
9025             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
9026           printf (_("  Registers restored: "));
9027           if (per_index == 4)
9028             printf (" (compact) ");
9029           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9030           putchar ('\n');
9031           printf (_("  Return register: %s\n"),
9032                   tic6x_unwind_regnames[word & 0xf]);
9033         }
9034       else
9035         printf (_("  [reserved (%d)]\n"), per_index);
9036       break;
9037
9038     default:
9039       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9040              filedata->file_header.e_machine);
9041       res = FALSE;
9042     }
9043
9044   /* Decode the descriptors.  Not implemented.  */
9045
9046   return res;
9047 }
9048
9049 static bfd_boolean
9050 dump_arm_unwind (Filedata *                 filedata,
9051                  struct arm_unw_aux_info *  aux,
9052                  Elf_Internal_Shdr *        exidx_sec)
9053 {
9054   struct arm_section exidx_arm_sec, extab_arm_sec;
9055   unsigned int i, exidx_len;
9056   unsigned long j, nfuns;
9057   bfd_boolean res = TRUE;
9058
9059   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9060   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9061   exidx_len = exidx_sec->sh_size / 8;
9062
9063   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9064   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9065     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9066       aux->funtab[nfuns++] = aux->symtab[j];
9067   aux->nfuns = nfuns;
9068   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9069
9070   for (i = 0; i < exidx_len; i++)
9071     {
9072       unsigned int exidx_fn, exidx_entry;
9073       struct absaddr fn_addr, entry_addr;
9074       bfd_vma fn;
9075
9076       fputc ('\n', stdout);
9077
9078       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9079                                      8 * i, & exidx_fn, & fn_addr, NULL)
9080           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9081                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9082         {
9083           free (aux->funtab);
9084           arm_free_section (& exidx_arm_sec);
9085           arm_free_section (& extab_arm_sec);
9086           return FALSE;
9087         }
9088
9089       /* ARM EHABI, Section 5:
9090          An index table entry consists of 2 words.
9091          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9092       if (exidx_fn & 0x80000000)
9093         {
9094           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9095           res = FALSE;
9096         }
9097
9098       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9099
9100       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9101       fputs (": ", stdout);
9102
9103       if (exidx_entry == 1)
9104         {
9105           print_vma (exidx_entry, PREFIX_HEX);
9106           fputs (" [cantunwind]\n", stdout);
9107         }
9108       else if (exidx_entry & 0x80000000)
9109         {
9110           print_vma (exidx_entry, PREFIX_HEX);
9111           fputc ('\n', stdout);
9112           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9113         }
9114       else
9115         {
9116           bfd_vma table, table_offset = 0;
9117           Elf_Internal_Shdr *table_sec;
9118
9119           fputs ("@", stdout);
9120           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9121           print_vma (table, PREFIX_HEX);
9122           printf ("\n");
9123
9124           /* Locate the matching .ARM.extab.  */
9125           if (entry_addr.section != SHN_UNDEF
9126               && entry_addr.section < filedata->file_header.e_shnum)
9127             {
9128               table_sec = filedata->section_headers + entry_addr.section;
9129               table_offset = entry_addr.offset;
9130               /* PR 18879 */
9131               if (table_offset > table_sec->sh_size
9132                   || ((bfd_signed_vma) table_offset) < 0)
9133                 {
9134                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9135                         (unsigned long) table_offset,
9136                         printable_section_name (filedata, table_sec));
9137                   res = FALSE;
9138                   continue;
9139                 }
9140             }
9141           else
9142             {
9143               table_sec = find_section_by_address (filedata, table);
9144               if (table_sec != NULL)
9145                 table_offset = table - table_sec->sh_addr;
9146             }
9147
9148           if (table_sec == NULL)
9149             {
9150               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9151                     (unsigned long) table);
9152               res = FALSE;
9153               continue;
9154             }
9155
9156           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9157                                    &extab_arm_sec))
9158             res = FALSE;
9159         }
9160     }
9161
9162   printf ("\n");
9163
9164   free (aux->funtab);
9165   arm_free_section (&exidx_arm_sec);
9166   arm_free_section (&extab_arm_sec);
9167
9168   return res;
9169 }
9170
9171 /* Used for both ARM and C6X unwinding tables.  */
9172
9173 static bfd_boolean
9174 arm_process_unwind (Filedata * filedata)
9175 {
9176   struct arm_unw_aux_info aux;
9177   Elf_Internal_Shdr *unwsec = NULL;
9178   Elf_Internal_Shdr *strsec;
9179   Elf_Internal_Shdr *sec;
9180   unsigned long i;
9181   unsigned int sec_type;
9182   bfd_boolean res = TRUE;
9183
9184   switch (filedata->file_header.e_machine)
9185     {
9186     case EM_ARM:
9187       sec_type = SHT_ARM_EXIDX;
9188       break;
9189
9190     case EM_TI_C6000:
9191       sec_type = SHT_C6000_UNWIND;
9192       break;
9193
9194     default:
9195       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9196              filedata->file_header.e_machine);
9197       return FALSE;
9198     }
9199
9200   if (filedata->string_table == NULL)
9201     return FALSE;
9202
9203   memset (& aux, 0, sizeof (aux));
9204   aux.filedata = filedata;
9205
9206   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9207     {
9208       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9209         {
9210           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9211
9212           strsec = filedata->section_headers + sec->sh_link;
9213
9214           /* PR binutils/17531 file: 011-12666-0.004.  */
9215           if (aux.strtab != NULL)
9216             {
9217               error (_("Multiple string tables found in file.\n"));
9218               free (aux.strtab);
9219               res = FALSE;
9220             }
9221           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9222                                  1, strsec->sh_size, _("string table"));
9223           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9224         }
9225       else if (sec->sh_type == sec_type)
9226         unwsec = sec;
9227     }
9228
9229   if (unwsec == NULL)
9230     printf (_("\nThere are no unwind sections in this file.\n"));
9231   else
9232     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9233       {
9234         if (sec->sh_type == sec_type)
9235           {
9236             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9237             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9238                               "contains %lu entry:\n",
9239                               "\nUnwind section '%s' at offset 0x%lx "
9240                               "contains %lu entries:\n",
9241                               num_unwind),
9242                     printable_section_name (filedata, sec),
9243                     (unsigned long) sec->sh_offset,
9244                     num_unwind);
9245
9246             if (! dump_arm_unwind (filedata, &aux, sec))
9247               res = FALSE;
9248           }
9249       }
9250
9251   if (aux.symtab)
9252     free (aux.symtab);
9253   if (aux.strtab)
9254     free ((char *) aux.strtab);
9255
9256   return res;
9257 }
9258
9259 static bfd_boolean
9260 process_unwind (Filedata * filedata)
9261 {
9262   struct unwind_handler
9263   {
9264     unsigned int machtype;
9265     bfd_boolean (* handler)(Filedata *);
9266   } handlers[] =
9267   {
9268     { EM_ARM, arm_process_unwind },
9269     { EM_IA_64, ia64_process_unwind },
9270     { EM_PARISC, hppa_process_unwind },
9271     { EM_TI_C6000, arm_process_unwind },
9272     { 0, NULL }
9273   };
9274   int i;
9275
9276   if (!do_unwind)
9277     return TRUE;
9278
9279   for (i = 0; handlers[i].handler != NULL; i++)
9280     if (filedata->file_header.e_machine == handlers[i].machtype)
9281       return handlers[i].handler (filedata);
9282
9283   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9284           get_machine_name (filedata->file_header.e_machine));
9285   return TRUE;
9286 }
9287
9288 static void
9289 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9290 {
9291   switch (entry->d_tag)
9292     {
9293     case DT_MIPS_FLAGS:
9294       if (entry->d_un.d_val == 0)
9295         printf (_("NONE"));
9296       else
9297         {
9298           static const char * opts[] =
9299           {
9300             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9301             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9302             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9303             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9304             "RLD_ORDER_SAFE"
9305           };
9306           unsigned int cnt;
9307           bfd_boolean first = TRUE;
9308
9309           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9310             if (entry->d_un.d_val & (1 << cnt))
9311               {
9312                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9313                 first = FALSE;
9314               }
9315         }
9316       break;
9317
9318     case DT_MIPS_IVERSION:
9319       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9320         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9321       else
9322         {
9323           char buf[40];
9324           sprintf_vma (buf, entry->d_un.d_ptr);
9325           /* Note: coded this way so that there is a single string for translation.  */
9326           printf (_("<corrupt: %s>"), buf);
9327         }
9328       break;
9329
9330     case DT_MIPS_TIME_STAMP:
9331       {
9332         char timebuf[128];
9333         struct tm * tmp;
9334         time_t atime = entry->d_un.d_val;
9335
9336         tmp = gmtime (&atime);
9337         /* PR 17531: file: 6accc532.  */
9338         if (tmp == NULL)
9339           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9340         else
9341           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9342                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9343                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9344         printf (_("Time Stamp: %s"), timebuf);
9345       }
9346       break;
9347
9348     case DT_MIPS_RLD_VERSION:
9349     case DT_MIPS_LOCAL_GOTNO:
9350     case DT_MIPS_CONFLICTNO:
9351     case DT_MIPS_LIBLISTNO:
9352     case DT_MIPS_SYMTABNO:
9353     case DT_MIPS_UNREFEXTNO:
9354     case DT_MIPS_HIPAGENO:
9355     case DT_MIPS_DELTA_CLASS_NO:
9356     case DT_MIPS_DELTA_INSTANCE_NO:
9357     case DT_MIPS_DELTA_RELOC_NO:
9358     case DT_MIPS_DELTA_SYM_NO:
9359     case DT_MIPS_DELTA_CLASSSYM_NO:
9360     case DT_MIPS_COMPACT_SIZE:
9361       print_vma (entry->d_un.d_val, DEC);
9362       break;
9363
9364     default:
9365       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9366     }
9367     putchar ('\n');
9368 }
9369
9370 static void
9371 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9372 {
9373   switch (entry->d_tag)
9374     {
9375     case DT_HP_DLD_FLAGS:
9376       {
9377         static struct
9378         {
9379           long int bit;
9380           const char * str;
9381         }
9382         flags[] =
9383         {
9384           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9385           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9386           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9387           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9388           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9389           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9390           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9391           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9392           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9393           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9394           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9395           { DT_HP_GST, "HP_GST" },
9396           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9397           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9398           { DT_HP_NODELETE, "HP_NODELETE" },
9399           { DT_HP_GROUP, "HP_GROUP" },
9400           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9401         };
9402         bfd_boolean first = TRUE;
9403         size_t cnt;
9404         bfd_vma val = entry->d_un.d_val;
9405
9406         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9407           if (val & flags[cnt].bit)
9408             {
9409               if (! first)
9410                 putchar (' ');
9411               fputs (flags[cnt].str, stdout);
9412               first = FALSE;
9413               val ^= flags[cnt].bit;
9414             }
9415
9416         if (val != 0 || first)
9417           {
9418             if (! first)
9419               putchar (' ');
9420             print_vma (val, HEX);
9421           }
9422       }
9423       break;
9424
9425     default:
9426       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9427       break;
9428     }
9429   putchar ('\n');
9430 }
9431
9432 #ifdef BFD64
9433
9434 /* VMS vs Unix time offset and factor.  */
9435
9436 #define VMS_EPOCH_OFFSET 35067168000000000LL
9437 #define VMS_GRANULARITY_FACTOR 10000000
9438
9439 /* Display a VMS time in a human readable format.  */
9440
9441 static void
9442 print_vms_time (bfd_int64_t vmstime)
9443 {
9444   struct tm *tm;
9445   time_t unxtime;
9446
9447   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9448   tm = gmtime (&unxtime);
9449   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9450           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9451           tm->tm_hour, tm->tm_min, tm->tm_sec);
9452 }
9453 #endif /* BFD64 */
9454
9455 static void
9456 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9457 {
9458   switch (entry->d_tag)
9459     {
9460     case DT_IA_64_PLT_RESERVE:
9461       /* First 3 slots reserved.  */
9462       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9463       printf (" -- ");
9464       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9465       break;
9466
9467     case DT_IA_64_VMS_LINKTIME:
9468 #ifdef BFD64
9469       print_vms_time (entry->d_un.d_val);
9470 #endif
9471       break;
9472
9473     case DT_IA_64_VMS_LNKFLAGS:
9474       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9475       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9476         printf (" CALL_DEBUG");
9477       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9478         printf (" NOP0BUFS");
9479       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9480         printf (" P0IMAGE");
9481       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9482         printf (" MKTHREADS");
9483       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9484         printf (" UPCALLS");
9485       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9486         printf (" IMGSTA");
9487       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9488         printf (" INITIALIZE");
9489       if (entry->d_un.d_val & VMS_LF_MAIN)
9490         printf (" MAIN");
9491       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9492         printf (" EXE_INIT");
9493       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9494         printf (" TBK_IN_IMG");
9495       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9496         printf (" DBG_IN_IMG");
9497       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9498         printf (" TBK_IN_DSF");
9499       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9500         printf (" DBG_IN_DSF");
9501       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9502         printf (" SIGNATURES");
9503       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9504         printf (" REL_SEG_OFF");
9505       break;
9506
9507     default:
9508       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9509       break;
9510     }
9511   putchar ('\n');
9512 }
9513
9514 static bfd_boolean
9515 get_32bit_dynamic_section (Filedata * filedata)
9516 {
9517   Elf32_External_Dyn * edyn;
9518   Elf32_External_Dyn * ext;
9519   Elf_Internal_Dyn * entry;
9520
9521   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9522                                           dynamic_size, _("dynamic section"));
9523   if (!edyn)
9524     return FALSE;
9525
9526   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9527      might not have the luxury of section headers.  Look for the DT_NULL
9528      terminator to determine the number of entries.  */
9529   for (ext = edyn, dynamic_nent = 0;
9530        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9531        ext++)
9532     {
9533       dynamic_nent++;
9534       if (BYTE_GET (ext->d_tag) == DT_NULL)
9535         break;
9536     }
9537
9538   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9539                                                   sizeof (* entry));
9540   if (dynamic_section == NULL)
9541     {
9542       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9543              (unsigned long) dynamic_nent);
9544       free (edyn);
9545       return FALSE;
9546     }
9547
9548   for (ext = edyn, entry = dynamic_section;
9549        entry < dynamic_section + dynamic_nent;
9550        ext++, entry++)
9551     {
9552       entry->d_tag      = BYTE_GET (ext->d_tag);
9553       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9554     }
9555
9556   free (edyn);
9557
9558   return TRUE;
9559 }
9560
9561 static bfd_boolean
9562 get_64bit_dynamic_section (Filedata * filedata)
9563 {
9564   Elf64_External_Dyn * edyn;
9565   Elf64_External_Dyn * ext;
9566   Elf_Internal_Dyn * entry;
9567
9568   /* Read in the data.  */
9569   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9570                                           dynamic_size, _("dynamic section"));
9571   if (!edyn)
9572     return FALSE;
9573
9574   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9575      might not have the luxury of section headers.  Look for the DT_NULL
9576      terminator to determine the number of entries.  */
9577   for (ext = edyn, dynamic_nent = 0;
9578        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9579        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9580        ext++)
9581     {
9582       dynamic_nent++;
9583       if (BYTE_GET (ext->d_tag) == DT_NULL)
9584         break;
9585     }
9586
9587   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9588                                                   sizeof (* entry));
9589   if (dynamic_section == NULL)
9590     {
9591       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9592              (unsigned long) dynamic_nent);
9593       free (edyn);
9594       return FALSE;
9595     }
9596
9597   /* Convert from external to internal formats.  */
9598   for (ext = edyn, entry = dynamic_section;
9599        entry < dynamic_section + dynamic_nent;
9600        ext++, entry++)
9601     {
9602       entry->d_tag      = BYTE_GET (ext->d_tag);
9603       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9604     }
9605
9606   free (edyn);
9607
9608   return TRUE;
9609 }
9610
9611 static void
9612 print_dynamic_flags (bfd_vma flags)
9613 {
9614   bfd_boolean first = TRUE;
9615
9616   while (flags)
9617     {
9618       bfd_vma flag;
9619
9620       flag = flags & - flags;
9621       flags &= ~ flag;
9622
9623       if (first)
9624         first = FALSE;
9625       else
9626         putc (' ', stdout);
9627
9628       switch (flag)
9629         {
9630         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9631         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9632         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9633         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9634         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9635         default:                fputs (_("unknown"), stdout); break;
9636         }
9637     }
9638   puts ("");
9639 }
9640
9641 /* Parse and display the contents of the dynamic section.  */
9642
9643 static bfd_boolean
9644 process_dynamic_section (Filedata * filedata)
9645 {
9646   Elf_Internal_Dyn * entry;
9647
9648   if (dynamic_size == 0)
9649     {
9650       if (do_dynamic)
9651         printf (_("\nThere is no dynamic section in this file.\n"));
9652
9653       return TRUE;
9654     }
9655
9656   if (is_32bit_elf)
9657     {
9658       if (! get_32bit_dynamic_section (filedata))
9659         return FALSE;
9660     }
9661   else
9662     {
9663       if (! get_64bit_dynamic_section (filedata))
9664         return FALSE;
9665     }
9666
9667   /* Find the appropriate symbol table.  */
9668   if (dynamic_symbols == NULL)
9669     {
9670       for (entry = dynamic_section;
9671            entry < dynamic_section + dynamic_nent;
9672            ++entry)
9673         {
9674           Elf_Internal_Shdr section;
9675
9676           if (entry->d_tag != DT_SYMTAB)
9677             continue;
9678
9679           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9680
9681           /* Since we do not know how big the symbol table is,
9682              we default to reading in the entire file (!) and
9683              processing that.  This is overkill, I know, but it
9684              should work.  */
9685           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9686           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9687             {
9688               /* See PR 21379 for a reproducer.  */
9689               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9690               return FALSE;
9691             }
9692
9693           if (archive_file_offset != 0)
9694             section.sh_size = archive_file_size - section.sh_offset;
9695           else
9696             section.sh_size = filedata->file_size - section.sh_offset;
9697
9698           if (is_32bit_elf)
9699             section.sh_entsize = sizeof (Elf32_External_Sym);
9700           else
9701             section.sh_entsize = sizeof (Elf64_External_Sym);
9702           section.sh_name = filedata->string_table_length;
9703
9704           if (dynamic_symbols != NULL)
9705             {
9706               error (_("Multiple dynamic symbol table sections found\n"));
9707               free (dynamic_symbols);
9708             }
9709           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9710           if (num_dynamic_syms < 1)
9711             {
9712               error (_("Unable to determine the number of symbols to load\n"));
9713               continue;
9714             }
9715         }
9716     }
9717
9718   /* Similarly find a string table.  */
9719   if (dynamic_strings == NULL)
9720     {
9721       for (entry = dynamic_section;
9722            entry < dynamic_section + dynamic_nent;
9723            ++entry)
9724         {
9725           unsigned long offset;
9726           long str_tab_len;
9727
9728           if (entry->d_tag != DT_STRTAB)
9729             continue;
9730
9731           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9732
9733           /* Since we do not know how big the string table is,
9734              we default to reading in the entire file (!) and
9735              processing that.  This is overkill, I know, but it
9736              should work.  */
9737
9738           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9739
9740           if (archive_file_offset != 0)
9741             str_tab_len = archive_file_size - offset;
9742           else
9743             str_tab_len = filedata->file_size - offset;
9744
9745           if (str_tab_len < 1)
9746             {
9747               error
9748                 (_("Unable to determine the length of the dynamic string table\n"));
9749               continue;
9750             }
9751
9752           if (dynamic_strings != NULL)
9753             {
9754               error (_("Multiple dynamic string tables found\n"));
9755               free (dynamic_strings);
9756             }
9757
9758           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9759                                                str_tab_len,
9760                                                _("dynamic string table"));
9761           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9762         }
9763     }
9764
9765   /* And find the syminfo section if available.  */
9766   if (dynamic_syminfo == NULL)
9767     {
9768       unsigned long syminsz = 0;
9769
9770       for (entry = dynamic_section;
9771            entry < dynamic_section + dynamic_nent;
9772            ++entry)
9773         {
9774           if (entry->d_tag == DT_SYMINENT)
9775             {
9776               /* Note: these braces are necessary to avoid a syntax
9777                  error from the SunOS4 C compiler.  */
9778               /* PR binutils/17531: A corrupt file can trigger this test.
9779                  So do not use an assert, instead generate an error message.  */
9780               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9781                 error (_("Bad value (%d) for SYMINENT entry\n"),
9782                        (int) entry->d_un.d_val);
9783             }
9784           else if (entry->d_tag == DT_SYMINSZ)
9785             syminsz = entry->d_un.d_val;
9786           else if (entry->d_tag == DT_SYMINFO)
9787             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9788                                                       syminsz);
9789         }
9790
9791       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9792         {
9793           Elf_External_Syminfo * extsyminfo;
9794           Elf_External_Syminfo * extsym;
9795           Elf_Internal_Syminfo * syminfo;
9796
9797           /* There is a syminfo section.  Read the data.  */
9798           extsyminfo = (Elf_External_Syminfo *)
9799               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9800                         _("symbol information"));
9801           if (!extsyminfo)
9802             return FALSE;
9803
9804           if (dynamic_syminfo != NULL)
9805             {
9806               error (_("Multiple dynamic symbol information sections found\n"));
9807               free (dynamic_syminfo);
9808             }
9809           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9810           if (dynamic_syminfo == NULL)
9811             {
9812               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9813                      (unsigned long) syminsz);
9814               return FALSE;
9815             }
9816
9817           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9818           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9819                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9820                ++syminfo, ++extsym)
9821             {
9822               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9823               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9824             }
9825
9826           free (extsyminfo);
9827         }
9828     }
9829
9830   if (do_dynamic && dynamic_addr)
9831     printf (ngettext ("\nDynamic section at offset 0x%lx "
9832                       "contains %lu entry:\n",
9833                       "\nDynamic section at offset 0x%lx "
9834                       "contains %lu entries:\n",
9835                       dynamic_nent),
9836             dynamic_addr, (unsigned long) dynamic_nent);
9837   if (do_dynamic)
9838     printf (_("  Tag        Type                         Name/Value\n"));
9839
9840   for (entry = dynamic_section;
9841        entry < dynamic_section + dynamic_nent;
9842        entry++)
9843     {
9844       if (do_dynamic)
9845         {
9846           const char * dtype;
9847
9848           putchar (' ');
9849           print_vma (entry->d_tag, FULL_HEX);
9850           dtype = get_dynamic_type (filedata, entry->d_tag);
9851           printf (" (%s)%*s", dtype,
9852                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9853         }
9854
9855       switch (entry->d_tag)
9856         {
9857         case DT_FLAGS:
9858           if (do_dynamic)
9859             print_dynamic_flags (entry->d_un.d_val);
9860           break;
9861
9862         case DT_AUXILIARY:
9863         case DT_FILTER:
9864         case DT_CONFIG:
9865         case DT_DEPAUDIT:
9866         case DT_AUDIT:
9867           if (do_dynamic)
9868             {
9869               switch (entry->d_tag)
9870                 {
9871                 case DT_AUXILIARY:
9872                   printf (_("Auxiliary library"));
9873                   break;
9874
9875                 case DT_FILTER:
9876                   printf (_("Filter library"));
9877                   break;
9878
9879                 case DT_CONFIG:
9880                   printf (_("Configuration file"));
9881                   break;
9882
9883                 case DT_DEPAUDIT:
9884                   printf (_("Dependency audit library"));
9885                   break;
9886
9887                 case DT_AUDIT:
9888                   printf (_("Audit library"));
9889                   break;
9890                 }
9891
9892               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9893                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9894               else
9895                 {
9896                   printf (": ");
9897                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9898                   putchar ('\n');
9899                 }
9900             }
9901           break;
9902
9903         case DT_FEATURE:
9904           if (do_dynamic)
9905             {
9906               printf (_("Flags:"));
9907
9908               if (entry->d_un.d_val == 0)
9909                 printf (_(" None\n"));
9910               else
9911                 {
9912                   unsigned long int val = entry->d_un.d_val;
9913
9914                   if (val & DTF_1_PARINIT)
9915                     {
9916                       printf (" PARINIT");
9917                       val ^= DTF_1_PARINIT;
9918                     }
9919                   if (val & DTF_1_CONFEXP)
9920                     {
9921                       printf (" CONFEXP");
9922                       val ^= DTF_1_CONFEXP;
9923                     }
9924                   if (val != 0)
9925                     printf (" %lx", val);
9926                   puts ("");
9927                 }
9928             }
9929           break;
9930
9931         case DT_POSFLAG_1:
9932           if (do_dynamic)
9933             {
9934               printf (_("Flags:"));
9935
9936               if (entry->d_un.d_val == 0)
9937                 printf (_(" None\n"));
9938               else
9939                 {
9940                   unsigned long int val = entry->d_un.d_val;
9941
9942                   if (val & DF_P1_LAZYLOAD)
9943                     {
9944                       printf (" LAZYLOAD");
9945                       val ^= DF_P1_LAZYLOAD;
9946                     }
9947                   if (val & DF_P1_GROUPPERM)
9948                     {
9949                       printf (" GROUPPERM");
9950                       val ^= DF_P1_GROUPPERM;
9951                     }
9952                   if (val != 0)
9953                     printf (" %lx", val);
9954                   puts ("");
9955                 }
9956             }
9957           break;
9958
9959         case DT_FLAGS_1:
9960           if (do_dynamic)
9961             {
9962               printf (_("Flags:"));
9963               if (entry->d_un.d_val == 0)
9964                 printf (_(" None\n"));
9965               else
9966                 {
9967                   unsigned long int val = entry->d_un.d_val;
9968
9969                   if (val & DF_1_NOW)
9970                     {
9971                       printf (" NOW");
9972                       val ^= DF_1_NOW;
9973                     }
9974                   if (val & DF_1_GLOBAL)
9975                     {
9976                       printf (" GLOBAL");
9977                       val ^= DF_1_GLOBAL;
9978                     }
9979                   if (val & DF_1_GROUP)
9980                     {
9981                       printf (" GROUP");
9982                       val ^= DF_1_GROUP;
9983                     }
9984                   if (val & DF_1_NODELETE)
9985                     {
9986                       printf (" NODELETE");
9987                       val ^= DF_1_NODELETE;
9988                     }
9989                   if (val & DF_1_LOADFLTR)
9990                     {
9991                       printf (" LOADFLTR");
9992                       val ^= DF_1_LOADFLTR;
9993                     }
9994                   if (val & DF_1_INITFIRST)
9995                     {
9996                       printf (" INITFIRST");
9997                       val ^= DF_1_INITFIRST;
9998                     }
9999                   if (val & DF_1_NOOPEN)
10000                     {
10001                       printf (" NOOPEN");
10002                       val ^= DF_1_NOOPEN;
10003                     }
10004                   if (val & DF_1_ORIGIN)
10005                     {
10006                       printf (" ORIGIN");
10007                       val ^= DF_1_ORIGIN;
10008                     }
10009                   if (val & DF_1_DIRECT)
10010                     {
10011                       printf (" DIRECT");
10012                       val ^= DF_1_DIRECT;
10013                     }
10014                   if (val & DF_1_TRANS)
10015                     {
10016                       printf (" TRANS");
10017                       val ^= DF_1_TRANS;
10018                     }
10019                   if (val & DF_1_INTERPOSE)
10020                     {
10021                       printf (" INTERPOSE");
10022                       val ^= DF_1_INTERPOSE;
10023                     }
10024                   if (val & DF_1_NODEFLIB)
10025                     {
10026                       printf (" NODEFLIB");
10027                       val ^= DF_1_NODEFLIB;
10028                     }
10029                   if (val & DF_1_NODUMP)
10030                     {
10031                       printf (" NODUMP");
10032                       val ^= DF_1_NODUMP;
10033                     }
10034                   if (val & DF_1_CONFALT)
10035                     {
10036                       printf (" CONFALT");
10037                       val ^= DF_1_CONFALT;
10038                     }
10039                   if (val & DF_1_ENDFILTEE)
10040                     {
10041                       printf (" ENDFILTEE");
10042                       val ^= DF_1_ENDFILTEE;
10043                     }
10044                   if (val & DF_1_DISPRELDNE)
10045                     {
10046                       printf (" DISPRELDNE");
10047                       val ^= DF_1_DISPRELDNE;
10048                     }
10049                   if (val & DF_1_DISPRELPND)
10050                     {
10051                       printf (" DISPRELPND");
10052                       val ^= DF_1_DISPRELPND;
10053                     }
10054                   if (val & DF_1_NODIRECT)
10055                     {
10056                       printf (" NODIRECT");
10057                       val ^= DF_1_NODIRECT;
10058                     }
10059                   if (val & DF_1_IGNMULDEF)
10060                     {
10061                       printf (" IGNMULDEF");
10062                       val ^= DF_1_IGNMULDEF;
10063                     }
10064                   if (val & DF_1_NOKSYMS)
10065                     {
10066                       printf (" NOKSYMS");
10067                       val ^= DF_1_NOKSYMS;
10068                     }
10069                   if (val & DF_1_NOHDR)
10070                     {
10071                       printf (" NOHDR");
10072                       val ^= DF_1_NOHDR;
10073                     }
10074                   if (val & DF_1_EDITED)
10075                     {
10076                       printf (" EDITED");
10077                       val ^= DF_1_EDITED;
10078                     }
10079                   if (val & DF_1_NORELOC)
10080                     {
10081                       printf (" NORELOC");
10082                       val ^= DF_1_NORELOC;
10083                     }
10084                   if (val & DF_1_SYMINTPOSE)
10085                     {
10086                       printf (" SYMINTPOSE");
10087                       val ^= DF_1_SYMINTPOSE;
10088                     }
10089                   if (val & DF_1_GLOBAUDIT)
10090                     {
10091                       printf (" GLOBAUDIT");
10092                       val ^= DF_1_GLOBAUDIT;
10093                     }
10094                   if (val & DF_1_SINGLETON)
10095                     {
10096                       printf (" SINGLETON");
10097                       val ^= DF_1_SINGLETON;
10098                     }
10099                   if (val & DF_1_STUB)
10100                     {
10101                       printf (" STUB");
10102                       val ^= DF_1_STUB;
10103                     }
10104                   if (val & DF_1_PIE)
10105                     {
10106                       printf (" PIE");
10107                       val ^= DF_1_PIE;
10108                     }
10109                   if (val & DF_1_KMOD)
10110                     {
10111                       printf (" KMOD");
10112                       val ^= DF_1_KMOD;
10113                     }
10114                   if (val & DF_1_WEAKFILTER)
10115                     {
10116                       printf (" WEAKFILTER");
10117                       val ^= DF_1_WEAKFILTER;
10118                     }
10119                   if (val & DF_1_NOCOMMON)
10120                     {
10121                       printf (" NOCOMMON");
10122                       val ^= DF_1_NOCOMMON;
10123                     }
10124                   if (val != 0)
10125                     printf (" %lx", val);
10126                   puts ("");
10127                 }
10128             }
10129           break;
10130
10131         case DT_PLTREL:
10132           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10133           if (do_dynamic)
10134             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10135           break;
10136
10137         case DT_NULL    :
10138         case DT_NEEDED  :
10139         case DT_PLTGOT  :
10140         case DT_HASH    :
10141         case DT_STRTAB  :
10142         case DT_SYMTAB  :
10143         case DT_RELA    :
10144         case DT_INIT    :
10145         case DT_FINI    :
10146         case DT_SONAME  :
10147         case DT_RPATH   :
10148         case DT_SYMBOLIC:
10149         case DT_REL     :
10150         case DT_DEBUG   :
10151         case DT_TEXTREL :
10152         case DT_JMPREL  :
10153         case DT_RUNPATH :
10154           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10155
10156           if (do_dynamic)
10157             {
10158               char * name;
10159
10160               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10161                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10162               else
10163                 name = NULL;
10164
10165               if (name)
10166                 {
10167                   switch (entry->d_tag)
10168                     {
10169                     case DT_NEEDED:
10170                       printf (_("Shared library: [%s]"), name);
10171
10172                       if (streq (name, program_interpreter))
10173                         printf (_(" program interpreter"));
10174                       break;
10175
10176                     case DT_SONAME:
10177                       printf (_("Library soname: [%s]"), name);
10178                       break;
10179
10180                     case DT_RPATH:
10181                       printf (_("Library rpath: [%s]"), name);
10182                       break;
10183
10184                     case DT_RUNPATH:
10185                       printf (_("Library runpath: [%s]"), name);
10186                       break;
10187
10188                     default:
10189                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10190                       break;
10191                     }
10192                 }
10193               else
10194                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10195
10196               putchar ('\n');
10197             }
10198           break;
10199
10200         case DT_PLTRELSZ:
10201         case DT_RELASZ  :
10202         case DT_STRSZ   :
10203         case DT_RELSZ   :
10204         case DT_RELAENT :
10205         case DT_SYMENT  :
10206         case DT_RELENT  :
10207           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10208           /* Fall through.  */
10209         case DT_PLTPADSZ:
10210         case DT_MOVEENT :
10211         case DT_MOVESZ  :
10212         case DT_INIT_ARRAYSZ:
10213         case DT_FINI_ARRAYSZ:
10214         case DT_GNU_CONFLICTSZ:
10215         case DT_GNU_LIBLISTSZ:
10216           if (do_dynamic)
10217             {
10218               print_vma (entry->d_un.d_val, UNSIGNED);
10219               printf (_(" (bytes)\n"));
10220             }
10221           break;
10222
10223         case DT_VERDEFNUM:
10224         case DT_VERNEEDNUM:
10225         case DT_RELACOUNT:
10226         case DT_RELCOUNT:
10227           if (do_dynamic)
10228             {
10229               print_vma (entry->d_un.d_val, UNSIGNED);
10230               putchar ('\n');
10231             }
10232           break;
10233
10234         case DT_SYMINSZ:
10235         case DT_SYMINENT:
10236         case DT_SYMINFO:
10237         case DT_USED:
10238         case DT_INIT_ARRAY:
10239         case DT_FINI_ARRAY:
10240           if (do_dynamic)
10241             {
10242               if (entry->d_tag == DT_USED
10243                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10244                 {
10245                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10246
10247                   if (*name)
10248                     {
10249                       printf (_("Not needed object: [%s]\n"), name);
10250                       break;
10251                     }
10252                 }
10253
10254               print_vma (entry->d_un.d_val, PREFIX_HEX);
10255               putchar ('\n');
10256             }
10257           break;
10258
10259         case DT_BIND_NOW:
10260           /* The value of this entry is ignored.  */
10261           if (do_dynamic)
10262             putchar ('\n');
10263           break;
10264
10265         case DT_GNU_PRELINKED:
10266           if (do_dynamic)
10267             {
10268               struct tm * tmp;
10269               time_t atime = entry->d_un.d_val;
10270
10271               tmp = gmtime (&atime);
10272               /* PR 17533 file: 041-1244816-0.004.  */
10273               if (tmp == NULL)
10274                 printf (_("<corrupt time val: %lx"),
10275                         (unsigned long) atime);
10276               else
10277                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10278                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10279                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10280
10281             }
10282           break;
10283
10284         case DT_GNU_HASH:
10285           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10286           if (do_dynamic)
10287             {
10288               print_vma (entry->d_un.d_val, PREFIX_HEX);
10289               putchar ('\n');
10290             }
10291           break;
10292
10293         default:
10294           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10295             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10296               entry->d_un.d_val;
10297
10298           if (do_dynamic)
10299             {
10300               switch (filedata->file_header.e_machine)
10301                 {
10302                 case EM_MIPS:
10303                 case EM_MIPS_RS3_LE:
10304                   dynamic_section_mips_val (entry);
10305                   break;
10306                 case EM_PARISC:
10307                   dynamic_section_parisc_val (entry);
10308                   break;
10309                 case EM_IA_64:
10310                   dynamic_section_ia64_val (entry);
10311                   break;
10312                 default:
10313                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10314                   putchar ('\n');
10315                 }
10316             }
10317           break;
10318         }
10319     }
10320
10321   return TRUE;
10322 }
10323
10324 static char *
10325 get_ver_flags (unsigned int flags)
10326 {
10327   static char buff[128];
10328
10329   buff[0] = 0;
10330
10331   if (flags == 0)
10332     return _("none");
10333
10334   if (flags & VER_FLG_BASE)
10335     strcat (buff, "BASE");
10336
10337   if (flags & VER_FLG_WEAK)
10338     {
10339       if (flags & VER_FLG_BASE)
10340         strcat (buff, " | ");
10341
10342       strcat (buff, "WEAK");
10343     }
10344
10345   if (flags & VER_FLG_INFO)
10346     {
10347       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10348         strcat (buff, " | ");
10349
10350       strcat (buff, "INFO");
10351     }
10352
10353   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10354     {
10355       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10356         strcat (buff, " | ");
10357
10358       strcat (buff, _("<unknown>"));
10359     }
10360
10361   return buff;
10362 }
10363
10364 /* Display the contents of the version sections.  */
10365
10366 static bfd_boolean
10367 process_version_sections (Filedata * filedata)
10368 {
10369   Elf_Internal_Shdr * section;
10370   unsigned i;
10371   bfd_boolean found = FALSE;
10372
10373   if (! do_version)
10374     return TRUE;
10375
10376   for (i = 0, section = filedata->section_headers;
10377        i < filedata->file_header.e_shnum;
10378        i++, section++)
10379     {
10380       switch (section->sh_type)
10381         {
10382         case SHT_GNU_verdef:
10383           {
10384             Elf_External_Verdef * edefs;
10385             unsigned long idx;
10386             unsigned long cnt;
10387             char * endbuf;
10388
10389             found = TRUE;
10390
10391             printf (ngettext ("\nVersion definition section '%s' "
10392                               "contains %u entry:\n",
10393                               "\nVersion definition section '%s' "
10394                               "contains %u entries:\n",
10395                               section->sh_info),
10396                     printable_section_name (filedata, section),
10397                     section->sh_info);
10398
10399             printf (_("  Addr: 0x"));
10400             printf_vma (section->sh_addr);
10401             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10402                     (unsigned long) section->sh_offset, section->sh_link,
10403                     printable_section_name_from_index (filedata, section->sh_link));
10404
10405             edefs = (Elf_External_Verdef *)
10406                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10407                           _("version definition section"));
10408             if (!edefs)
10409               break;
10410             endbuf = (char *) edefs + section->sh_size;
10411
10412             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10413               {
10414                 char * vstart;
10415                 Elf_External_Verdef * edef;
10416                 Elf_Internal_Verdef ent;
10417                 Elf_External_Verdaux * eaux;
10418                 Elf_Internal_Verdaux aux;
10419                 unsigned long isum;
10420                 int j;
10421
10422                 vstart = ((char *) edefs) + idx;
10423                 if (vstart + sizeof (*edef) > endbuf)
10424                   break;
10425
10426                 edef = (Elf_External_Verdef *) vstart;
10427
10428                 ent.vd_version = BYTE_GET (edef->vd_version);
10429                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10430                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10431                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10432                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10433                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10434                 ent.vd_next    = BYTE_GET (edef->vd_next);
10435
10436                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10437                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10438
10439                 printf (_("  Index: %d  Cnt: %d  "),
10440                         ent.vd_ndx, ent.vd_cnt);
10441
10442                 /* Check for overflow.  */
10443                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10444                   break;
10445
10446                 vstart += ent.vd_aux;
10447
10448                 if (vstart + sizeof (*eaux) > endbuf)
10449                   break;
10450                 eaux = (Elf_External_Verdaux *) vstart;
10451
10452                 aux.vda_name = BYTE_GET (eaux->vda_name);
10453                 aux.vda_next = BYTE_GET (eaux->vda_next);
10454
10455                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10456                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10457                 else
10458                   printf (_("Name index: %ld\n"), aux.vda_name);
10459
10460                 isum = idx + ent.vd_aux;
10461
10462                 for (j = 1; j < ent.vd_cnt; j++)
10463                   {
10464                     if (aux.vda_next < sizeof (*eaux)
10465                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10466                       {
10467                         warn (_("Invalid vda_next field of %lx\n"),
10468                               aux.vda_next);
10469                         j = ent.vd_cnt;
10470                         break;
10471                       }
10472                     /* Check for overflow.  */
10473                     if (aux.vda_next > (size_t) (endbuf - vstart))
10474                       break;
10475
10476                     isum   += aux.vda_next;
10477                     vstart += aux.vda_next;
10478
10479                     if (vstart + sizeof (*eaux) > endbuf)
10480                       break;
10481                     eaux = (Elf_External_Verdaux *) vstart;
10482
10483                     aux.vda_name = BYTE_GET (eaux->vda_name);
10484                     aux.vda_next = BYTE_GET (eaux->vda_next);
10485
10486                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10487                       printf (_("  %#06lx: Parent %d: %s\n"),
10488                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10489                     else
10490                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10491                               isum, j, aux.vda_name);
10492                   }
10493
10494                 if (j < ent.vd_cnt)
10495                   printf (_("  Version def aux past end of section\n"));
10496
10497                 /* PR 17531:
10498                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10499                 if (ent.vd_next < sizeof (*edef)
10500                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10501                   {
10502                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10503                     cnt = section->sh_info;
10504                     break;
10505                   }
10506                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10507                   break;
10508
10509                 idx += ent.vd_next;
10510               }
10511
10512             if (cnt < section->sh_info)
10513               printf (_("  Version definition past end of section\n"));
10514
10515             free (edefs);
10516           }
10517           break;
10518
10519         case SHT_GNU_verneed:
10520           {
10521             Elf_External_Verneed * eneed;
10522             unsigned long idx;
10523             unsigned long cnt;
10524             char * endbuf;
10525
10526             found = TRUE;
10527
10528             printf (ngettext ("\nVersion needs section '%s' "
10529                               "contains %u entry:\n",
10530                               "\nVersion needs section '%s' "
10531                               "contains %u entries:\n",
10532                               section->sh_info),
10533                     printable_section_name (filedata, section), section->sh_info);
10534
10535             printf (_(" Addr: 0x"));
10536             printf_vma (section->sh_addr);
10537             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10538                     (unsigned long) section->sh_offset, section->sh_link,
10539                     printable_section_name_from_index (filedata, section->sh_link));
10540
10541             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10542                                                        section->sh_offset, 1,
10543                                                        section->sh_size,
10544                                                        _("Version Needs section"));
10545             if (!eneed)
10546               break;
10547             endbuf = (char *) eneed + section->sh_size;
10548
10549             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10550               {
10551                 Elf_External_Verneed * entry;
10552                 Elf_Internal_Verneed ent;
10553                 unsigned long isum;
10554                 int j;
10555                 char * vstart;
10556
10557                 vstart = ((char *) eneed) + idx;
10558                 if (vstart + sizeof (*entry) > endbuf)
10559                   break;
10560
10561                 entry = (Elf_External_Verneed *) vstart;
10562
10563                 ent.vn_version = BYTE_GET (entry->vn_version);
10564                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10565                 ent.vn_file    = BYTE_GET (entry->vn_file);
10566                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10567                 ent.vn_next    = BYTE_GET (entry->vn_next);
10568
10569                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10570
10571                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10572                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10573                 else
10574                   printf (_("  File: %lx"), ent.vn_file);
10575
10576                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10577
10578                 /* Check for overflow.  */
10579                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10580                   break;
10581                 vstart += ent.vn_aux;
10582
10583                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10584                   {
10585                     Elf_External_Vernaux * eaux;
10586                     Elf_Internal_Vernaux aux;
10587
10588                     if (vstart + sizeof (*eaux) > endbuf)
10589                       break;
10590                     eaux = (Elf_External_Vernaux *) vstart;
10591
10592                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10593                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10594                     aux.vna_other = BYTE_GET (eaux->vna_other);
10595                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10596                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10597
10598                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10599                       printf (_("  %#06lx:   Name: %s"),
10600                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10601                     else
10602                       printf (_("  %#06lx:   Name index: %lx"),
10603                               isum, aux.vna_name);
10604
10605                     printf (_("  Flags: %s  Version: %d\n"),
10606                             get_ver_flags (aux.vna_flags), aux.vna_other);
10607
10608                     if (aux.vna_next < sizeof (*eaux)
10609                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10610                       {
10611                         warn (_("Invalid vna_next field of %lx\n"),
10612                               aux.vna_next);
10613                         j = ent.vn_cnt;
10614                         break;
10615                       }
10616                     /* Check for overflow.  */
10617                     if (aux.vna_next > (size_t) (endbuf - vstart))
10618                       break;
10619                     isum   += aux.vna_next;
10620                     vstart += aux.vna_next;
10621                   }
10622
10623                 if (j < ent.vn_cnt)
10624                   warn (_("Missing Version Needs auxillary information\n"));
10625
10626                 if (ent.vn_next < sizeof (*entry)
10627                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10628                   {
10629                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10630                     cnt = section->sh_info;
10631                     break;
10632                   }
10633                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10634                   break;
10635                 idx += ent.vn_next;
10636               }
10637
10638             if (cnt < section->sh_info)
10639               warn (_("Missing Version Needs information\n"));
10640
10641             free (eneed);
10642           }
10643           break;
10644
10645         case SHT_GNU_versym:
10646           {
10647             Elf_Internal_Shdr * link_section;
10648             size_t total;
10649             unsigned int cnt;
10650             unsigned char * edata;
10651             unsigned short * data;
10652             char * strtab;
10653             Elf_Internal_Sym * symbols;
10654             Elf_Internal_Shdr * string_sec;
10655             unsigned long num_syms;
10656             long off;
10657
10658             if (section->sh_link >= filedata->file_header.e_shnum)
10659               break;
10660
10661             link_section = filedata->section_headers + section->sh_link;
10662             total = section->sh_size / sizeof (Elf_External_Versym);
10663
10664             if (link_section->sh_link >= filedata->file_header.e_shnum)
10665               break;
10666
10667             found = TRUE;
10668
10669             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10670             if (symbols == NULL)
10671               break;
10672
10673             string_sec = filedata->section_headers + link_section->sh_link;
10674
10675             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10676                                         string_sec->sh_size,
10677                                         _("version string table"));
10678             if (!strtab)
10679               {
10680                 free (symbols);
10681                 break;
10682               }
10683
10684             printf (ngettext ("\nVersion symbols section '%s' "
10685                               "contains %lu entry:\n",
10686                               "\nVersion symbols section '%s' "
10687                               "contains %lu entries:\n",
10688                               total),
10689                     printable_section_name (filedata, section), (unsigned long) total);
10690
10691             printf (_(" Addr: "));
10692             printf_vma (section->sh_addr);
10693             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10694                     (unsigned long) section->sh_offset, section->sh_link,
10695                     printable_section_name (filedata, link_section));
10696
10697             off = offset_from_vma (filedata,
10698                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10699                                    total * sizeof (short));
10700             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10701                                                 sizeof (short),
10702                                                 _("version symbol data"));
10703             if (!edata)
10704               {
10705                 free (strtab);
10706                 free (symbols);
10707                 break;
10708               }
10709
10710             data = (short unsigned int *) cmalloc (total, sizeof (short));
10711
10712             for (cnt = total; cnt --;)
10713               data[cnt] = byte_get (edata + cnt * sizeof (short),
10714                                     sizeof (short));
10715
10716             free (edata);
10717
10718             for (cnt = 0; cnt < total; cnt += 4)
10719               {
10720                 int j, nn;
10721                 char *name;
10722                 char *invalid = _("*invalid*");
10723
10724                 printf ("  %03x:", cnt);
10725
10726                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10727                   switch (data[cnt + j])
10728                     {
10729                     case 0:
10730                       fputs (_("   0 (*local*)    "), stdout);
10731                       break;
10732
10733                     case 1:
10734                       fputs (_("   1 (*global*)   "), stdout);
10735                       break;
10736
10737                     default:
10738                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10739                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10740
10741                       /* If this index value is greater than the size of the symbols
10742                          array, break to avoid an out-of-bounds read.  */
10743                       if ((unsigned long)(cnt + j) >= num_syms)
10744                         {
10745                           warn (_("invalid index into symbol array\n"));
10746                           break;
10747                         }
10748
10749                       name = NULL;
10750                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10751                         {
10752                           Elf_Internal_Verneed ivn;
10753                           unsigned long offset;
10754
10755                           offset = offset_from_vma
10756                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10757                              sizeof (Elf_External_Verneed));
10758
10759                           do
10760                             {
10761                               Elf_Internal_Vernaux ivna;
10762                               Elf_External_Verneed evn;
10763                               Elf_External_Vernaux evna;
10764                               unsigned long a_off;
10765
10766                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10767                                             _("version need")) == NULL)
10768                                 break;
10769
10770                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10771                               ivn.vn_next = BYTE_GET (evn.vn_next);
10772
10773                               a_off = offset + ivn.vn_aux;
10774
10775                               do
10776                                 {
10777                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10778                                                 1, _("version need aux (2)")) == NULL)
10779                                     {
10780                                       ivna.vna_next  = 0;
10781                                       ivna.vna_other = 0;
10782                                     }
10783                                   else
10784                                     {
10785                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10786                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10787                                     }
10788
10789                                   a_off += ivna.vna_next;
10790                                 }
10791                               while (ivna.vna_other != data[cnt + j]
10792                                      && ivna.vna_next != 0);
10793
10794                               if (ivna.vna_other == data[cnt + j])
10795                                 {
10796                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10797
10798                                   if (ivna.vna_name >= string_sec->sh_size)
10799                                     name = invalid;
10800                                   else
10801                                     name = strtab + ivna.vna_name;
10802                                   break;
10803                                 }
10804
10805                               offset += ivn.vn_next;
10806                             }
10807                           while (ivn.vn_next);
10808                         }
10809
10810                       if (data[cnt + j] != 0x8001
10811                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10812                         {
10813                           Elf_Internal_Verdef ivd;
10814                           Elf_External_Verdef evd;
10815                           unsigned long offset;
10816
10817                           offset = offset_from_vma
10818                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10819                              sizeof evd);
10820
10821                           do
10822                             {
10823                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10824                                             _("version def")) == NULL)
10825                                 {
10826                                   ivd.vd_next = 0;
10827                                   /* PR 17531: file: 046-1082287-0.004.  */
10828                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10829                                   break;
10830                                 }
10831                               else
10832                                 {
10833                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10834                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10835                                 }
10836
10837                               offset += ivd.vd_next;
10838                             }
10839                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10840                                  && ivd.vd_next != 0);
10841
10842                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10843                             {
10844                               Elf_External_Verdaux evda;
10845                               Elf_Internal_Verdaux ivda;
10846
10847                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10848
10849                               if (get_data (&evda, filedata,
10850                                             offset - ivd.vd_next + ivd.vd_aux,
10851                                             sizeof (evda), 1,
10852                                             _("version def aux")) == NULL)
10853                                 break;
10854
10855                               ivda.vda_name = BYTE_GET (evda.vda_name);
10856
10857                               if (ivda.vda_name >= string_sec->sh_size)
10858                                 name = invalid;
10859                               else if (name != NULL && name != invalid)
10860                                 name = _("*both*");
10861                               else
10862                                 name = strtab + ivda.vda_name;
10863                             }
10864                         }
10865                       if (name != NULL)
10866                         nn += printf ("(%s%-*s",
10867                                       name,
10868                                       12 - (int) strlen (name),
10869                                       ")");
10870
10871                       if (nn < 18)
10872                         printf ("%*c", 18 - nn, ' ');
10873                     }
10874
10875                 putchar ('\n');
10876               }
10877
10878             free (data);
10879             free (strtab);
10880             free (symbols);
10881           }
10882           break;
10883
10884         default:
10885           break;
10886         }
10887     }
10888
10889   if (! found)
10890     printf (_("\nNo version information found in this file.\n"));
10891
10892   return TRUE;
10893 }
10894
10895 static const char *
10896 get_symbol_binding (Filedata * filedata, unsigned int binding)
10897 {
10898   static char buff[32];
10899
10900   switch (binding)
10901     {
10902     case STB_LOCAL:     return "LOCAL";
10903     case STB_GLOBAL:    return "GLOBAL";
10904     case STB_WEAK:      return "WEAK";
10905     default:
10906       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10907         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10908                   binding);
10909       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10910         {
10911           if (binding == STB_GNU_UNIQUE
10912               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10913                   /* GNU is still using the default value 0.  */
10914                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10915             return "UNIQUE";
10916           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10917         }
10918       else
10919         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10920       return buff;
10921     }
10922 }
10923
10924 static const char *
10925 get_symbol_type (Filedata * filedata, unsigned int type)
10926 {
10927   static char buff[32];
10928
10929   switch (type)
10930     {
10931     case STT_NOTYPE:    return "NOTYPE";
10932     case STT_OBJECT:    return "OBJECT";
10933     case STT_FUNC:      return "FUNC";
10934     case STT_SECTION:   return "SECTION";
10935     case STT_FILE:      return "FILE";
10936     case STT_COMMON:    return "COMMON";
10937     case STT_TLS:       return "TLS";
10938     case STT_RELC:      return "RELC";
10939     case STT_SRELC:     return "SRELC";
10940     default:
10941       if (type >= STT_LOPROC && type <= STT_HIPROC)
10942         {
10943           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10944             return "THUMB_FUNC";
10945
10946           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10947             return "REGISTER";
10948
10949           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10950             return "PARISC_MILLI";
10951
10952           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10953         }
10954       else if (type >= STT_LOOS && type <= STT_HIOS)
10955         {
10956           if (filedata->file_header.e_machine == EM_PARISC)
10957             {
10958               if (type == STT_HP_OPAQUE)
10959                 return "HP_OPAQUE";
10960               if (type == STT_HP_STUB)
10961                 return "HP_STUB";
10962             }
10963
10964           if (type == STT_GNU_IFUNC
10965               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10966                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10967                   /* GNU is still using the default value 0.  */
10968                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10969             return "IFUNC";
10970
10971           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10972         }
10973       else
10974         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10975       return buff;
10976     }
10977 }
10978
10979 static const char *
10980 get_symbol_visibility (unsigned int visibility)
10981 {
10982   switch (visibility)
10983     {
10984     case STV_DEFAULT:   return "DEFAULT";
10985     case STV_INTERNAL:  return "INTERNAL";
10986     case STV_HIDDEN:    return "HIDDEN";
10987     case STV_PROTECTED: return "PROTECTED";
10988     default:
10989       error (_("Unrecognized visibility value: %u"), visibility);
10990       return _("<unknown>");
10991     }
10992 }
10993
10994 static const char *
10995 get_solaris_symbol_visibility (unsigned int visibility)
10996 {
10997   switch (visibility)
10998     {
10999     case 4: return "EXPORTED";
11000     case 5: return "SINGLETON";
11001     case 6: return "ELIMINATE";
11002     default: return get_symbol_visibility (visibility);
11003     }
11004 }
11005
11006 static const char *
11007 get_mips_symbol_other (unsigned int other)
11008 {
11009   switch (other)
11010     {
11011     case STO_OPTIONAL:      return "OPTIONAL";
11012     case STO_MIPS_PLT:      return "MIPS PLT";
11013     case STO_MIPS_PIC:      return "MIPS PIC";
11014     case STO_MICROMIPS:     return "MICROMIPS";
11015     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
11016     case STO_MIPS16:        return "MIPS16";
11017     default:                return NULL;
11018     }
11019 }
11020
11021 static const char *
11022 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11023 {
11024   if (is_ia64_vms (filedata))
11025     {
11026       static char res[32];
11027
11028       res[0] = 0;
11029
11030       /* Function types is for images and .STB files only.  */
11031       switch (filedata->file_header.e_type)
11032         {
11033         case ET_DYN:
11034         case ET_EXEC:
11035           switch (VMS_ST_FUNC_TYPE (other))
11036             {
11037             case VMS_SFT_CODE_ADDR:
11038               strcat (res, " CA");
11039               break;
11040             case VMS_SFT_SYMV_IDX:
11041               strcat (res, " VEC");
11042               break;
11043             case VMS_SFT_FD:
11044               strcat (res, " FD");
11045               break;
11046             case VMS_SFT_RESERVE:
11047               strcat (res, " RSV");
11048               break;
11049             default:
11050               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11051                     VMS_ST_FUNC_TYPE (other));
11052               strcat (res, " <unknown>");
11053               break;
11054             }
11055           break;
11056         default:
11057           break;
11058         }
11059       switch (VMS_ST_LINKAGE (other))
11060         {
11061         case VMS_STL_IGNORE:
11062           strcat (res, " IGN");
11063           break;
11064         case VMS_STL_RESERVE:
11065           strcat (res, " RSV");
11066           break;
11067         case VMS_STL_STD:
11068           strcat (res, " STD");
11069           break;
11070         case VMS_STL_LNK:
11071           strcat (res, " LNK");
11072           break;
11073         default:
11074           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11075                 VMS_ST_LINKAGE (other));
11076           strcat (res, " <unknown>");
11077           break;
11078         }
11079
11080       if (res[0] != 0)
11081         return res + 1;
11082       else
11083         return res;
11084     }
11085   return NULL;
11086 }
11087
11088 static const char *
11089 get_ppc64_symbol_other (unsigned int other)
11090 {
11091   if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11092     return NULL;
11093
11094   other >>= STO_PPC64_LOCAL_BIT;
11095   if (other <= 6)
11096     {
11097       static char buf[32];
11098       if (other >= 2)
11099         other = ppc64_decode_local_entry (other);
11100       snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11101       return buf;
11102     }
11103   return NULL;
11104 }
11105
11106 static const char *
11107 get_symbol_other (Filedata * filedata, unsigned int other)
11108 {
11109   const char * result = NULL;
11110   static char buff [32];
11111
11112   if (other == 0)
11113     return "";
11114
11115   switch (filedata->file_header.e_machine)
11116     {
11117     case EM_MIPS:
11118       result = get_mips_symbol_other (other);
11119       break;
11120     case EM_IA_64:
11121       result = get_ia64_symbol_other (filedata, other);
11122       break;
11123     case EM_PPC64:
11124       result = get_ppc64_symbol_other (other);
11125       break;
11126     default:
11127       result = NULL;
11128       break;
11129     }
11130
11131   if (result)
11132     return result;
11133
11134   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11135   return buff;
11136 }
11137
11138 static const char *
11139 get_symbol_index_type (Filedata * filedata, unsigned int type)
11140 {
11141   static char buff[32];
11142
11143   switch (type)
11144     {
11145     case SHN_UNDEF:     return "UND";
11146     case SHN_ABS:       return "ABS";
11147     case SHN_COMMON:    return "COM";
11148     default:
11149       if (type == SHN_IA_64_ANSI_COMMON
11150           && filedata->file_header.e_machine == EM_IA_64
11151           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11152         return "ANSI_COM";
11153       else if ((filedata->file_header.e_machine == EM_X86_64
11154                 || filedata->file_header.e_machine == EM_L1OM
11155                 || filedata->file_header.e_machine == EM_K1OM)
11156                && type == SHN_X86_64_LCOMMON)
11157         return "LARGE_COM";
11158       else if ((type == SHN_MIPS_SCOMMON
11159                 && filedata->file_header.e_machine == EM_MIPS)
11160                || (type == SHN_TIC6X_SCOMMON
11161                    && filedata->file_header.e_machine == EM_TI_C6000))
11162         return "SCOM";
11163       else if (type == SHN_MIPS_SUNDEFINED
11164                && filedata->file_header.e_machine == EM_MIPS)
11165         return "SUND";
11166       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11167         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11168       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11169         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11170       else if (type >= SHN_LORESERVE)
11171         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11172       else if (type >= filedata->file_header.e_shnum)
11173         sprintf (buff, _("bad section index[%3d]"), type);
11174       else
11175         sprintf (buff, "%3d", type);
11176       break;
11177     }
11178
11179   return buff;
11180 }
11181
11182 static bfd_vma *
11183 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11184 {
11185   unsigned char * e_data;
11186   bfd_vma * i_data;
11187
11188   /* If the size_t type is smaller than the bfd_size_type, eg because
11189      you are building a 32-bit tool on a 64-bit host, then make sure
11190      that when (number) is cast to (size_t) no information is lost.  */
11191   if (sizeof (size_t) < sizeof (bfd_size_type)
11192       && (bfd_size_type) ((size_t) number) != number)
11193     {
11194       error (_("Size truncation prevents reading %s elements of size %u\n"),
11195              bfd_vmatoa ("u", number), ent_size);
11196       return NULL;
11197     }
11198
11199   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11200      attempting to allocate memory when the read is bound to fail.  */
11201   if (ent_size * number > filedata->file_size)
11202     {
11203       error (_("Invalid number of dynamic entries: %s\n"),
11204              bfd_vmatoa ("u", number));
11205       return NULL;
11206     }
11207
11208   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11209   if (e_data == NULL)
11210     {
11211       error (_("Out of memory reading %s dynamic entries\n"),
11212              bfd_vmatoa ("u", number));
11213       return NULL;
11214     }
11215
11216   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11217     {
11218       error (_("Unable to read in %s bytes of dynamic data\n"),
11219              bfd_vmatoa ("u", number * ent_size));
11220       free (e_data);
11221       return NULL;
11222     }
11223
11224   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11225   if (i_data == NULL)
11226     {
11227       error (_("Out of memory allocating space for %s dynamic entries\n"),
11228              bfd_vmatoa ("u", number));
11229       free (e_data);
11230       return NULL;
11231     }
11232
11233   while (number--)
11234     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11235
11236   free (e_data);
11237
11238   return i_data;
11239 }
11240
11241 static void
11242 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11243 {
11244   Elf_Internal_Sym * psym;
11245   int n;
11246
11247   n = print_vma (si, DEC_5);
11248   if (n < 5)
11249     fputs (&"     "[n], stdout);
11250   printf (" %3lu: ", hn);
11251
11252   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11253     {
11254       printf (_("<No info available for dynamic symbol number %lu>\n"),
11255               (unsigned long) si);
11256       return;
11257     }
11258
11259   psym = dynamic_symbols + si;
11260   print_vma (psym->st_value, LONG_HEX);
11261   putchar (' ');
11262   print_vma (psym->st_size, DEC_5);
11263
11264   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11265   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11266
11267   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11268     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11269   else
11270     {
11271       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11272
11273       printf (" %-7s",  get_symbol_visibility (vis));
11274       /* Check to see if any other bits in the st_other field are set.
11275          Note - displaying this information disrupts the layout of the
11276          table being generated, but for the moment this case is very
11277          rare.  */
11278       if (psym->st_other ^ vis)
11279         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11280     }
11281
11282   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11283   if (VALID_DYNAMIC_NAME (psym->st_name))
11284     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11285   else
11286     printf (_(" <corrupt: %14ld>"), psym->st_name);
11287   putchar ('\n');
11288 }
11289
11290 static const char *
11291 get_symbol_version_string (Filedata *                   filedata,
11292                            bfd_boolean                  is_dynsym,
11293                            const char *                 strtab,
11294                            unsigned long int            strtab_size,
11295                            unsigned int                 si,
11296                            Elf_Internal_Sym *           psym,
11297                            enum versioned_symbol_info * sym_info,
11298                            unsigned short *             vna_other)
11299 {
11300   unsigned char data[2];
11301   unsigned short vers_data;
11302   unsigned long offset;
11303
11304   if (!is_dynsym
11305       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11306     return NULL;
11307
11308   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11309                             sizeof data + si * sizeof (vers_data));
11310
11311   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11312                 sizeof (data), 1, _("version data")) == NULL)
11313     return NULL;
11314
11315   vers_data = byte_get (data, 2);
11316
11317   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11318     return NULL;
11319
11320   /* Usually we'd only see verdef for defined symbols, and verneed for
11321      undefined symbols.  However, symbols defined by the linker in
11322      .dynbss for variables copied from a shared library in order to
11323      avoid text relocations are defined yet have verneed.  We could
11324      use a heuristic to detect the special case, for example, check
11325      for verneed first on symbols defined in SHT_NOBITS sections, but
11326      it is simpler and more reliable to just look for both verdef and
11327      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11328
11329   if (psym->st_shndx != SHN_UNDEF
11330       && vers_data != 0x8001
11331       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11332     {
11333       Elf_Internal_Verdef ivd;
11334       Elf_Internal_Verdaux ivda;
11335       Elf_External_Verdaux evda;
11336       unsigned long off;
11337
11338       off = offset_from_vma (filedata,
11339                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11340                              sizeof (Elf_External_Verdef));
11341
11342       do
11343         {
11344           Elf_External_Verdef evd;
11345
11346           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11347                         _("version def")) == NULL)
11348             {
11349               ivd.vd_ndx = 0;
11350               ivd.vd_aux = 0;
11351               ivd.vd_next = 0;
11352               ivd.vd_flags = 0;
11353             }
11354           else
11355             {
11356               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11357               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11358               ivd.vd_next = BYTE_GET (evd.vd_next);
11359               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11360             }
11361
11362           off += ivd.vd_next;
11363         }
11364       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11365
11366       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11367         {
11368           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11369             return NULL;
11370
11371           off -= ivd.vd_next;
11372           off += ivd.vd_aux;
11373
11374           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11375                         _("version def aux")) != NULL)
11376             {
11377               ivda.vda_name = BYTE_GET (evda.vda_name);
11378
11379               if (psym->st_name != ivda.vda_name)
11380                 {
11381                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11382                                ? symbol_hidden : symbol_public);
11383                   return (ivda.vda_name < strtab_size
11384                           ? strtab + ivda.vda_name : _("<corrupt>"));
11385                 }
11386             }
11387         }
11388     }
11389
11390   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11391     {
11392       Elf_External_Verneed evn;
11393       Elf_Internal_Verneed ivn;
11394       Elf_Internal_Vernaux ivna;
11395
11396       offset = offset_from_vma (filedata,
11397                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11398                                 sizeof evn);
11399       do
11400         {
11401           unsigned long vna_off;
11402
11403           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11404                         _("version need")) == NULL)
11405             {
11406               ivna.vna_next = 0;
11407               ivna.vna_other = 0;
11408               ivna.vna_name = 0;
11409               break;
11410             }
11411
11412           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11413           ivn.vn_next = BYTE_GET (evn.vn_next);
11414
11415           vna_off = offset + ivn.vn_aux;
11416
11417           do
11418             {
11419               Elf_External_Vernaux evna;
11420
11421               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11422                             _("version need aux (3)")) == NULL)
11423                 {
11424                   ivna.vna_next = 0;
11425                   ivna.vna_other = 0;
11426                   ivna.vna_name = 0;
11427                 }
11428               else
11429                 {
11430                   ivna.vna_other = BYTE_GET (evna.vna_other);
11431                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11432                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11433                 }
11434
11435               vna_off += ivna.vna_next;
11436             }
11437           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11438
11439           if (ivna.vna_other == vers_data)
11440             break;
11441
11442           offset += ivn.vn_next;
11443         }
11444       while (ivn.vn_next != 0);
11445
11446       if (ivna.vna_other == vers_data)
11447         {
11448           *sym_info = symbol_undefined;
11449           *vna_other = ivna.vna_other;
11450           return (ivna.vna_name < strtab_size
11451                   ? strtab + ivna.vna_name : _("<corrupt>"));
11452         }
11453     }
11454   return NULL;
11455 }
11456
11457 /* Dump the symbol table.  */
11458 static bfd_boolean
11459 process_symbol_table (Filedata * filedata)
11460 {
11461   Elf_Internal_Shdr * section;
11462   bfd_size_type nbuckets = 0;
11463   bfd_size_type nchains = 0;
11464   bfd_vma * buckets = NULL;
11465   bfd_vma * chains = NULL;
11466   bfd_vma ngnubuckets = 0;
11467   bfd_vma * gnubuckets = NULL;
11468   bfd_vma * gnuchains = NULL;
11469   bfd_vma gnusymidx = 0;
11470   bfd_size_type ngnuchains = 0;
11471
11472   if (!do_syms && !do_dyn_syms && !do_histogram)
11473     return TRUE;
11474
11475   if (dynamic_info[DT_HASH]
11476       && (do_histogram
11477           || (do_using_dynamic
11478               && !do_dyn_syms
11479               && dynamic_strings != NULL)))
11480     {
11481       unsigned char nb[8];
11482       unsigned char nc[8];
11483       unsigned int hash_ent_size = 4;
11484
11485       if ((filedata->file_header.e_machine == EM_ALPHA
11486            || filedata->file_header.e_machine == EM_S390
11487            || filedata->file_header.e_machine == EM_S390_OLD)
11488           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11489         hash_ent_size = 8;
11490
11491       if (fseek (filedata->handle,
11492                  (archive_file_offset
11493                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11494                                      sizeof nb + sizeof nc)),
11495                  SEEK_SET))
11496         {
11497           error (_("Unable to seek to start of dynamic information\n"));
11498           goto no_hash;
11499         }
11500
11501       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11502         {
11503           error (_("Failed to read in number of buckets\n"));
11504           goto no_hash;
11505         }
11506
11507       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11508         {
11509           error (_("Failed to read in number of chains\n"));
11510           goto no_hash;
11511         }
11512
11513       nbuckets = byte_get (nb, hash_ent_size);
11514       nchains  = byte_get (nc, hash_ent_size);
11515
11516       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11517       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11518
11519     no_hash:
11520       if (buckets == NULL || chains == NULL)
11521         {
11522           if (do_using_dynamic)
11523             return FALSE;
11524           free (buckets);
11525           free (chains);
11526           buckets = NULL;
11527           chains = NULL;
11528           nbuckets = 0;
11529           nchains = 0;
11530         }
11531     }
11532
11533   if (dynamic_info_DT_GNU_HASH
11534       && (do_histogram
11535           || (do_using_dynamic
11536               && !do_dyn_syms
11537               && dynamic_strings != NULL)))
11538     {
11539       unsigned char nb[16];
11540       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11541       bfd_vma buckets_vma;
11542
11543       if (fseek (filedata->handle,
11544                  (archive_file_offset
11545                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11546                                      sizeof nb)),
11547                  SEEK_SET))
11548         {
11549           error (_("Unable to seek to start of dynamic information\n"));
11550           goto no_gnu_hash;
11551         }
11552
11553       if (fread (nb, 16, 1, filedata->handle) != 1)
11554         {
11555           error (_("Failed to read in number of buckets\n"));
11556           goto no_gnu_hash;
11557         }
11558
11559       ngnubuckets = byte_get (nb, 4);
11560       gnusymidx = byte_get (nb + 4, 4);
11561       bitmaskwords = byte_get (nb + 8, 4);
11562       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11563       if (is_32bit_elf)
11564         buckets_vma += bitmaskwords * 4;
11565       else
11566         buckets_vma += bitmaskwords * 8;
11567
11568       if (fseek (filedata->handle,
11569                  (archive_file_offset
11570                   + offset_from_vma (filedata, buckets_vma, 4)),
11571                  SEEK_SET))
11572         {
11573           error (_("Unable to seek to start of dynamic information\n"));
11574           goto no_gnu_hash;
11575         }
11576
11577       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11578
11579       if (gnubuckets == NULL)
11580         goto no_gnu_hash;
11581
11582       for (i = 0; i < ngnubuckets; i++)
11583         if (gnubuckets[i] != 0)
11584           {
11585             if (gnubuckets[i] < gnusymidx)
11586               return FALSE;
11587
11588             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11589               maxchain = gnubuckets[i];
11590           }
11591
11592       if (maxchain == 0xffffffff)
11593         goto no_gnu_hash;
11594
11595       maxchain -= gnusymidx;
11596
11597       if (fseek (filedata->handle,
11598                  (archive_file_offset
11599                   + offset_from_vma (filedata, buckets_vma
11600                                            + 4 * (ngnubuckets + maxchain), 4)),
11601                  SEEK_SET))
11602         {
11603           error (_("Unable to seek to start of dynamic information\n"));
11604           goto no_gnu_hash;
11605         }
11606
11607       do
11608         {
11609           if (fread (nb, 4, 1, filedata->handle) != 1)
11610             {
11611               error (_("Failed to determine last chain length\n"));
11612               goto no_gnu_hash;
11613             }
11614
11615           if (maxchain + 1 == 0)
11616             goto no_gnu_hash;
11617
11618           ++maxchain;
11619         }
11620       while ((byte_get (nb, 4) & 1) == 0);
11621
11622       if (fseek (filedata->handle,
11623                  (archive_file_offset
11624                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11625                  SEEK_SET))
11626         {
11627           error (_("Unable to seek to start of dynamic information\n"));
11628           goto no_gnu_hash;
11629         }
11630
11631       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11632       ngnuchains = maxchain;
11633
11634     no_gnu_hash:
11635       if (gnuchains == NULL)
11636         {
11637           free (gnubuckets);
11638           gnubuckets = NULL;
11639           ngnubuckets = 0;
11640           if (do_using_dynamic)
11641             return FALSE;
11642         }
11643     }
11644
11645   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11646       && do_syms
11647       && do_using_dynamic
11648       && dynamic_strings != NULL
11649       && dynamic_symbols != NULL)
11650     {
11651       unsigned long hn;
11652
11653       if (dynamic_info[DT_HASH])
11654         {
11655           bfd_vma si;
11656           char *visited;
11657
11658           printf (_("\nSymbol table for image:\n"));
11659           if (is_32bit_elf)
11660             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11661           else
11662             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11663
11664           visited = xcmalloc (nchains, 1);
11665           memset (visited, 0, nchains);
11666           for (hn = 0; hn < nbuckets; hn++)
11667             {
11668               for (si = buckets[hn]; si > 0; si = chains[si])
11669                 {
11670                   print_dynamic_symbol (filedata, si, hn);
11671                   if (si >= nchains || visited[si])
11672                     {
11673                       error (_("histogram chain is corrupt\n"));
11674                       break;
11675                     }
11676                   visited[si] = 1;
11677                 }
11678             }
11679           free (visited);
11680         }
11681
11682       if (dynamic_info_DT_GNU_HASH)
11683         {
11684           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11685           if (is_32bit_elf)
11686             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11687           else
11688             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11689
11690           for (hn = 0; hn < ngnubuckets; ++hn)
11691             if (gnubuckets[hn] != 0)
11692               {
11693                 bfd_vma si = gnubuckets[hn];
11694                 bfd_vma off = si - gnusymidx;
11695
11696                 do
11697                   {
11698                     print_dynamic_symbol (filedata, si, hn);
11699                     si++;
11700                   }
11701                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11702               }
11703         }
11704     }
11705   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11706            && filedata->section_headers != NULL)
11707     {
11708       unsigned int i;
11709
11710       for (i = 0, section = filedata->section_headers;
11711            i < filedata->file_header.e_shnum;
11712            i++, section++)
11713         {
11714           unsigned int si;
11715           char * strtab = NULL;
11716           unsigned long int strtab_size = 0;
11717           Elf_Internal_Sym * symtab;
11718           Elf_Internal_Sym * psym;
11719           unsigned long num_syms;
11720
11721           if ((section->sh_type != SHT_SYMTAB
11722                && section->sh_type != SHT_DYNSYM)
11723               || (!do_syms
11724                   && section->sh_type == SHT_SYMTAB))
11725             continue;
11726
11727           if (section->sh_entsize == 0)
11728             {
11729               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11730                       printable_section_name (filedata, section));
11731               continue;
11732             }
11733
11734           num_syms = section->sh_size / section->sh_entsize;
11735           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11736                             "\nSymbol table '%s' contains %lu entries:\n",
11737                             num_syms),
11738                   printable_section_name (filedata, section),
11739                   num_syms);
11740
11741           if (is_32bit_elf)
11742             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11743           else
11744             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11745
11746           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11747           if (symtab == NULL)
11748             continue;
11749
11750           if (section->sh_link == filedata->file_header.e_shstrndx)
11751             {
11752               strtab = filedata->string_table;
11753               strtab_size = filedata->string_table_length;
11754             }
11755           else if (section->sh_link < filedata->file_header.e_shnum)
11756             {
11757               Elf_Internal_Shdr * string_sec;
11758
11759               string_sec = filedata->section_headers + section->sh_link;
11760
11761               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11762                                           1, string_sec->sh_size,
11763                                           _("string table"));
11764               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11765             }
11766
11767           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11768             {
11769               const char *version_string;
11770               enum versioned_symbol_info sym_info;
11771               unsigned short vna_other;
11772
11773               printf ("%6d: ", si);
11774               print_vma (psym->st_value, LONG_HEX);
11775               putchar (' ');
11776               print_vma (psym->st_size, DEC_5);
11777               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11778               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11779               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11780                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11781               else
11782                 {
11783                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11784
11785                   printf (" %-7s", get_symbol_visibility (vis));
11786                   /* Check to see if any other bits in the st_other field are set.
11787                      Note - displaying this information disrupts the layout of the
11788                      table being generated, but for the moment this case is very rare.  */
11789                   if (psym->st_other ^ vis)
11790                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11791                 }
11792               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11793               print_symbol (25, psym->st_name < strtab_size
11794                             ? strtab + psym->st_name : _("<corrupt>"));
11795
11796               version_string
11797                 = get_symbol_version_string (filedata,
11798                                              section->sh_type == SHT_DYNSYM,
11799                                              strtab, strtab_size, si,
11800                                              psym, &sym_info, &vna_other);
11801               if (version_string)
11802                 {
11803                   if (sym_info == symbol_undefined)
11804                     printf ("@%s (%d)", version_string, vna_other);
11805                   else
11806                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11807                             version_string);
11808                 }
11809
11810               putchar ('\n');
11811
11812               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11813                   && si >= section->sh_info
11814                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11815                   && filedata->file_header.e_machine != EM_MIPS
11816                   /* Solaris binaries have been found to violate this requirement as
11817                      well.  Not sure if this is a bug or an ABI requirement.  */
11818                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11819                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11820                       si, printable_section_name (filedata, section), section->sh_info);
11821             }
11822
11823           free (symtab);
11824           if (strtab != filedata->string_table)
11825             free (strtab);
11826         }
11827     }
11828   else if (do_syms)
11829     printf
11830       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11831
11832   if (do_histogram && buckets != NULL)
11833     {
11834       unsigned long * lengths;
11835       unsigned long * counts;
11836       unsigned long hn;
11837       bfd_vma si;
11838       unsigned long maxlength = 0;
11839       unsigned long nzero_counts = 0;
11840       unsigned long nsyms = 0;
11841       char *visited;
11842
11843       printf (ngettext ("\nHistogram for bucket list length "
11844                         "(total of %lu bucket):\n",
11845                         "\nHistogram for bucket list length "
11846                         "(total of %lu buckets):\n",
11847                         (unsigned long) nbuckets),
11848               (unsigned long) nbuckets);
11849
11850       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11851       if (lengths == NULL)
11852         {
11853           error (_("Out of memory allocating space for histogram buckets\n"));
11854           return FALSE;
11855         }
11856       visited = xcmalloc (nchains, 1);
11857       memset (visited, 0, nchains);
11858
11859       printf (_(" Length  Number     %% of total  Coverage\n"));
11860       for (hn = 0; hn < nbuckets; ++hn)
11861         {
11862           for (si = buckets[hn]; si > 0; si = chains[si])
11863             {
11864               ++nsyms;
11865               if (maxlength < ++lengths[hn])
11866                 ++maxlength;
11867               if (si >= nchains || visited[si])
11868                 {
11869                   error (_("histogram chain is corrupt\n"));
11870                   break;
11871                 }
11872               visited[si] = 1;
11873             }
11874         }
11875       free (visited);
11876
11877       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11878       if (counts == NULL)
11879         {
11880           free (lengths);
11881           error (_("Out of memory allocating space for histogram counts\n"));
11882           return FALSE;
11883         }
11884
11885       for (hn = 0; hn < nbuckets; ++hn)
11886         ++counts[lengths[hn]];
11887
11888       if (nbuckets > 0)
11889         {
11890           unsigned long i;
11891           printf ("      0  %-10lu (%5.1f%%)\n",
11892                   counts[0], (counts[0] * 100.0) / nbuckets);
11893           for (i = 1; i <= maxlength; ++i)
11894             {
11895               nzero_counts += counts[i] * i;
11896               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11897                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11898                       (nzero_counts * 100.0) / nsyms);
11899             }
11900         }
11901
11902       free (counts);
11903       free (lengths);
11904     }
11905
11906   if (buckets != NULL)
11907     {
11908       free (buckets);
11909       free (chains);
11910     }
11911
11912   if (do_histogram && gnubuckets != NULL)
11913     {
11914       unsigned long * lengths;
11915       unsigned long * counts;
11916       unsigned long hn;
11917       unsigned long maxlength = 0;
11918       unsigned long nzero_counts = 0;
11919       unsigned long nsyms = 0;
11920
11921       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11922                         "(total of %lu bucket):\n",
11923                         "\nHistogram for `.gnu.hash' bucket list length "
11924                         "(total of %lu buckets):\n",
11925                         (unsigned long) ngnubuckets),
11926               (unsigned long) ngnubuckets);
11927
11928       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11929       if (lengths == NULL)
11930         {
11931           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11932           return FALSE;
11933         }
11934
11935       printf (_(" Length  Number     %% of total  Coverage\n"));
11936
11937       for (hn = 0; hn < ngnubuckets; ++hn)
11938         if (gnubuckets[hn] != 0)
11939           {
11940             bfd_vma off, length = 1;
11941
11942             for (off = gnubuckets[hn] - gnusymidx;
11943                  /* PR 17531 file: 010-77222-0.004.  */
11944                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11945                  ++off)
11946               ++length;
11947             lengths[hn] = length;
11948             if (length > maxlength)
11949               maxlength = length;
11950             nsyms += length;
11951           }
11952
11953       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11954       if (counts == NULL)
11955         {
11956           free (lengths);
11957           error (_("Out of memory allocating space for gnu histogram counts\n"));
11958           return FALSE;
11959         }
11960
11961       for (hn = 0; hn < ngnubuckets; ++hn)
11962         ++counts[lengths[hn]];
11963
11964       if (ngnubuckets > 0)
11965         {
11966           unsigned long j;
11967           printf ("      0  %-10lu (%5.1f%%)\n",
11968                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11969           for (j = 1; j <= maxlength; ++j)
11970             {
11971               nzero_counts += counts[j] * j;
11972               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11973                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11974                       (nzero_counts * 100.0) / nsyms);
11975             }
11976         }
11977
11978       free (counts);
11979       free (lengths);
11980       free (gnubuckets);
11981       free (gnuchains);
11982     }
11983
11984   return TRUE;
11985 }
11986
11987 static bfd_boolean
11988 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11989 {
11990   unsigned int i;
11991
11992   if (dynamic_syminfo == NULL
11993       || !do_dynamic)
11994     /* No syminfo, this is ok.  */
11995     return TRUE;
11996
11997   /* There better should be a dynamic symbol section.  */
11998   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11999     return FALSE;
12000
12001   if (dynamic_addr)
12002     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12003                       "contains %d entry:\n",
12004                       "\nDynamic info segment at offset 0x%lx "
12005                       "contains %d entries:\n",
12006                       dynamic_syminfo_nent),
12007             dynamic_syminfo_offset, dynamic_syminfo_nent);
12008
12009   printf (_(" Num: Name                           BoundTo     Flags\n"));
12010   for (i = 0; i < dynamic_syminfo_nent; ++i)
12011     {
12012       unsigned short int flags = dynamic_syminfo[i].si_flags;
12013
12014       printf ("%4d: ", i);
12015       if (i >= num_dynamic_syms)
12016         printf (_("<corrupt index>"));
12017       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12018         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12019       else
12020         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12021       putchar (' ');
12022
12023       switch (dynamic_syminfo[i].si_boundto)
12024         {
12025         case SYMINFO_BT_SELF:
12026           fputs ("SELF       ", stdout);
12027           break;
12028         case SYMINFO_BT_PARENT:
12029           fputs ("PARENT     ", stdout);
12030           break;
12031         default:
12032           if (dynamic_syminfo[i].si_boundto > 0
12033               && dynamic_syminfo[i].si_boundto < dynamic_nent
12034               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12035             {
12036               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12037               putchar (' ' );
12038             }
12039           else
12040             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12041           break;
12042         }
12043
12044       if (flags & SYMINFO_FLG_DIRECT)
12045         printf (" DIRECT");
12046       if (flags & SYMINFO_FLG_PASSTHRU)
12047         printf (" PASSTHRU");
12048       if (flags & SYMINFO_FLG_COPY)
12049         printf (" COPY");
12050       if (flags & SYMINFO_FLG_LAZYLOAD)
12051         printf (" LAZYLOAD");
12052
12053       puts ("");
12054     }
12055
12056   return TRUE;
12057 }
12058
12059 #define IN_RANGE(START,END,ADDR,OFF)            \
12060   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12061
12062 /* Check to see if the given reloc needs to be handled in a target specific
12063    manner.  If so then process the reloc and return TRUE otherwise return
12064    FALSE.
12065
12066    If called with reloc == NULL, then this is a signal that reloc processing
12067    for the current section has finished, and any saved state should be
12068    discarded.  */
12069
12070 static bfd_boolean
12071 target_specific_reloc_handling (Filedata *           filedata,
12072                                 Elf_Internal_Rela *  reloc,
12073                                 unsigned char *      start,
12074                                 unsigned char *      end,
12075                                 Elf_Internal_Sym *   symtab,
12076                                 unsigned long        num_syms)
12077 {
12078   unsigned int reloc_type = 0;
12079   unsigned long sym_index = 0;
12080
12081   if (reloc)
12082     {
12083       reloc_type = get_reloc_type (filedata, reloc->r_info);
12084       sym_index = get_reloc_symindex (reloc->r_info);
12085     }
12086
12087   switch (filedata->file_header.e_machine)
12088     {
12089     case EM_MSP430:
12090     case EM_MSP430_OLD:
12091       {
12092         static Elf_Internal_Sym * saved_sym = NULL;
12093
12094         if (reloc == NULL)
12095           {
12096             saved_sym = NULL;
12097             return TRUE;
12098           }
12099
12100         switch (reloc_type)
12101           {
12102           case 10: /* R_MSP430_SYM_DIFF */
12103             if (uses_msp430x_relocs (filedata))
12104               break;
12105             /* Fall through.  */
12106           case 21: /* R_MSP430X_SYM_DIFF */
12107             /* PR 21139.  */
12108             if (sym_index >= num_syms)
12109               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12110                      sym_index);
12111             else
12112               saved_sym = symtab + sym_index;
12113             return TRUE;
12114
12115           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12116           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12117             goto handle_sym_diff;
12118
12119           case 5: /* R_MSP430_16_BYTE */
12120           case 9: /* R_MSP430_8 */
12121             if (uses_msp430x_relocs (filedata))
12122               break;
12123             goto handle_sym_diff;
12124
12125           case 2: /* R_MSP430_ABS16 */
12126           case 15: /* R_MSP430X_ABS16 */
12127             if (! uses_msp430x_relocs (filedata))
12128               break;
12129             goto handle_sym_diff;
12130
12131           handle_sym_diff:
12132             if (saved_sym != NULL)
12133               {
12134                 int reloc_size = reloc_type == 1 ? 4 : 2;
12135                 bfd_vma value;
12136
12137                 if (sym_index >= num_syms)
12138                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12139                          sym_index);
12140                 else
12141                   {
12142                     value = reloc->r_addend + (symtab[sym_index].st_value
12143                                                - saved_sym->st_value);
12144
12145                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12146                       byte_put (start + reloc->r_offset, value, reloc_size);
12147                     else
12148                       /* PR 21137 */
12149                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12150                              (long) reloc->r_offset);
12151                   }
12152
12153                 saved_sym = NULL;
12154                 return TRUE;
12155               }
12156             break;
12157
12158           default:
12159             if (saved_sym != NULL)
12160               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12161             break;
12162           }
12163         break;
12164       }
12165
12166     case EM_MN10300:
12167     case EM_CYGNUS_MN10300:
12168       {
12169         static Elf_Internal_Sym * saved_sym = NULL;
12170
12171         if (reloc == NULL)
12172           {
12173             saved_sym = NULL;
12174             return TRUE;
12175           }
12176
12177         switch (reloc_type)
12178           {
12179           case 34: /* R_MN10300_ALIGN */
12180             return TRUE;
12181           case 33: /* R_MN10300_SYM_DIFF */
12182             if (sym_index >= num_syms)
12183               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12184                      sym_index);
12185             else
12186               saved_sym = symtab + sym_index;
12187             return TRUE;
12188
12189           case 1: /* R_MN10300_32 */
12190           case 2: /* R_MN10300_16 */
12191             if (saved_sym != NULL)
12192               {
12193                 int reloc_size = reloc_type == 1 ? 4 : 2;
12194                 bfd_vma value;
12195
12196                 if (sym_index >= num_syms)
12197                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12198                          sym_index);
12199                 else
12200                   {
12201                     value = reloc->r_addend + (symtab[sym_index].st_value
12202                                                - saved_sym->st_value);
12203
12204                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12205                       byte_put (start + reloc->r_offset, value, reloc_size);
12206                     else
12207                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12208                              (long) reloc->r_offset);
12209                   }
12210
12211                 saved_sym = NULL;
12212                 return TRUE;
12213               }
12214             break;
12215           default:
12216             if (saved_sym != NULL)
12217               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12218             break;
12219           }
12220         break;
12221       }
12222
12223     case EM_RL78:
12224       {
12225         static bfd_vma saved_sym1 = 0;
12226         static bfd_vma saved_sym2 = 0;
12227         static bfd_vma value;
12228
12229         if (reloc == NULL)
12230           {
12231             saved_sym1 = saved_sym2 = 0;
12232             return TRUE;
12233           }
12234
12235         switch (reloc_type)
12236           {
12237           case 0x80: /* R_RL78_SYM.  */
12238             saved_sym1 = saved_sym2;
12239             if (sym_index >= num_syms)
12240               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12241                      sym_index);
12242             else
12243               {
12244                 saved_sym2 = symtab[sym_index].st_value;
12245                 saved_sym2 += reloc->r_addend;
12246               }
12247             return TRUE;
12248
12249           case 0x83: /* R_RL78_OPsub.  */
12250             value = saved_sym1 - saved_sym2;
12251             saved_sym2 = saved_sym1 = 0;
12252             return TRUE;
12253             break;
12254
12255           case 0x41: /* R_RL78_ABS32.  */
12256             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12257               byte_put (start + reloc->r_offset, value, 4);
12258             else
12259               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12260                      (long) reloc->r_offset);
12261             value = 0;
12262             return TRUE;
12263
12264           case 0x43: /* R_RL78_ABS16.  */
12265             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12266               byte_put (start + reloc->r_offset, value, 2);
12267             else
12268               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12269                      (long) reloc->r_offset);
12270             value = 0;
12271             return TRUE;
12272
12273           default:
12274             break;
12275           }
12276         break;
12277       }
12278     }
12279
12280   return FALSE;
12281 }
12282
12283 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12284    DWARF debug sections.  This is a target specific test.  Note - we do not
12285    go through the whole including-target-headers-multiple-times route, (as
12286    we have already done with <elf/h8.h>) because this would become very
12287    messy and even then this function would have to contain target specific
12288    information (the names of the relocs instead of their numeric values).
12289    FIXME: This is not the correct way to solve this problem.  The proper way
12290    is to have target specific reloc sizing and typing functions created by
12291    the reloc-macros.h header, in the same way that it already creates the
12292    reloc naming functions.  */
12293
12294 static bfd_boolean
12295 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12296 {
12297   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12298   switch (filedata->file_header.e_machine)
12299     {
12300     case EM_386:
12301     case EM_IAMCU:
12302       return reloc_type == 1; /* R_386_32.  */
12303     case EM_68K:
12304       return reloc_type == 1; /* R_68K_32.  */
12305     case EM_860:
12306       return reloc_type == 1; /* R_860_32.  */
12307     case EM_960:
12308       return reloc_type == 2; /* R_960_32.  */
12309     case EM_AARCH64:
12310       return (reloc_type == 258
12311               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12312     case EM_ADAPTEVA_EPIPHANY:
12313       return reloc_type == 3;
12314     case EM_ALPHA:
12315       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12316     case EM_ARC:
12317       return reloc_type == 1; /* R_ARC_32.  */
12318     case EM_ARC_COMPACT:
12319     case EM_ARC_COMPACT2:
12320       return reloc_type == 4; /* R_ARC_32.  */
12321     case EM_ARM:
12322       return reloc_type == 2; /* R_ARM_ABS32 */
12323     case EM_AVR_OLD:
12324     case EM_AVR:
12325       return reloc_type == 1;
12326     case EM_BLACKFIN:
12327       return reloc_type == 0x12; /* R_byte4_data.  */
12328     case EM_CRIS:
12329       return reloc_type == 3; /* R_CRIS_32.  */
12330     case EM_CR16:
12331       return reloc_type == 3; /* R_CR16_NUM32.  */
12332     case EM_CRX:
12333       return reloc_type == 15; /* R_CRX_NUM32.  */
12334     case EM_CSKY:
12335       return reloc_type == 1; /* R_CKCORE_ADDR32.  */
12336     case EM_CYGNUS_FRV:
12337       return reloc_type == 1;
12338     case EM_CYGNUS_D10V:
12339     case EM_D10V:
12340       return reloc_type == 6; /* R_D10V_32.  */
12341     case EM_CYGNUS_D30V:
12342     case EM_D30V:
12343       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12344     case EM_DLX:
12345       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12346     case EM_CYGNUS_FR30:
12347     case EM_FR30:
12348       return reloc_type == 3; /* R_FR30_32.  */
12349     case EM_FT32:
12350       return reloc_type == 1; /* R_FT32_32.  */
12351     case EM_H8S:
12352     case EM_H8_300:
12353     case EM_H8_300H:
12354       return reloc_type == 1; /* R_H8_DIR32.  */
12355     case EM_IA_64:
12356       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12357               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12358               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12359               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12360     case EM_IP2K_OLD:
12361     case EM_IP2K:
12362       return reloc_type == 2; /* R_IP2K_32.  */
12363     case EM_IQ2000:
12364       return reloc_type == 2; /* R_IQ2000_32.  */
12365     case EM_LATTICEMICO32:
12366       return reloc_type == 3; /* R_LM32_32.  */
12367     case EM_M32C_OLD:
12368     case EM_M32C:
12369       return reloc_type == 3; /* R_M32C_32.  */
12370     case EM_M32R:
12371       return reloc_type == 34; /* R_M32R_32_RELA.  */
12372     case EM_68HC11:
12373     case EM_68HC12:
12374       return reloc_type == 6; /* R_M68HC11_32.  */
12375     case EM_S12Z:
12376       return reloc_type == 6; /* R_S12Z_EXT32.  */
12377     case EM_MCORE:
12378       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12379     case EM_CYGNUS_MEP:
12380       return reloc_type == 4; /* R_MEP_32.  */
12381     case EM_METAG:
12382       return reloc_type == 2; /* R_METAG_ADDR32.  */
12383     case EM_MICROBLAZE:
12384       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12385     case EM_MIPS:
12386       return reloc_type == 2; /* R_MIPS_32.  */
12387     case EM_MMIX:
12388       return reloc_type == 4; /* R_MMIX_32.  */
12389     case EM_CYGNUS_MN10200:
12390     case EM_MN10200:
12391       return reloc_type == 1; /* R_MN10200_32.  */
12392     case EM_CYGNUS_MN10300:
12393     case EM_MN10300:
12394       return reloc_type == 1; /* R_MN10300_32.  */
12395     case EM_MOXIE:
12396       return reloc_type == 1; /* R_MOXIE_32.  */
12397     case EM_MSP430_OLD:
12398     case EM_MSP430:
12399       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12400     case EM_MT:
12401       return reloc_type == 2; /* R_MT_32.  */
12402     case EM_NDS32:
12403       return reloc_type == 20; /* R_NDS32_RELA.  */
12404     case EM_ALTERA_NIOS2:
12405       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12406     case EM_NIOS32:
12407       return reloc_type == 1; /* R_NIOS_32.  */
12408     case EM_OR1K:
12409       return reloc_type == 1; /* R_OR1K_32.  */
12410     case EM_PARISC:
12411       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12412               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12413               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12414     case EM_PJ:
12415     case EM_PJ_OLD:
12416       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12417     case EM_PPC64:
12418       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12419     case EM_PPC:
12420       return reloc_type == 1; /* R_PPC_ADDR32.  */
12421     case EM_TI_PRU:
12422       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12423     case EM_RISCV:
12424       return reloc_type == 1; /* R_RISCV_32.  */
12425     case EM_RL78:
12426       return reloc_type == 1; /* R_RL78_DIR32.  */
12427     case EM_RX:
12428       return reloc_type == 1; /* R_RX_DIR32.  */
12429     case EM_S370:
12430       return reloc_type == 1; /* R_I370_ADDR31.  */
12431     case EM_S390_OLD:
12432     case EM_S390:
12433       return reloc_type == 4; /* R_S390_32.  */
12434     case EM_SCORE:
12435       return reloc_type == 8; /* R_SCORE_ABS32.  */
12436     case EM_SH:
12437       return reloc_type == 1; /* R_SH_DIR32.  */
12438     case EM_SPARC32PLUS:
12439     case EM_SPARCV9:
12440     case EM_SPARC:
12441       return reloc_type == 3 /* R_SPARC_32.  */
12442         || reloc_type == 23; /* R_SPARC_UA32.  */
12443     case EM_SPU:
12444       return reloc_type == 6; /* R_SPU_ADDR32 */
12445     case EM_TI_C6000:
12446       return reloc_type == 1; /* R_C6000_ABS32.  */
12447     case EM_TILEGX:
12448       return reloc_type == 2; /* R_TILEGX_32.  */
12449     case EM_TILEPRO:
12450       return reloc_type == 1; /* R_TILEPRO_32.  */
12451     case EM_CYGNUS_V850:
12452     case EM_V850:
12453       return reloc_type == 6; /* R_V850_ABS32.  */
12454     case EM_V800:
12455       return reloc_type == 0x33; /* R_V810_WORD.  */
12456     case EM_VAX:
12457       return reloc_type == 1; /* R_VAX_32.  */
12458     case EM_VISIUM:
12459       return reloc_type == 3;  /* R_VISIUM_32. */
12460     case EM_WEBASSEMBLY:
12461       return reloc_type == 1;  /* R_WASM32_32.  */
12462     case EM_X86_64:
12463     case EM_L1OM:
12464     case EM_K1OM:
12465       return reloc_type == 10; /* R_X86_64_32.  */
12466     case EM_XC16X:
12467     case EM_C166:
12468       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12469     case EM_XGATE:
12470       return reloc_type == 4; /* R_XGATE_32.  */
12471     case EM_XSTORMY16:
12472       return reloc_type == 1; /* R_XSTROMY16_32.  */
12473     case EM_XTENSA_OLD:
12474     case EM_XTENSA:
12475       return reloc_type == 1; /* R_XTENSA_32.  */
12476     default:
12477       {
12478         static unsigned int prev_warn = 0;
12479
12480         /* Avoid repeating the same warning multiple times.  */
12481         if (prev_warn != filedata->file_header.e_machine)
12482           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12483                  filedata->file_header.e_machine);
12484         prev_warn = filedata->file_header.e_machine;
12485         return FALSE;
12486       }
12487     }
12488 }
12489
12490 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12491    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12492
12493 static bfd_boolean
12494 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12495 {
12496   switch (filedata->file_header.e_machine)
12497   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12498     {
12499     case EM_386:
12500     case EM_IAMCU:
12501       return reloc_type == 2;  /* R_386_PC32.  */
12502     case EM_68K:
12503       return reloc_type == 4;  /* R_68K_PC32.  */
12504     case EM_AARCH64:
12505       return reloc_type == 261; /* R_AARCH64_PREL32 */
12506     case EM_ADAPTEVA_EPIPHANY:
12507       return reloc_type == 6;
12508     case EM_ALPHA:
12509       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12510     case EM_ARC_COMPACT:
12511     case EM_ARC_COMPACT2:
12512       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12513     case EM_ARM:
12514       return reloc_type == 3;  /* R_ARM_REL32 */
12515     case EM_AVR_OLD:
12516     case EM_AVR:
12517       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12518     case EM_MICROBLAZE:
12519       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12520     case EM_OR1K:
12521       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12522     case EM_PARISC:
12523       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12524     case EM_PPC:
12525       return reloc_type == 26; /* R_PPC_REL32.  */
12526     case EM_PPC64:
12527       return reloc_type == 26; /* R_PPC64_REL32.  */
12528     case EM_S390_OLD:
12529     case EM_S390:
12530       return reloc_type == 5;  /* R_390_PC32.  */
12531     case EM_SH:
12532       return reloc_type == 2;  /* R_SH_REL32.  */
12533     case EM_SPARC32PLUS:
12534     case EM_SPARCV9:
12535     case EM_SPARC:
12536       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12537     case EM_SPU:
12538       return reloc_type == 13; /* R_SPU_REL32.  */
12539     case EM_TILEGX:
12540       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12541     case EM_TILEPRO:
12542       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12543     case EM_VISIUM:
12544       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12545     case EM_X86_64:
12546     case EM_L1OM:
12547     case EM_K1OM:
12548       return reloc_type == 2;  /* R_X86_64_PC32.  */
12549     case EM_XTENSA_OLD:
12550     case EM_XTENSA:
12551       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12552     default:
12553       /* Do not abort or issue an error message here.  Not all targets use
12554          pc-relative 32-bit relocs in their DWARF debug information and we
12555          have already tested for target coverage in is_32bit_abs_reloc.  A
12556          more helpful warning message will be generated by apply_relocations
12557          anyway, so just return.  */
12558       return FALSE;
12559     }
12560 }
12561
12562 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12563    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12564
12565 static bfd_boolean
12566 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12567 {
12568   switch (filedata->file_header.e_machine)
12569     {
12570     case EM_AARCH64:
12571       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12572     case EM_ALPHA:
12573       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12574     case EM_IA_64:
12575       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12576               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12577     case EM_PARISC:
12578       return reloc_type == 80; /* R_PARISC_DIR64.  */
12579     case EM_PPC64:
12580       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12581     case EM_RISCV:
12582       return reloc_type == 2; /* R_RISCV_64.  */
12583     case EM_SPARC32PLUS:
12584     case EM_SPARCV9:
12585     case EM_SPARC:
12586       return reloc_type == 32 /* R_SPARC_64.  */
12587         || reloc_type == 54; /* R_SPARC_UA64.  */
12588     case EM_X86_64:
12589     case EM_L1OM:
12590     case EM_K1OM:
12591       return reloc_type == 1; /* R_X86_64_64.  */
12592     case EM_S390_OLD:
12593     case EM_S390:
12594       return reloc_type == 22;  /* R_S390_64.  */
12595     case EM_TILEGX:
12596       return reloc_type == 1; /* R_TILEGX_64.  */
12597     case EM_MIPS:
12598       return reloc_type == 18;  /* R_MIPS_64.  */
12599     default:
12600       return FALSE;
12601     }
12602 }
12603
12604 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12605    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12606
12607 static bfd_boolean
12608 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12609 {
12610   switch (filedata->file_header.e_machine)
12611     {
12612     case EM_AARCH64:
12613       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12614     case EM_ALPHA:
12615       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12616     case EM_IA_64:
12617       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12618               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12619     case EM_PARISC:
12620       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12621     case EM_PPC64:
12622       return reloc_type == 44; /* R_PPC64_REL64.  */
12623     case EM_SPARC32PLUS:
12624     case EM_SPARCV9:
12625     case EM_SPARC:
12626       return reloc_type == 46; /* R_SPARC_DISP64.  */
12627     case EM_X86_64:
12628     case EM_L1OM:
12629     case EM_K1OM:
12630       return reloc_type == 24; /* R_X86_64_PC64.  */
12631     case EM_S390_OLD:
12632     case EM_S390:
12633       return reloc_type == 23;  /* R_S390_PC64.  */
12634     case EM_TILEGX:
12635       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12636     default:
12637       return FALSE;
12638     }
12639 }
12640
12641 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12642    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12643
12644 static bfd_boolean
12645 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12646 {
12647   switch (filedata->file_header.e_machine)
12648     {
12649     case EM_CYGNUS_MN10200:
12650     case EM_MN10200:
12651       return reloc_type == 4; /* R_MN10200_24.  */
12652     case EM_FT32:
12653       return reloc_type == 5; /* R_FT32_20.  */
12654     default:
12655       return FALSE;
12656     }
12657 }
12658
12659 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12660    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12661
12662 static bfd_boolean
12663 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12664 {
12665   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12666   switch (filedata->file_header.e_machine)
12667     {
12668     case EM_ARC:
12669     case EM_ARC_COMPACT:
12670     case EM_ARC_COMPACT2:
12671       return reloc_type == 2; /* R_ARC_16.  */
12672     case EM_ADAPTEVA_EPIPHANY:
12673       return reloc_type == 5;
12674     case EM_AVR_OLD:
12675     case EM_AVR:
12676       return reloc_type == 4; /* R_AVR_16.  */
12677     case EM_CYGNUS_D10V:
12678     case EM_D10V:
12679       return reloc_type == 3; /* R_D10V_16.  */
12680     case EM_FT32:
12681       return reloc_type == 2; /* R_FT32_16.  */
12682     case EM_H8S:
12683     case EM_H8_300:
12684     case EM_H8_300H:
12685       return reloc_type == R_H8_DIR16;
12686     case EM_IP2K_OLD:
12687     case EM_IP2K:
12688       return reloc_type == 1; /* R_IP2K_16.  */
12689     case EM_M32C_OLD:
12690     case EM_M32C:
12691       return reloc_type == 1; /* R_M32C_16 */
12692     case EM_CYGNUS_MN10200:
12693     case EM_MN10200:
12694       return reloc_type == 2; /* R_MN10200_16.  */
12695     case EM_CYGNUS_MN10300:
12696     case EM_MN10300:
12697       return reloc_type == 2; /* R_MN10300_16.  */
12698     case EM_MSP430:
12699       if (uses_msp430x_relocs (filedata))
12700         return reloc_type == 2; /* R_MSP430_ABS16.  */
12701       /* Fall through.  */
12702     case EM_MSP430_OLD:
12703       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12704     case EM_NDS32:
12705       return reloc_type == 19; /* R_NDS32_RELA.  */
12706     case EM_ALTERA_NIOS2:
12707       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12708     case EM_NIOS32:
12709       return reloc_type == 9; /* R_NIOS_16.  */
12710     case EM_OR1K:
12711       return reloc_type == 2; /* R_OR1K_16.  */
12712     case EM_RISCV:
12713       return reloc_type == 55; /* R_RISCV_SET16.  */
12714     case EM_TI_PRU:
12715       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12716     case EM_TI_C6000:
12717       return reloc_type == 2; /* R_C6000_ABS16.  */
12718     case EM_VISIUM:
12719       return reloc_type == 2; /* R_VISIUM_16. */
12720     case EM_XC16X:
12721     case EM_C166:
12722       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12723     case EM_XGATE:
12724       return reloc_type == 3; /* R_XGATE_16.  */
12725     default:
12726       return FALSE;
12727     }
12728 }
12729
12730 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12731    a 8-bit absolute RELA relocation used in DWARF debug sections.  */
12732
12733 static bfd_boolean
12734 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12735 {
12736   switch (filedata->file_header.e_machine)
12737     {
12738     case EM_RISCV:
12739       return reloc_type == 54; /* R_RISCV_SET8.  */
12740     default:
12741       return FALSE;
12742     }
12743 }
12744
12745 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12746    a 6-bit absolute RELA relocation used in DWARF debug sections.  */
12747
12748 static bfd_boolean
12749 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12750 {
12751   switch (filedata->file_header.e_machine)
12752     {
12753     case EM_RISCV:
12754       return reloc_type == 53; /* R_RISCV_SET6.  */
12755     default:
12756       return FALSE;
12757     }
12758 }
12759
12760 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12761    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12762
12763 static bfd_boolean
12764 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12765 {
12766   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12767   switch (filedata->file_header.e_machine)
12768     {
12769     case EM_RISCV:
12770       return reloc_type == 35; /* R_RISCV_ADD32.  */
12771     default:
12772       return FALSE;
12773     }
12774 }
12775
12776 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12777    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12778
12779 static bfd_boolean
12780 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12781 {
12782   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12783   switch (filedata->file_header.e_machine)
12784     {
12785     case EM_RISCV:
12786       return reloc_type == 39; /* R_RISCV_SUB32.  */
12787     default:
12788       return FALSE;
12789     }
12790 }
12791
12792 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12793    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12794
12795 static bfd_boolean
12796 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12797 {
12798   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12799   switch (filedata->file_header.e_machine)
12800     {
12801     case EM_RISCV:
12802       return reloc_type == 36; /* R_RISCV_ADD64.  */
12803     default:
12804       return FALSE;
12805     }
12806 }
12807
12808 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12809    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12810
12811 static bfd_boolean
12812 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12813 {
12814   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12815   switch (filedata->file_header.e_machine)
12816     {
12817     case EM_RISCV:
12818       return reloc_type == 40; /* R_RISCV_SUB64.  */
12819     default:
12820       return FALSE;
12821     }
12822 }
12823
12824 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12825    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12826
12827 static bfd_boolean
12828 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12829 {
12830   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12831   switch (filedata->file_header.e_machine)
12832     {
12833     case EM_RISCV:
12834       return reloc_type == 34; /* R_RISCV_ADD16.  */
12835     default:
12836       return FALSE;
12837     }
12838 }
12839
12840 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12841    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12842
12843 static bfd_boolean
12844 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12845 {
12846   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12847   switch (filedata->file_header.e_machine)
12848     {
12849     case EM_RISCV:
12850       return reloc_type == 38; /* R_RISCV_SUB16.  */
12851     default:
12852       return FALSE;
12853     }
12854 }
12855
12856 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12857    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12858
12859 static bfd_boolean
12860 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12861 {
12862   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12863   switch (filedata->file_header.e_machine)
12864     {
12865     case EM_RISCV:
12866       return reloc_type == 33; /* R_RISCV_ADD8.  */
12867     default:
12868       return FALSE;
12869     }
12870 }
12871
12872 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12873    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12874
12875 static bfd_boolean
12876 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12877 {
12878   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12879   switch (filedata->file_header.e_machine)
12880     {
12881     case EM_RISCV:
12882       return reloc_type == 37; /* R_RISCV_SUB8.  */
12883     default:
12884       return FALSE;
12885     }
12886 }
12887
12888 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12889    a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
12890
12891 static bfd_boolean
12892 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12893 {
12894   switch (filedata->file_header.e_machine)
12895     {
12896     case EM_RISCV:
12897       return reloc_type == 52; /* R_RISCV_SUB6.  */
12898     default:
12899       return FALSE;
12900     }
12901 }
12902
12903 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12904    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12905
12906 static bfd_boolean
12907 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12908 {
12909   switch (filedata->file_header.e_machine)
12910     {
12911     case EM_386:     /* R_386_NONE.  */
12912     case EM_68K:     /* R_68K_NONE.  */
12913     case EM_ADAPTEVA_EPIPHANY:
12914     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12915     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12916     case EM_ARC:     /* R_ARC_NONE.  */
12917     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12918     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12919     case EM_ARM:     /* R_ARM_NONE.  */
12920     case EM_C166:    /* R_XC16X_NONE.  */
12921     case EM_CRIS:    /* R_CRIS_NONE.  */
12922     case EM_FT32:    /* R_FT32_NONE.  */
12923     case EM_IA_64:   /* R_IA64_NONE.  */
12924     case EM_K1OM:    /* R_X86_64_NONE.  */
12925     case EM_L1OM:    /* R_X86_64_NONE.  */
12926     case EM_M32R:    /* R_M32R_NONE.  */
12927     case EM_MIPS:    /* R_MIPS_NONE.  */
12928     case EM_MN10300: /* R_MN10300_NONE.  */
12929     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12930     case EM_NIOS32:  /* R_NIOS_NONE.  */
12931     case EM_OR1K:    /* R_OR1K_NONE. */
12932     case EM_PARISC:  /* R_PARISC_NONE.  */
12933     case EM_PPC64:   /* R_PPC64_NONE.  */
12934     case EM_PPC:     /* R_PPC_NONE.  */
12935     case EM_RISCV:   /* R_RISCV_NONE.  */
12936     case EM_S390:    /* R_390_NONE.  */
12937     case EM_S390_OLD:
12938     case EM_SH:      /* R_SH_NONE.  */
12939     case EM_SPARC32PLUS:
12940     case EM_SPARC:   /* R_SPARC_NONE.  */
12941     case EM_SPARCV9:
12942     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12943     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12944     case EM_TI_C6000:/* R_C6000_NONE.  */
12945     case EM_X86_64:  /* R_X86_64_NONE.  */
12946     case EM_XC16X:
12947     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12948       return reloc_type == 0;
12949
12950     case EM_AARCH64:
12951       return reloc_type == 0 || reloc_type == 256;
12952     case EM_AVR_OLD:
12953     case EM_AVR:
12954       return (reloc_type == 0 /* R_AVR_NONE.  */
12955               || reloc_type == 30 /* R_AVR_DIFF8.  */
12956               || reloc_type == 31 /* R_AVR_DIFF16.  */
12957               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12958     case EM_METAG:
12959       return reloc_type == 3; /* R_METAG_NONE.  */
12960     case EM_NDS32:
12961       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12962               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12963               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12964               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12965               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12966     case EM_TI_PRU:
12967       return (reloc_type == 0       /* R_PRU_NONE.  */
12968               || reloc_type == 65   /* R_PRU_DIFF8.  */
12969               || reloc_type == 66   /* R_PRU_DIFF16.  */
12970               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12971     case EM_XTENSA_OLD:
12972     case EM_XTENSA:
12973       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12974               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12975               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12976               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12977     }
12978   return FALSE;
12979 }
12980
12981 /* Returns TRUE if there is a relocation against
12982    section NAME at OFFSET bytes.  */
12983
12984 bfd_boolean
12985 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12986 {
12987   Elf_Internal_Rela * relocs;
12988   Elf_Internal_Rela * rp;
12989
12990   if (dsec == NULL || dsec->reloc_info == NULL)
12991     return FALSE;
12992
12993   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12994
12995   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12996     if (rp->r_offset == offset)
12997       return TRUE;
12998
12999    return FALSE;
13000 }
13001
13002 /* Apply relocations to a section.
13003    Returns TRUE upon success, FALSE otherwise.
13004    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13005    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
13006    will be set to the number of relocs loaded.
13007
13008    Note: So far support has been added only for those relocations
13009    which can be found in debug sections. FIXME: Add support for
13010    more relocations ?  */
13011
13012 static bfd_boolean
13013 apply_relocations (Filedata *                 filedata,
13014                    const Elf_Internal_Shdr *  section,
13015                    unsigned char *            start,
13016                    bfd_size_type              size,
13017                    void **                    relocs_return,
13018                    unsigned long *            num_relocs_return)
13019 {
13020   Elf_Internal_Shdr * relsec;
13021   unsigned char * end = start + size;
13022   bfd_boolean res = TRUE;
13023
13024   if (relocs_return != NULL)
13025     {
13026       * (Elf_Internal_Rela **) relocs_return = NULL;
13027       * num_relocs_return = 0;
13028     }
13029
13030   if (filedata->file_header.e_type != ET_REL)
13031     /* No relocs to apply.  */
13032     return TRUE;
13033
13034   /* Find the reloc section associated with the section.  */
13035   for (relsec = filedata->section_headers;
13036        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13037        ++relsec)
13038     {
13039       bfd_boolean is_rela;
13040       unsigned long num_relocs;
13041       Elf_Internal_Rela * relocs;
13042       Elf_Internal_Rela * rp;
13043       Elf_Internal_Shdr * symsec;
13044       Elf_Internal_Sym * symtab;
13045       unsigned long num_syms;
13046       Elf_Internal_Sym * sym;
13047
13048       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13049           || relsec->sh_info >= filedata->file_header.e_shnum
13050           || filedata->section_headers + relsec->sh_info != section
13051           || relsec->sh_size == 0
13052           || relsec->sh_link >= filedata->file_header.e_shnum)
13053         continue;
13054
13055       is_rela = relsec->sh_type == SHT_RELA;
13056
13057       if (is_rela)
13058         {
13059           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13060                                   relsec->sh_size, & relocs, & num_relocs))
13061             return FALSE;
13062         }
13063       else
13064         {
13065           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13066                                  relsec->sh_size, & relocs, & num_relocs))
13067             return FALSE;
13068         }
13069
13070       /* SH uses RELA but uses in place value instead of the addend field.  */
13071       if (filedata->file_header.e_machine == EM_SH)
13072         is_rela = FALSE;
13073
13074       symsec = filedata->section_headers + relsec->sh_link;
13075       if (symsec->sh_type != SHT_SYMTAB
13076           && symsec->sh_type != SHT_DYNSYM)
13077         return FALSE;
13078       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13079
13080       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13081         {
13082           bfd_vma         addend;
13083           unsigned int    reloc_type;
13084           unsigned int    reloc_size;
13085           bfd_boolean     reloc_inplace = FALSE;
13086           bfd_boolean     reloc_subtract = FALSE;
13087           unsigned char * rloc;
13088           unsigned long   sym_index;
13089
13090           reloc_type = get_reloc_type (filedata, rp->r_info);
13091
13092           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13093             continue;
13094           else if (is_none_reloc (filedata, reloc_type))
13095             continue;
13096           else if (is_32bit_abs_reloc (filedata, reloc_type)
13097                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13098             reloc_size = 4;
13099           else if (is_64bit_abs_reloc (filedata, reloc_type)
13100                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13101             reloc_size = 8;
13102           else if (is_24bit_abs_reloc (filedata, reloc_type))
13103             reloc_size = 3;
13104           else if (is_16bit_abs_reloc (filedata, reloc_type))
13105             reloc_size = 2;
13106           else if (is_8bit_abs_reloc (filedata, reloc_type)
13107                    || is_6bit_abs_reloc (filedata, reloc_type))
13108             reloc_size = 1;
13109           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13110                                                                  reloc_type))
13111                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13112             {
13113               reloc_size = 4;
13114               reloc_inplace = TRUE;
13115             }
13116           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13117                                                                  reloc_type))
13118                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13119             {
13120               reloc_size = 8;
13121               reloc_inplace = TRUE;
13122             }
13123           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13124                                                                  reloc_type))
13125                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13126             {
13127               reloc_size = 2;
13128               reloc_inplace = TRUE;
13129             }
13130           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13131                                                                 reloc_type))
13132                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13133             {
13134               reloc_size = 1;
13135               reloc_inplace = TRUE;
13136             }
13137           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13138                                                                 reloc_type)))
13139             {
13140               reloc_size = 1;
13141               reloc_inplace = TRUE;
13142             }
13143           else
13144             {
13145               static unsigned int prev_reloc = 0;
13146
13147               if (reloc_type != prev_reloc)
13148                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13149                       reloc_type, printable_section_name (filedata, section));
13150               prev_reloc = reloc_type;
13151               res = FALSE;
13152               continue;
13153             }
13154
13155           rloc = start + rp->r_offset;
13156           if ((rloc + reloc_size) > end || (rloc < start))
13157             {
13158               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13159                     (unsigned long) rp->r_offset,
13160                     printable_section_name (filedata, section));
13161               res = FALSE;
13162               continue;
13163             }
13164
13165           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13166           if (sym_index >= num_syms)
13167             {
13168               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13169                     sym_index, printable_section_name (filedata, section));
13170               res = FALSE;
13171               continue;
13172             }
13173           sym = symtab + sym_index;
13174
13175           /* If the reloc has a symbol associated with it,
13176              make sure that it is of an appropriate type.
13177
13178              Relocations against symbols without type can happen.
13179              Gcc -feliminate-dwarf2-dups may generate symbols
13180              without type for debug info.
13181
13182              Icc generates relocations against function symbols
13183              instead of local labels.
13184
13185              Relocations against object symbols can happen, eg when
13186              referencing a global array.  For an example of this see
13187              the _clz.o binary in libgcc.a.  */
13188           if (sym != symtab
13189               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13190               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13191             {
13192               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13193                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13194                     printable_section_name (filedata, relsec),
13195                     (long int)(rp - relocs));
13196               res = FALSE;
13197               continue;
13198             }
13199
13200           addend = 0;
13201           if (is_rela)
13202             addend += rp->r_addend;
13203           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13204              partial_inplace.  */
13205           if (!is_rela
13206               || (filedata->file_header.e_machine == EM_XTENSA
13207                   && reloc_type == 1)
13208               || ((filedata->file_header.e_machine == EM_PJ
13209                    || filedata->file_header.e_machine == EM_PJ_OLD)
13210                   && reloc_type == 1)
13211               || ((filedata->file_header.e_machine == EM_D30V
13212                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13213                   && reloc_type == 12)
13214               || reloc_inplace)
13215             {
13216               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13217                 addend += byte_get (rloc, reloc_size) & 0x3f;
13218               else
13219                 addend += byte_get (rloc, reloc_size);
13220             }
13221
13222           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13223               || is_64bit_pcrel_reloc (filedata, reloc_type))
13224             {
13225               /* On HPPA, all pc-relative relocations are biased by 8.  */
13226               if (filedata->file_header.e_machine == EM_PARISC)
13227                 addend -= 8;
13228               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13229                         reloc_size);
13230             }
13231           else if (is_6bit_abs_reloc (filedata, reloc_type)
13232                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13233             {
13234               if (reloc_subtract)
13235                 addend -= sym->st_value;
13236               else
13237                 addend += sym->st_value;
13238               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13239               byte_put (rloc, addend, reloc_size);
13240             }
13241           else if (reloc_subtract)
13242             byte_put (rloc, addend - sym->st_value, reloc_size);
13243           else
13244             byte_put (rloc, addend + sym->st_value, reloc_size);
13245         }
13246
13247       free (symtab);
13248       /* Let the target specific reloc processing code know that
13249          we have finished with these relocs.  */
13250       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13251
13252       if (relocs_return)
13253         {
13254           * (Elf_Internal_Rela **) relocs_return = relocs;
13255           * num_relocs_return = num_relocs;
13256         }
13257       else
13258         free (relocs);
13259
13260       break;
13261     }
13262
13263   return res;
13264 }
13265
13266 #ifdef SUPPORT_DISASSEMBLY
13267 static bfd_boolean
13268 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13269 {
13270   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13271
13272   /* FIXME: XXX -- to be done --- XXX */
13273
13274   return TRUE;
13275 }
13276 #endif
13277
13278 /* Reads in the contents of SECTION from FILE, returning a pointer
13279    to a malloc'ed buffer or NULL if something went wrong.  */
13280
13281 static char *
13282 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13283 {
13284   bfd_size_type num_bytes = section->sh_size;
13285
13286   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13287     {
13288       printf (_("Section '%s' has no data to dump.\n"),
13289               printable_section_name (filedata, section));
13290       return NULL;
13291     }
13292
13293   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13294                              _("section contents"));
13295 }
13296
13297 /* Uncompresses a section that was compressed using zlib, in place.  */
13298
13299 static bfd_boolean
13300 uncompress_section_contents (unsigned char **   buffer,
13301                              dwarf_size_type    uncompressed_size,
13302                              dwarf_size_type *  size)
13303 {
13304   dwarf_size_type compressed_size = *size;
13305   unsigned char * compressed_buffer = *buffer;
13306   unsigned char * uncompressed_buffer;
13307   z_stream strm;
13308   int rc;
13309
13310   /* It is possible the section consists of several compressed
13311      buffers concatenated together, so we uncompress in a loop.  */
13312   /* PR 18313: The state field in the z_stream structure is supposed
13313      to be invisible to the user (ie us), but some compilers will
13314      still complain about it being used without initialisation.  So
13315      we first zero the entire z_stream structure and then set the fields
13316      that we need.  */
13317   memset (& strm, 0, sizeof strm);
13318   strm.avail_in = compressed_size;
13319   strm.next_in = (Bytef *) compressed_buffer;
13320   strm.avail_out = uncompressed_size;
13321   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13322
13323   rc = inflateInit (& strm);
13324   while (strm.avail_in > 0)
13325     {
13326       if (rc != Z_OK)
13327         goto fail;
13328       strm.next_out = ((Bytef *) uncompressed_buffer
13329                        + (uncompressed_size - strm.avail_out));
13330       rc = inflate (&strm, Z_FINISH);
13331       if (rc != Z_STREAM_END)
13332         goto fail;
13333       rc = inflateReset (& strm);
13334     }
13335   rc = inflateEnd (& strm);
13336   if (rc != Z_OK
13337       || strm.avail_out != 0)
13338     goto fail;
13339
13340   *buffer = uncompressed_buffer;
13341   *size = uncompressed_size;
13342   return TRUE;
13343
13344  fail:
13345   free (uncompressed_buffer);
13346   /* Indicate decompression failure.  */
13347   *buffer = NULL;
13348   return FALSE;
13349 }
13350
13351 static bfd_boolean
13352 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13353 {
13354   Elf_Internal_Shdr *  relsec;
13355   bfd_size_type        num_bytes;
13356   unsigned char *      data;
13357   unsigned char *      end;
13358   unsigned char *      real_start;
13359   unsigned char *      start;
13360   bfd_boolean          some_strings_shown;
13361
13362   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13363   if (start == NULL)
13364     /* PR 21820: Do not fail if the section was empty.  */
13365     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13366
13367   num_bytes = section->sh_size;
13368
13369   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13370
13371   if (decompress_dumps)
13372     {
13373       dwarf_size_type new_size = num_bytes;
13374       dwarf_size_type uncompressed_size = 0;
13375
13376       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13377         {
13378           Elf_Internal_Chdr chdr;
13379           unsigned int compression_header_size
13380             = get_compression_header (& chdr, (unsigned char *) start,
13381                                       num_bytes);
13382
13383           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13384             {
13385               warn (_("section '%s' has unsupported compress type: %d\n"),
13386                     printable_section_name (filedata, section), chdr.ch_type);
13387               return FALSE;
13388             }
13389           else if (chdr.ch_addralign != section->sh_addralign)
13390             {
13391               warn (_("compressed section '%s' is corrupted\n"),
13392                     printable_section_name (filedata, section));
13393               return FALSE;
13394             }
13395           uncompressed_size = chdr.ch_size;
13396           start += compression_header_size;
13397           new_size -= compression_header_size;
13398         }
13399       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13400         {
13401           /* Read the zlib header.  In this case, it should be "ZLIB"
13402              followed by the uncompressed section size, 8 bytes in
13403              big-endian order.  */
13404           uncompressed_size = start[4]; uncompressed_size <<= 8;
13405           uncompressed_size += start[5]; uncompressed_size <<= 8;
13406           uncompressed_size += start[6]; uncompressed_size <<= 8;
13407           uncompressed_size += start[7]; uncompressed_size <<= 8;
13408           uncompressed_size += start[8]; uncompressed_size <<= 8;
13409           uncompressed_size += start[9]; uncompressed_size <<= 8;
13410           uncompressed_size += start[10]; uncompressed_size <<= 8;
13411           uncompressed_size += start[11];
13412           start += 12;
13413           new_size -= 12;
13414         }
13415
13416       if (uncompressed_size)
13417         {
13418           if (uncompress_section_contents (& start,
13419                                            uncompressed_size, & new_size))
13420             num_bytes = new_size;
13421           else
13422             {
13423               error (_("Unable to decompress section %s\n"),
13424                      printable_section_name (filedata, section));
13425               return FALSE;
13426             }
13427         }
13428       else
13429         start = real_start;
13430     }
13431
13432   /* If the section being dumped has relocations against it the user might
13433      be expecting these relocations to have been applied.  Check for this
13434      case and issue a warning message in order to avoid confusion.
13435      FIXME: Maybe we ought to have an option that dumps a section with
13436      relocs applied ?  */
13437   for (relsec = filedata->section_headers;
13438        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13439        ++relsec)
13440     {
13441       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13442           || relsec->sh_info >= filedata->file_header.e_shnum
13443           || filedata->section_headers + relsec->sh_info != section
13444           || relsec->sh_size == 0
13445           || relsec->sh_link >= filedata->file_header.e_shnum)
13446         continue;
13447
13448       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13449       break;
13450     }
13451
13452   data = start;
13453   end  = start + num_bytes;
13454   some_strings_shown = FALSE;
13455
13456   while (data < end)
13457     {
13458       while (!ISPRINT (* data))
13459         if (++ data >= end)
13460           break;
13461
13462       if (data < end)
13463         {
13464           size_t maxlen = end - data;
13465
13466 #ifndef __MSVCRT__
13467           /* PR 11128: Use two separate invocations in order to work
13468              around bugs in the Solaris 8 implementation of printf.  */
13469           printf ("  [%6tx]  ", data - start);
13470 #else
13471           printf ("  [%6Ix]  ", (size_t) (data - start));
13472 #endif
13473           if (maxlen > 0)
13474             {
13475               print_symbol ((int) maxlen, (const char *) data);
13476               putchar ('\n');
13477               data += strnlen ((const char *) data, maxlen);
13478             }
13479           else
13480             {
13481               printf (_("<corrupt>\n"));
13482               data = end;
13483             }
13484           some_strings_shown = TRUE;
13485         }
13486     }
13487
13488   if (! some_strings_shown)
13489     printf (_("  No strings found in this section."));
13490
13491   free (real_start);
13492
13493   putchar ('\n');
13494   return TRUE;
13495 }
13496
13497 static bfd_boolean
13498 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13499                        Filedata *           filedata,
13500                        bfd_boolean          relocate)
13501 {
13502   Elf_Internal_Shdr * relsec;
13503   bfd_size_type       bytes;
13504   bfd_size_type       section_size;
13505   bfd_vma             addr;
13506   unsigned char *     data;
13507   unsigned char *     real_start;
13508   unsigned char *     start;
13509
13510   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13511   if (start == NULL)
13512     /* PR 21820: Do not fail if the section was empty.  */
13513     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13514
13515   section_size = section->sh_size;
13516
13517   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13518
13519   if (decompress_dumps)
13520     {
13521       dwarf_size_type new_size = section_size;
13522       dwarf_size_type uncompressed_size = 0;
13523
13524       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13525         {
13526           Elf_Internal_Chdr chdr;
13527           unsigned int compression_header_size
13528             = get_compression_header (& chdr, start, section_size);
13529
13530           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13531             {
13532               warn (_("section '%s' has unsupported compress type: %d\n"),
13533                     printable_section_name (filedata, section), chdr.ch_type);
13534               return FALSE;
13535             }
13536           else if (chdr.ch_addralign != section->sh_addralign)
13537             {
13538               warn (_("compressed section '%s' is corrupted\n"),
13539                     printable_section_name (filedata, section));
13540               return FALSE;
13541             }
13542           uncompressed_size = chdr.ch_size;
13543           start += compression_header_size;
13544           new_size -= compression_header_size;
13545         }
13546       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13547         {
13548           /* Read the zlib header.  In this case, it should be "ZLIB"
13549              followed by the uncompressed section size, 8 bytes in
13550              big-endian order.  */
13551           uncompressed_size = start[4]; uncompressed_size <<= 8;
13552           uncompressed_size += start[5]; uncompressed_size <<= 8;
13553           uncompressed_size += start[6]; uncompressed_size <<= 8;
13554           uncompressed_size += start[7]; uncompressed_size <<= 8;
13555           uncompressed_size += start[8]; uncompressed_size <<= 8;
13556           uncompressed_size += start[9]; uncompressed_size <<= 8;
13557           uncompressed_size += start[10]; uncompressed_size <<= 8;
13558           uncompressed_size += start[11];
13559           start += 12;
13560           new_size -= 12;
13561         }
13562
13563       if (uncompressed_size)
13564         {
13565           if (uncompress_section_contents (& start, uncompressed_size,
13566                                            & new_size))
13567             {
13568               section_size = new_size;
13569             }
13570           else
13571             {
13572               error (_("Unable to decompress section %s\n"),
13573                      printable_section_name (filedata, section));
13574               /* FIXME: Print the section anyway ?  */
13575               return FALSE;
13576             }
13577         }
13578       else
13579         start = real_start;
13580     }
13581
13582   if (relocate)
13583     {
13584       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13585         return FALSE;
13586     }
13587   else
13588     {
13589       /* If the section being dumped has relocations against it the user might
13590          be expecting these relocations to have been applied.  Check for this
13591          case and issue a warning message in order to avoid confusion.
13592          FIXME: Maybe we ought to have an option that dumps a section with
13593          relocs applied ?  */
13594       for (relsec = filedata->section_headers;
13595            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13596            ++relsec)
13597         {
13598           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13599               || relsec->sh_info >= filedata->file_header.e_shnum
13600               || filedata->section_headers + relsec->sh_info != section
13601               || relsec->sh_size == 0
13602               || relsec->sh_link >= filedata->file_header.e_shnum)
13603             continue;
13604
13605           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13606           break;
13607         }
13608     }
13609
13610   addr = section->sh_addr;
13611   bytes = section_size;
13612   data = start;
13613
13614   while (bytes)
13615     {
13616       int j;
13617       int k;
13618       int lbytes;
13619
13620       lbytes = (bytes > 16 ? 16 : bytes);
13621
13622       printf ("  0x%8.8lx ", (unsigned long) addr);
13623
13624       for (j = 0; j < 16; j++)
13625         {
13626           if (j < lbytes)
13627             printf ("%2.2x", data[j]);
13628           else
13629             printf ("  ");
13630
13631           if ((j & 3) == 3)
13632             printf (" ");
13633         }
13634
13635       for (j = 0; j < lbytes; j++)
13636         {
13637           k = data[j];
13638           if (k >= ' ' && k < 0x7f)
13639             printf ("%c", k);
13640           else
13641             printf (".");
13642         }
13643
13644       putchar ('\n');
13645
13646       data  += lbytes;
13647       addr  += lbytes;
13648       bytes -= lbytes;
13649     }
13650
13651   free (real_start);
13652
13653   putchar ('\n');
13654   return TRUE;
13655 }
13656
13657 static bfd_boolean
13658 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13659                              const Elf_Internal_Shdr *        sec,
13660                              void *                           data)
13661 {
13662   struct dwarf_section * section = &debug_displays [debug].section;
13663   char buf [64];
13664   Filedata * filedata = (Filedata *) data;
13665
13666   if (section->start != NULL)
13667     {
13668       /* If it is already loaded, do nothing.  */
13669       if (streq (section->filename, filedata->file_name))
13670         return TRUE;
13671       free (section->start);
13672     }
13673
13674   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13675   section->address = sec->sh_addr;
13676   section->user_data = NULL;
13677   section->filename = filedata->file_name;
13678   section->start = (unsigned char *) get_data (NULL, filedata,
13679                                                sec->sh_offset, 1,
13680                                                sec->sh_size, buf);
13681   if (section->start == NULL)
13682     section->size = 0;
13683   else
13684     {
13685       unsigned char *start = section->start;
13686       dwarf_size_type size = sec->sh_size;
13687       dwarf_size_type uncompressed_size = 0;
13688
13689       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13690         {
13691           Elf_Internal_Chdr chdr;
13692           unsigned int compression_header_size;
13693
13694           if (size < (is_32bit_elf
13695                       ? sizeof (Elf32_External_Chdr)
13696                       : sizeof (Elf64_External_Chdr)))
13697             {
13698               warn (_("compressed section %s is too small to contain a compression header"),
13699                     section->name);
13700               return FALSE;
13701             }
13702
13703           compression_header_size = get_compression_header (&chdr, start, size);
13704
13705           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13706             {
13707               warn (_("section '%s' has unsupported compress type: %d\n"),
13708                     section->name, chdr.ch_type);
13709               return FALSE;
13710             }
13711           else if (chdr.ch_addralign != sec->sh_addralign)
13712             {
13713               warn (_("compressed section '%s' is corrupted\n"),
13714                     section->name);
13715               return FALSE;
13716             }
13717           uncompressed_size = chdr.ch_size;
13718           start += compression_header_size;
13719           size -= compression_header_size;
13720         }
13721       else if (size > 12 && streq ((char *) start, "ZLIB"))
13722         {
13723           /* Read the zlib header.  In this case, it should be "ZLIB"
13724              followed by the uncompressed section size, 8 bytes in
13725              big-endian order.  */
13726           uncompressed_size = start[4]; uncompressed_size <<= 8;
13727           uncompressed_size += start[5]; uncompressed_size <<= 8;
13728           uncompressed_size += start[6]; uncompressed_size <<= 8;
13729           uncompressed_size += start[7]; uncompressed_size <<= 8;
13730           uncompressed_size += start[8]; uncompressed_size <<= 8;
13731           uncompressed_size += start[9]; uncompressed_size <<= 8;
13732           uncompressed_size += start[10]; uncompressed_size <<= 8;
13733           uncompressed_size += start[11];
13734           start += 12;
13735           size -= 12;
13736         }
13737
13738       if (uncompressed_size)
13739         {
13740           if (uncompress_section_contents (&start, uncompressed_size,
13741                                            &size))
13742             {
13743               /* Free the compressed buffer, update the section buffer
13744                  and the section size if uncompress is successful.  */
13745               free (section->start);
13746               section->start = start;
13747             }
13748           else
13749             {
13750               error (_("Unable to decompress section %s\n"),
13751                      printable_section_name (filedata, sec));
13752               return FALSE;
13753             }
13754         }
13755
13756       section->size = size;
13757     }
13758
13759   if (section->start == NULL)
13760     return FALSE;
13761
13762   if (debug_displays [debug].relocate)
13763     {
13764       if (! apply_relocations (filedata, sec, section->start, section->size,
13765                                & section->reloc_info, & section->num_relocs))
13766         return FALSE;
13767     }
13768   else
13769     {
13770       section->reloc_info = NULL;
13771       section->num_relocs = 0;
13772     }
13773
13774   return TRUE;
13775 }
13776
13777 /* If this is not NULL, load_debug_section will only look for sections
13778    within the list of sections given here.  */
13779 static unsigned int * section_subset = NULL;
13780
13781 bfd_boolean
13782 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13783 {
13784   struct dwarf_section * section = &debug_displays [debug].section;
13785   Elf_Internal_Shdr * sec;
13786   Filedata * filedata = (Filedata *) data;
13787
13788   /* Without section headers we cannot find any sections.  */
13789   if (filedata->section_headers == NULL)
13790     return FALSE;
13791
13792   if (filedata->string_table == NULL
13793       && filedata->file_header.e_shstrndx != SHN_UNDEF
13794       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13795     {
13796       Elf_Internal_Shdr * strs;
13797
13798       /* Read in the string table, so that we have section names to scan.  */
13799       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13800
13801       if (strs != NULL && strs->sh_size != 0)
13802         {
13803           filedata->string_table
13804             = (char *) get_data (NULL, filedata, strs->sh_offset,
13805                                  1, strs->sh_size, _("string table"));
13806
13807           filedata->string_table_length
13808             = filedata->string_table != NULL ? strs->sh_size : 0;
13809         }
13810     }
13811
13812   /* Locate the debug section.  */
13813   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13814   if (sec != NULL)
13815     section->name = section->uncompressed_name;
13816   else
13817     {
13818       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13819       if (sec != NULL)
13820         section->name = section->compressed_name;
13821     }
13822   if (sec == NULL)
13823     return FALSE;
13824
13825   /* If we're loading from a subset of sections, and we've loaded
13826      a section matching this name before, it's likely that it's a
13827      different one.  */
13828   if (section_subset != NULL)
13829     free_debug_section (debug);
13830
13831   return load_specific_debug_section (debug, sec, data);
13832 }
13833
13834 void
13835 free_debug_section (enum dwarf_section_display_enum debug)
13836 {
13837   struct dwarf_section * section = &debug_displays [debug].section;
13838
13839   if (section->start == NULL)
13840     return;
13841
13842   free ((char *) section->start);
13843   section->start = NULL;
13844   section->address = 0;
13845   section->size = 0;
13846 }
13847
13848 static bfd_boolean
13849 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13850 {
13851   char * name = SECTION_NAME (section);
13852   const char * print_name = printable_section_name (filedata, section);
13853   bfd_size_type length;
13854   bfd_boolean result = TRUE;
13855   int i;
13856
13857   length = section->sh_size;
13858   if (length == 0)
13859     {
13860       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13861       return TRUE;
13862     }
13863   if (section->sh_type == SHT_NOBITS)
13864     {
13865       /* There is no point in dumping the contents of a debugging section
13866          which has the NOBITS type - the bits in the file will be random.
13867          This can happen when a file containing a .eh_frame section is
13868          stripped with the --only-keep-debug command line option.  */
13869       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13870               print_name);
13871       return FALSE;
13872     }
13873
13874   if (const_strneq (name, ".gnu.linkonce.wi."))
13875     name = ".debug_info";
13876
13877   /* See if we know how to display the contents of this section.  */
13878   for (i = 0; i < max; i++)
13879     {
13880       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13881       struct dwarf_section_display *   display = debug_displays + i;
13882       struct dwarf_section *           sec = & display->section;
13883
13884       if (streq (sec->uncompressed_name, name)
13885           || (id == line && const_strneq (name, ".debug_line."))
13886           || streq (sec->compressed_name, name))
13887         {
13888           bfd_boolean secondary = (section != find_section (filedata, name));
13889
13890           if (secondary)
13891             free_debug_section (id);
13892
13893           if (i == line && const_strneq (name, ".debug_line."))
13894             sec->name = name;
13895           else if (streq (sec->uncompressed_name, name))
13896             sec->name = sec->uncompressed_name;
13897           else
13898             sec->name = sec->compressed_name;
13899
13900           if (load_specific_debug_section (id, section, filedata))
13901             {
13902               /* If this debug section is part of a CU/TU set in a .dwp file,
13903                  restrict load_debug_section to the sections in that set.  */
13904               section_subset = find_cu_tu_set (filedata, shndx);
13905
13906               result &= display->display (sec, filedata);
13907
13908               section_subset = NULL;
13909
13910               if (secondary || (id != info && id != abbrev))
13911                 free_debug_section (id);
13912             }
13913           break;
13914         }
13915     }
13916
13917   if (i == max)
13918     {
13919       printf (_("Unrecognized debug section: %s\n"), print_name);
13920       result = FALSE;
13921     }
13922
13923   return result;
13924 }
13925
13926 /* Set DUMP_SECTS for all sections where dumps were requested
13927    based on section name.  */
13928
13929 static void
13930 initialise_dumps_byname (Filedata * filedata)
13931 {
13932   struct dump_list_entry * cur;
13933
13934   for (cur = dump_sects_byname; cur; cur = cur->next)
13935     {
13936       unsigned int i;
13937       bfd_boolean any = FALSE;
13938
13939       for (i = 0; i < filedata->file_header.e_shnum; i++)
13940         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13941           {
13942             request_dump_bynumber (filedata, i, cur->type);
13943             any = TRUE;
13944           }
13945
13946       if (!any)
13947         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13948               cur->name);
13949     }
13950 }
13951
13952 static bfd_boolean
13953 process_section_contents (Filedata * filedata)
13954 {
13955   Elf_Internal_Shdr * section;
13956   unsigned int i;
13957   bfd_boolean res = TRUE;
13958
13959   if (! do_dump)
13960     return TRUE;
13961
13962   initialise_dumps_byname (filedata);
13963
13964   for (i = 0, section = filedata->section_headers;
13965        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13966        i++, section++)
13967     {
13968       dump_type dump = filedata->dump_sects[i];
13969
13970 #ifdef SUPPORT_DISASSEMBLY
13971       if (dump & DISASS_DUMP)
13972         {
13973           if (! disassemble_section (section, filedata))
13974             res = FALSE;
13975         }
13976 #endif
13977       if (dump & HEX_DUMP)
13978         {
13979           if (! dump_section_as_bytes (section, filedata, FALSE))
13980             res = FALSE;
13981         }
13982
13983       if (dump & RELOC_DUMP)
13984         {
13985           if (! dump_section_as_bytes (section, filedata, TRUE))
13986             res = FALSE;
13987         }
13988
13989       if (dump & STRING_DUMP)
13990         {
13991           if (! dump_section_as_strings (section, filedata))
13992             res = FALSE;
13993         }
13994
13995       if (dump & DEBUG_DUMP)
13996         {
13997           if (! display_debug_section (i, section, filedata))
13998             res = FALSE;
13999         }
14000     }
14001
14002   /* Check to see if the user requested a
14003      dump of a section that does not exist.  */
14004   while (i < filedata->num_dump_sects)
14005     {
14006       if (filedata->dump_sects[i])
14007         {
14008           warn (_("Section %d was not dumped because it does not exist!\n"), i);
14009           res = FALSE;
14010         }
14011       i++;
14012     }
14013
14014   return res;
14015 }
14016
14017 static void
14018 process_mips_fpe_exception (int mask)
14019 {
14020   if (mask)
14021     {
14022       bfd_boolean first = TRUE;
14023
14024       if (mask & OEX_FPU_INEX)
14025         fputs ("INEX", stdout), first = FALSE;
14026       if (mask & OEX_FPU_UFLO)
14027         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14028       if (mask & OEX_FPU_OFLO)
14029         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14030       if (mask & OEX_FPU_DIV0)
14031         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14032       if (mask & OEX_FPU_INVAL)
14033         printf ("%sINVAL", first ? "" : "|");
14034     }
14035   else
14036     fputs ("0", stdout);
14037 }
14038
14039 /* Display's the value of TAG at location P.  If TAG is
14040    greater than 0 it is assumed to be an unknown tag, and
14041    a message is printed to this effect.  Otherwise it is
14042    assumed that a message has already been printed.
14043
14044    If the bottom bit of TAG is set it assumed to have a
14045    string value, otherwise it is assumed to have an integer
14046    value.
14047
14048    Returns an updated P pointing to the first unread byte
14049    beyond the end of TAG's value.
14050
14051    Reads at or beyond END will not be made.  */
14052
14053 static unsigned char *
14054 display_tag_value (signed int tag,
14055                    unsigned char * p,
14056                    const unsigned char * const end)
14057 {
14058   unsigned long val;
14059
14060   if (tag > 0)
14061     printf ("  Tag_unknown_%d: ", tag);
14062
14063   if (p >= end)
14064     {
14065       warn (_("<corrupt tag>\n"));
14066     }
14067   else if (tag & 1)
14068     {
14069       /* PR 17531 file: 027-19978-0.004.  */
14070       size_t maxlen = (end - p) - 1;
14071
14072       putchar ('"');
14073       if (maxlen > 0)
14074         {
14075           print_symbol ((int) maxlen, (const char *) p);
14076           p += strnlen ((char *) p, maxlen) + 1;
14077         }
14078       else
14079         {
14080           printf (_("<corrupt string tag>"));
14081           p = (unsigned char *) end;
14082         }
14083       printf ("\"\n");
14084     }
14085   else
14086     {
14087       unsigned int len;
14088
14089       val = read_uleb128 (p, &len, end);
14090       p += len;
14091       printf ("%ld (0x%lx)\n", val, val);
14092     }
14093
14094   assert (p <= end);
14095   return p;
14096 }
14097
14098 /* ARC ABI attributes section.  */
14099
14100 static unsigned char *
14101 display_arc_attribute (unsigned char * p,
14102                        const unsigned char * const end)
14103 {
14104   unsigned int tag;
14105   unsigned int len;
14106   unsigned int val;
14107
14108   tag = read_uleb128 (p, &len, end);
14109   p += len;
14110
14111   switch (tag)
14112     {
14113     case Tag_ARC_PCS_config:
14114       val = read_uleb128 (p, &len, end);
14115       p += len;
14116       printf ("  Tag_ARC_PCS_config: ");
14117       switch (val)
14118         {
14119         case 0:
14120           printf (_("Absent/Non standard\n"));
14121           break;
14122         case 1:
14123           printf (_("Bare metal/mwdt\n"));
14124           break;
14125         case 2:
14126           printf (_("Bare metal/newlib\n"));
14127           break;
14128         case 3:
14129           printf (_("Linux/uclibc\n"));
14130           break;
14131         case 4:
14132           printf (_("Linux/glibc\n"));
14133           break;
14134         default:
14135           printf (_("Unknown\n"));
14136           break;
14137         }
14138       break;
14139
14140     case Tag_ARC_CPU_base:
14141       val = read_uleb128 (p, &len, end);
14142       p += len;
14143       printf ("  Tag_ARC_CPU_base: ");
14144       switch (val)
14145         {
14146         default:
14147         case TAG_CPU_NONE:
14148           printf (_("Absent\n"));
14149           break;
14150         case TAG_CPU_ARC6xx:
14151           printf ("ARC6xx\n");
14152           break;
14153         case TAG_CPU_ARC7xx:
14154           printf ("ARC7xx\n");
14155           break;
14156         case TAG_CPU_ARCEM:
14157           printf ("ARCEM\n");
14158           break;
14159         case TAG_CPU_ARCHS:
14160           printf ("ARCHS\n");
14161           break;
14162         }
14163       break;
14164
14165     case Tag_ARC_CPU_variation:
14166       val = read_uleb128 (p, &len, end);
14167       p += len;
14168       printf ("  Tag_ARC_CPU_variation: ");
14169       switch (val)
14170         {
14171         default:
14172           if (val > 0 && val < 16)
14173               printf ("Core%d\n", val);
14174           else
14175               printf ("Unknown\n");
14176           break;
14177
14178         case 0:
14179           printf (_("Absent\n"));
14180           break;
14181         }
14182       break;
14183
14184     case Tag_ARC_CPU_name:
14185       printf ("  Tag_ARC_CPU_name: ");
14186       p = display_tag_value (-1, p, end);
14187       break;
14188
14189     case Tag_ARC_ABI_rf16:
14190       val = read_uleb128 (p, &len, end);
14191       p += len;
14192       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14193       break;
14194
14195     case Tag_ARC_ABI_osver:
14196       val = read_uleb128 (p, &len, end);
14197       p += len;
14198       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14199       break;
14200
14201     case Tag_ARC_ABI_pic:
14202     case Tag_ARC_ABI_sda:
14203       val = read_uleb128 (p, &len, end);
14204       p += len;
14205       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14206               : "  Tag_ARC_ABI_pic: ");
14207       switch (val)
14208         {
14209         case 0:
14210           printf (_("Absent\n"));
14211           break;
14212         case 1:
14213           printf ("MWDT\n");
14214           break;
14215         case 2:
14216           printf ("GNU\n");
14217           break;
14218         default:
14219           printf (_("Unknown\n"));
14220           break;
14221         }
14222       break;
14223
14224     case Tag_ARC_ABI_tls:
14225       val = read_uleb128 (p, &len, end);
14226       p += len;
14227       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14228       break;
14229
14230     case Tag_ARC_ABI_enumsize:
14231       val = read_uleb128 (p, &len, end);
14232       p += len;
14233       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14234               _("smallest"));
14235       break;
14236
14237     case Tag_ARC_ABI_exceptions:
14238       val = read_uleb128 (p, &len, end);
14239       p += len;
14240       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14241               : _("default"));
14242       break;
14243
14244     case Tag_ARC_ABI_double_size:
14245       val = read_uleb128 (p, &len, end);
14246       p += len;
14247       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14248       break;
14249
14250     case Tag_ARC_ISA_config:
14251       printf ("  Tag_ARC_ISA_config: ");
14252       p = display_tag_value (-1, p, end);
14253       break;
14254
14255     case Tag_ARC_ISA_apex:
14256       printf ("  Tag_ARC_ISA_apex: ");
14257       p = display_tag_value (-1, p, end);
14258       break;
14259
14260     case Tag_ARC_ISA_mpy_option:
14261       val = read_uleb128 (p, &len, end);
14262       p += len;
14263       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14264       break;
14265
14266     case Tag_ARC_ATR_version:
14267       val = read_uleb128 (p, &len, end);
14268       p += len;
14269       printf ("  Tag_ARC_ATR_version: %d\n", val);
14270       break;
14271
14272     default:
14273       return display_tag_value (tag & 1, p, end);
14274     }
14275
14276   return p;
14277 }
14278
14279 /* ARM EABI attributes section.  */
14280 typedef struct
14281 {
14282   unsigned int tag;
14283   const char * name;
14284   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14285   unsigned int type;
14286   const char ** table;
14287 } arm_attr_public_tag;
14288
14289 static const char * arm_attr_tag_CPU_arch[] =
14290   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14291    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14292    "v8-M.mainline"};
14293 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14294 static const char * arm_attr_tag_THUMB_ISA_use[] =
14295   {"No", "Thumb-1", "Thumb-2", "Yes"};
14296 static const char * arm_attr_tag_FP_arch[] =
14297   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14298    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14299 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14300 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14301   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14302    "NEON for ARMv8.1"};
14303 static const char * arm_attr_tag_PCS_config[] =
14304   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14305    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14306 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14307   {"V6", "SB", "TLS", "Unused"};
14308 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14309   {"Absolute", "PC-relative", "SB-relative", "None"};
14310 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14311   {"Absolute", "PC-relative", "None"};
14312 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14313   {"None", "direct", "GOT-indirect"};
14314 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14315   {"None", "??? 1", "2", "??? 3", "4"};
14316 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14317 static const char * arm_attr_tag_ABI_FP_denormal[] =
14318   {"Unused", "Needed", "Sign only"};
14319 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14320 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14321 static const char * arm_attr_tag_ABI_FP_number_model[] =
14322   {"Unused", "Finite", "RTABI", "IEEE 754"};
14323 static const char * arm_attr_tag_ABI_enum_size[] =
14324   {"Unused", "small", "int", "forced to int"};
14325 static const char * arm_attr_tag_ABI_HardFP_use[] =
14326   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14327 static const char * arm_attr_tag_ABI_VFP_args[] =
14328   {"AAPCS", "VFP registers", "custom", "compatible"};
14329 static const char * arm_attr_tag_ABI_WMMX_args[] =
14330   {"AAPCS", "WMMX registers", "custom"};
14331 static const char * arm_attr_tag_ABI_optimization_goals[] =
14332   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14333     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14334 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14335   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14336     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14337 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14338 static const char * arm_attr_tag_FP_HP_extension[] =
14339   {"Not Allowed", "Allowed"};
14340 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14341   {"None", "IEEE 754", "Alternative Format"};
14342 static const char * arm_attr_tag_DSP_extension[] =
14343   {"Follow architecture", "Allowed"};
14344 static const char * arm_attr_tag_MPextension_use[] =
14345   {"Not Allowed", "Allowed"};
14346 static const char * arm_attr_tag_DIV_use[] =
14347   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14348     "Allowed in v7-A with integer division extension"};
14349 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14350 static const char * arm_attr_tag_Virtualization_use[] =
14351   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14352     "TrustZone and Virtualization Extensions"};
14353 static const char * arm_attr_tag_MPextension_use_legacy[] =
14354   {"Not Allowed", "Allowed"};
14355
14356 #define LOOKUP(id, name) \
14357   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14358 static arm_attr_public_tag arm_attr_public_tags[] =
14359 {
14360   {4, "CPU_raw_name", 1, NULL},
14361   {5, "CPU_name", 1, NULL},
14362   LOOKUP(6, CPU_arch),
14363   {7, "CPU_arch_profile", 0, NULL},
14364   LOOKUP(8, ARM_ISA_use),
14365   LOOKUP(9, THUMB_ISA_use),
14366   LOOKUP(10, FP_arch),
14367   LOOKUP(11, WMMX_arch),
14368   LOOKUP(12, Advanced_SIMD_arch),
14369   LOOKUP(13, PCS_config),
14370   LOOKUP(14, ABI_PCS_R9_use),
14371   LOOKUP(15, ABI_PCS_RW_data),
14372   LOOKUP(16, ABI_PCS_RO_data),
14373   LOOKUP(17, ABI_PCS_GOT_use),
14374   LOOKUP(18, ABI_PCS_wchar_t),
14375   LOOKUP(19, ABI_FP_rounding),
14376   LOOKUP(20, ABI_FP_denormal),
14377   LOOKUP(21, ABI_FP_exceptions),
14378   LOOKUP(22, ABI_FP_user_exceptions),
14379   LOOKUP(23, ABI_FP_number_model),
14380   {24, "ABI_align_needed", 0, NULL},
14381   {25, "ABI_align_preserved", 0, NULL},
14382   LOOKUP(26, ABI_enum_size),
14383   LOOKUP(27, ABI_HardFP_use),
14384   LOOKUP(28, ABI_VFP_args),
14385   LOOKUP(29, ABI_WMMX_args),
14386   LOOKUP(30, ABI_optimization_goals),
14387   LOOKUP(31, ABI_FP_optimization_goals),
14388   {32, "compatibility", 0, NULL},
14389   LOOKUP(34, CPU_unaligned_access),
14390   LOOKUP(36, FP_HP_extension),
14391   LOOKUP(38, ABI_FP_16bit_format),
14392   LOOKUP(42, MPextension_use),
14393   LOOKUP(44, DIV_use),
14394   LOOKUP(46, DSP_extension),
14395   {64, "nodefaults", 0, NULL},
14396   {65, "also_compatible_with", 0, NULL},
14397   LOOKUP(66, T2EE_use),
14398   {67, "conformance", 1, NULL},
14399   LOOKUP(68, Virtualization_use),
14400   LOOKUP(70, MPextension_use_legacy)
14401 };
14402 #undef LOOKUP
14403
14404 static unsigned char *
14405 display_arm_attribute (unsigned char * p,
14406                        const unsigned char * const end)
14407 {
14408   unsigned int tag;
14409   unsigned int len;
14410   unsigned int val;
14411   arm_attr_public_tag * attr;
14412   unsigned i;
14413   unsigned int type;
14414
14415   tag = read_uleb128 (p, &len, end);
14416   p += len;
14417   attr = NULL;
14418   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14419     {
14420       if (arm_attr_public_tags[i].tag == tag)
14421         {
14422           attr = &arm_attr_public_tags[i];
14423           break;
14424         }
14425     }
14426
14427   if (attr)
14428     {
14429       printf ("  Tag_%s: ", attr->name);
14430       switch (attr->type)
14431         {
14432         case 0:
14433           switch (tag)
14434             {
14435             case 7: /* Tag_CPU_arch_profile.  */
14436               val = read_uleb128 (p, &len, end);
14437               p += len;
14438               switch (val)
14439                 {
14440                 case 0: printf (_("None\n")); break;
14441                 case 'A': printf (_("Application\n")); break;
14442                 case 'R': printf (_("Realtime\n")); break;
14443                 case 'M': printf (_("Microcontroller\n")); break;
14444                 case 'S': printf (_("Application or Realtime\n")); break;
14445                 default: printf ("??? (%d)\n", val); break;
14446                 }
14447               break;
14448
14449             case 24: /* Tag_align_needed.  */
14450               val = read_uleb128 (p, &len, end);
14451               p += len;
14452               switch (val)
14453                 {
14454                 case 0: printf (_("None\n")); break;
14455                 case 1: printf (_("8-byte\n")); break;
14456                 case 2: printf (_("4-byte\n")); break;
14457                 case 3: printf ("??? 3\n"); break;
14458                 default:
14459                   if (val <= 12)
14460                     printf (_("8-byte and up to %d-byte extended\n"),
14461                             1 << val);
14462                   else
14463                     printf ("??? (%d)\n", val);
14464                   break;
14465                 }
14466               break;
14467
14468             case 25: /* Tag_align_preserved.  */
14469               val = read_uleb128 (p, &len, end);
14470               p += len;
14471               switch (val)
14472                 {
14473                 case 0: printf (_("None\n")); break;
14474                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14475                 case 2: printf (_("8-byte\n")); break;
14476                 case 3: printf ("??? 3\n"); break;
14477                 default:
14478                   if (val <= 12)
14479                     printf (_("8-byte and up to %d-byte extended\n"),
14480                             1 << val);
14481                   else
14482                     printf ("??? (%d)\n", val);
14483                   break;
14484                 }
14485               break;
14486
14487             case 32: /* Tag_compatibility.  */
14488               {
14489                 val = read_uleb128 (p, &len, end);
14490                 p += len;
14491                 printf (_("flag = %d, vendor = "), val);
14492                 if (p < end - 1)
14493                   {
14494                     size_t maxlen = (end - p) - 1;
14495
14496                     print_symbol ((int) maxlen, (const char *) p);
14497                     p += strnlen ((char *) p, maxlen) + 1;
14498                   }
14499                 else
14500                   {
14501                     printf (_("<corrupt>"));
14502                     p = (unsigned char *) end;
14503                   }
14504                 putchar ('\n');
14505               }
14506               break;
14507
14508             case 64: /* Tag_nodefaults.  */
14509               /* PR 17531: file: 001-505008-0.01.  */
14510               if (p < end)
14511                 p++;
14512               printf (_("True\n"));
14513               break;
14514
14515             case 65: /* Tag_also_compatible_with.  */
14516               val = read_uleb128 (p, &len, end);
14517               p += len;
14518               if (val == 6 /* Tag_CPU_arch.  */)
14519                 {
14520                   val = read_uleb128 (p, &len, end);
14521                   p += len;
14522                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14523                     printf ("??? (%d)\n", val);
14524                   else
14525                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14526                 }
14527               else
14528                 printf ("???\n");
14529               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14530                 ;
14531               break;
14532
14533             default:
14534               printf (_("<unknown: %d>\n"), tag);
14535               break;
14536             }
14537           return p;
14538
14539         case 1:
14540           return display_tag_value (-1, p, end);
14541         case 2:
14542           return display_tag_value (0, p, end);
14543
14544         default:
14545           assert (attr->type & 0x80);
14546           val = read_uleb128 (p, &len, end);
14547           p += len;
14548           type = attr->type & 0x7f;
14549           if (val >= type)
14550             printf ("??? (%d)\n", val);
14551           else
14552             printf ("%s\n", attr->table[val]);
14553           return p;
14554         }
14555     }
14556
14557   return display_tag_value (tag, p, end);
14558 }
14559
14560 static unsigned char *
14561 display_gnu_attribute (unsigned char * p,
14562                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14563                        const unsigned char * const end)
14564 {
14565   int tag;
14566   unsigned int len;
14567   unsigned int val;
14568
14569   tag = read_uleb128 (p, &len, end);
14570   p += len;
14571
14572   /* Tag_compatibility is the only generic GNU attribute defined at
14573      present.  */
14574   if (tag == 32)
14575     {
14576       val = read_uleb128 (p, &len, end);
14577       p += len;
14578
14579       printf (_("flag = %d, vendor = "), val);
14580       if (p == end)
14581         {
14582           printf (_("<corrupt>\n"));
14583           warn (_("corrupt vendor attribute\n"));
14584         }
14585       else
14586         {
14587           if (p < end - 1)
14588             {
14589               size_t maxlen = (end - p) - 1;
14590
14591               print_symbol ((int) maxlen, (const char *) p);
14592               p += strnlen ((char *) p, maxlen) + 1;
14593             }
14594           else
14595             {
14596               printf (_("<corrupt>"));
14597               p = (unsigned char *) end;
14598             }
14599           putchar ('\n');
14600         }
14601       return p;
14602     }
14603
14604   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14605     return display_proc_gnu_attribute (p, tag, end);
14606
14607   return display_tag_value (tag, p, end);
14608 }
14609
14610 static unsigned char *
14611 display_power_gnu_attribute (unsigned char * p,
14612                              unsigned int tag,
14613                              const unsigned char * const end)
14614 {
14615   unsigned int len;
14616   unsigned int val;
14617
14618   if (tag == Tag_GNU_Power_ABI_FP)
14619     {
14620       val = read_uleb128 (p, &len, end);
14621       p += len;
14622       printf ("  Tag_GNU_Power_ABI_FP: ");
14623       if (len == 0)
14624         {
14625           printf (_("<corrupt>\n"));
14626           return p;
14627         }
14628
14629       if (val > 15)
14630         printf ("(%#x), ", val);
14631
14632       switch (val & 3)
14633         {
14634         case 0:
14635           printf (_("unspecified hard/soft float, "));
14636           break;
14637         case 1:
14638           printf (_("hard float, "));
14639           break;
14640         case 2:
14641           printf (_("soft float, "));
14642           break;
14643         case 3:
14644           printf (_("single-precision hard float, "));
14645           break;
14646         }
14647
14648       switch (val & 0xC)
14649         {
14650         case 0:
14651           printf (_("unspecified long double\n"));
14652           break;
14653         case 4:
14654           printf (_("128-bit IBM long double\n"));
14655           break;
14656         case 8:
14657           printf (_("64-bit long double\n"));
14658           break;
14659         case 12:
14660           printf (_("128-bit IEEE long double\n"));
14661           break;
14662         }
14663       return p;
14664     }
14665
14666   if (tag == Tag_GNU_Power_ABI_Vector)
14667     {
14668       val = read_uleb128 (p, &len, end);
14669       p += len;
14670       printf ("  Tag_GNU_Power_ABI_Vector: ");
14671       if (len == 0)
14672         {
14673           printf (_("<corrupt>\n"));
14674           return p;
14675         }
14676
14677       if (val > 3)
14678         printf ("(%#x), ", val);
14679
14680       switch (val & 3)
14681         {
14682         case 0:
14683           printf (_("unspecified\n"));
14684           break;
14685         case 1:
14686           printf (_("generic\n"));
14687           break;
14688         case 2:
14689           printf ("AltiVec\n");
14690           break;
14691         case 3:
14692           printf ("SPE\n");
14693           break;
14694         }
14695       return p;
14696     }
14697
14698   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14699     {
14700       val = read_uleb128 (p, &len, end);
14701       p += len;
14702       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14703       if (len == 0)
14704         {
14705           printf (_("<corrupt>\n"));
14706           return p;
14707         }
14708
14709       if (val > 2)
14710         printf ("(%#x), ", val);
14711
14712       switch (val & 3)
14713         {
14714         case 0:
14715           printf (_("unspecified\n"));
14716           break;
14717         case 1:
14718           printf ("r3/r4\n");
14719           break;
14720         case 2:
14721           printf (_("memory\n"));
14722           break;
14723         case 3:
14724           printf ("???\n");
14725           break;
14726         }
14727       return p;
14728     }
14729
14730   return display_tag_value (tag & 1, p, end);
14731 }
14732
14733 static unsigned char *
14734 display_s390_gnu_attribute (unsigned char * p,
14735                             unsigned int tag,
14736                             const unsigned char * const end)
14737 {
14738   unsigned int len;
14739   int val;
14740
14741   if (tag == Tag_GNU_S390_ABI_Vector)
14742     {
14743       val = read_uleb128 (p, &len, end);
14744       p += len;
14745       printf ("  Tag_GNU_S390_ABI_Vector: ");
14746
14747       switch (val)
14748         {
14749         case 0:
14750           printf (_("any\n"));
14751           break;
14752         case 1:
14753           printf (_("software\n"));
14754           break;
14755         case 2:
14756           printf (_("hardware\n"));
14757           break;
14758         default:
14759           printf ("??? (%d)\n", val);
14760           break;
14761         }
14762       return p;
14763    }
14764
14765   return display_tag_value (tag & 1, p, end);
14766 }
14767
14768 static void
14769 display_sparc_hwcaps (unsigned int mask)
14770 {
14771   if (mask)
14772     {
14773       bfd_boolean first = TRUE;
14774
14775       if (mask & ELF_SPARC_HWCAP_MUL32)
14776         fputs ("mul32", stdout), first = FALSE;
14777       if (mask & ELF_SPARC_HWCAP_DIV32)
14778         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14779       if (mask & ELF_SPARC_HWCAP_FSMULD)
14780         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14781       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14782         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14783       if (mask & ELF_SPARC_HWCAP_POPC)
14784         printf ("%spopc", first ? "" : "|"), first = FALSE;
14785       if (mask & ELF_SPARC_HWCAP_VIS)
14786         printf ("%svis", first ? "" : "|"), first = FALSE;
14787       if (mask & ELF_SPARC_HWCAP_VIS2)
14788         printf ("%svis2", first ? "" : "|"), first = FALSE;
14789       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14790         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14791       if (mask & ELF_SPARC_HWCAP_FMAF)
14792         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14793       if (mask & ELF_SPARC_HWCAP_VIS3)
14794         printf ("%svis3", first ? "" : "|"), first = FALSE;
14795       if (mask & ELF_SPARC_HWCAP_HPC)
14796         printf ("%shpc", first ? "" : "|"), first = FALSE;
14797       if (mask & ELF_SPARC_HWCAP_RANDOM)
14798         printf ("%srandom", first ? "" : "|"), first = FALSE;
14799       if (mask & ELF_SPARC_HWCAP_TRANS)
14800         printf ("%strans", first ? "" : "|"), first = FALSE;
14801       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14802         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14803       if (mask & ELF_SPARC_HWCAP_IMA)
14804         printf ("%sima", first ? "" : "|"), first = FALSE;
14805       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14806         printf ("%scspare", first ? "" : "|"), first = FALSE;
14807     }
14808   else
14809     fputc ('0', stdout);
14810   fputc ('\n', stdout);
14811 }
14812
14813 static void
14814 display_sparc_hwcaps2 (unsigned int mask)
14815 {
14816   if (mask)
14817     {
14818       bfd_boolean first = TRUE;
14819
14820       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14821         fputs ("fjathplus", stdout), first = FALSE;
14822       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14823         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14824       if (mask & ELF_SPARC_HWCAP2_ADP)
14825         printf ("%sadp", first ? "" : "|"), first = FALSE;
14826       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14827         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14828       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14829         printf ("%smwait", first ? "" : "|"), first = FALSE;
14830       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14831         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14832       if (mask & ELF_SPARC_HWCAP2_XMONT)
14833         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14834       if (mask & ELF_SPARC_HWCAP2_NSEC)
14835         printf ("%snsec", first ? "" : "|"), first = FALSE;
14836       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14837         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14838       if (mask & ELF_SPARC_HWCAP2_FJDES)
14839         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14840       if (mask & ELF_SPARC_HWCAP2_FJAES)
14841         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14842     }
14843   else
14844     fputc ('0', stdout);
14845   fputc ('\n', stdout);
14846 }
14847
14848 static unsigned char *
14849 display_sparc_gnu_attribute (unsigned char * p,
14850                              unsigned int tag,
14851                              const unsigned char * const end)
14852 {
14853   unsigned int len;
14854   int val;
14855
14856   if (tag == Tag_GNU_Sparc_HWCAPS)
14857     {
14858       val = read_uleb128 (p, &len, end);
14859       p += len;
14860       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14861       display_sparc_hwcaps (val);
14862       return p;
14863     }
14864   if (tag == Tag_GNU_Sparc_HWCAPS2)
14865     {
14866       val = read_uleb128 (p, &len, end);
14867       p += len;
14868       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14869       display_sparc_hwcaps2 (val);
14870       return p;
14871     }
14872
14873   return display_tag_value (tag, p, end);
14874 }
14875
14876 static void
14877 print_mips_fp_abi_value (unsigned int val)
14878 {
14879   switch (val)
14880     {
14881     case Val_GNU_MIPS_ABI_FP_ANY:
14882       printf (_("Hard or soft float\n"));
14883       break;
14884     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14885       printf (_("Hard float (double precision)\n"));
14886       break;
14887     case Val_GNU_MIPS_ABI_FP_SINGLE:
14888       printf (_("Hard float (single precision)\n"));
14889       break;
14890     case Val_GNU_MIPS_ABI_FP_SOFT:
14891       printf (_("Soft float\n"));
14892       break;
14893     case Val_GNU_MIPS_ABI_FP_OLD_64:
14894       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14895       break;
14896     case Val_GNU_MIPS_ABI_FP_XX:
14897       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14898       break;
14899     case Val_GNU_MIPS_ABI_FP_64:
14900       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14901       break;
14902     case Val_GNU_MIPS_ABI_FP_64A:
14903       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14904       break;
14905     case Val_GNU_MIPS_ABI_FP_NAN2008:
14906       printf (_("NaN 2008 compatibility\n"));
14907       break;
14908     default:
14909       printf ("??? (%d)\n", val);
14910       break;
14911     }
14912 }
14913
14914 static unsigned char *
14915 display_mips_gnu_attribute (unsigned char * p,
14916                             unsigned int tag,
14917                             const unsigned char * const end)
14918 {
14919   if (tag == Tag_GNU_MIPS_ABI_FP)
14920     {
14921       unsigned int len;
14922       unsigned int val;
14923
14924       val = read_uleb128 (p, &len, end);
14925       p += len;
14926       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14927
14928       print_mips_fp_abi_value (val);
14929
14930       return p;
14931    }
14932
14933   if (tag == Tag_GNU_MIPS_ABI_MSA)
14934     {
14935       unsigned int len;
14936       unsigned int val;
14937
14938       val = read_uleb128 (p, &len, end);
14939       p += len;
14940       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14941
14942       switch (val)
14943         {
14944         case Val_GNU_MIPS_ABI_MSA_ANY:
14945           printf (_("Any MSA or not\n"));
14946           break;
14947         case Val_GNU_MIPS_ABI_MSA_128:
14948           printf (_("128-bit MSA\n"));
14949           break;
14950         default:
14951           printf ("??? (%d)\n", val);
14952           break;
14953         }
14954       return p;
14955     }
14956
14957   return display_tag_value (tag & 1, p, end);
14958 }
14959
14960 static unsigned char *
14961 display_tic6x_attribute (unsigned char * p,
14962                          const unsigned char * const end)
14963 {
14964   unsigned int tag;
14965   unsigned int len;
14966   int val;
14967
14968   tag = read_uleb128 (p, &len, end);
14969   p += len;
14970
14971   switch (tag)
14972     {
14973     case Tag_ISA:
14974       val = read_uleb128 (p, &len, end);
14975       p += len;
14976       printf ("  Tag_ISA: ");
14977
14978       switch (val)
14979         {
14980         case C6XABI_Tag_ISA_none:
14981           printf (_("None\n"));
14982           break;
14983         case C6XABI_Tag_ISA_C62X:
14984           printf ("C62x\n");
14985           break;
14986         case C6XABI_Tag_ISA_C67X:
14987           printf ("C67x\n");
14988           break;
14989         case C6XABI_Tag_ISA_C67XP:
14990           printf ("C67x+\n");
14991           break;
14992         case C6XABI_Tag_ISA_C64X:
14993           printf ("C64x\n");
14994           break;
14995         case C6XABI_Tag_ISA_C64XP:
14996           printf ("C64x+\n");
14997           break;
14998         case C6XABI_Tag_ISA_C674X:
14999           printf ("C674x\n");
15000           break;
15001         default:
15002           printf ("??? (%d)\n", val);
15003           break;
15004         }
15005       return p;
15006
15007     case Tag_ABI_wchar_t:
15008       val = read_uleb128 (p, &len, end);
15009       p += len;
15010       printf ("  Tag_ABI_wchar_t: ");
15011       switch (val)
15012         {
15013         case 0:
15014           printf (_("Not used\n"));
15015           break;
15016         case 1:
15017           printf (_("2 bytes\n"));
15018           break;
15019         case 2:
15020           printf (_("4 bytes\n"));
15021           break;
15022         default:
15023           printf ("??? (%d)\n", val);
15024           break;
15025         }
15026       return p;
15027
15028     case Tag_ABI_stack_align_needed:
15029       val = read_uleb128 (p, &len, end);
15030       p += len;
15031       printf ("  Tag_ABI_stack_align_needed: ");
15032       switch (val)
15033         {
15034         case 0:
15035           printf (_("8-byte\n"));
15036           break;
15037         case 1:
15038           printf (_("16-byte\n"));
15039           break;
15040         default:
15041           printf ("??? (%d)\n", val);
15042           break;
15043         }
15044       return p;
15045
15046     case Tag_ABI_stack_align_preserved:
15047       val = read_uleb128 (p, &len, end);
15048       p += len;
15049       printf ("  Tag_ABI_stack_align_preserved: ");
15050       switch (val)
15051         {
15052         case 0:
15053           printf (_("8-byte\n"));
15054           break;
15055         case 1:
15056           printf (_("16-byte\n"));
15057           break;
15058         default:
15059           printf ("??? (%d)\n", val);
15060           break;
15061         }
15062       return p;
15063
15064     case Tag_ABI_DSBT:
15065       val = read_uleb128 (p, &len, end);
15066       p += len;
15067       printf ("  Tag_ABI_DSBT: ");
15068       switch (val)
15069         {
15070         case 0:
15071           printf (_("DSBT addressing not used\n"));
15072           break;
15073         case 1:
15074           printf (_("DSBT addressing used\n"));
15075           break;
15076         default:
15077           printf ("??? (%d)\n", val);
15078           break;
15079         }
15080       return p;
15081
15082     case Tag_ABI_PID:
15083       val = read_uleb128 (p, &len, end);
15084       p += len;
15085       printf ("  Tag_ABI_PID: ");
15086       switch (val)
15087         {
15088         case 0:
15089           printf (_("Data addressing position-dependent\n"));
15090           break;
15091         case 1:
15092           printf (_("Data addressing position-independent, GOT near DP\n"));
15093           break;
15094         case 2:
15095           printf (_("Data addressing position-independent, GOT far from DP\n"));
15096           break;
15097         default:
15098           printf ("??? (%d)\n", val);
15099           break;
15100         }
15101       return p;
15102
15103     case Tag_ABI_PIC:
15104       val = read_uleb128 (p, &len, end);
15105       p += len;
15106       printf ("  Tag_ABI_PIC: ");
15107       switch (val)
15108         {
15109         case 0:
15110           printf (_("Code addressing position-dependent\n"));
15111           break;
15112         case 1:
15113           printf (_("Code addressing position-independent\n"));
15114           break;
15115         default:
15116           printf ("??? (%d)\n", val);
15117           break;
15118         }
15119       return p;
15120
15121     case Tag_ABI_array_object_alignment:
15122       val = read_uleb128 (p, &len, end);
15123       p += len;
15124       printf ("  Tag_ABI_array_object_alignment: ");
15125       switch (val)
15126         {
15127         case 0:
15128           printf (_("8-byte\n"));
15129           break;
15130         case 1:
15131           printf (_("4-byte\n"));
15132           break;
15133         case 2:
15134           printf (_("16-byte\n"));
15135           break;
15136         default:
15137           printf ("??? (%d)\n", val);
15138           break;
15139         }
15140       return p;
15141
15142     case Tag_ABI_array_object_align_expected:
15143       val = read_uleb128 (p, &len, end);
15144       p += len;
15145       printf ("  Tag_ABI_array_object_align_expected: ");
15146       switch (val)
15147         {
15148         case 0:
15149           printf (_("8-byte\n"));
15150           break;
15151         case 1:
15152           printf (_("4-byte\n"));
15153           break;
15154         case 2:
15155           printf (_("16-byte\n"));
15156           break;
15157         default:
15158           printf ("??? (%d)\n", val);
15159           break;
15160         }
15161       return p;
15162
15163     case Tag_ABI_compatibility:
15164       {
15165         val = read_uleb128 (p, &len, end);
15166         p += len;
15167         printf ("  Tag_ABI_compatibility: ");
15168         printf (_("flag = %d, vendor = "), val);
15169         if (p < end - 1)
15170           {
15171             size_t maxlen = (end - p) - 1;
15172
15173             print_symbol ((int) maxlen, (const char *) p);
15174             p += strnlen ((char *) p, maxlen) + 1;
15175           }
15176         else
15177           {
15178             printf (_("<corrupt>"));
15179             p = (unsigned char *) end;
15180           }
15181         putchar ('\n');
15182         return p;
15183       }
15184
15185     case Tag_ABI_conformance:
15186       {
15187         printf ("  Tag_ABI_conformance: \"");
15188         if (p < end - 1)
15189           {
15190             size_t maxlen = (end - p) - 1;
15191
15192             print_symbol ((int) maxlen, (const char *) p);
15193             p += strnlen ((char *) p, maxlen) + 1;
15194           }
15195         else
15196           {
15197             printf (_("<corrupt>"));
15198             p = (unsigned char *) end;
15199           }
15200         printf ("\"\n");
15201         return p;
15202       }
15203     }
15204
15205   return display_tag_value (tag, p, end);
15206 }
15207
15208 static void
15209 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15210 {
15211   unsigned long addr = 0;
15212   size_t bytes = end - p;
15213
15214   assert (end > p);
15215   while (bytes)
15216     {
15217       int j;
15218       int k;
15219       int lbytes = (bytes > 16 ? 16 : bytes);
15220
15221       printf ("  0x%8.8lx ", addr);
15222
15223       for (j = 0; j < 16; j++)
15224         {
15225           if (j < lbytes)
15226             printf ("%2.2x", p[j]);
15227           else
15228             printf ("  ");
15229
15230           if ((j & 3) == 3)
15231             printf (" ");
15232         }
15233
15234       for (j = 0; j < lbytes; j++)
15235         {
15236           k = p[j];
15237           if (k >= ' ' && k < 0x7f)
15238             printf ("%c", k);
15239           else
15240             printf (".");
15241         }
15242
15243       putchar ('\n');
15244
15245       p  += lbytes;
15246       bytes -= lbytes;
15247       addr += lbytes;
15248     }
15249
15250   putchar ('\n');
15251 }
15252
15253 static unsigned char *
15254 display_msp430x_attribute (unsigned char * p,
15255                            const unsigned char * const end)
15256 {
15257   unsigned int len;
15258   unsigned int val;
15259   unsigned int tag;
15260
15261   tag = read_uleb128 (p, & len, end);
15262   p += len;
15263
15264   switch (tag)
15265     {
15266     case OFBA_MSPABI_Tag_ISA:
15267       val = read_uleb128 (p, &len, end);
15268       p += len;
15269       printf ("  Tag_ISA: ");
15270       switch (val)
15271         {
15272         case 0: printf (_("None\n")); break;
15273         case 1: printf (_("MSP430\n")); break;
15274         case 2: printf (_("MSP430X\n")); break;
15275         default: printf ("??? (%d)\n", val); break;
15276         }
15277       break;
15278
15279     case OFBA_MSPABI_Tag_Code_Model:
15280       val = read_uleb128 (p, &len, end);
15281       p += len;
15282       printf ("  Tag_Code_Model: ");
15283       switch (val)
15284         {
15285         case 0: printf (_("None\n")); break;
15286         case 1: printf (_("Small\n")); break;
15287         case 2: printf (_("Large\n")); break;
15288         default: printf ("??? (%d)\n", val); break;
15289         }
15290       break;
15291
15292     case OFBA_MSPABI_Tag_Data_Model:
15293       val = read_uleb128 (p, &len, end);
15294       p += len;
15295       printf ("  Tag_Data_Model: ");
15296       switch (val)
15297         {
15298         case 0: printf (_("None\n")); break;
15299         case 1: printf (_("Small\n")); break;
15300         case 2: printf (_("Large\n")); break;
15301         case 3: printf (_("Restricted Large\n")); break;
15302         default: printf ("??? (%d)\n", val); break;
15303         }
15304       break;
15305
15306     default:
15307       printf (_("  <unknown tag %d>: "), tag);
15308
15309       if (tag & 1)
15310         {
15311           putchar ('"');
15312           if (p < end - 1)
15313             {
15314               size_t maxlen = (end - p) - 1;
15315
15316               print_symbol ((int) maxlen, (const char *) p);
15317               p += strnlen ((char *) p, maxlen) + 1;
15318             }
15319           else
15320             {
15321               printf (_("<corrupt>"));
15322               p = (unsigned char *) end;
15323             }
15324           printf ("\"\n");
15325         }
15326       else
15327         {
15328           val = read_uleb128 (p, &len, end);
15329           p += len;
15330           printf ("%d (0x%x)\n", val, val);
15331         }
15332       break;
15333    }
15334
15335   assert (p <= end);
15336   return p;
15337 }
15338
15339 static bfd_boolean
15340 process_attributes (Filedata * filedata,
15341                     const char * public_name,
15342                     unsigned int proc_type,
15343                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15344                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15345 {
15346   Elf_Internal_Shdr * sect;
15347   unsigned i;
15348   bfd_boolean res = TRUE;
15349
15350   /* Find the section header so that we get the size.  */
15351   for (i = 0, sect = filedata->section_headers;
15352        i < filedata->file_header.e_shnum;
15353        i++, sect++)
15354     {
15355       unsigned char * contents;
15356       unsigned char * p;
15357
15358       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15359         continue;
15360
15361       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15362                                              sect->sh_size, _("attributes"));
15363       if (contents == NULL)
15364         {
15365           res = FALSE;
15366           continue;
15367         }
15368
15369       p = contents;
15370       /* The first character is the version of the attributes.
15371          Currently only version 1, (aka 'A') is recognised here.  */
15372       if (*p != 'A')
15373         {
15374           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15375           res = FALSE;
15376         }
15377       else
15378         {
15379           bfd_vma section_len;
15380
15381           section_len = sect->sh_size - 1;
15382           p++;
15383
15384           while (section_len > 0)
15385             {
15386               bfd_vma attr_len;
15387               unsigned int namelen;
15388               bfd_boolean public_section;
15389               bfd_boolean gnu_section;
15390
15391               if (section_len <= 4)
15392                 {
15393                   error (_("Tag section ends prematurely\n"));
15394                   res = FALSE;
15395                   break;
15396                 }
15397               attr_len = byte_get (p, 4);
15398               p += 4;
15399
15400               if (attr_len > section_len)
15401                 {
15402                   error (_("Bad attribute length (%u > %u)\n"),
15403                           (unsigned) attr_len, (unsigned) section_len);
15404                   attr_len = section_len;
15405                   res = FALSE;
15406                 }
15407               /* PR 17531: file: 001-101425-0.004  */
15408               else if (attr_len < 5)
15409                 {
15410                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15411                   res = FALSE;
15412                   break;
15413                 }
15414
15415               section_len -= attr_len;
15416               attr_len -= 4;
15417
15418               namelen = strnlen ((char *) p, attr_len) + 1;
15419               if (namelen == 0 || namelen >= attr_len)
15420                 {
15421                   error (_("Corrupt attribute section name\n"));
15422                   res = FALSE;
15423                   break;
15424                 }
15425
15426               printf (_("Attribute Section: "));
15427               print_symbol (INT_MAX, (const char *) p);
15428               putchar ('\n');
15429
15430               if (public_name && streq ((char *) p, public_name))
15431                 public_section = TRUE;
15432               else
15433                 public_section = FALSE;
15434
15435               if (streq ((char *) p, "gnu"))
15436                 gnu_section = TRUE;
15437               else
15438                 gnu_section = FALSE;
15439
15440               p += namelen;
15441               attr_len -= namelen;
15442
15443               while (attr_len > 0 && p < contents + sect->sh_size)
15444                 {
15445                   int tag;
15446                   int val;
15447                   bfd_vma size;
15448                   unsigned char * end;
15449
15450                   /* PR binutils/17531: Safe handling of corrupt files.  */
15451                   if (attr_len < 6)
15452                     {
15453                       error (_("Unused bytes at end of section\n"));
15454                       res = FALSE;
15455                       section_len = 0;
15456                       break;
15457                     }
15458
15459                   tag = *(p++);
15460                   size = byte_get (p, 4);
15461                   if (size > attr_len)
15462                     {
15463                       error (_("Bad subsection length (%u > %u)\n"),
15464                               (unsigned) size, (unsigned) attr_len);
15465                       res = FALSE;
15466                       size = attr_len;
15467                     }
15468                   /* PR binutils/17531: Safe handling of corrupt files.  */
15469                   if (size < 6)
15470                     {
15471                       error (_("Bad subsection length (%u < 6)\n"),
15472                               (unsigned) size);
15473                       res = FALSE;
15474                       section_len = 0;
15475                       break;
15476                     }
15477
15478                   attr_len -= size;
15479                   end = p + size - 1;
15480                   assert (end <= contents + sect->sh_size);
15481                   p += 4;
15482
15483                   switch (tag)
15484                     {
15485                     case 1:
15486                       printf (_("File Attributes\n"));
15487                       break;
15488                     case 2:
15489                       printf (_("Section Attributes:"));
15490                       goto do_numlist;
15491                     case 3:
15492                       printf (_("Symbol Attributes:"));
15493                       /* Fall through.  */
15494                     do_numlist:
15495                       for (;;)
15496                         {
15497                           unsigned int j;
15498
15499                           val = read_uleb128 (p, &j, end);
15500                           p += j;
15501                           if (val == 0)
15502                             break;
15503                           printf (" %d", val);
15504                         }
15505                       printf ("\n");
15506                       break;
15507                     default:
15508                       printf (_("Unknown tag: %d\n"), tag);
15509                       public_section = FALSE;
15510                       break;
15511                     }
15512
15513                   if (public_section && display_pub_attribute != NULL)
15514                     {
15515                       while (p < end)
15516                         p = display_pub_attribute (p, end);
15517                       assert (p == end);
15518                     }
15519                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15520                     {
15521                       while (p < end)
15522                         p = display_gnu_attribute (p,
15523                                                    display_proc_gnu_attribute,
15524                                                    end);
15525                       assert (p == end);
15526                     }
15527                   else if (p < end)
15528                     {
15529                       printf (_("  Unknown attribute:\n"));
15530                       display_raw_attribute (p, end);
15531                       p = end;
15532                     }
15533                   else
15534                     attr_len = 0;
15535                 }
15536             }
15537         }
15538
15539       free (contents);
15540     }
15541
15542   return res;
15543 }
15544
15545 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15546    Print the Address, Access and Initial fields of an entry at VMA ADDR
15547    and return the VMA of the next entry, or -1 if there was a problem.
15548    Does not read from DATA_END or beyond.  */
15549
15550 static bfd_vma
15551 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15552                       unsigned char * data_end)
15553 {
15554   printf ("  ");
15555   print_vma (addr, LONG_HEX);
15556   printf (" ");
15557   if (addr < pltgot + 0xfff0)
15558     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15559   else
15560     printf ("%10s", "");
15561   printf (" ");
15562   if (data == NULL)
15563     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15564   else
15565     {
15566       bfd_vma entry;
15567       unsigned char * from = data + addr - pltgot;
15568
15569       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15570         {
15571           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15572           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15573           return (bfd_vma) -1;
15574         }
15575       else
15576         {
15577           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15578           print_vma (entry, LONG_HEX);
15579         }
15580     }
15581   return addr + (is_32bit_elf ? 4 : 8);
15582 }
15583
15584 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15585    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15586    ADDR and return the VMA of the next entry.  */
15587
15588 static bfd_vma
15589 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15590 {
15591   printf ("  ");
15592   print_vma (addr, LONG_HEX);
15593   printf (" ");
15594   if (data == NULL)
15595     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15596   else
15597     {
15598       bfd_vma entry;
15599
15600       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15601       print_vma (entry, LONG_HEX);
15602     }
15603   return addr + (is_32bit_elf ? 4 : 8);
15604 }
15605
15606 static void
15607 print_mips_ases (unsigned int mask)
15608 {
15609   if (mask & AFL_ASE_DSP)
15610     fputs ("\n\tDSP ASE", stdout);
15611   if (mask & AFL_ASE_DSPR2)
15612     fputs ("\n\tDSP R2 ASE", stdout);
15613   if (mask & AFL_ASE_DSPR3)
15614     fputs ("\n\tDSP R3 ASE", stdout);
15615   if (mask & AFL_ASE_EVA)
15616     fputs ("\n\tEnhanced VA Scheme", stdout);
15617   if (mask & AFL_ASE_MCU)
15618     fputs ("\n\tMCU (MicroController) ASE", stdout);
15619   if (mask & AFL_ASE_MDMX)
15620     fputs ("\n\tMDMX ASE", stdout);
15621   if (mask & AFL_ASE_MIPS3D)
15622     fputs ("\n\tMIPS-3D ASE", stdout);
15623   if (mask & AFL_ASE_MT)
15624     fputs ("\n\tMT ASE", stdout);
15625   if (mask & AFL_ASE_SMARTMIPS)
15626     fputs ("\n\tSmartMIPS ASE", stdout);
15627   if (mask & AFL_ASE_VIRT)
15628     fputs ("\n\tVZ ASE", stdout);
15629   if (mask & AFL_ASE_MSA)
15630     fputs ("\n\tMSA ASE", stdout);
15631   if (mask & AFL_ASE_MIPS16)
15632     fputs ("\n\tMIPS16 ASE", stdout);
15633   if (mask & AFL_ASE_MICROMIPS)
15634     fputs ("\n\tMICROMIPS ASE", stdout);
15635   if (mask & AFL_ASE_XPA)
15636     fputs ("\n\tXPA ASE", stdout);
15637   if (mask & AFL_ASE_MIPS16E2)
15638     fputs ("\n\tMIPS16e2 ASE", stdout);
15639   if (mask & AFL_ASE_CRC)
15640     fputs ("\n\tCRC ASE", stdout);
15641   if (mask & AFL_ASE_GINV)
15642     fputs ("\n\tGINV ASE", stdout);
15643   if (mask & AFL_ASE_LOONGSON_MMI)
15644     fputs ("\n\tLoongson MMI ASE", stdout);
15645   if (mask == 0)
15646     fprintf (stdout, "\n\t%s", _("None"));
15647   else if ((mask & ~AFL_ASE_MASK) != 0)
15648     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15649 }
15650
15651 static void
15652 print_mips_isa_ext (unsigned int isa_ext)
15653 {
15654   switch (isa_ext)
15655     {
15656     case 0:
15657       fputs (_("None"), stdout);
15658       break;
15659     case AFL_EXT_XLR:
15660       fputs ("RMI XLR", stdout);
15661       break;
15662     case AFL_EXT_OCTEON3:
15663       fputs ("Cavium Networks Octeon3", stdout);
15664       break;
15665     case AFL_EXT_OCTEON2:
15666       fputs ("Cavium Networks Octeon2", stdout);
15667       break;
15668     case AFL_EXT_OCTEONP:
15669       fputs ("Cavium Networks OcteonP", stdout);
15670       break;
15671     case AFL_EXT_LOONGSON_3A:
15672       fputs ("Loongson 3A", stdout);
15673       break;
15674     case AFL_EXT_OCTEON:
15675       fputs ("Cavium Networks Octeon", stdout);
15676       break;
15677     case AFL_EXT_5900:
15678       fputs ("Toshiba R5900", stdout);
15679       break;
15680     case AFL_EXT_4650:
15681       fputs ("MIPS R4650", stdout);
15682       break;
15683     case AFL_EXT_4010:
15684       fputs ("LSI R4010", stdout);
15685       break;
15686     case AFL_EXT_4100:
15687       fputs ("NEC VR4100", stdout);
15688       break;
15689     case AFL_EXT_3900:
15690       fputs ("Toshiba R3900", stdout);
15691       break;
15692     case AFL_EXT_10000:
15693       fputs ("MIPS R10000", stdout);
15694       break;
15695     case AFL_EXT_SB1:
15696       fputs ("Broadcom SB-1", stdout);
15697       break;
15698     case AFL_EXT_4111:
15699       fputs ("NEC VR4111/VR4181", stdout);
15700       break;
15701     case AFL_EXT_4120:
15702       fputs ("NEC VR4120", stdout);
15703       break;
15704     case AFL_EXT_5400:
15705       fputs ("NEC VR5400", stdout);
15706       break;
15707     case AFL_EXT_5500:
15708       fputs ("NEC VR5500", stdout);
15709       break;
15710     case AFL_EXT_LOONGSON_2E:
15711       fputs ("ST Microelectronics Loongson 2E", stdout);
15712       break;
15713     case AFL_EXT_LOONGSON_2F:
15714       fputs ("ST Microelectronics Loongson 2F", stdout);
15715       break;
15716     case AFL_EXT_INTERAPTIV_MR2:
15717       fputs ("Imagination interAptiv MR2", stdout);
15718       break;
15719     default:
15720       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15721     }
15722 }
15723
15724 static signed int
15725 get_mips_reg_size (int reg_size)
15726 {
15727   return (reg_size == AFL_REG_NONE) ? 0
15728          : (reg_size == AFL_REG_32) ? 32
15729          : (reg_size == AFL_REG_64) ? 64
15730          : (reg_size == AFL_REG_128) ? 128
15731          : -1;
15732 }
15733
15734 static bfd_boolean
15735 process_mips_specific (Filedata * filedata)
15736 {
15737   Elf_Internal_Dyn * entry;
15738   Elf_Internal_Shdr *sect = NULL;
15739   size_t liblist_offset = 0;
15740   size_t liblistno = 0;
15741   size_t conflictsno = 0;
15742   size_t options_offset = 0;
15743   size_t conflicts_offset = 0;
15744   size_t pltrelsz = 0;
15745   size_t pltrel = 0;
15746   bfd_vma pltgot = 0;
15747   bfd_vma mips_pltgot = 0;
15748   bfd_vma jmprel = 0;
15749   bfd_vma local_gotno = 0;
15750   bfd_vma gotsym = 0;
15751   bfd_vma symtabno = 0;
15752   bfd_boolean res = TRUE;
15753
15754   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15755                             display_mips_gnu_attribute))
15756     res = FALSE;
15757
15758   sect = find_section (filedata, ".MIPS.abiflags");
15759
15760   if (sect != NULL)
15761     {
15762       Elf_External_ABIFlags_v0 *abiflags_ext;
15763       Elf_Internal_ABIFlags_v0 abiflags_in;
15764
15765       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15766         {
15767           error (_("Corrupt MIPS ABI Flags section.\n"));
15768           res = FALSE;
15769         }
15770       else
15771         {
15772           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15773                                    sect->sh_size, _("MIPS ABI Flags section"));
15774           if (abiflags_ext)
15775             {
15776               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15777               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15778               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15779               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15780               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15781               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15782               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15783               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15784               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15785               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15786               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15787
15788               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15789               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15790               if (abiflags_in.isa_rev > 1)
15791                 printf ("r%d", abiflags_in.isa_rev);
15792               printf ("\nGPR size: %d",
15793                       get_mips_reg_size (abiflags_in.gpr_size));
15794               printf ("\nCPR1 size: %d",
15795                       get_mips_reg_size (abiflags_in.cpr1_size));
15796               printf ("\nCPR2 size: %d",
15797                       get_mips_reg_size (abiflags_in.cpr2_size));
15798               fputs ("\nFP ABI: ", stdout);
15799               print_mips_fp_abi_value (abiflags_in.fp_abi);
15800               fputs ("ISA Extension: ", stdout);
15801               print_mips_isa_ext (abiflags_in.isa_ext);
15802               fputs ("\nASEs:", stdout);
15803               print_mips_ases (abiflags_in.ases);
15804               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15805               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15806               fputc ('\n', stdout);
15807               free (abiflags_ext);
15808             }
15809         }
15810     }
15811
15812   /* We have a lot of special sections.  Thanks SGI!  */
15813   if (dynamic_section == NULL)
15814     {
15815       /* No dynamic information available.  See if there is static GOT.  */
15816       sect = find_section (filedata, ".got");
15817       if (sect != NULL)
15818         {
15819           unsigned char *data_end;
15820           unsigned char *data;
15821           bfd_vma ent, end;
15822           int addr_size;
15823
15824           pltgot = sect->sh_addr;
15825
15826           ent = pltgot;
15827           addr_size = (is_32bit_elf ? 4 : 8);
15828           end = pltgot + sect->sh_size;
15829
15830           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15831                                              end - pltgot, 1,
15832                                              _("Global Offset Table data"));
15833           /* PR 12855: Null data is handled gracefully throughout.  */
15834           data_end = data + (end - pltgot);
15835
15836           printf (_("\nStatic GOT:\n"));
15837           printf (_(" Canonical gp value: "));
15838           print_vma (ent + 0x7ff0, LONG_HEX);
15839           printf ("\n\n");
15840
15841           /* In a dynamic binary GOT[0] is reserved for the dynamic
15842              loader to store the lazy resolver pointer, however in
15843              a static binary it may well have been omitted and GOT
15844              reduced to a table of addresses.
15845              PR 21344: Check for the entry being fully available
15846              before fetching it.  */
15847           if (data
15848               && data + ent - pltgot + addr_size <= data_end
15849               && byte_get (data + ent - pltgot, addr_size) == 0)
15850             {
15851               printf (_(" Reserved entries:\n"));
15852               printf (_("  %*s %10s %*s\n"),
15853                       addr_size * 2, _("Address"), _("Access"),
15854                       addr_size * 2, _("Value"));
15855               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15856               printf ("\n");
15857               if (ent == (bfd_vma) -1)
15858                 goto sgot_print_fail;
15859
15860               /* Check for the MSB of GOT[1] being set, identifying a
15861                  GNU object.  This entry will be used by some runtime
15862                  loaders, to store the module pointer.  Otherwise this
15863                  is an ordinary local entry.
15864                  PR 21344: Check for the entry being fully available
15865                  before fetching it.  */
15866               if (data
15867                   && data + ent - pltgot + addr_size <= data_end
15868                   && (byte_get (data + ent - pltgot, addr_size)
15869                       >> (addr_size * 8 - 1)) != 0)
15870                 {
15871                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15872                   printf ("\n");
15873                   if (ent == (bfd_vma) -1)
15874                     goto sgot_print_fail;
15875                 }
15876               printf ("\n");
15877             }
15878
15879           if (data != NULL && ent < end)
15880             {
15881               printf (_(" Local entries:\n"));
15882               printf ("  %*s %10s %*s\n",
15883                       addr_size * 2, _("Address"), _("Access"),
15884                       addr_size * 2, _("Value"));
15885               while (ent < end)
15886                 {
15887                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15888                   printf ("\n");
15889                   if (ent == (bfd_vma) -1)
15890                     goto sgot_print_fail;
15891                 }
15892               printf ("\n");
15893             }
15894
15895         sgot_print_fail:
15896           if (data)
15897             free (data);
15898         }
15899       return res;
15900     }
15901
15902   for (entry = dynamic_section;
15903        /* PR 17531 file: 012-50589-0.004.  */
15904        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15905        ++entry)
15906     switch (entry->d_tag)
15907       {
15908       case DT_MIPS_LIBLIST:
15909         liblist_offset
15910           = offset_from_vma (filedata, entry->d_un.d_val,
15911                              liblistno * sizeof (Elf32_External_Lib));
15912         break;
15913       case DT_MIPS_LIBLISTNO:
15914         liblistno = entry->d_un.d_val;
15915         break;
15916       case DT_MIPS_OPTIONS:
15917         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15918         break;
15919       case DT_MIPS_CONFLICT:
15920         conflicts_offset
15921           = offset_from_vma (filedata, entry->d_un.d_val,
15922                              conflictsno * sizeof (Elf32_External_Conflict));
15923         break;
15924       case DT_MIPS_CONFLICTNO:
15925         conflictsno = entry->d_un.d_val;
15926         break;
15927       case DT_PLTGOT:
15928         pltgot = entry->d_un.d_ptr;
15929         break;
15930       case DT_MIPS_LOCAL_GOTNO:
15931         local_gotno = entry->d_un.d_val;
15932         break;
15933       case DT_MIPS_GOTSYM:
15934         gotsym = entry->d_un.d_val;
15935         break;
15936       case DT_MIPS_SYMTABNO:
15937         symtabno = entry->d_un.d_val;
15938         break;
15939       case DT_MIPS_PLTGOT:
15940         mips_pltgot = entry->d_un.d_ptr;
15941         break;
15942       case DT_PLTREL:
15943         pltrel = entry->d_un.d_val;
15944         break;
15945       case DT_PLTRELSZ:
15946         pltrelsz = entry->d_un.d_val;
15947         break;
15948       case DT_JMPREL:
15949         jmprel = entry->d_un.d_ptr;
15950         break;
15951       default:
15952         break;
15953       }
15954
15955   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15956     {
15957       Elf32_External_Lib * elib;
15958       size_t cnt;
15959
15960       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15961                                               liblistno,
15962                                               sizeof (Elf32_External_Lib),
15963                                               _("liblist section data"));
15964       if (elib)
15965         {
15966           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15967                             "\nSection '.liblist' contains %lu entries:\n",
15968                             (unsigned long) liblistno),
15969                   (unsigned long) liblistno);
15970           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15971                  stdout);
15972
15973           for (cnt = 0; cnt < liblistno; ++cnt)
15974             {
15975               Elf32_Lib liblist;
15976               time_t atime;
15977               char timebuf[128];
15978               struct tm * tmp;
15979
15980               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15981               atime = BYTE_GET (elib[cnt].l_time_stamp);
15982               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15983               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15984               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15985
15986               tmp = gmtime (&atime);
15987               snprintf (timebuf, sizeof (timebuf),
15988                         "%04u-%02u-%02uT%02u:%02u:%02u",
15989                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15990                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15991
15992               printf ("%3lu: ", (unsigned long) cnt);
15993               if (VALID_DYNAMIC_NAME (liblist.l_name))
15994                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15995               else
15996                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15997               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15998                       liblist.l_version);
15999
16000               if (liblist.l_flags == 0)
16001                 puts (_(" NONE"));
16002               else
16003                 {
16004                   static const struct
16005                   {
16006                     const char * name;
16007                     int bit;
16008                   }
16009                   l_flags_vals[] =
16010                   {
16011                     { " EXACT_MATCH", LL_EXACT_MATCH },
16012                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16013                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16014                     { " EXPORTS", LL_EXPORTS },
16015                     { " DELAY_LOAD", LL_DELAY_LOAD },
16016                     { " DELTA", LL_DELTA }
16017                   };
16018                   int flags = liblist.l_flags;
16019                   size_t fcnt;
16020
16021                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16022                     if ((flags & l_flags_vals[fcnt].bit) != 0)
16023                       {
16024                         fputs (l_flags_vals[fcnt].name, stdout);
16025                         flags ^= l_flags_vals[fcnt].bit;
16026                       }
16027                   if (flags != 0)
16028                     printf (" %#x", (unsigned int) flags);
16029
16030                   puts ("");
16031                 }
16032             }
16033
16034           free (elib);
16035         }
16036       else
16037         res = FALSE;
16038     }
16039
16040   if (options_offset != 0)
16041     {
16042       Elf_External_Options * eopt;
16043       Elf_Internal_Options * iopt;
16044       Elf_Internal_Options * option;
16045       size_t offset;
16046       int cnt;
16047       sect = filedata->section_headers;
16048
16049       /* Find the section header so that we get the size.  */
16050       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16051       /* PR 17533 file: 012-277276-0.004.  */
16052       if (sect == NULL)
16053         {
16054           error (_("No MIPS_OPTIONS header found\n"));
16055           return FALSE;
16056         }
16057
16058       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16059                                                 sect->sh_size, _("options"));
16060       if (eopt)
16061         {
16062           iopt = (Elf_Internal_Options *)
16063               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16064           if (iopt == NULL)
16065             {
16066               error (_("Out of memory allocating space for MIPS options\n"));
16067               return FALSE;
16068             }
16069
16070           offset = cnt = 0;
16071           option = iopt;
16072
16073           while (offset <= sect->sh_size - sizeof (* eopt))
16074             {
16075               Elf_External_Options * eoption;
16076
16077               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16078
16079               option->kind = BYTE_GET (eoption->kind);
16080               option->size = BYTE_GET (eoption->size);
16081               option->section = BYTE_GET (eoption->section);
16082               option->info = BYTE_GET (eoption->info);
16083
16084               /* PR 17531: file: ffa0fa3b.  */
16085               if (option->size < sizeof (* eopt)
16086                   || offset + option->size > sect->sh_size)
16087                 {
16088                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
16089                   return FALSE;
16090                 }
16091               offset += option->size;
16092
16093               ++option;
16094               ++cnt;
16095             }
16096
16097           printf (ngettext ("\nSection '%s' contains %d entry:\n",
16098                             "\nSection '%s' contains %d entries:\n",
16099                             cnt),
16100                   printable_section_name (filedata, sect), cnt);
16101
16102           option = iopt;
16103           offset = 0;
16104
16105           while (cnt-- > 0)
16106             {
16107               size_t len;
16108
16109               switch (option->kind)
16110                 {
16111                 case ODK_NULL:
16112                   /* This shouldn't happen.  */
16113                   printf (" NULL       %d %lx", option->section, option->info);
16114                   break;
16115                 case ODK_REGINFO:
16116                   printf (" REGINFO    ");
16117                   if (filedata->file_header.e_machine == EM_MIPS)
16118                     {
16119                       /* 32bit form.  */
16120                       Elf32_External_RegInfo * ereg;
16121                       Elf32_RegInfo reginfo;
16122
16123                       ereg = (Elf32_External_RegInfo *) (option + 1);
16124                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16125                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16126                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16127                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16128                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16129                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16130
16131                       printf ("GPR %08lx  GP 0x%lx\n",
16132                               reginfo.ri_gprmask,
16133                               (unsigned long) reginfo.ri_gp_value);
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                   else
16139                     {
16140                       /* 64 bit form.  */
16141                       Elf64_External_RegInfo * ereg;
16142                       Elf64_Internal_RegInfo reginfo;
16143
16144                       ereg = (Elf64_External_RegInfo *) (option + 1);
16145                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
16146                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16147                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16148                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16149                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16150                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16151
16152                       printf ("GPR %08lx  GP 0x",
16153                               reginfo.ri_gprmask);
16154                       printf_vma (reginfo.ri_gp_value);
16155                       printf ("\n");
16156
16157                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16158                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16159                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16160                     }
16161                   ++option;
16162                   continue;
16163                 case ODK_EXCEPTIONS:
16164                   fputs (" EXCEPTIONS fpe_min(", stdout);
16165                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16166                   fputs (") fpe_max(", stdout);
16167                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16168                   fputs (")", stdout);
16169
16170                   if (option->info & OEX_PAGE0)
16171                     fputs (" PAGE0", stdout);
16172                   if (option->info & OEX_SMM)
16173                     fputs (" SMM", stdout);
16174                   if (option->info & OEX_FPDBUG)
16175                     fputs (" FPDBUG", stdout);
16176                   if (option->info & OEX_DISMISS)
16177                     fputs (" DISMISS", stdout);
16178                   break;
16179                 case ODK_PAD:
16180                   fputs (" PAD       ", stdout);
16181                   if (option->info & OPAD_PREFIX)
16182                     fputs (" PREFIX", stdout);
16183                   if (option->info & OPAD_POSTFIX)
16184                     fputs (" POSTFIX", stdout);
16185                   if (option->info & OPAD_SYMBOL)
16186                     fputs (" SYMBOL", stdout);
16187                   break;
16188                 case ODK_HWPATCH:
16189                   fputs (" HWPATCH   ", stdout);
16190                   if (option->info & OHW_R4KEOP)
16191                     fputs (" R4KEOP", stdout);
16192                   if (option->info & OHW_R8KPFETCH)
16193                     fputs (" R8KPFETCH", stdout);
16194                   if (option->info & OHW_R5KEOP)
16195                     fputs (" R5KEOP", stdout);
16196                   if (option->info & OHW_R5KCVTL)
16197                     fputs (" R5KCVTL", stdout);
16198                   break;
16199                 case ODK_FILL:
16200                   fputs (" FILL       ", stdout);
16201                   /* XXX Print content of info word?  */
16202                   break;
16203                 case ODK_TAGS:
16204                   fputs (" TAGS       ", stdout);
16205                   /* XXX Print content of info word?  */
16206                   break;
16207                 case ODK_HWAND:
16208                   fputs (" HWAND     ", stdout);
16209                   if (option->info & OHWA0_R4KEOP_CHECKED)
16210                     fputs (" R4KEOP_CHECKED", stdout);
16211                   if (option->info & OHWA0_R4KEOP_CLEAN)
16212                     fputs (" R4KEOP_CLEAN", stdout);
16213                   break;
16214                 case ODK_HWOR:
16215                   fputs (" HWOR      ", stdout);
16216                   if (option->info & OHWA0_R4KEOP_CHECKED)
16217                     fputs (" R4KEOP_CHECKED", stdout);
16218                   if (option->info & OHWA0_R4KEOP_CLEAN)
16219                     fputs (" R4KEOP_CLEAN", stdout);
16220                   break;
16221                 case ODK_GP_GROUP:
16222                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16223                           option->info & OGP_GROUP,
16224                           (option->info & OGP_SELF) >> 16);
16225                   break;
16226                 case ODK_IDENT:
16227                   printf (" IDENT     %#06lx  self-contained %#06lx",
16228                           option->info & OGP_GROUP,
16229                           (option->info & OGP_SELF) >> 16);
16230                   break;
16231                 default:
16232                   /* This shouldn't happen.  */
16233                   printf (" %3d ???     %d %lx",
16234                           option->kind, option->section, option->info);
16235                   break;
16236                 }
16237
16238               len = sizeof (* eopt);
16239               while (len < option->size)
16240                 {
16241                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16242
16243                   if (ISPRINT (datum))
16244                     printf ("%c", datum);
16245                   else
16246                     printf ("\\%03o", datum);
16247                   len ++;
16248                 }
16249               fputs ("\n", stdout);
16250
16251               offset += option->size;
16252               ++option;
16253             }
16254
16255           free (eopt);
16256         }
16257       else
16258         res = FALSE;
16259     }
16260
16261   if (conflicts_offset != 0 && conflictsno != 0)
16262     {
16263       Elf32_Conflict * iconf;
16264       size_t cnt;
16265
16266       if (dynamic_symbols == NULL)
16267         {
16268           error (_("conflict list found without a dynamic symbol table\n"));
16269           return FALSE;
16270         }
16271
16272       /* PR 21345 - print a slightly more helpful error message
16273          if we are sure that the cmalloc will fail.  */
16274       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16275         {
16276           error (_("Overlarge number of conflicts detected: %lx\n"),
16277                  (long) conflictsno);
16278           return FALSE;
16279         }
16280
16281       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16282       if (iconf == NULL)
16283         {
16284           error (_("Out of memory allocating space for dynamic conflicts\n"));
16285           return FALSE;
16286         }
16287
16288       if (is_32bit_elf)
16289         {
16290           Elf32_External_Conflict * econf32;
16291
16292           econf32 = (Elf32_External_Conflict *)
16293               get_data (NULL, filedata, conflicts_offset, conflictsno,
16294                         sizeof (* econf32), _("conflict"));
16295           if (!econf32)
16296             return FALSE;
16297
16298           for (cnt = 0; cnt < conflictsno; ++cnt)
16299             iconf[cnt] = BYTE_GET (econf32[cnt]);
16300
16301           free (econf32);
16302         }
16303       else
16304         {
16305           Elf64_External_Conflict * econf64;
16306
16307           econf64 = (Elf64_External_Conflict *)
16308               get_data (NULL, filedata, conflicts_offset, conflictsno,
16309                         sizeof (* econf64), _("conflict"));
16310           if (!econf64)
16311             return FALSE;
16312
16313           for (cnt = 0; cnt < conflictsno; ++cnt)
16314             iconf[cnt] = BYTE_GET (econf64[cnt]);
16315
16316           free (econf64);
16317         }
16318
16319       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16320                         "\nSection '.conflict' contains %lu entries:\n",
16321                         (unsigned long) conflictsno),
16322               (unsigned long) conflictsno);
16323       puts (_("  Num:    Index       Value  Name"));
16324
16325       for (cnt = 0; cnt < conflictsno; ++cnt)
16326         {
16327           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16328
16329           if (iconf[cnt] >= num_dynamic_syms)
16330             printf (_("<corrupt symbol index>"));
16331           else
16332             {
16333               Elf_Internal_Sym * psym;
16334
16335               psym = & dynamic_symbols[iconf[cnt]];
16336               print_vma (psym->st_value, FULL_HEX);
16337               putchar (' ');
16338               if (VALID_DYNAMIC_NAME (psym->st_name))
16339                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16340               else
16341                 printf (_("<corrupt: %14ld>"), psym->st_name);
16342             }
16343           putchar ('\n');
16344         }
16345
16346       free (iconf);
16347     }
16348
16349   if (pltgot != 0 && local_gotno != 0)
16350     {
16351       bfd_vma ent, local_end, global_end;
16352       size_t i, offset;
16353       unsigned char * data;
16354       unsigned char * data_end;
16355       int addr_size;
16356
16357       ent = pltgot;
16358       addr_size = (is_32bit_elf ? 4 : 8);
16359       local_end = pltgot + local_gotno * addr_size;
16360
16361       /* PR binutils/17533 file: 012-111227-0.004  */
16362       if (symtabno < gotsym)
16363         {
16364           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16365                  (unsigned long) gotsym, (unsigned long) symtabno);
16366           return FALSE;
16367         }
16368
16369       global_end = local_end + (symtabno - gotsym) * addr_size;
16370       /* PR 17531: file: 54c91a34.  */
16371       if (global_end < local_end)
16372         {
16373           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16374           return FALSE;
16375         }
16376
16377       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16378       data = (unsigned char *) get_data (NULL, filedata, offset,
16379                                          global_end - pltgot, 1,
16380                                          _("Global Offset Table data"));
16381       /* PR 12855: Null data is handled gracefully throughout.  */
16382       data_end = data + (global_end - pltgot);
16383
16384       printf (_("\nPrimary GOT:\n"));
16385       printf (_(" Canonical gp value: "));
16386       print_vma (pltgot + 0x7ff0, LONG_HEX);
16387       printf ("\n\n");
16388
16389       printf (_(" Reserved entries:\n"));
16390       printf (_("  %*s %10s %*s Purpose\n"),
16391               addr_size * 2, _("Address"), _("Access"),
16392               addr_size * 2, _("Initial"));
16393       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16394       printf (_(" Lazy resolver\n"));
16395       if (ent == (bfd_vma) -1)
16396         goto got_print_fail;
16397
16398       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16399          This entry will be used by some runtime loaders, to store the
16400          module pointer.  Otherwise this is an ordinary local entry.
16401          PR 21344: Check for the entry being fully available before
16402          fetching it.  */
16403       if (data
16404           && data + ent - pltgot + addr_size <= data_end
16405           && (byte_get (data + ent - pltgot, addr_size)
16406               >> (addr_size * 8 - 1)) != 0)
16407         {
16408           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16409           printf (_(" Module pointer (GNU extension)\n"));
16410           if (ent == (bfd_vma) -1)
16411             goto got_print_fail;
16412         }
16413       printf ("\n");
16414
16415       if (data != NULL && ent < local_end)
16416         {
16417           printf (_(" Local entries:\n"));
16418           printf ("  %*s %10s %*s\n",
16419                   addr_size * 2, _("Address"), _("Access"),
16420                   addr_size * 2, _("Initial"));
16421           while (ent < local_end)
16422             {
16423               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16424               printf ("\n");
16425               if (ent == (bfd_vma) -1)
16426                 goto got_print_fail;
16427             }
16428           printf ("\n");
16429         }
16430
16431       if (data != NULL && gotsym < symtabno)
16432         {
16433           int sym_width;
16434
16435           printf (_(" Global entries:\n"));
16436           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16437                   addr_size * 2, _("Address"),
16438                   _("Access"),
16439                   addr_size * 2, _("Initial"),
16440                   addr_size * 2, _("Sym.Val."),
16441                   _("Type"),
16442                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16443                   _("Ndx"), _("Name"));
16444
16445           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16446
16447           for (i = gotsym; i < symtabno; i++)
16448             {
16449               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16450               printf (" ");
16451
16452               if (dynamic_symbols == NULL)
16453                 printf (_("<no dynamic symbols>"));
16454               else if (i < num_dynamic_syms)
16455                 {
16456                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16457
16458                   print_vma (psym->st_value, LONG_HEX);
16459                   printf (" %-7s %3s ",
16460                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16461                           get_symbol_index_type (filedata, psym->st_shndx));
16462
16463                   if (VALID_DYNAMIC_NAME (psym->st_name))
16464                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16465                   else
16466                     printf (_("<corrupt: %14ld>"), psym->st_name);
16467                 }
16468               else
16469                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16470                         (unsigned long) i);
16471
16472               printf ("\n");
16473               if (ent == (bfd_vma) -1)
16474                 break;
16475             }
16476           printf ("\n");
16477         }
16478
16479     got_print_fail:
16480       if (data)
16481         free (data);
16482     }
16483
16484   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16485     {
16486       bfd_vma ent, end;
16487       size_t offset, rel_offset;
16488       unsigned long count, i;
16489       unsigned char * data;
16490       int addr_size, sym_width;
16491       Elf_Internal_Rela * rels;
16492
16493       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16494       if (pltrel == DT_RELA)
16495         {
16496           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16497             return FALSE;
16498         }
16499       else
16500         {
16501           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16502             return FALSE;
16503         }
16504
16505       ent = mips_pltgot;
16506       addr_size = (is_32bit_elf ? 4 : 8);
16507       end = mips_pltgot + (2 + count) * addr_size;
16508
16509       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16510       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16511                                          1, _("Procedure Linkage Table data"));
16512       if (data == NULL)
16513         return FALSE;
16514
16515       printf ("\nPLT GOT:\n\n");
16516       printf (_(" Reserved entries:\n"));
16517       printf (_("  %*s %*s Purpose\n"),
16518               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16519       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16520       printf (_(" PLT lazy resolver\n"));
16521       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16522       printf (_(" Module pointer\n"));
16523       printf ("\n");
16524
16525       printf (_(" Entries:\n"));
16526       printf ("  %*s %*s %*s %-7s %3s %s\n",
16527               addr_size * 2, _("Address"),
16528               addr_size * 2, _("Initial"),
16529               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16530       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16531       for (i = 0; i < count; i++)
16532         {
16533           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16534
16535           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16536           printf (" ");
16537
16538           if (idx >= num_dynamic_syms)
16539             printf (_("<corrupt symbol index: %lu>"), idx);
16540           else
16541             {
16542               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16543
16544               print_vma (psym->st_value, LONG_HEX);
16545               printf (" %-7s %3s ",
16546                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16547                       get_symbol_index_type (filedata, psym->st_shndx));
16548               if (VALID_DYNAMIC_NAME (psym->st_name))
16549                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16550               else
16551                 printf (_("<corrupt: %14ld>"), psym->st_name);
16552             }
16553           printf ("\n");
16554         }
16555       printf ("\n");
16556
16557       if (data)
16558         free (data);
16559       free (rels);
16560     }
16561
16562   return res;
16563 }
16564
16565 static bfd_boolean
16566 process_nds32_specific (Filedata * filedata)
16567 {
16568   Elf_Internal_Shdr *sect = NULL;
16569
16570   sect = find_section (filedata, ".nds32_e_flags");
16571   if (sect != NULL)
16572     {
16573       unsigned int *flag;
16574
16575       printf ("\nNDS32 elf flags section:\n");
16576       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16577                        sect->sh_size, _("NDS32 elf flags section"));
16578
16579       if (! flag)
16580         return FALSE;
16581
16582       switch ((*flag) & 0x3)
16583         {
16584         case 0:
16585           printf ("(VEC_SIZE):\tNo entry.\n");
16586           break;
16587         case 1:
16588           printf ("(VEC_SIZE):\t4 bytes\n");
16589           break;
16590         case 2:
16591           printf ("(VEC_SIZE):\t16 bytes\n");
16592           break;
16593         case 3:
16594           printf ("(VEC_SIZE):\treserved\n");
16595           break;
16596         }
16597     }
16598
16599   return TRUE;
16600 }
16601
16602 static bfd_boolean
16603 process_gnu_liblist (Filedata * filedata)
16604 {
16605   Elf_Internal_Shdr * section;
16606   Elf_Internal_Shdr * string_sec;
16607   Elf32_External_Lib * elib;
16608   char * strtab;
16609   size_t strtab_size;
16610   size_t cnt;
16611   unsigned long num_liblist;
16612   unsigned i;
16613   bfd_boolean res = TRUE;
16614
16615   if (! do_arch)
16616     return TRUE;
16617
16618   for (i = 0, section = filedata->section_headers;
16619        i < filedata->file_header.e_shnum;
16620        i++, section++)
16621     {
16622       switch (section->sh_type)
16623         {
16624         case SHT_GNU_LIBLIST:
16625           if (section->sh_link >= filedata->file_header.e_shnum)
16626             break;
16627
16628           elib = (Elf32_External_Lib *)
16629               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16630                         _("liblist section data"));
16631
16632           if (elib == NULL)
16633             {
16634               res = FALSE;
16635               break;
16636             }
16637
16638           string_sec = filedata->section_headers + section->sh_link;
16639           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16640                                       string_sec->sh_size,
16641                                       _("liblist string table"));
16642           if (strtab == NULL
16643               || section->sh_entsize != sizeof (Elf32_External_Lib))
16644             {
16645               free (elib);
16646               free (strtab);
16647               res = FALSE;
16648               break;
16649             }
16650           strtab_size = string_sec->sh_size;
16651
16652           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16653           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16654                             "\nLibrary list section '%s' contains %lu entries:\n",
16655                             num_liblist),
16656                   printable_section_name (filedata, section),
16657                   num_liblist);
16658
16659           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16660
16661           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16662                ++cnt)
16663             {
16664               Elf32_Lib liblist;
16665               time_t atime;
16666               char timebuf[128];
16667               struct tm * tmp;
16668
16669               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16670               atime = BYTE_GET (elib[cnt].l_time_stamp);
16671               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16672               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16673               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16674
16675               tmp = gmtime (&atime);
16676               snprintf (timebuf, sizeof (timebuf),
16677                         "%04u-%02u-%02uT%02u:%02u:%02u",
16678                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16679                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16680
16681               printf ("%3lu: ", (unsigned long) cnt);
16682               if (do_wide)
16683                 printf ("%-20s", liblist.l_name < strtab_size
16684                         ? strtab + liblist.l_name : _("<corrupt>"));
16685               else
16686                 printf ("%-20.20s", liblist.l_name < strtab_size
16687                         ? strtab + liblist.l_name : _("<corrupt>"));
16688               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16689                       liblist.l_version, liblist.l_flags);
16690             }
16691
16692           free (elib);
16693           free (strtab);
16694         }
16695     }
16696
16697   return res;
16698 }
16699
16700 static const char *
16701 get_note_type (Filedata * filedata, unsigned e_type)
16702 {
16703   static char buff[64];
16704
16705   if (filedata->file_header.e_type == ET_CORE)
16706     switch (e_type)
16707       {
16708       case NT_AUXV:
16709         return _("NT_AUXV (auxiliary vector)");
16710       case NT_PRSTATUS:
16711         return _("NT_PRSTATUS (prstatus structure)");
16712       case NT_FPREGSET:
16713         return _("NT_FPREGSET (floating point registers)");
16714       case NT_PRPSINFO:
16715         return _("NT_PRPSINFO (prpsinfo structure)");
16716       case NT_TASKSTRUCT:
16717         return _("NT_TASKSTRUCT (task structure)");
16718       case NT_PRXFPREG:
16719         return _("NT_PRXFPREG (user_xfpregs structure)");
16720       case NT_PPC_VMX:
16721         return _("NT_PPC_VMX (ppc Altivec registers)");
16722       case NT_PPC_VSX:
16723         return _("NT_PPC_VSX (ppc VSX registers)");
16724       case NT_PPC_TAR:
16725         return _("NT_PPC_TAR (ppc TAR register)");
16726       case NT_PPC_PPR:
16727         return _("NT_PPC_PPR (ppc PPR register)");
16728       case NT_PPC_DSCR:
16729         return _("NT_PPC_DSCR (ppc DSCR register)");
16730       case NT_PPC_EBB:
16731         return _("NT_PPC_EBB (ppc EBB registers)");
16732       case NT_PPC_PMU:
16733         return _("NT_PPC_PMU (ppc PMU registers)");
16734       case NT_PPC_TM_CGPR:
16735         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16736       case NT_PPC_TM_CFPR:
16737         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16738       case NT_PPC_TM_CVMX:
16739         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16740       case NT_PPC_TM_CVSX:
16741         return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16742       case NT_PPC_TM_SPR:
16743         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16744       case NT_PPC_TM_CTAR:
16745         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16746       case NT_PPC_TM_CPPR:
16747         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16748       case NT_PPC_TM_CDSCR:
16749         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16750       case NT_386_TLS:
16751         return _("NT_386_TLS (x86 TLS information)");
16752       case NT_386_IOPERM:
16753         return _("NT_386_IOPERM (x86 I/O permissions)");
16754       case NT_X86_XSTATE:
16755         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16756       case NT_S390_HIGH_GPRS:
16757         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16758       case NT_S390_TIMER:
16759         return _("NT_S390_TIMER (s390 timer register)");
16760       case NT_S390_TODCMP:
16761         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16762       case NT_S390_TODPREG:
16763         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16764       case NT_S390_CTRS:
16765         return _("NT_S390_CTRS (s390 control registers)");
16766       case NT_S390_PREFIX:
16767         return _("NT_S390_PREFIX (s390 prefix register)");
16768       case NT_S390_LAST_BREAK:
16769         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16770       case NT_S390_SYSTEM_CALL:
16771         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16772       case NT_S390_TDB:
16773         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16774       case NT_S390_VXRS_LOW:
16775         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16776       case NT_S390_VXRS_HIGH:
16777         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16778       case NT_S390_GS_CB:
16779         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16780       case NT_S390_GS_BC:
16781         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16782       case NT_ARM_VFP:
16783         return _("NT_ARM_VFP (arm VFP registers)");
16784       case NT_ARM_TLS:
16785         return _("NT_ARM_TLS (AArch TLS registers)");
16786       case NT_ARM_HW_BREAK:
16787         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16788       case NT_ARM_HW_WATCH:
16789         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16790       case NT_PSTATUS:
16791         return _("NT_PSTATUS (pstatus structure)");
16792       case NT_FPREGS:
16793         return _("NT_FPREGS (floating point registers)");
16794       case NT_PSINFO:
16795         return _("NT_PSINFO (psinfo structure)");
16796       case NT_LWPSTATUS:
16797         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16798       case NT_LWPSINFO:
16799         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16800       case NT_WIN32PSTATUS:
16801         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16802       case NT_SIGINFO:
16803         return _("NT_SIGINFO (siginfo_t data)");
16804       case NT_FILE:
16805         return _("NT_FILE (mapped files)");
16806       default:
16807         break;
16808       }
16809   else
16810     switch (e_type)
16811       {
16812       case NT_VERSION:
16813         return _("NT_VERSION (version)");
16814       case NT_ARCH:
16815         return _("NT_ARCH (architecture)");
16816       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16817         return _("OPEN");
16818       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16819         return _("func");
16820       default:
16821         break;
16822       }
16823
16824   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16825   return buff;
16826 }
16827
16828 static bfd_boolean
16829 print_core_note (Elf_Internal_Note *pnote)
16830 {
16831   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16832   bfd_vma count, page_size;
16833   unsigned char *descdata, *filenames, *descend;
16834
16835   if (pnote->type != NT_FILE)
16836     {
16837       if (do_wide)
16838         printf ("\n");
16839       return TRUE;
16840     }
16841
16842 #ifndef BFD64
16843   if (!is_32bit_elf)
16844     {
16845       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16846       /* Still "successful".  */
16847       return TRUE;
16848     }
16849 #endif
16850
16851   if (pnote->descsz < 2 * addr_size)
16852     {
16853       error (_("    Malformed note - too short for header\n"));
16854       return FALSE;
16855     }
16856
16857   descdata = (unsigned char *) pnote->descdata;
16858   descend = descdata + pnote->descsz;
16859
16860   if (descdata[pnote->descsz - 1] != '\0')
16861     {
16862       error (_("    Malformed note - does not end with \\0\n"));
16863       return FALSE;
16864     }
16865
16866   count = byte_get (descdata, addr_size);
16867   descdata += addr_size;
16868
16869   page_size = byte_get (descdata, addr_size);
16870   descdata += addr_size;
16871
16872   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16873       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16874     {
16875       error (_("    Malformed note - too short for supplied file count\n"));
16876       return FALSE;
16877     }
16878
16879   printf (_("    Page size: "));
16880   print_vma (page_size, DEC);
16881   printf ("\n");
16882
16883   printf (_("    %*s%*s%*s\n"),
16884           (int) (2 + 2 * addr_size), _("Start"),
16885           (int) (4 + 2 * addr_size), _("End"),
16886           (int) (4 + 2 * addr_size), _("Page Offset"));
16887   filenames = descdata + count * 3 * addr_size;
16888   while (count-- > 0)
16889     {
16890       bfd_vma start, end, file_ofs;
16891
16892       if (filenames == descend)
16893         {
16894           error (_("    Malformed note - filenames end too early\n"));
16895           return FALSE;
16896         }
16897
16898       start = byte_get (descdata, addr_size);
16899       descdata += addr_size;
16900       end = byte_get (descdata, addr_size);
16901       descdata += addr_size;
16902       file_ofs = byte_get (descdata, addr_size);
16903       descdata += addr_size;
16904
16905       printf ("    ");
16906       print_vma (start, FULL_HEX);
16907       printf ("  ");
16908       print_vma (end, FULL_HEX);
16909       printf ("  ");
16910       print_vma (file_ofs, FULL_HEX);
16911       printf ("\n        %s\n", filenames);
16912
16913       filenames += 1 + strlen ((char *) filenames);
16914     }
16915
16916   return TRUE;
16917 }
16918
16919 static const char *
16920 get_gnu_elf_note_type (unsigned e_type)
16921 {
16922   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16923   switch (e_type)
16924     {
16925     case NT_GNU_ABI_TAG:
16926       return _("NT_GNU_ABI_TAG (ABI version tag)");
16927     case NT_GNU_HWCAP:
16928       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16929     case NT_GNU_BUILD_ID:
16930       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16931     case NT_GNU_GOLD_VERSION:
16932       return _("NT_GNU_GOLD_VERSION (gold version)");
16933     case NT_GNU_PROPERTY_TYPE_0:
16934       return _("NT_GNU_PROPERTY_TYPE_0");
16935     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16936       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16937     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16938       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16939     default:
16940       {
16941         static char buff[64];
16942
16943         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16944         return buff;
16945       }
16946     }
16947 }
16948
16949 static void
16950 decode_x86_isa (unsigned int bitmask)
16951 {
16952   while (bitmask)
16953     {
16954       unsigned int bit = bitmask & (- bitmask);
16955
16956       bitmask &= ~ bit;
16957       switch (bit)
16958         {
16959         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16960         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16961         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16962         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16963         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16964         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16965         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16966         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16967         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16968         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16969         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16970         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16971         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16972         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16973         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16974         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16975         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16976         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16977         default: printf (_("<unknown: %x>"), bit); break;
16978         }
16979       if (bitmask)
16980         printf (", ");
16981     }
16982 }
16983
16984 static void
16985 decode_x86_feature (unsigned int type, unsigned int bitmask)
16986 {
16987   while (bitmask)
16988     {
16989       unsigned int bit = bitmask & (- bitmask);
16990
16991       bitmask &= ~ bit;
16992       switch (bit)
16993         {
16994         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16995           switch (type)
16996             {
16997             case GNU_PROPERTY_X86_FEATURE_1_AND:
16998               printf ("IBT");
16999               break;
17000             default:
17001               /* This should never happen.  */
17002               abort ();
17003             }
17004           break;
17005         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17006           switch (type)
17007             {
17008             case GNU_PROPERTY_X86_FEATURE_1_AND:
17009               printf ("SHSTK");
17010               break;
17011             default:
17012               /* This should never happen.  */
17013               abort ();
17014             }
17015           break;
17016         default:
17017           printf (_("<unknown: %x>"), bit);
17018           break;
17019         }
17020       if (bitmask)
17021         printf (", ");
17022     }
17023 }
17024
17025 static void
17026 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17027 {
17028   unsigned char * ptr = (unsigned char *) pnote->descdata;
17029   unsigned char * ptr_end = ptr + pnote->descsz;
17030   unsigned int    size = is_32bit_elf ? 4 : 8;
17031
17032   printf (_("      Properties: "));
17033
17034   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17035     {
17036       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17037       return;
17038     }
17039
17040   while (ptr < ptr_end)
17041     {
17042       unsigned int j;
17043       unsigned int type;
17044       unsigned int datasz;
17045
17046       if ((size_t) (ptr_end - ptr) < 8)
17047         {
17048           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17049           break;
17050         }
17051
17052       type = byte_get (ptr, 4);
17053       datasz = byte_get (ptr + 4, 4);
17054
17055       ptr += 8;
17056
17057       if (datasz > (size_t) (ptr_end - ptr))
17058         {
17059           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17060                   type, datasz);
17061           break;
17062         }
17063
17064       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17065         {
17066           if (filedata->file_header.e_machine == EM_X86_64
17067               || filedata->file_header.e_machine == EM_IAMCU
17068               || filedata->file_header.e_machine == EM_386)
17069             {
17070               unsigned int bitmask;
17071
17072               if (datasz == 4)
17073                 {
17074                   bitmask = byte_get (ptr, 4);
17075                   if (filedata->file_header.e_type == ET_EXEC
17076                       || filedata->file_header.e_type == ET_DYN)
17077                     {
17078                       if ((bitmask & GNU_PROPERTY_X86_UINT32_VALID))
17079                         bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17080                       else
17081                         printf ("Invalid ");
17082                     }
17083                 }
17084               else
17085                 bitmask = 0;
17086
17087               switch (type)
17088                 {
17089                 case GNU_PROPERTY_X86_ISA_1_USED:
17090                   if (datasz != 4)
17091                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17092                             datasz);
17093                   else
17094                     {
17095                       printf ("x86 ISA used: ");
17096                       decode_x86_isa (bitmask);
17097                     }
17098                   goto next;
17099
17100                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17101                   if (datasz != 4)
17102                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17103                             datasz);
17104                   else
17105                     {
17106                       printf ("x86 ISA needed: ");
17107                       decode_x86_isa (bitmask);
17108                     }
17109                   goto next;
17110
17111                 case GNU_PROPERTY_X86_FEATURE_1_AND:
17112                   if (datasz != 4)
17113                     printf (_("x86 feature: <corrupt length: %#x> "),
17114                             datasz);
17115                   else
17116                     {
17117                       printf ("x86 feature: ");
17118                       decode_x86_feature (type, bitmask);
17119                     }
17120                   goto next;
17121
17122                 default:
17123                   break;
17124                 }
17125             }
17126         }
17127       else
17128         {
17129           switch (type)
17130             {
17131             case GNU_PROPERTY_STACK_SIZE:
17132               printf (_("stack size: "));
17133               if (datasz != size)
17134                 printf (_("<corrupt length: %#x> "), datasz);
17135               else
17136                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17137               goto next;
17138
17139             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17140               printf ("no copy on protected ");
17141               if (datasz)
17142                 printf (_("<corrupt length: %#x> "), datasz);
17143               goto next;
17144
17145             default:
17146               break;
17147             }
17148         }
17149
17150       if (type < GNU_PROPERTY_LOPROC)
17151         printf (_("<unknown type %#x data: "), type);
17152       else if (type < GNU_PROPERTY_LOUSER)
17153         printf (_("<procesor-specific type %#x data: "), type);
17154       else
17155         printf (_("<application-specific type %#x data: "), type);
17156       for (j = 0; j < datasz; ++j)
17157         printf ("%02x ", ptr[j] & 0xff);
17158       printf (">");
17159
17160 next:
17161       ptr += ((datasz + (size - 1)) & ~ (size - 1));
17162       if (ptr == ptr_end)
17163         break;
17164
17165       if (do_wide)
17166         printf (", ");
17167       else
17168         printf ("\n\t");
17169     }
17170
17171   printf ("\n");
17172 }
17173
17174 static bfd_boolean
17175 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17176 {
17177   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17178   switch (pnote->type)
17179     {
17180     case NT_GNU_BUILD_ID:
17181       {
17182         unsigned long i;
17183
17184         printf (_("    Build ID: "));
17185         for (i = 0; i < pnote->descsz; ++i)
17186           printf ("%02x", pnote->descdata[i] & 0xff);
17187         printf ("\n");
17188       }
17189       break;
17190
17191     case NT_GNU_ABI_TAG:
17192       {
17193         unsigned long os, major, minor, subminor;
17194         const char *osname;
17195
17196         /* PR 17531: file: 030-599401-0.004.  */
17197         if (pnote->descsz < 16)
17198           {
17199             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17200             break;
17201           }
17202
17203         os = byte_get ((unsigned char *) pnote->descdata, 4);
17204         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17205         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17206         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17207
17208         switch (os)
17209           {
17210           case GNU_ABI_TAG_LINUX:
17211             osname = "Linux";
17212             break;
17213           case GNU_ABI_TAG_HURD:
17214             osname = "Hurd";
17215             break;
17216           case GNU_ABI_TAG_SOLARIS:
17217             osname = "Solaris";
17218             break;
17219           case GNU_ABI_TAG_FREEBSD:
17220             osname = "FreeBSD";
17221             break;
17222           case GNU_ABI_TAG_NETBSD:
17223             osname = "NetBSD";
17224             break;
17225           case GNU_ABI_TAG_SYLLABLE:
17226             osname = "Syllable";
17227             break;
17228           case GNU_ABI_TAG_NACL:
17229             osname = "NaCl";
17230             break;
17231           default:
17232             osname = "Unknown";
17233             break;
17234           }
17235
17236         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17237                 major, minor, subminor);
17238       }
17239       break;
17240
17241     case NT_GNU_GOLD_VERSION:
17242       {
17243         unsigned long i;
17244
17245         printf (_("    Version: "));
17246         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17247           printf ("%c", pnote->descdata[i]);
17248         printf ("\n");
17249       }
17250       break;
17251
17252     case NT_GNU_HWCAP:
17253       {
17254         unsigned long num_entries, mask;
17255
17256         /* Hardware capabilities information.  Word 0 is the number of entries.
17257            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17258            is a series of entries, where each entry is a single byte followed
17259            by a nul terminated string.  The byte gives the bit number to test
17260            if enabled in the bitmask.  */
17261         printf (_("      Hardware Capabilities: "));
17262         if (pnote->descsz < 8)
17263           {
17264             error (_("<corrupt GNU_HWCAP>\n"));
17265             return FALSE;
17266           }
17267         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17268         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17269         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17270         /* FIXME: Add code to display the entries... */
17271       }
17272       break;
17273
17274     case NT_GNU_PROPERTY_TYPE_0:
17275       print_gnu_property_note (filedata, pnote);
17276       break;
17277
17278     default:
17279       /* Handle unrecognised types.  An error message should have already been
17280          created by get_gnu_elf_note_type(), so all that we need to do is to
17281          display the data.  */
17282       {
17283         unsigned long i;
17284
17285         printf (_("    Description data: "));
17286         for (i = 0; i < pnote->descsz; ++i)
17287           printf ("%02x ", pnote->descdata[i] & 0xff);
17288         printf ("\n");
17289       }
17290       break;
17291     }
17292
17293   return TRUE;
17294 }
17295
17296 static const char *
17297 get_v850_elf_note_type (enum v850_notes n_type)
17298 {
17299   static char buff[64];
17300
17301   switch (n_type)
17302     {
17303     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17304     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17305     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17306     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17307     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17308     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17309     default:
17310       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17311       return buff;
17312     }
17313 }
17314
17315 static bfd_boolean
17316 print_v850_note (Elf_Internal_Note * pnote)
17317 {
17318   unsigned int val;
17319
17320   if (pnote->descsz != 4)
17321     return FALSE;
17322
17323   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17324
17325   if (val == 0)
17326     {
17327       printf (_("not set\n"));
17328       return TRUE;
17329     }
17330
17331   switch (pnote->type)
17332     {
17333     case V850_NOTE_ALIGNMENT:
17334       switch (val)
17335         {
17336         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17337         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17338         }
17339       break;
17340
17341     case V850_NOTE_DATA_SIZE:
17342       switch (val)
17343         {
17344         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17345         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17346         }
17347       break;
17348
17349     case V850_NOTE_FPU_INFO:
17350       switch (val)
17351         {
17352         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17353         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17354         }
17355       break;
17356
17357     case V850_NOTE_MMU_INFO:
17358     case V850_NOTE_CACHE_INFO:
17359     case V850_NOTE_SIMD_INFO:
17360       if (val == EF_RH850_SIMD)
17361         {
17362           printf (_("yes\n"));
17363           return TRUE;
17364         }
17365       break;
17366
17367     default:
17368       /* An 'unknown note type' message will already have been displayed.  */
17369       break;
17370     }
17371
17372   printf (_("unknown value: %x\n"), val);
17373   return FALSE;
17374 }
17375
17376 static bfd_boolean
17377 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17378 {
17379   unsigned int version;
17380
17381   switch (pnote->type)
17382     {
17383     case NT_NETBSD_IDENT:
17384       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17385       if ((version / 10000) % 100)
17386         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17387                 version, version / 100000000, (version / 1000000) % 100,
17388                 (version / 10000) % 100 > 26 ? "Z" : "",
17389                 'A' + (version / 10000) % 26);
17390       else
17391         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17392                 version, version / 100000000, (version / 1000000) % 100,
17393                 (version / 100) % 100);
17394       return TRUE;
17395
17396     case NT_NETBSD_MARCH:
17397       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17398               pnote->descdata);
17399       return TRUE;
17400
17401     default:
17402       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17403               pnote->type);
17404       return FALSE;
17405     }
17406 }
17407
17408 static const char *
17409 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17410 {
17411   switch (e_type)
17412     {
17413     case NT_FREEBSD_THRMISC:
17414       return _("NT_THRMISC (thrmisc structure)");
17415     case NT_FREEBSD_PROCSTAT_PROC:
17416       return _("NT_PROCSTAT_PROC (proc data)");
17417     case NT_FREEBSD_PROCSTAT_FILES:
17418       return _("NT_PROCSTAT_FILES (files data)");
17419     case NT_FREEBSD_PROCSTAT_VMMAP:
17420       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17421     case NT_FREEBSD_PROCSTAT_GROUPS:
17422       return _("NT_PROCSTAT_GROUPS (groups data)");
17423     case NT_FREEBSD_PROCSTAT_UMASK:
17424       return _("NT_PROCSTAT_UMASK (umask data)");
17425     case NT_FREEBSD_PROCSTAT_RLIMIT:
17426       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17427     case NT_FREEBSD_PROCSTAT_OSREL:
17428       return _("NT_PROCSTAT_OSREL (osreldate data)");
17429     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17430       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17431     case NT_FREEBSD_PROCSTAT_AUXV:
17432       return _("NT_PROCSTAT_AUXV (auxv data)");
17433     case NT_FREEBSD_PTLWPINFO:
17434       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17435     }
17436   return get_note_type (filedata, e_type);
17437 }
17438
17439 static const char *
17440 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17441 {
17442   static char buff[64];
17443
17444   if (e_type == NT_NETBSDCORE_PROCINFO)
17445     return _("NetBSD procinfo structure");
17446
17447   /* As of Jan 2002 there are no other machine-independent notes
17448      defined for NetBSD core files.  If the note type is less
17449      than the start of the machine-dependent note types, we don't
17450      understand it.  */
17451
17452   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17453     {
17454       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17455       return buff;
17456     }
17457
17458   switch (filedata->file_header.e_machine)
17459     {
17460     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17461        and PT_GETFPREGS == mach+2.  */
17462
17463     case EM_OLD_ALPHA:
17464     case EM_ALPHA:
17465     case EM_SPARC:
17466     case EM_SPARC32PLUS:
17467     case EM_SPARCV9:
17468       switch (e_type)
17469         {
17470         case NT_NETBSDCORE_FIRSTMACH + 0:
17471           return _("PT_GETREGS (reg structure)");
17472         case NT_NETBSDCORE_FIRSTMACH + 2:
17473           return _("PT_GETFPREGS (fpreg structure)");
17474         default:
17475           break;
17476         }
17477       break;
17478
17479     /* On all other arch's, PT_GETREGS == mach+1 and
17480        PT_GETFPREGS == mach+3.  */
17481     default:
17482       switch (e_type)
17483         {
17484         case NT_NETBSDCORE_FIRSTMACH + 1:
17485           return _("PT_GETREGS (reg structure)");
17486         case NT_NETBSDCORE_FIRSTMACH + 3:
17487           return _("PT_GETFPREGS (fpreg structure)");
17488         default:
17489           break;
17490         }
17491     }
17492
17493   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17494             e_type - NT_NETBSDCORE_FIRSTMACH);
17495   return buff;
17496 }
17497
17498 static const char *
17499 get_stapsdt_note_type (unsigned e_type)
17500 {
17501   static char buff[64];
17502
17503   switch (e_type)
17504     {
17505     case NT_STAPSDT:
17506       return _("NT_STAPSDT (SystemTap probe descriptors)");
17507
17508     default:
17509       break;
17510     }
17511
17512   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17513   return buff;
17514 }
17515
17516 static bfd_boolean
17517 print_stapsdt_note (Elf_Internal_Note *pnote)
17518 {
17519   int addr_size = is_32bit_elf ? 4 : 8;
17520   char *data = pnote->descdata;
17521   char *data_end = pnote->descdata + pnote->descsz;
17522   bfd_vma pc, base_addr, semaphore;
17523   char *provider, *probe, *arg_fmt;
17524
17525   pc = byte_get ((unsigned char *) data, addr_size);
17526   data += addr_size;
17527   base_addr = byte_get ((unsigned char *) data, addr_size);
17528   data += addr_size;
17529   semaphore = byte_get ((unsigned char *) data, addr_size);
17530   data += addr_size;
17531
17532   provider = data;
17533   data += strlen (data) + 1;
17534   probe = data;
17535   data += strlen (data) + 1;
17536   arg_fmt = data;
17537   data += strlen (data) + 1;
17538
17539   printf (_("    Provider: %s\n"), provider);
17540   printf (_("    Name: %s\n"), probe);
17541   printf (_("    Location: "));
17542   print_vma (pc, FULL_HEX);
17543   printf (_(", Base: "));
17544   print_vma (base_addr, FULL_HEX);
17545   printf (_(", Semaphore: "));
17546   print_vma (semaphore, FULL_HEX);
17547   printf ("\n");
17548   printf (_("    Arguments: %s\n"), arg_fmt);
17549
17550   return data == data_end;
17551 }
17552
17553 static const char *
17554 get_ia64_vms_note_type (unsigned e_type)
17555 {
17556   static char buff[64];
17557
17558   switch (e_type)
17559     {
17560     case NT_VMS_MHD:
17561       return _("NT_VMS_MHD (module header)");
17562     case NT_VMS_LNM:
17563       return _("NT_VMS_LNM (language name)");
17564     case NT_VMS_SRC:
17565       return _("NT_VMS_SRC (source files)");
17566     case NT_VMS_TITLE:
17567       return "NT_VMS_TITLE";
17568     case NT_VMS_EIDC:
17569       return _("NT_VMS_EIDC (consistency check)");
17570     case NT_VMS_FPMODE:
17571       return _("NT_VMS_FPMODE (FP mode)");
17572     case NT_VMS_LINKTIME:
17573       return "NT_VMS_LINKTIME";
17574     case NT_VMS_IMGNAM:
17575       return _("NT_VMS_IMGNAM (image name)");
17576     case NT_VMS_IMGID:
17577       return _("NT_VMS_IMGID (image id)");
17578     case NT_VMS_LINKID:
17579       return _("NT_VMS_LINKID (link id)");
17580     case NT_VMS_IMGBID:
17581       return _("NT_VMS_IMGBID (build id)");
17582     case NT_VMS_GSTNAM:
17583       return _("NT_VMS_GSTNAM (sym table name)");
17584     case NT_VMS_ORIG_DYN:
17585       return "NT_VMS_ORIG_DYN";
17586     case NT_VMS_PATCHTIME:
17587       return "NT_VMS_PATCHTIME";
17588     default:
17589       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17590       return buff;
17591     }
17592 }
17593
17594 static bfd_boolean
17595 print_ia64_vms_note (Elf_Internal_Note * pnote)
17596 {
17597   switch (pnote->type)
17598     {
17599     case NT_VMS_MHD:
17600       if (pnote->descsz > 36)
17601         {
17602           size_t l = strlen (pnote->descdata + 34);
17603           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17604           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17605           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17606           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17607         }
17608       else
17609         printf (_("    Invalid size\n"));
17610       break;
17611     case NT_VMS_LNM:
17612       printf (_("   Language: %s\n"), pnote->descdata);
17613       break;
17614 #ifdef BFD64
17615     case NT_VMS_FPMODE:
17616       printf (_("   Floating Point mode: "));
17617       printf ("0x%016" BFD_VMA_FMT "x\n",
17618               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17619       break;
17620     case NT_VMS_LINKTIME:
17621       printf (_("   Link time: "));
17622       print_vms_time
17623         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17624       printf ("\n");
17625       break;
17626     case NT_VMS_PATCHTIME:
17627       printf (_("   Patch time: "));
17628       print_vms_time
17629         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17630       printf ("\n");
17631       break;
17632     case NT_VMS_ORIG_DYN:
17633       printf (_("   Major id: %u,  minor id: %u\n"),
17634               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17635               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17636       printf (_("   Last modified  : "));
17637       print_vms_time
17638         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17639       printf (_("\n   Link flags  : "));
17640       printf ("0x%016" BFD_VMA_FMT "x\n",
17641               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17642       printf (_("   Header flags: 0x%08x\n"),
17643               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17644       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17645       break;
17646 #endif
17647     case NT_VMS_IMGNAM:
17648       printf (_("    Image name: %s\n"), pnote->descdata);
17649       break;
17650     case NT_VMS_GSTNAM:
17651       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17652       break;
17653     case NT_VMS_IMGID:
17654       printf (_("    Image id: %s\n"), pnote->descdata);
17655       break;
17656     case NT_VMS_LINKID:
17657       printf (_("    Linker id: %s\n"), pnote->descdata);
17658       break;
17659     default:
17660       return FALSE;
17661     }
17662   return TRUE;
17663 }
17664
17665 /* Find the symbol associated with a build attribute that is attached
17666    to address OFFSET.  If PNAME is non-NULL then store the name of
17667    the symbol (if found) in the provided pointer,  Returns NULL if a
17668    symbol could not be found.  */
17669
17670 static Elf_Internal_Sym *
17671 get_symbol_for_build_attribute (Filedata *       filedata,
17672                                 unsigned long    offset,
17673                                 bfd_boolean      is_open_attr,
17674                                 const char **    pname)
17675 {
17676   static Filedata *         saved_filedata = NULL;
17677   static char *             strtab;
17678   static unsigned long      strtablen;
17679   static Elf_Internal_Sym * symtab;
17680   static unsigned long      nsyms;
17681   Elf_Internal_Sym *        saved_sym = NULL;
17682   Elf_Internal_Sym *        sym;
17683
17684   if (filedata->section_headers != NULL
17685       && (saved_filedata == NULL || filedata != saved_filedata))
17686     {
17687       Elf_Internal_Shdr * symsec;
17688
17689       /* Load the symbol and string sections.  */
17690       for (symsec = filedata->section_headers;
17691            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17692            symsec ++)
17693         {
17694           if (symsec->sh_type == SHT_SYMTAB)
17695             {
17696               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17697
17698               if (symsec->sh_link < filedata->file_header.e_shnum)
17699                 {
17700                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17701
17702                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17703                                               1, strtab_sec->sh_size,
17704                                               _("string table"));
17705                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17706                 }
17707             }
17708         }
17709       saved_filedata = filedata;
17710     }
17711
17712   if (symtab == NULL || strtab == NULL)
17713     return NULL;
17714
17715   /* Find a symbol whose value matches offset.  */
17716   for (sym = symtab; sym < symtab + nsyms; sym ++)
17717     if (sym->st_value == offset)
17718       {
17719         if (sym->st_name >= strtablen)
17720           /* Huh ?  This should not happen.  */
17721           continue;
17722
17723         if (strtab[sym->st_name] == 0)
17724           continue;
17725
17726         /* The AArch64 and ARM architectures define mapping symbols
17727            (eg $d, $x, $t) which we want to ignore.  */
17728         if (strtab[sym->st_name] == '$'
17729             && strtab[sym->st_name + 1] != 0
17730             && strtab[sym->st_name + 2] == 0)
17731           continue;
17732
17733         if (is_open_attr)
17734           {
17735             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17736                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17737                FUNC symbols entirely.  */
17738             switch (ELF_ST_TYPE (sym->st_info))
17739               {
17740               case STT_OBJECT:
17741               case STT_FILE:
17742                 saved_sym = sym;
17743                 if (sym->st_size)
17744                   {
17745                     /* If the symbol has a size associated
17746                        with it then we can stop searching.  */
17747                     sym = symtab + nsyms;
17748                   }
17749                 continue;
17750
17751               case STT_FUNC:
17752                 /* Ignore function symbols.  */
17753                 continue;
17754
17755               default:
17756                 break;
17757               }
17758
17759             switch (ELF_ST_BIND (sym->st_info))
17760               {
17761               case STB_GLOBAL:
17762                 if (saved_sym == NULL
17763                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17764                   saved_sym = sym;
17765                 break;
17766
17767               case STB_LOCAL:
17768                 if (saved_sym == NULL)
17769                   saved_sym = sym;
17770                 break;
17771
17772               default:
17773                 break;
17774               }
17775           }
17776         else
17777           {
17778             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17779               continue;
17780
17781             saved_sym = sym;
17782             break;
17783           }
17784       }
17785
17786   if (saved_sym && pname)
17787     * pname = strtab + saved_sym->st_name;
17788
17789   return saved_sym;
17790 }
17791
17792 /* Returns true iff addr1 and addr2 are in the same section.  */
17793
17794 static bfd_boolean
17795 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
17796 {
17797   Elf_Internal_Shdr * a1;
17798   Elf_Internal_Shdr * a2;
17799
17800   a1 = find_section_by_address (filedata, addr1);
17801   a2 = find_section_by_address (filedata, addr2);
17802
17803   return a1 == a2 && a1 != NULL;
17804 }
17805
17806 static bfd_boolean
17807 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
17808                                        Filedata *           filedata)
17809 {
17810   static unsigned long  global_offset = 0;
17811   static unsigned long  global_end = 0;
17812   static unsigned long  func_offset = 0;
17813   static unsigned long  func_end = 0;
17814
17815   Elf_Internal_Sym *    sym;
17816   const char *          name;
17817   unsigned long         start;
17818   unsigned long         end;
17819   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17820
17821   switch (pnote->descsz)
17822     {
17823     case 0:
17824       /* A zero-length description means that the range of
17825          the previous note of the same type should be used.  */
17826       if (is_open_attr)
17827         {
17828           if (global_end > global_offset)
17829             printf (_("    Applies to region from %#lx to %#lx\n"),
17830                     global_offset, global_end);
17831           else
17832             printf (_("    Applies to region from %#lx\n"), global_offset);
17833         }
17834       else
17835         {
17836           if (func_end > func_offset)
17837             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
17838           else
17839             printf (_("    Applies to region from %#lx\n"), func_offset);
17840         }
17841       return TRUE;
17842
17843     case 4:
17844       start = byte_get ((unsigned char *) pnote->descdata, 4);
17845       end = 0;
17846       break;
17847
17848     case 8:
17849       if (is_32bit_elf)
17850         {
17851           /* FIXME: We should check that version 3+ notes are being used here...  */
17852           start = byte_get ((unsigned char *) pnote->descdata, 4);
17853           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17854         }
17855       else
17856         {
17857           start = byte_get ((unsigned char *) pnote->descdata, 8);
17858           end = 0;
17859         }
17860       break;
17861
17862     case 16:
17863       start = byte_get ((unsigned char *) pnote->descdata, 8);
17864       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
17865       break;
17866
17867     default:
17868       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17869       printf (_("    <invalid descsz>"));
17870       return FALSE;
17871     }
17872
17873   name = NULL;
17874   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
17875   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17876      in order to avoid them being confused with the start address of the
17877      first function in the file...  */
17878   if (sym == NULL && is_open_attr)
17879     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
17880                                           & name);
17881
17882   if (end == 0 && sym != NULL && sym->st_size > 0)
17883     end = start + sym->st_size;
17884
17885   if (is_open_attr)
17886     {
17887       /* FIXME: Need to properly allow for section alignment.
17888          16 is just the alignment used on x86_64.  */
17889       if (global_end > 0
17890           && start > BFD_ALIGN (global_end, 16)
17891           /* Build notes are not guaranteed to be organised in order of
17892              increasing address, but we should find the all of the notes
17893              for one section in the same place.  */
17894           && same_section (filedata, start, global_end))
17895         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17896               global_end + 1, start - 1);
17897
17898       printf (_("    Applies to region from %#lx"), start);
17899       global_offset = start;
17900
17901       if (end)
17902         {
17903           printf (_(" to %#lx"), end);
17904           global_end = end;
17905         }
17906     }
17907   else
17908     {
17909       printf (_("    Applies to region from %#lx"), start);
17910       func_offset = start;
17911
17912       if (end)
17913         {
17914           printf (_(" to %#lx"), end);
17915           func_end = end;
17916         }
17917     }
17918
17919   if (sym && name)
17920     printf (_(" (%s)"), name);
17921
17922   printf ("\n");
17923   return TRUE;
17924 }
17925
17926 static bfd_boolean
17927 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17928 {
17929   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17930   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17931   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17932   char         name_type;
17933   char         name_attribute;
17934   const char * expected_types;
17935   const char * name = pnote->namedata;
17936   const char * text;
17937   signed int   left;
17938
17939   if (name == NULL || pnote->namesz < 2)
17940     {
17941       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17942       print_symbol (-20, _("  <corrupt name>"));
17943       return FALSE;
17944     }
17945
17946   if (do_wide)
17947     left = 28;
17948   else
17949     left = 20;
17950
17951   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17952   if (name[0] == 'G' && name[1] == 'A')
17953     {
17954       if (pnote->namesz < 4)
17955         {
17956           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17957           print_symbol (-20, _("  <corrupt name>"));
17958           return FALSE;
17959         }
17960
17961       printf ("GA");
17962       name += 2;
17963       left -= 2;
17964     }
17965
17966   switch ((name_type = * name))
17967     {
17968     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17969     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17970     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17971     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17972       printf ("%c", * name);
17973       left --;
17974       break;
17975     default:
17976       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17977       print_symbol (-20, _("<unknown name type>"));
17978       return FALSE;
17979     }
17980
17981   ++ name;
17982   text = NULL;
17983
17984   switch ((name_attribute = * name))
17985     {
17986     case GNU_BUILD_ATTRIBUTE_VERSION:
17987       text = _("<version>");
17988       expected_types = string_expected;
17989       ++ name;
17990       break;
17991     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17992       text = _("<stack prot>");
17993       expected_types = "!+*";
17994       ++ name;
17995       break;
17996     case GNU_BUILD_ATTRIBUTE_RELRO:
17997       text = _("<relro>");
17998       expected_types = bool_expected;
17999       ++ name;
18000       break;
18001     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18002       text = _("<stack size>");
18003       expected_types = number_expected;
18004       ++ name;
18005       break;
18006     case GNU_BUILD_ATTRIBUTE_TOOL:
18007       text = _("<tool>");
18008       expected_types = string_expected;
18009       ++ name;
18010       break;
18011     case GNU_BUILD_ATTRIBUTE_ABI:
18012       text = _("<ABI>");
18013       expected_types = "$*";
18014       ++ name;
18015       break;
18016     case GNU_BUILD_ATTRIBUTE_PIC:
18017       text = _("<PIC>");
18018       expected_types = number_expected;
18019       ++ name;
18020       break;
18021     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18022       text = _("<short enum>");
18023       expected_types = bool_expected;
18024       ++ name;
18025       break;
18026     default:
18027       if (ISPRINT (* name))
18028         {
18029           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18030
18031           if (len > left && ! do_wide)
18032             len = left;
18033           printf ("%.*s:", len, name);
18034           left -= len;
18035           name += len;
18036         }
18037       else
18038         {
18039           static char tmpbuf [128];
18040
18041           error (_("unrecognised byte in name field: %d\n"), * name);
18042           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18043           text = tmpbuf;
18044           name ++;
18045         }
18046       expected_types = "*$!+";
18047       break;
18048     }
18049
18050   if (text)
18051     left -= printf ("%s", text);
18052
18053   if (strchr (expected_types, name_type) == NULL)
18054     warn (_("attribute does not have an expected type (%c)\n"), name_type);
18055
18056   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18057     {
18058       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18059              (unsigned long) pnote->namesz,
18060              (long) (name - pnote->namedata));
18061       return FALSE;
18062     }
18063
18064   if (left < 1 && ! do_wide)
18065     return TRUE;
18066
18067   switch (name_type)
18068     {
18069     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18070       {
18071         unsigned int        bytes;
18072         unsigned long long  val = 0;
18073         unsigned int        shift = 0;
18074         char *              decoded = NULL;
18075
18076         bytes = pnote->namesz - (name - pnote->namedata);
18077         if (bytes > 0)
18078           /* The -1 is because the name field is always 0 terminated, and we
18079              want to be able to ensure that the shift in the while loop below
18080              will not overflow.  */
18081           -- bytes;
18082
18083         if (bytes > sizeof (val))
18084           {
18085             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18086                    bytes);
18087             bytes = sizeof (val);
18088           }
18089         /* We do not bother to warn if bytes == 0 as this can
18090            happen with some early versions of the gcc plugin.  */
18091
18092         while (bytes --)
18093           {
18094             unsigned long byte = (* name ++) & 0xff;
18095
18096             val |= byte << shift;
18097             shift += 8;
18098           }
18099
18100         switch (name_attribute)
18101           {
18102           case GNU_BUILD_ATTRIBUTE_PIC:
18103             switch (val)
18104               {
18105               case 0: decoded = "static"; break;
18106               case 1: decoded = "pic"; break;
18107               case 2: decoded = "PIC"; break;
18108               case 3: decoded = "pie"; break;
18109               case 4: decoded = "PIE"; break;
18110               default: break;
18111               }
18112             break;
18113           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18114             switch (val)
18115               {
18116                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
18117               case 0: decoded = "off"; break;
18118               case 1: decoded = "on"; break;
18119               case 2: decoded = "all"; break;
18120               case 3: decoded = "strong"; break;
18121               case 4: decoded = "explicit"; break;
18122               default: break;
18123               }
18124             break;
18125           default:
18126             break;
18127           }
18128
18129         if (decoded != NULL)
18130           {
18131             print_symbol (-left, decoded);
18132             left = 0;
18133           }
18134         else if (val == 0)
18135           {
18136             printf ("0x0");
18137             left -= 3;
18138           }
18139         else
18140           {
18141             if (do_wide)
18142               left -= printf ("0x%llx", val);
18143             else
18144               left -= printf ("0x%-.*llx", left, val);
18145           }
18146       }
18147       break;
18148     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18149       left -= print_symbol (- left, name);
18150       break;
18151     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18152       left -= print_symbol (- left, "true");
18153       break;
18154     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18155       left -= print_symbol (- left, "false");
18156       break;
18157     }
18158
18159   if (do_wide && left > 0)
18160     printf ("%-*s", left, " ");
18161
18162   return TRUE;
18163 }
18164
18165 /* Note that by the ELF standard, the name field is already null byte
18166    terminated, and namesz includes the terminating null byte.
18167    I.E. the value of namesz for the name "FSF" is 4.
18168
18169    If the value of namesz is zero, there is no name present.  */
18170
18171 static bfd_boolean
18172 process_note (Elf_Internal_Note *  pnote,
18173               Filedata *           filedata)
18174 {
18175   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18176   const char * nt;
18177
18178   if (pnote->namesz == 0)
18179     /* If there is no note name, then use the default set of
18180        note type strings.  */
18181     nt = get_note_type (filedata, pnote->type);
18182
18183   else if (const_strneq (pnote->namedata, "GNU"))
18184     /* GNU-specific object file notes.  */
18185     nt = get_gnu_elf_note_type (pnote->type);
18186
18187   else if (const_strneq (pnote->namedata, "FreeBSD"))
18188     /* FreeBSD-specific core file notes.  */
18189     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18190
18191   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18192     /* NetBSD-specific core file notes.  */
18193     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18194
18195   else if (const_strneq (pnote->namedata, "NetBSD"))
18196     /* NetBSD-specific core file notes.  */
18197     return process_netbsd_elf_note (pnote);
18198
18199   else if (strneq (pnote->namedata, "SPU/", 4))
18200     {
18201       /* SPU-specific core file notes.  */
18202       nt = pnote->namedata + 4;
18203       name = "SPU";
18204     }
18205
18206   else if (const_strneq (pnote->namedata, "IPF/VMS"))
18207     /* VMS/ia64-specific file notes.  */
18208     nt = get_ia64_vms_note_type (pnote->type);
18209
18210   else if (const_strneq (pnote->namedata, "stapsdt"))
18211     nt = get_stapsdt_note_type (pnote->type);
18212
18213   else
18214     /* Don't recognize this note name; just use the default set of
18215        note type strings.  */
18216     nt = get_note_type (filedata, pnote->type);
18217
18218   printf ("  ");
18219
18220   if (((const_strneq (pnote->namedata, "GA")
18221         && strchr ("*$!+", pnote->namedata[2]) != NULL)
18222        || strchr ("*$!+", pnote->namedata[0]) != NULL)
18223       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18224           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18225     print_gnu_build_attribute_name (pnote);
18226   else
18227     print_symbol (-20, name);
18228
18229   if (do_wide)
18230     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18231   else
18232     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18233
18234   if (const_strneq (pnote->namedata, "IPF/VMS"))
18235     return print_ia64_vms_note (pnote);
18236   else if (const_strneq (pnote->namedata, "GNU"))
18237     return print_gnu_note (filedata, pnote);
18238   else if (const_strneq (pnote->namedata, "stapsdt"))
18239     return print_stapsdt_note (pnote);
18240   else if (const_strneq (pnote->namedata, "CORE"))
18241     return print_core_note (pnote);
18242   else if (((const_strneq (pnote->namedata, "GA")
18243              && strchr ("*$!+", pnote->namedata[2]) != NULL)
18244             || strchr ("*$!+", pnote->namedata[0]) != NULL)
18245            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18246                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18247     return print_gnu_build_attribute_description (pnote, filedata);
18248
18249   if (pnote->descsz)
18250     {
18251       unsigned long i;
18252
18253       printf (_("   description data: "));
18254       for (i = 0; i < pnote->descsz; i++)
18255         printf ("%02x ", pnote->descdata[i]);
18256       if (!do_wide)
18257         printf ("\n");
18258     }
18259
18260   if (do_wide)
18261     printf ("\n");
18262
18263   return TRUE;
18264 }
18265
18266 static bfd_boolean
18267 process_notes_at (Filedata *           filedata,
18268                   Elf_Internal_Shdr *  section,
18269                   bfd_vma              offset,
18270                   bfd_vma              length,
18271                   bfd_vma              align)
18272 {
18273   Elf_External_Note * pnotes;
18274   Elf_External_Note * external;
18275   char *              end;
18276   bfd_boolean         res = TRUE;
18277
18278   if (length <= 0)
18279     return FALSE;
18280
18281   if (section)
18282     {
18283       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18284       if (pnotes)
18285         {
18286           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18287             return FALSE;
18288         }
18289     }
18290   else
18291     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18292                                              _("notes"));
18293
18294   if (pnotes == NULL)
18295     return FALSE;
18296
18297   external = pnotes;
18298
18299   if (section)
18300     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18301   else
18302     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18303             (unsigned long) offset, (unsigned long) length);
18304
18305   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18306      specifies that notes should be aligned to 4 bytes in 32-bit
18307      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18308      we also support 4 byte alignment in 64-bit objects.  If section
18309      alignment is less than 4, we treate alignment as 4 bytes.   */
18310   if (align < 4)
18311     align = 4;
18312   else if (align != 4 && align != 8)
18313     {
18314       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18315             (long) align);
18316       return FALSE;
18317     }
18318
18319   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18320
18321   end = (char *) pnotes + length;
18322   while ((char *) external < end)
18323     {
18324       Elf_Internal_Note inote;
18325       size_t min_notesz;
18326       char * next;
18327       char * temp = NULL;
18328       size_t data_remaining = end - (char *) external;
18329
18330       if (!is_ia64_vms (filedata))
18331         {
18332           /* PR binutils/15191
18333              Make sure that there is enough data to read.  */
18334           min_notesz = offsetof (Elf_External_Note, name);
18335           if (data_remaining < min_notesz)
18336             {
18337               warn (ngettext ("Corrupt note: only %ld byte remains, "
18338                               "not enough for a full note\n",
18339                               "Corrupt note: only %ld bytes remain, "
18340                               "not enough for a full note\n",
18341                               data_remaining),
18342                     (long) data_remaining);
18343               break;
18344             }
18345           data_remaining -= min_notesz;
18346
18347           inote.type     = BYTE_GET (external->type);
18348           inote.namesz   = BYTE_GET (external->namesz);
18349           inote.namedata = external->name;
18350           inote.descsz   = BYTE_GET (external->descsz);
18351           inote.descdata = ((char *) external
18352                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18353           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18354           next = ((char *) external
18355                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18356         }
18357       else
18358         {
18359           Elf64_External_VMS_Note *vms_external;
18360
18361           /* PR binutils/15191
18362              Make sure that there is enough data to read.  */
18363           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18364           if (data_remaining < min_notesz)
18365             {
18366               warn (ngettext ("Corrupt note: only %ld byte remains, "
18367                               "not enough for a full note\n",
18368                               "Corrupt note: only %ld bytes remain, "
18369                               "not enough for a full note\n",
18370                               data_remaining),
18371                     (long) data_remaining);
18372               break;
18373             }
18374           data_remaining -= min_notesz;
18375
18376           vms_external = (Elf64_External_VMS_Note *) external;
18377           inote.type     = BYTE_GET (vms_external->type);
18378           inote.namesz   = BYTE_GET (vms_external->namesz);
18379           inote.namedata = vms_external->name;
18380           inote.descsz   = BYTE_GET (vms_external->descsz);
18381           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18382           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18383           next = inote.descdata + align_power (inote.descsz, 3);
18384         }
18385
18386       /* PR 17531: file: 3443835e.  */
18387       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18388       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18389           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18390           || (size_t) (next - inote.descdata) < inote.descsz
18391           || ((size_t) (next - inote.descdata)
18392               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18393         {
18394           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18395                 (unsigned long) ((char *) external - (char *) pnotes));
18396           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18397                 inote.type, inote.namesz, inote.descsz, (int) align);
18398           break;
18399         }
18400
18401       external = (Elf_External_Note *) next;
18402
18403       /* Verify that name is null terminated.  It appears that at least
18404          one version of Linux (RedHat 6.0) generates corefiles that don't
18405          comply with the ELF spec by failing to include the null byte in
18406          namesz.  */
18407       if (inote.namedata[inote.namesz - 1] != '\0')
18408         {
18409           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18410             {
18411               temp = (char *) malloc (inote.namesz + 1);
18412               if (temp == NULL)
18413                 {
18414                   error (_("Out of memory allocating space for inote name\n"));
18415                   res = FALSE;
18416                   break;
18417                 }
18418
18419               memcpy (temp, inote.namedata, inote.namesz);
18420               inote.namedata = temp;
18421             }
18422           inote.namedata[inote.namesz] = 0;
18423         }
18424
18425       if (! process_note (& inote, filedata))
18426         res = FALSE;
18427
18428       if (temp != NULL)
18429         {
18430           free (temp);
18431           temp = NULL;
18432         }
18433     }
18434
18435   free (pnotes);
18436
18437   return res;
18438 }
18439
18440 static bfd_boolean
18441 process_corefile_note_segments (Filedata * filedata)
18442 {
18443   Elf_Internal_Phdr * segment;
18444   unsigned int i;
18445   bfd_boolean res = TRUE;
18446
18447   if (! get_program_headers (filedata))
18448     return TRUE;
18449
18450   for (i = 0, segment = filedata->program_headers;
18451        i < filedata->file_header.e_phnum;
18452        i++, segment++)
18453     {
18454       if (segment->p_type == PT_NOTE)
18455         if (! process_notes_at (filedata, NULL,
18456                                 (bfd_vma) segment->p_offset,
18457                                 (bfd_vma) segment->p_filesz,
18458                                 (bfd_vma) segment->p_align))
18459           res = FALSE;
18460     }
18461
18462   return res;
18463 }
18464
18465 static bfd_boolean
18466 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18467 {
18468   Elf_External_Note * pnotes;
18469   Elf_External_Note * external;
18470   char * end;
18471   bfd_boolean res = TRUE;
18472
18473   if (length <= 0)
18474     return FALSE;
18475
18476   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18477                                            _("v850 notes"));
18478   if (pnotes == NULL)
18479     return FALSE;
18480
18481   external = pnotes;
18482   end = (char*) pnotes + length;
18483
18484   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18485           (unsigned long) offset, (unsigned long) length);
18486
18487   while ((char *) external + sizeof (Elf_External_Note) < end)
18488     {
18489       Elf_External_Note * next;
18490       Elf_Internal_Note inote;
18491
18492       inote.type     = BYTE_GET (external->type);
18493       inote.namesz   = BYTE_GET (external->namesz);
18494       inote.namedata = external->name;
18495       inote.descsz   = BYTE_GET (external->descsz);
18496       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18497       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18498
18499       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18500         {
18501           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18502           inote.descdata = inote.namedata;
18503           inote.namesz   = 0;
18504         }
18505
18506       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18507
18508       if (   ((char *) next > end)
18509           || ((char *) next <  (char *) pnotes))
18510         {
18511           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18512                 (unsigned long) ((char *) external - (char *) pnotes));
18513           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18514                 inote.type, inote.namesz, inote.descsz);
18515           break;
18516         }
18517
18518       external = next;
18519
18520       /* Prevent out-of-bounds indexing.  */
18521       if (   inote.namedata + inote.namesz > end
18522           || inote.namedata + inote.namesz < inote.namedata)
18523         {
18524           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18525                 (unsigned long) ((char *) external - (char *) pnotes));
18526           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18527                 inote.type, inote.namesz, inote.descsz);
18528           break;
18529         }
18530
18531       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18532
18533       if (! print_v850_note (& inote))
18534         {
18535           res = FALSE;
18536           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18537                   inote.namesz, inote.descsz);
18538         }
18539     }
18540
18541   free (pnotes);
18542
18543   return res;
18544 }
18545
18546 static bfd_boolean
18547 process_note_sections (Filedata * filedata)
18548 {
18549   Elf_Internal_Shdr * section;
18550   unsigned long i;
18551   unsigned int n = 0;
18552   bfd_boolean res = TRUE;
18553
18554   for (i = 0, section = filedata->section_headers;
18555        i < filedata->file_header.e_shnum && section != NULL;
18556        i++, section++)
18557     {
18558       if (section->sh_type == SHT_NOTE)
18559         {
18560           if (! process_notes_at (filedata, section,
18561                                   (bfd_vma) section->sh_offset,
18562                                   (bfd_vma) section->sh_size,
18563                                   (bfd_vma) section->sh_addralign))
18564             res = FALSE;
18565           n++;
18566         }
18567
18568       if ((   filedata->file_header.e_machine == EM_V800
18569            || filedata->file_header.e_machine == EM_V850
18570            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18571           && section->sh_type == SHT_RENESAS_INFO)
18572         {
18573           if (! process_v850_notes (filedata,
18574                                     (bfd_vma) section->sh_offset,
18575                                     (bfd_vma) section->sh_size))
18576             res = FALSE;
18577           n++;
18578         }
18579     }
18580
18581   if (n == 0)
18582     /* Try processing NOTE segments instead.  */
18583     return process_corefile_note_segments (filedata);
18584
18585   return res;
18586 }
18587
18588 static bfd_boolean
18589 process_notes (Filedata * filedata)
18590 {
18591   /* If we have not been asked to display the notes then do nothing.  */
18592   if (! do_notes)
18593     return TRUE;
18594
18595   if (filedata->file_header.e_type != ET_CORE)
18596     return process_note_sections (filedata);
18597
18598   /* No program headers means no NOTE segment.  */
18599   if (filedata->file_header.e_phnum > 0)
18600     return process_corefile_note_segments (filedata);
18601
18602   printf (_("No note segments present in the core file.\n"));
18603   return TRUE;
18604 }
18605
18606 static unsigned char *
18607 display_public_gnu_attributes (unsigned char * start,
18608                                const unsigned char * const end)
18609 {
18610   printf (_("  Unknown GNU attribute: %s\n"), start);
18611
18612   start += strnlen ((char *) start, end - start);
18613   display_raw_attribute (start, end);
18614
18615   return (unsigned char *) end;
18616 }
18617
18618 static unsigned char *
18619 display_generic_attribute (unsigned char * start,
18620                            unsigned int tag,
18621                            const unsigned char * const end)
18622 {
18623   if (tag == 0)
18624     return (unsigned char *) end;
18625
18626   return display_tag_value (tag, start, end);
18627 }
18628
18629 static bfd_boolean
18630 process_arch_specific (Filedata * filedata)
18631 {
18632   if (! do_arch)
18633     return TRUE;
18634
18635   switch (filedata->file_header.e_machine)
18636     {
18637     case EM_ARC:
18638     case EM_ARC_COMPACT:
18639     case EM_ARC_COMPACT2:
18640       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18641                                  display_arc_attribute,
18642                                  display_generic_attribute);
18643     case EM_ARM:
18644       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18645                                  display_arm_attribute,
18646                                  display_generic_attribute);
18647
18648     case EM_MIPS:
18649     case EM_MIPS_RS3_LE:
18650       return process_mips_specific (filedata);
18651
18652     case EM_MSP430:
18653      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18654                                 display_msp430x_attribute,
18655                                 display_generic_attribute);
18656
18657     case EM_NDS32:
18658       return process_nds32_specific (filedata);
18659
18660     case EM_PPC:
18661     case EM_PPC64:
18662       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18663                                  display_power_gnu_attribute);
18664
18665     case EM_S390:
18666     case EM_S390_OLD:
18667       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18668                                  display_s390_gnu_attribute);
18669
18670     case EM_SPARC:
18671     case EM_SPARC32PLUS:
18672     case EM_SPARCV9:
18673       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18674                                  display_sparc_gnu_attribute);
18675
18676     case EM_TI_C6000:
18677       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18678                                  display_tic6x_attribute,
18679                                  display_generic_attribute);
18680
18681     default:
18682       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18683                                  display_public_gnu_attributes,
18684                                  display_generic_attribute);
18685     }
18686 }
18687
18688 static bfd_boolean
18689 get_file_header (Filedata * filedata)
18690 {
18691   /* Read in the identity array.  */
18692   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18693     return FALSE;
18694
18695   /* Determine how to read the rest of the header.  */
18696   switch (filedata->file_header.e_ident[EI_DATA])
18697     {
18698     default:
18699     case ELFDATANONE:
18700     case ELFDATA2LSB:
18701       byte_get = byte_get_little_endian;
18702       byte_put = byte_put_little_endian;
18703       break;
18704     case ELFDATA2MSB:
18705       byte_get = byte_get_big_endian;
18706       byte_put = byte_put_big_endian;
18707       break;
18708     }
18709
18710   /* For now we only support 32 bit and 64 bit ELF files.  */
18711   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18712
18713   /* Read in the rest of the header.  */
18714   if (is_32bit_elf)
18715     {
18716       Elf32_External_Ehdr ehdr32;
18717
18718       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18719         return FALSE;
18720
18721       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18722       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18723       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18724       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18725       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18726       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18727       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18728       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18729       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18730       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18731       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18732       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18733       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18734     }
18735   else
18736     {
18737       Elf64_External_Ehdr ehdr64;
18738
18739       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18740          we will not be able to cope with the 64bit data found in
18741          64 ELF files.  Detect this now and abort before we start
18742          overwriting things.  */
18743       if (sizeof (bfd_vma) < 8)
18744         {
18745           error (_("This instance of readelf has been built without support for a\n\
18746 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18747           return FALSE;
18748         }
18749
18750       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18751         return FALSE;
18752
18753       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18754       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18755       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18756       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18757       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18758       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18759       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18760       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18761       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18762       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18763       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18764       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18765       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18766     }
18767
18768   if (filedata->file_header.e_shoff)
18769     {
18770       /* There may be some extensions in the first section header.  Don't
18771          bomb if we can't read it.  */
18772       if (is_32bit_elf)
18773         get_32bit_section_headers (filedata, TRUE);
18774       else
18775         get_64bit_section_headers (filedata, TRUE);
18776     }
18777
18778   return TRUE;
18779 }
18780
18781 static void
18782 close_file (Filedata * filedata)
18783 {
18784   if (filedata)
18785     {
18786       if (filedata->handle)
18787         fclose (filedata->handle);
18788       free (filedata);
18789     }
18790 }
18791
18792 void
18793 close_debug_file (void * data)
18794 {
18795   close_file ((Filedata *) data);
18796 }
18797
18798 static Filedata *
18799 open_file (const char * pathname)
18800 {
18801   struct stat  statbuf;
18802   Filedata *   filedata = NULL;
18803
18804   if (stat (pathname, & statbuf) < 0
18805       || ! S_ISREG (statbuf.st_mode))
18806     goto fail;
18807
18808   filedata = calloc (1, sizeof * filedata);
18809   if (filedata == NULL)
18810     goto fail;
18811
18812   filedata->handle = fopen (pathname, "rb");
18813   if (filedata->handle == NULL)
18814     goto fail;
18815
18816   filedata->file_size = (bfd_size_type) statbuf.st_size;
18817   filedata->file_name = pathname;
18818
18819   if (! get_file_header (filedata))
18820     goto fail;
18821
18822   if (filedata->file_header.e_shoff)
18823     {
18824       bfd_boolean res;
18825
18826       /* Read the section headers again, this time for real.  */
18827       if (is_32bit_elf)
18828         res = get_32bit_section_headers (filedata, FALSE);
18829       else
18830         res = get_64bit_section_headers (filedata, FALSE);
18831
18832       if (!res)
18833         goto fail;
18834     }
18835
18836   return filedata;
18837
18838  fail:
18839   if (filedata)
18840     {
18841       if (filedata->handle)
18842         fclose (filedata->handle);
18843       free (filedata);
18844     }
18845   return NULL;
18846 }
18847
18848 void *
18849 open_debug_file (const char * pathname)
18850 {
18851   return open_file (pathname);
18852 }
18853
18854 /* Process one ELF object file according to the command line options.
18855    This file may actually be stored in an archive.  The file is
18856    positioned at the start of the ELF object.  Returns TRUE if no
18857    problems were encountered, FALSE otherwise.  */
18858
18859 static bfd_boolean
18860 process_object (Filedata * filedata)
18861 {
18862   Filedata * separates;
18863   unsigned int i;
18864   bfd_boolean res = TRUE;
18865
18866   if (! get_file_header (filedata))
18867     {
18868       error (_("%s: Failed to read file header\n"), filedata->file_name);
18869       return FALSE;
18870     }
18871
18872   /* Initialise per file variables.  */
18873   for (i = ARRAY_SIZE (version_info); i--;)
18874     version_info[i] = 0;
18875
18876   for (i = ARRAY_SIZE (dynamic_info); i--;)
18877     dynamic_info[i] = 0;
18878   dynamic_info_DT_GNU_HASH = 0;
18879
18880   /* Process the file.  */
18881   if (show_name)
18882     printf (_("\nFile: %s\n"), filedata->file_name);
18883
18884   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18885      Note we do this even if cmdline_dump_sects is empty because we
18886      must make sure that the dump_sets array is zeroed out before each
18887      object file is processed.  */
18888   if (filedata->num_dump_sects > cmdline.num_dump_sects)
18889     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
18890
18891   if (cmdline.num_dump_sects > 0)
18892     {
18893       if (filedata->num_dump_sects == 0)
18894         /* A sneaky way of allocating the dump_sects array.  */
18895         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
18896
18897       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
18898       memcpy (filedata->dump_sects, cmdline.dump_sects,
18899               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
18900     }
18901
18902   if (! process_file_header (filedata))
18903     return FALSE;
18904
18905   if (! process_section_headers (filedata))
18906     {
18907       /* Without loaded section headers we cannot process lots of things.  */
18908       do_unwind = do_version = do_dump = do_arch = FALSE;
18909
18910       if (! do_using_dynamic)
18911         do_syms = do_dyn_syms = do_reloc = FALSE;
18912     }
18913
18914   if (! process_section_groups (filedata))
18915     /* Without loaded section groups we cannot process unwind.  */
18916     do_unwind = FALSE;
18917
18918   if (process_program_headers (filedata))
18919     process_dynamic_section (filedata);
18920   else
18921     res = FALSE;
18922
18923   if (! process_relocs (filedata))
18924     res = FALSE;
18925
18926   if (! process_unwind (filedata))
18927     res = FALSE;
18928
18929   if (! process_symbol_table (filedata))
18930     res = FALSE;
18931
18932   if (! process_syminfo (filedata))
18933     res = FALSE;
18934
18935   if (! process_version_sections (filedata))
18936     res = FALSE;
18937
18938   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
18939     separates = load_separate_debug_file (filedata, filedata->file_name);
18940   else
18941     separates = NULL;
18942
18943   if (! process_section_contents (filedata))
18944     res = FALSE;
18945
18946   if (separates)
18947     {
18948       if (! process_section_headers (separates))
18949         res = FALSE;
18950       else if (! process_section_contents (separates))
18951         res = FALSE;
18952     }
18953
18954   if (! process_notes (filedata))
18955     res = FALSE;
18956
18957   if (! process_gnu_liblist (filedata))
18958     res = FALSE;
18959
18960   if (! process_arch_specific (filedata))
18961     res = FALSE;
18962
18963   free (filedata->program_headers);
18964   filedata->program_headers = NULL;
18965
18966   free (filedata->section_headers);
18967   filedata->section_headers = NULL;
18968
18969   free (filedata->string_table);
18970   filedata->string_table = NULL;
18971   filedata->string_table_length = 0;
18972
18973   if (dynamic_strings)
18974     {
18975       free (dynamic_strings);
18976       dynamic_strings = NULL;
18977       dynamic_strings_length = 0;
18978     }
18979
18980   if (dynamic_symbols)
18981     {
18982       free (dynamic_symbols);
18983       dynamic_symbols = NULL;
18984       num_dynamic_syms = 0;
18985     }
18986
18987   if (dynamic_syminfo)
18988     {
18989       free (dynamic_syminfo);
18990       dynamic_syminfo = NULL;
18991     }
18992
18993   if (dynamic_section)
18994     {
18995       free (dynamic_section);
18996       dynamic_section = NULL;
18997     }
18998
18999   if (section_headers_groups)
19000     {
19001       free (section_headers_groups);
19002       section_headers_groups = NULL;
19003     }
19004
19005   if (section_groups)
19006     {
19007       struct group_list * g;
19008       struct group_list * next;
19009
19010       for (i = 0; i < group_count; i++)
19011         {
19012           for (g = section_groups [i].root; g != NULL; g = next)
19013             {
19014               next = g->next;
19015               free (g);
19016             }
19017         }
19018
19019       free (section_groups);
19020       section_groups = NULL;
19021     }
19022
19023   free_debug_memory ();
19024
19025   return res;
19026 }
19027
19028 /* Process an ELF archive.
19029    On entry the file is positioned just after the ARMAG string.
19030    Returns TRUE upon success, FALSE otherwise.  */
19031
19032 static bfd_boolean
19033 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19034 {
19035   struct archive_info arch;
19036   struct archive_info nested_arch;
19037   size_t got;
19038   bfd_boolean ret = TRUE;
19039
19040   show_name = TRUE;
19041
19042   /* The ARCH structure is used to hold information about this archive.  */
19043   arch.file_name = NULL;
19044   arch.file = NULL;
19045   arch.index_array = NULL;
19046   arch.sym_table = NULL;
19047   arch.longnames = NULL;
19048
19049   /* The NESTED_ARCH structure is used as a single-item cache of information
19050      about a nested archive (when members of a thin archive reside within
19051      another regular archive file).  */
19052   nested_arch.file_name = NULL;
19053   nested_arch.file = NULL;
19054   nested_arch.index_array = NULL;
19055   nested_arch.sym_table = NULL;
19056   nested_arch.longnames = NULL;
19057
19058   if (setup_archive (&arch, filedata->file_name, filedata->handle,
19059                      is_thin_archive, do_archive_index) != 0)
19060     {
19061       ret = FALSE;
19062       goto out;
19063     }
19064
19065   if (do_archive_index)
19066     {
19067       if (arch.sym_table == NULL)
19068         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19069       else
19070         {
19071           unsigned long i, l;
19072           unsigned long current_pos;
19073
19074           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19075                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19076
19077           current_pos = ftell (filedata->handle);
19078
19079           for (i = l = 0; i < arch.index_num; i++)
19080             {
19081               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19082                 {
19083                   char * member_name;
19084
19085                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19086
19087                   if (member_name != NULL)
19088                     {
19089                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19090
19091                       if (qualified_name != NULL)
19092                         {
19093                           printf (_("Contents of binary %s at offset "), qualified_name);
19094                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
19095                           putchar ('\n');
19096                           free (qualified_name);
19097                         }
19098                     }
19099                 }
19100
19101               if (l >= arch.sym_size)
19102                 {
19103                   error (_("%s: end of the symbol table reached before the end of the index\n"),
19104                          filedata->file_name);
19105                   ret = FALSE;
19106                   break;
19107                 }
19108               /* PR 17531: file: 0b6630b2.  */
19109               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19110               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19111             }
19112
19113           if (arch.uses_64bit_indices)
19114             l = (l + 7) & ~ 7;
19115           else
19116             l += l & 1;
19117
19118           if (l < arch.sym_size)
19119             {
19120               error (ngettext ("%s: %ld byte remains in the symbol table, "
19121                                "but without corresponding entries in "
19122                                "the index table\n",
19123                                "%s: %ld bytes remain in the symbol table, "
19124                                "but without corresponding entries in "
19125                                "the index table\n",
19126                                arch.sym_size - l),
19127                      filedata->file_name, arch.sym_size - l);
19128               ret = FALSE;
19129             }
19130
19131           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19132             {
19133               error (_("%s: failed to seek back to start of object files in the archive\n"),
19134                      filedata->file_name);
19135               ret = FALSE;
19136               goto out;
19137             }
19138         }
19139
19140       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19141           && !do_segments && !do_header && !do_dump && !do_version
19142           && !do_histogram && !do_debugging && !do_arch && !do_notes
19143           && !do_section_groups && !do_dyn_syms)
19144         {
19145           ret = TRUE; /* Archive index only.  */
19146           goto out;
19147         }
19148     }
19149
19150   while (1)
19151     {
19152       char * name;
19153       size_t namelen;
19154       char * qualified_name;
19155
19156       /* Read the next archive header.  */
19157       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19158         {
19159           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
19160           return FALSE;
19161         }
19162       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19163       if (got != sizeof arch.arhdr)
19164         {
19165           if (got == 0)
19166             break;
19167           error (_("%s: failed to read archive header\n"), filedata->file_name);
19168           ret = FALSE;
19169           break;
19170         }
19171       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19172         {
19173           error (_("%s: did not find a valid archive header\n"), arch.file_name);
19174           ret = FALSE;
19175           break;
19176         }
19177
19178       arch.next_arhdr_offset += sizeof arch.arhdr;
19179
19180       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19181       if (archive_file_size & 01)
19182         ++archive_file_size;
19183
19184       name = get_archive_member_name (&arch, &nested_arch);
19185       if (name == NULL)
19186         {
19187           error (_("%s: bad archive file name\n"), filedata->file_name);
19188           ret = FALSE;
19189           break;
19190         }
19191       namelen = strlen (name);
19192
19193       qualified_name = make_qualified_name (&arch, &nested_arch, name);
19194       if (qualified_name == NULL)
19195         {
19196           error (_("%s: bad archive file name\n"), filedata->file_name);
19197           ret = FALSE;
19198           break;
19199         }
19200
19201       if (is_thin_archive && arch.nested_member_origin == 0)
19202         {
19203           /* This is a proxy for an external member of a thin archive.  */
19204           Filedata * member_filedata;
19205           char * member_file_name = adjust_relative_path
19206             (filedata->file_name, name, namelen);
19207
19208           if (member_file_name == NULL)
19209             {
19210               ret = FALSE;
19211               break;
19212             }
19213
19214           member_filedata = open_file (member_file_name);
19215           if (member_filedata == NULL)
19216             {
19217               error (_("Input file '%s' is not readable.\n"), member_file_name);
19218               free (member_file_name);
19219               ret = FALSE;
19220               break;
19221             }
19222
19223           archive_file_offset = arch.nested_member_origin;
19224           member_filedata->file_name = qualified_name;
19225
19226           if (! process_object (member_filedata))
19227             ret = FALSE;
19228
19229           close_file (member_filedata);
19230           free (member_file_name);
19231         }
19232       else if (is_thin_archive)
19233         {
19234           Filedata thin_filedata;
19235
19236           memset (&thin_filedata, 0, sizeof (thin_filedata));
19237
19238           /* PR 15140: Allow for corrupt thin archives.  */
19239           if (nested_arch.file == NULL)
19240             {
19241               error (_("%s: contains corrupt thin archive: %s\n"),
19242                      filedata->file_name, name);
19243               ret = FALSE;
19244               break;
19245             }
19246
19247           /* This is a proxy for a member of a nested archive.  */
19248           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19249
19250           /* The nested archive file will have been opened and setup by
19251              get_archive_member_name.  */
19252           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19253             {
19254               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19255               ret = FALSE;
19256               break;
19257             }
19258
19259           thin_filedata.handle = nested_arch.file;
19260           thin_filedata.file_name = qualified_name;
19261
19262           if (! process_object (& thin_filedata))
19263             ret = FALSE;
19264         }
19265       else
19266         {
19267           archive_file_offset = arch.next_arhdr_offset;
19268           arch.next_arhdr_offset += archive_file_size;
19269
19270           filedata->file_name = qualified_name;
19271           if (! process_object (filedata))
19272             ret = FALSE;
19273         }
19274
19275       if (filedata->dump_sects != NULL)
19276         {
19277           free (filedata->dump_sects);
19278           filedata->dump_sects = NULL;
19279           filedata->num_dump_sects = 0;
19280         }
19281
19282       free (qualified_name);
19283     }
19284
19285  out:
19286   if (nested_arch.file != NULL)
19287     fclose (nested_arch.file);
19288   release_archive (&nested_arch);
19289   release_archive (&arch);
19290
19291   return ret;
19292 }
19293
19294 static bfd_boolean
19295 process_file (char * file_name)
19296 {
19297   Filedata * filedata = NULL;
19298   struct stat statbuf;
19299   char armag[SARMAG];
19300   bfd_boolean ret = TRUE;
19301
19302   if (stat (file_name, &statbuf) < 0)
19303     {
19304       if (errno == ENOENT)
19305         error (_("'%s': No such file\n"), file_name);
19306       else
19307         error (_("Could not locate '%s'.  System error message: %s\n"),
19308                file_name, strerror (errno));
19309       return FALSE;
19310     }
19311
19312   if (! S_ISREG (statbuf.st_mode))
19313     {
19314       error (_("'%s' is not an ordinary file\n"), file_name);
19315       return FALSE;
19316     }
19317
19318   filedata = calloc (1, sizeof * filedata);
19319   if (filedata == NULL)
19320     {
19321       error (_("Out of memory allocating file data structure\n"));
19322       return FALSE;
19323     }
19324
19325   filedata->file_name = file_name;
19326   filedata->handle = fopen (file_name, "rb");
19327   if (filedata->handle == NULL)
19328     {
19329       error (_("Input file '%s' is not readable.\n"), file_name);
19330       free (filedata);
19331       return FALSE;
19332     }
19333
19334   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19335     {
19336       error (_("%s: Failed to read file's magic number\n"), file_name);
19337       fclose (filedata->handle);
19338       free (filedata);
19339       return FALSE;
19340     }
19341
19342   filedata->file_size = (bfd_size_type) statbuf.st_size;
19343
19344   if (memcmp (armag, ARMAG, SARMAG) == 0)
19345     {
19346       if (! process_archive (filedata, FALSE))
19347         ret = FALSE;
19348     }
19349   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19350     {
19351       if ( ! process_archive (filedata, TRUE))
19352         ret = FALSE;
19353     }
19354   else
19355     {
19356       if (do_archive_index)
19357         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19358                file_name);
19359
19360       rewind (filedata->handle);
19361       archive_file_size = archive_file_offset = 0;
19362
19363       if (! process_object (filedata))
19364         ret = FALSE;
19365     }
19366
19367   fclose (filedata->handle);
19368   free (filedata);
19369
19370   return ret;
19371 }
19372
19373 #ifdef SUPPORT_DISASSEMBLY
19374 /* Needed by the i386 disassembler.  For extra credit, someone could
19375    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19376    symbols.  */
19377
19378 void
19379 print_address (unsigned int addr, FILE * outfile)
19380 {
19381   fprintf (outfile,"0x%8.8x", addr);
19382 }
19383
19384 /* Needed by the i386 disassembler.  */
19385
19386 void
19387 db_task_printsym (unsigned int addr)
19388 {
19389   print_address (addr, stderr);
19390 }
19391 #endif
19392
19393 int
19394 main (int argc, char ** argv)
19395 {
19396   int err;
19397
19398 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19399   setlocale (LC_MESSAGES, "");
19400 #endif
19401 #if defined (HAVE_SETLOCALE)
19402   setlocale (LC_CTYPE, "");
19403 #endif
19404   bindtextdomain (PACKAGE, LOCALEDIR);
19405   textdomain (PACKAGE);
19406
19407   expandargv (&argc, &argv);
19408
19409   cmdline.file_name = "<cmdline>";
19410   parse_args (& cmdline, argc, argv);
19411
19412   if (optind < (argc - 1))
19413     show_name = TRUE;
19414   else if (optind >= argc)
19415     {
19416       warn (_("Nothing to do.\n"));
19417       usage (stderr);
19418     }
19419
19420   err = FALSE;
19421   while (optind < argc)
19422     if (! process_file (argv[optind++]))
19423       err = TRUE;
19424
19425   if (cmdline.dump_sects != NULL)
19426     free (cmdline.dump_sects);
19427
19428   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19429 }