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   unsigned short max_vd_ndx;
11304
11305   if (!is_dynsym
11306       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11307     return NULL;
11308
11309   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11310                             sizeof data + si * sizeof (vers_data));
11311
11312   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11313                 sizeof (data), 1, _("version data")) == NULL)
11314     return NULL;
11315
11316   vers_data = byte_get (data, 2);
11317
11318   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11319     return NULL;
11320
11321   max_vd_ndx = 0;
11322
11323   /* Usually we'd only see verdef for defined symbols, and verneed for
11324      undefined symbols.  However, symbols defined by the linker in
11325      .dynbss for variables copied from a shared library in order to
11326      avoid text relocations are defined yet have verneed.  We could
11327      use a heuristic to detect the special case, for example, check
11328      for verneed first on symbols defined in SHT_NOBITS sections, but
11329      it is simpler and more reliable to just look for both verdef and
11330      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11331
11332   if (psym->st_shndx != SHN_UNDEF
11333       && vers_data != 0x8001
11334       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11335     {
11336       Elf_Internal_Verdef ivd;
11337       Elf_Internal_Verdaux ivda;
11338       Elf_External_Verdaux evda;
11339       unsigned long off;
11340
11341       off = offset_from_vma (filedata,
11342                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11343                              sizeof (Elf_External_Verdef));
11344
11345       do
11346         {
11347           Elf_External_Verdef evd;
11348
11349           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11350                         _("version def")) == NULL)
11351             {
11352               ivd.vd_ndx = 0;
11353               ivd.vd_aux = 0;
11354               ivd.vd_next = 0;
11355               ivd.vd_flags = 0;
11356             }
11357           else
11358             {
11359               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11360               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11361               ivd.vd_next = BYTE_GET (evd.vd_next);
11362               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11363             }
11364
11365           if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11366             max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11367
11368           off += ivd.vd_next;
11369         }
11370       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11371
11372       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11373         {
11374           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11375             return NULL;
11376
11377           off -= ivd.vd_next;
11378           off += ivd.vd_aux;
11379
11380           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11381                         _("version def aux")) != NULL)
11382             {
11383               ivda.vda_name = BYTE_GET (evda.vda_name);
11384
11385               if (psym->st_name != ivda.vda_name)
11386                 {
11387                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11388                                ? symbol_hidden : symbol_public);
11389                   return (ivda.vda_name < strtab_size
11390                           ? strtab + ivda.vda_name : _("<corrupt>"));
11391                 }
11392             }
11393         }
11394     }
11395
11396   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11397     {
11398       Elf_External_Verneed evn;
11399       Elf_Internal_Verneed ivn;
11400       Elf_Internal_Vernaux ivna;
11401
11402       offset = offset_from_vma (filedata,
11403                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11404                                 sizeof evn);
11405       do
11406         {
11407           unsigned long vna_off;
11408
11409           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11410                         _("version need")) == NULL)
11411             {
11412               ivna.vna_next = 0;
11413               ivna.vna_other = 0;
11414               ivna.vna_name = 0;
11415               break;
11416             }
11417
11418           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11419           ivn.vn_next = BYTE_GET (evn.vn_next);
11420
11421           vna_off = offset + ivn.vn_aux;
11422
11423           do
11424             {
11425               Elf_External_Vernaux evna;
11426
11427               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11428                             _("version need aux (3)")) == NULL)
11429                 {
11430                   ivna.vna_next = 0;
11431                   ivna.vna_other = 0;
11432                   ivna.vna_name = 0;
11433                 }
11434               else
11435                 {
11436                   ivna.vna_other = BYTE_GET (evna.vna_other);
11437                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11438                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11439                 }
11440
11441               vna_off += ivna.vna_next;
11442             }
11443           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11444
11445           if (ivna.vna_other == vers_data)
11446             break;
11447
11448           offset += ivn.vn_next;
11449         }
11450       while (ivn.vn_next != 0);
11451
11452       if (ivna.vna_other == vers_data)
11453         {
11454           *sym_info = symbol_undefined;
11455           *vna_other = ivna.vna_other;
11456           return (ivna.vna_name < strtab_size
11457                   ? strtab + ivna.vna_name : _("<corrupt>"));
11458         }
11459       else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11460                && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11461         return _("<corrupt>");
11462     }
11463   return NULL;
11464 }
11465
11466 /* Dump the symbol table.  */
11467 static bfd_boolean
11468 process_symbol_table (Filedata * filedata)
11469 {
11470   Elf_Internal_Shdr * section;
11471   bfd_size_type nbuckets = 0;
11472   bfd_size_type nchains = 0;
11473   bfd_vma * buckets = NULL;
11474   bfd_vma * chains = NULL;
11475   bfd_vma ngnubuckets = 0;
11476   bfd_vma * gnubuckets = NULL;
11477   bfd_vma * gnuchains = NULL;
11478   bfd_vma gnusymidx = 0;
11479   bfd_size_type ngnuchains = 0;
11480
11481   if (!do_syms && !do_dyn_syms && !do_histogram)
11482     return TRUE;
11483
11484   if (dynamic_info[DT_HASH]
11485       && (do_histogram
11486           || (do_using_dynamic
11487               && !do_dyn_syms
11488               && dynamic_strings != NULL)))
11489     {
11490       unsigned char nb[8];
11491       unsigned char nc[8];
11492       unsigned int hash_ent_size = 4;
11493
11494       if ((filedata->file_header.e_machine == EM_ALPHA
11495            || filedata->file_header.e_machine == EM_S390
11496            || filedata->file_header.e_machine == EM_S390_OLD)
11497           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11498         hash_ent_size = 8;
11499
11500       if (fseek (filedata->handle,
11501                  (archive_file_offset
11502                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11503                                      sizeof nb + sizeof nc)),
11504                  SEEK_SET))
11505         {
11506           error (_("Unable to seek to start of dynamic information\n"));
11507           goto no_hash;
11508         }
11509
11510       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11511         {
11512           error (_("Failed to read in number of buckets\n"));
11513           goto no_hash;
11514         }
11515
11516       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11517         {
11518           error (_("Failed to read in number of chains\n"));
11519           goto no_hash;
11520         }
11521
11522       nbuckets = byte_get (nb, hash_ent_size);
11523       nchains  = byte_get (nc, hash_ent_size);
11524
11525       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11526       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11527
11528     no_hash:
11529       if (buckets == NULL || chains == NULL)
11530         {
11531           if (do_using_dynamic)
11532             return FALSE;
11533           free (buckets);
11534           free (chains);
11535           buckets = NULL;
11536           chains = NULL;
11537           nbuckets = 0;
11538           nchains = 0;
11539         }
11540     }
11541
11542   if (dynamic_info_DT_GNU_HASH
11543       && (do_histogram
11544           || (do_using_dynamic
11545               && !do_dyn_syms
11546               && dynamic_strings != NULL)))
11547     {
11548       unsigned char nb[16];
11549       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11550       bfd_vma buckets_vma;
11551
11552       if (fseek (filedata->handle,
11553                  (archive_file_offset
11554                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11555                                      sizeof nb)),
11556                  SEEK_SET))
11557         {
11558           error (_("Unable to seek to start of dynamic information\n"));
11559           goto no_gnu_hash;
11560         }
11561
11562       if (fread (nb, 16, 1, filedata->handle) != 1)
11563         {
11564           error (_("Failed to read in number of buckets\n"));
11565           goto no_gnu_hash;
11566         }
11567
11568       ngnubuckets = byte_get (nb, 4);
11569       gnusymidx = byte_get (nb + 4, 4);
11570       bitmaskwords = byte_get (nb + 8, 4);
11571       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11572       if (is_32bit_elf)
11573         buckets_vma += bitmaskwords * 4;
11574       else
11575         buckets_vma += bitmaskwords * 8;
11576
11577       if (fseek (filedata->handle,
11578                  (archive_file_offset
11579                   + offset_from_vma (filedata, buckets_vma, 4)),
11580                  SEEK_SET))
11581         {
11582           error (_("Unable to seek to start of dynamic information\n"));
11583           goto no_gnu_hash;
11584         }
11585
11586       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11587
11588       if (gnubuckets == NULL)
11589         goto no_gnu_hash;
11590
11591       for (i = 0; i < ngnubuckets; i++)
11592         if (gnubuckets[i] != 0)
11593           {
11594             if (gnubuckets[i] < gnusymidx)
11595               return FALSE;
11596
11597             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11598               maxchain = gnubuckets[i];
11599           }
11600
11601       if (maxchain == 0xffffffff)
11602         goto no_gnu_hash;
11603
11604       maxchain -= gnusymidx;
11605
11606       if (fseek (filedata->handle,
11607                  (archive_file_offset
11608                   + offset_from_vma (filedata, buckets_vma
11609                                            + 4 * (ngnubuckets + maxchain), 4)),
11610                  SEEK_SET))
11611         {
11612           error (_("Unable to seek to start of dynamic information\n"));
11613           goto no_gnu_hash;
11614         }
11615
11616       do
11617         {
11618           if (fread (nb, 4, 1, filedata->handle) != 1)
11619             {
11620               error (_("Failed to determine last chain length\n"));
11621               goto no_gnu_hash;
11622             }
11623
11624           if (maxchain + 1 == 0)
11625             goto no_gnu_hash;
11626
11627           ++maxchain;
11628         }
11629       while ((byte_get (nb, 4) & 1) == 0);
11630
11631       if (fseek (filedata->handle,
11632                  (archive_file_offset
11633                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11634                  SEEK_SET))
11635         {
11636           error (_("Unable to seek to start of dynamic information\n"));
11637           goto no_gnu_hash;
11638         }
11639
11640       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11641       ngnuchains = maxchain;
11642
11643     no_gnu_hash:
11644       if (gnuchains == NULL)
11645         {
11646           free (gnubuckets);
11647           gnubuckets = NULL;
11648           ngnubuckets = 0;
11649           if (do_using_dynamic)
11650             return FALSE;
11651         }
11652     }
11653
11654   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11655       && do_syms
11656       && do_using_dynamic
11657       && dynamic_strings != NULL
11658       && dynamic_symbols != NULL)
11659     {
11660       unsigned long hn;
11661
11662       if (dynamic_info[DT_HASH])
11663         {
11664           bfd_vma si;
11665           char *visited;
11666
11667           printf (_("\nSymbol table for image:\n"));
11668           if (is_32bit_elf)
11669             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11670           else
11671             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11672
11673           visited = xcmalloc (nchains, 1);
11674           memset (visited, 0, nchains);
11675           for (hn = 0; hn < nbuckets; hn++)
11676             {
11677               for (si = buckets[hn]; si > 0; si = chains[si])
11678                 {
11679                   print_dynamic_symbol (filedata, si, hn);
11680                   if (si >= nchains || visited[si])
11681                     {
11682                       error (_("histogram chain is corrupt\n"));
11683                       break;
11684                     }
11685                   visited[si] = 1;
11686                 }
11687             }
11688           free (visited);
11689         }
11690
11691       if (dynamic_info_DT_GNU_HASH)
11692         {
11693           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11694           if (is_32bit_elf)
11695             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11696           else
11697             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11698
11699           for (hn = 0; hn < ngnubuckets; ++hn)
11700             if (gnubuckets[hn] != 0)
11701               {
11702                 bfd_vma si = gnubuckets[hn];
11703                 bfd_vma off = si - gnusymidx;
11704
11705                 do
11706                   {
11707                     print_dynamic_symbol (filedata, si, hn);
11708                     si++;
11709                   }
11710                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11711               }
11712         }
11713     }
11714   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11715            && filedata->section_headers != NULL)
11716     {
11717       unsigned int i;
11718
11719       for (i = 0, section = filedata->section_headers;
11720            i < filedata->file_header.e_shnum;
11721            i++, section++)
11722         {
11723           unsigned int si;
11724           char * strtab = NULL;
11725           unsigned long int strtab_size = 0;
11726           Elf_Internal_Sym * symtab;
11727           Elf_Internal_Sym * psym;
11728           unsigned long num_syms;
11729
11730           if ((section->sh_type != SHT_SYMTAB
11731                && section->sh_type != SHT_DYNSYM)
11732               || (!do_syms
11733                   && section->sh_type == SHT_SYMTAB))
11734             continue;
11735
11736           if (section->sh_entsize == 0)
11737             {
11738               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11739                       printable_section_name (filedata, section));
11740               continue;
11741             }
11742
11743           num_syms = section->sh_size / section->sh_entsize;
11744           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11745                             "\nSymbol table '%s' contains %lu entries:\n",
11746                             num_syms),
11747                   printable_section_name (filedata, section),
11748                   num_syms);
11749
11750           if (is_32bit_elf)
11751             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11752           else
11753             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11754
11755           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11756           if (symtab == NULL)
11757             continue;
11758
11759           if (section->sh_link == filedata->file_header.e_shstrndx)
11760             {
11761               strtab = filedata->string_table;
11762               strtab_size = filedata->string_table_length;
11763             }
11764           else if (section->sh_link < filedata->file_header.e_shnum)
11765             {
11766               Elf_Internal_Shdr * string_sec;
11767
11768               string_sec = filedata->section_headers + section->sh_link;
11769
11770               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11771                                           1, string_sec->sh_size,
11772                                           _("string table"));
11773               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11774             }
11775
11776           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11777             {
11778               const char *version_string;
11779               enum versioned_symbol_info sym_info;
11780               unsigned short vna_other;
11781
11782               printf ("%6d: ", si);
11783               print_vma (psym->st_value, LONG_HEX);
11784               putchar (' ');
11785               print_vma (psym->st_size, DEC_5);
11786               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11787               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11788               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11789                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11790               else
11791                 {
11792                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11793
11794                   printf (" %-7s", get_symbol_visibility (vis));
11795                   /* Check to see if any other bits in the st_other field are set.
11796                      Note - displaying this information disrupts the layout of the
11797                      table being generated, but for the moment this case is very rare.  */
11798                   if (psym->st_other ^ vis)
11799                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11800                 }
11801               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11802               print_symbol (25, psym->st_name < strtab_size
11803                             ? strtab + psym->st_name : _("<corrupt>"));
11804
11805               version_string
11806                 = get_symbol_version_string (filedata,
11807                                              section->sh_type == SHT_DYNSYM,
11808                                              strtab, strtab_size, si,
11809                                              psym, &sym_info, &vna_other);
11810               if (version_string)
11811                 {
11812                   if (sym_info == symbol_undefined)
11813                     printf ("@%s (%d)", version_string, vna_other);
11814                   else
11815                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11816                             version_string);
11817                 }
11818
11819               putchar ('\n');
11820
11821               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11822                   && si >= section->sh_info
11823                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11824                   && filedata->file_header.e_machine != EM_MIPS
11825                   /* Solaris binaries have been found to violate this requirement as
11826                      well.  Not sure if this is a bug or an ABI requirement.  */
11827                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11828                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11829                       si, printable_section_name (filedata, section), section->sh_info);
11830             }
11831
11832           free (symtab);
11833           if (strtab != filedata->string_table)
11834             free (strtab);
11835         }
11836     }
11837   else if (do_syms)
11838     printf
11839       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11840
11841   if (do_histogram && buckets != NULL)
11842     {
11843       unsigned long * lengths;
11844       unsigned long * counts;
11845       unsigned long hn;
11846       bfd_vma si;
11847       unsigned long maxlength = 0;
11848       unsigned long nzero_counts = 0;
11849       unsigned long nsyms = 0;
11850       char *visited;
11851
11852       printf (ngettext ("\nHistogram for bucket list length "
11853                         "(total of %lu bucket):\n",
11854                         "\nHistogram for bucket list length "
11855                         "(total of %lu buckets):\n",
11856                         (unsigned long) nbuckets),
11857               (unsigned long) nbuckets);
11858
11859       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11860       if (lengths == NULL)
11861         {
11862           error (_("Out of memory allocating space for histogram buckets\n"));
11863           return FALSE;
11864         }
11865       visited = xcmalloc (nchains, 1);
11866       memset (visited, 0, nchains);
11867
11868       printf (_(" Length  Number     %% of total  Coverage\n"));
11869       for (hn = 0; hn < nbuckets; ++hn)
11870         {
11871           for (si = buckets[hn]; si > 0; si = chains[si])
11872             {
11873               ++nsyms;
11874               if (maxlength < ++lengths[hn])
11875                 ++maxlength;
11876               if (si >= nchains || visited[si])
11877                 {
11878                   error (_("histogram chain is corrupt\n"));
11879                   break;
11880                 }
11881               visited[si] = 1;
11882             }
11883         }
11884       free (visited);
11885
11886       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11887       if (counts == NULL)
11888         {
11889           free (lengths);
11890           error (_("Out of memory allocating space for histogram counts\n"));
11891           return FALSE;
11892         }
11893
11894       for (hn = 0; hn < nbuckets; ++hn)
11895         ++counts[lengths[hn]];
11896
11897       if (nbuckets > 0)
11898         {
11899           unsigned long i;
11900           printf ("      0  %-10lu (%5.1f%%)\n",
11901                   counts[0], (counts[0] * 100.0) / nbuckets);
11902           for (i = 1; i <= maxlength; ++i)
11903             {
11904               nzero_counts += counts[i] * i;
11905               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11906                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11907                       (nzero_counts * 100.0) / nsyms);
11908             }
11909         }
11910
11911       free (counts);
11912       free (lengths);
11913     }
11914
11915   if (buckets != NULL)
11916     {
11917       free (buckets);
11918       free (chains);
11919     }
11920
11921   if (do_histogram && gnubuckets != NULL)
11922     {
11923       unsigned long * lengths;
11924       unsigned long * counts;
11925       unsigned long hn;
11926       unsigned long maxlength = 0;
11927       unsigned long nzero_counts = 0;
11928       unsigned long nsyms = 0;
11929
11930       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11931                         "(total of %lu bucket):\n",
11932                         "\nHistogram for `.gnu.hash' bucket list length "
11933                         "(total of %lu buckets):\n",
11934                         (unsigned long) ngnubuckets),
11935               (unsigned long) ngnubuckets);
11936
11937       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11938       if (lengths == NULL)
11939         {
11940           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11941           return FALSE;
11942         }
11943
11944       printf (_(" Length  Number     %% of total  Coverage\n"));
11945
11946       for (hn = 0; hn < ngnubuckets; ++hn)
11947         if (gnubuckets[hn] != 0)
11948           {
11949             bfd_vma off, length = 1;
11950
11951             for (off = gnubuckets[hn] - gnusymidx;
11952                  /* PR 17531 file: 010-77222-0.004.  */
11953                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11954                  ++off)
11955               ++length;
11956             lengths[hn] = length;
11957             if (length > maxlength)
11958               maxlength = length;
11959             nsyms += length;
11960           }
11961
11962       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11963       if (counts == NULL)
11964         {
11965           free (lengths);
11966           error (_("Out of memory allocating space for gnu histogram counts\n"));
11967           return FALSE;
11968         }
11969
11970       for (hn = 0; hn < ngnubuckets; ++hn)
11971         ++counts[lengths[hn]];
11972
11973       if (ngnubuckets > 0)
11974         {
11975           unsigned long j;
11976           printf ("      0  %-10lu (%5.1f%%)\n",
11977                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11978           for (j = 1; j <= maxlength; ++j)
11979             {
11980               nzero_counts += counts[j] * j;
11981               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11982                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11983                       (nzero_counts * 100.0) / nsyms);
11984             }
11985         }
11986
11987       free (counts);
11988       free (lengths);
11989       free (gnubuckets);
11990       free (gnuchains);
11991     }
11992
11993   return TRUE;
11994 }
11995
11996 static bfd_boolean
11997 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11998 {
11999   unsigned int i;
12000
12001   if (dynamic_syminfo == NULL
12002       || !do_dynamic)
12003     /* No syminfo, this is ok.  */
12004     return TRUE;
12005
12006   /* There better should be a dynamic symbol section.  */
12007   if (dynamic_symbols == NULL || dynamic_strings == NULL)
12008     return FALSE;
12009
12010   if (dynamic_addr)
12011     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12012                       "contains %d entry:\n",
12013                       "\nDynamic info segment at offset 0x%lx "
12014                       "contains %d entries:\n",
12015                       dynamic_syminfo_nent),
12016             dynamic_syminfo_offset, dynamic_syminfo_nent);
12017
12018   printf (_(" Num: Name                           BoundTo     Flags\n"));
12019   for (i = 0; i < dynamic_syminfo_nent; ++i)
12020     {
12021       unsigned short int flags = dynamic_syminfo[i].si_flags;
12022
12023       printf ("%4d: ", i);
12024       if (i >= num_dynamic_syms)
12025         printf (_("<corrupt index>"));
12026       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12027         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12028       else
12029         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12030       putchar (' ');
12031
12032       switch (dynamic_syminfo[i].si_boundto)
12033         {
12034         case SYMINFO_BT_SELF:
12035           fputs ("SELF       ", stdout);
12036           break;
12037         case SYMINFO_BT_PARENT:
12038           fputs ("PARENT     ", stdout);
12039           break;
12040         default:
12041           if (dynamic_syminfo[i].si_boundto > 0
12042               && dynamic_syminfo[i].si_boundto < dynamic_nent
12043               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12044             {
12045               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12046               putchar (' ' );
12047             }
12048           else
12049             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12050           break;
12051         }
12052
12053       if (flags & SYMINFO_FLG_DIRECT)
12054         printf (" DIRECT");
12055       if (flags & SYMINFO_FLG_PASSTHRU)
12056         printf (" PASSTHRU");
12057       if (flags & SYMINFO_FLG_COPY)
12058         printf (" COPY");
12059       if (flags & SYMINFO_FLG_LAZYLOAD)
12060         printf (" LAZYLOAD");
12061
12062       puts ("");
12063     }
12064
12065   return TRUE;
12066 }
12067
12068 #define IN_RANGE(START,END,ADDR,OFF)            \
12069   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12070
12071 /* Check to see if the given reloc needs to be handled in a target specific
12072    manner.  If so then process the reloc and return TRUE otherwise return
12073    FALSE.
12074
12075    If called with reloc == NULL, then this is a signal that reloc processing
12076    for the current section has finished, and any saved state should be
12077    discarded.  */
12078
12079 static bfd_boolean
12080 target_specific_reloc_handling (Filedata *           filedata,
12081                                 Elf_Internal_Rela *  reloc,
12082                                 unsigned char *      start,
12083                                 unsigned char *      end,
12084                                 Elf_Internal_Sym *   symtab,
12085                                 unsigned long        num_syms)
12086 {
12087   unsigned int reloc_type = 0;
12088   unsigned long sym_index = 0;
12089
12090   if (reloc)
12091     {
12092       reloc_type = get_reloc_type (filedata, reloc->r_info);
12093       sym_index = get_reloc_symindex (reloc->r_info);
12094     }
12095
12096   switch (filedata->file_header.e_machine)
12097     {
12098     case EM_MSP430:
12099     case EM_MSP430_OLD:
12100       {
12101         static Elf_Internal_Sym * saved_sym = NULL;
12102
12103         if (reloc == NULL)
12104           {
12105             saved_sym = NULL;
12106             return TRUE;
12107           }
12108
12109         switch (reloc_type)
12110           {
12111           case 10: /* R_MSP430_SYM_DIFF */
12112             if (uses_msp430x_relocs (filedata))
12113               break;
12114             /* Fall through.  */
12115           case 21: /* R_MSP430X_SYM_DIFF */
12116             /* PR 21139.  */
12117             if (sym_index >= num_syms)
12118               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12119                      sym_index);
12120             else
12121               saved_sym = symtab + sym_index;
12122             return TRUE;
12123
12124           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12125           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12126             goto handle_sym_diff;
12127
12128           case 5: /* R_MSP430_16_BYTE */
12129           case 9: /* R_MSP430_8 */
12130             if (uses_msp430x_relocs (filedata))
12131               break;
12132             goto handle_sym_diff;
12133
12134           case 2: /* R_MSP430_ABS16 */
12135           case 15: /* R_MSP430X_ABS16 */
12136             if (! uses_msp430x_relocs (filedata))
12137               break;
12138             goto handle_sym_diff;
12139
12140           handle_sym_diff:
12141             if (saved_sym != NULL)
12142               {
12143                 int reloc_size = reloc_type == 1 ? 4 : 2;
12144                 bfd_vma value;
12145
12146                 if (sym_index >= num_syms)
12147                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12148                          sym_index);
12149                 else
12150                   {
12151                     value = reloc->r_addend + (symtab[sym_index].st_value
12152                                                - saved_sym->st_value);
12153
12154                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12155                       byte_put (start + reloc->r_offset, value, reloc_size);
12156                     else
12157                       /* PR 21137 */
12158                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12159                              (long) reloc->r_offset);
12160                   }
12161
12162                 saved_sym = NULL;
12163                 return TRUE;
12164               }
12165             break;
12166
12167           default:
12168             if (saved_sym != NULL)
12169               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12170             break;
12171           }
12172         break;
12173       }
12174
12175     case EM_MN10300:
12176     case EM_CYGNUS_MN10300:
12177       {
12178         static Elf_Internal_Sym * saved_sym = NULL;
12179
12180         if (reloc == NULL)
12181           {
12182             saved_sym = NULL;
12183             return TRUE;
12184           }
12185
12186         switch (reloc_type)
12187           {
12188           case 34: /* R_MN10300_ALIGN */
12189             return TRUE;
12190           case 33: /* R_MN10300_SYM_DIFF */
12191             if (sym_index >= num_syms)
12192               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12193                      sym_index);
12194             else
12195               saved_sym = symtab + sym_index;
12196             return TRUE;
12197
12198           case 1: /* R_MN10300_32 */
12199           case 2: /* R_MN10300_16 */
12200             if (saved_sym != NULL)
12201               {
12202                 int reloc_size = reloc_type == 1 ? 4 : 2;
12203                 bfd_vma value;
12204
12205                 if (sym_index >= num_syms)
12206                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12207                          sym_index);
12208                 else
12209                   {
12210                     value = reloc->r_addend + (symtab[sym_index].st_value
12211                                                - saved_sym->st_value);
12212
12213                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12214                       byte_put (start + reloc->r_offset, value, reloc_size);
12215                     else
12216                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12217                              (long) reloc->r_offset);
12218                   }
12219
12220                 saved_sym = NULL;
12221                 return TRUE;
12222               }
12223             break;
12224           default:
12225             if (saved_sym != NULL)
12226               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12227             break;
12228           }
12229         break;
12230       }
12231
12232     case EM_RL78:
12233       {
12234         static bfd_vma saved_sym1 = 0;
12235         static bfd_vma saved_sym2 = 0;
12236         static bfd_vma value;
12237
12238         if (reloc == NULL)
12239           {
12240             saved_sym1 = saved_sym2 = 0;
12241             return TRUE;
12242           }
12243
12244         switch (reloc_type)
12245           {
12246           case 0x80: /* R_RL78_SYM.  */
12247             saved_sym1 = saved_sym2;
12248             if (sym_index >= num_syms)
12249               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12250                      sym_index);
12251             else
12252               {
12253                 saved_sym2 = symtab[sym_index].st_value;
12254                 saved_sym2 += reloc->r_addend;
12255               }
12256             return TRUE;
12257
12258           case 0x83: /* R_RL78_OPsub.  */
12259             value = saved_sym1 - saved_sym2;
12260             saved_sym2 = saved_sym1 = 0;
12261             return TRUE;
12262             break;
12263
12264           case 0x41: /* R_RL78_ABS32.  */
12265             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12266               byte_put (start + reloc->r_offset, value, 4);
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           case 0x43: /* R_RL78_ABS16.  */
12274             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12275               byte_put (start + reloc->r_offset, value, 2);
12276             else
12277               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12278                      (long) reloc->r_offset);
12279             value = 0;
12280             return TRUE;
12281
12282           default:
12283             break;
12284           }
12285         break;
12286       }
12287     }
12288
12289   return FALSE;
12290 }
12291
12292 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12293    DWARF debug sections.  This is a target specific test.  Note - we do not
12294    go through the whole including-target-headers-multiple-times route, (as
12295    we have already done with <elf/h8.h>) because this would become very
12296    messy and even then this function would have to contain target specific
12297    information (the names of the relocs instead of their numeric values).
12298    FIXME: This is not the correct way to solve this problem.  The proper way
12299    is to have target specific reloc sizing and typing functions created by
12300    the reloc-macros.h header, in the same way that it already creates the
12301    reloc naming functions.  */
12302
12303 static bfd_boolean
12304 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12305 {
12306   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12307   switch (filedata->file_header.e_machine)
12308     {
12309     case EM_386:
12310     case EM_IAMCU:
12311       return reloc_type == 1; /* R_386_32.  */
12312     case EM_68K:
12313       return reloc_type == 1; /* R_68K_32.  */
12314     case EM_860:
12315       return reloc_type == 1; /* R_860_32.  */
12316     case EM_960:
12317       return reloc_type == 2; /* R_960_32.  */
12318     case EM_AARCH64:
12319       return (reloc_type == 258
12320               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12321     case EM_ADAPTEVA_EPIPHANY:
12322       return reloc_type == 3;
12323     case EM_ALPHA:
12324       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12325     case EM_ARC:
12326       return reloc_type == 1; /* R_ARC_32.  */
12327     case EM_ARC_COMPACT:
12328     case EM_ARC_COMPACT2:
12329       return reloc_type == 4; /* R_ARC_32.  */
12330     case EM_ARM:
12331       return reloc_type == 2; /* R_ARM_ABS32 */
12332     case EM_AVR_OLD:
12333     case EM_AVR:
12334       return reloc_type == 1;
12335     case EM_BLACKFIN:
12336       return reloc_type == 0x12; /* R_byte4_data.  */
12337     case EM_CRIS:
12338       return reloc_type == 3; /* R_CRIS_32.  */
12339     case EM_CR16:
12340       return reloc_type == 3; /* R_CR16_NUM32.  */
12341     case EM_CRX:
12342       return reloc_type == 15; /* R_CRX_NUM32.  */
12343     case EM_CSKY:
12344       return reloc_type == 1; /* R_CKCORE_ADDR32.  */
12345     case EM_CYGNUS_FRV:
12346       return reloc_type == 1;
12347     case EM_CYGNUS_D10V:
12348     case EM_D10V:
12349       return reloc_type == 6; /* R_D10V_32.  */
12350     case EM_CYGNUS_D30V:
12351     case EM_D30V:
12352       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12353     case EM_DLX:
12354       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12355     case EM_CYGNUS_FR30:
12356     case EM_FR30:
12357       return reloc_type == 3; /* R_FR30_32.  */
12358     case EM_FT32:
12359       return reloc_type == 1; /* R_FT32_32.  */
12360     case EM_H8S:
12361     case EM_H8_300:
12362     case EM_H8_300H:
12363       return reloc_type == 1; /* R_H8_DIR32.  */
12364     case EM_IA_64:
12365       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12366               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12367               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12368               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12369     case EM_IP2K_OLD:
12370     case EM_IP2K:
12371       return reloc_type == 2; /* R_IP2K_32.  */
12372     case EM_IQ2000:
12373       return reloc_type == 2; /* R_IQ2000_32.  */
12374     case EM_LATTICEMICO32:
12375       return reloc_type == 3; /* R_LM32_32.  */
12376     case EM_M32C_OLD:
12377     case EM_M32C:
12378       return reloc_type == 3; /* R_M32C_32.  */
12379     case EM_M32R:
12380       return reloc_type == 34; /* R_M32R_32_RELA.  */
12381     case EM_68HC11:
12382     case EM_68HC12:
12383       return reloc_type == 6; /* R_M68HC11_32.  */
12384     case EM_S12Z:
12385       return reloc_type == 6; /* R_S12Z_EXT32.  */
12386     case EM_MCORE:
12387       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12388     case EM_CYGNUS_MEP:
12389       return reloc_type == 4; /* R_MEP_32.  */
12390     case EM_METAG:
12391       return reloc_type == 2; /* R_METAG_ADDR32.  */
12392     case EM_MICROBLAZE:
12393       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12394     case EM_MIPS:
12395       return reloc_type == 2; /* R_MIPS_32.  */
12396     case EM_MMIX:
12397       return reloc_type == 4; /* R_MMIX_32.  */
12398     case EM_CYGNUS_MN10200:
12399     case EM_MN10200:
12400       return reloc_type == 1; /* R_MN10200_32.  */
12401     case EM_CYGNUS_MN10300:
12402     case EM_MN10300:
12403       return reloc_type == 1; /* R_MN10300_32.  */
12404     case EM_MOXIE:
12405       return reloc_type == 1; /* R_MOXIE_32.  */
12406     case EM_MSP430_OLD:
12407     case EM_MSP430:
12408       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12409     case EM_MT:
12410       return reloc_type == 2; /* R_MT_32.  */
12411     case EM_NDS32:
12412       return reloc_type == 20; /* R_NDS32_RELA.  */
12413     case EM_ALTERA_NIOS2:
12414       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12415     case EM_NIOS32:
12416       return reloc_type == 1; /* R_NIOS_32.  */
12417     case EM_OR1K:
12418       return reloc_type == 1; /* R_OR1K_32.  */
12419     case EM_PARISC:
12420       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12421               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12422               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12423     case EM_PJ:
12424     case EM_PJ_OLD:
12425       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12426     case EM_PPC64:
12427       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12428     case EM_PPC:
12429       return reloc_type == 1; /* R_PPC_ADDR32.  */
12430     case EM_TI_PRU:
12431       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12432     case EM_RISCV:
12433       return reloc_type == 1; /* R_RISCV_32.  */
12434     case EM_RL78:
12435       return reloc_type == 1; /* R_RL78_DIR32.  */
12436     case EM_RX:
12437       return reloc_type == 1; /* R_RX_DIR32.  */
12438     case EM_S370:
12439       return reloc_type == 1; /* R_I370_ADDR31.  */
12440     case EM_S390_OLD:
12441     case EM_S390:
12442       return reloc_type == 4; /* R_S390_32.  */
12443     case EM_SCORE:
12444       return reloc_type == 8; /* R_SCORE_ABS32.  */
12445     case EM_SH:
12446       return reloc_type == 1; /* R_SH_DIR32.  */
12447     case EM_SPARC32PLUS:
12448     case EM_SPARCV9:
12449     case EM_SPARC:
12450       return reloc_type == 3 /* R_SPARC_32.  */
12451         || reloc_type == 23; /* R_SPARC_UA32.  */
12452     case EM_SPU:
12453       return reloc_type == 6; /* R_SPU_ADDR32 */
12454     case EM_TI_C6000:
12455       return reloc_type == 1; /* R_C6000_ABS32.  */
12456     case EM_TILEGX:
12457       return reloc_type == 2; /* R_TILEGX_32.  */
12458     case EM_TILEPRO:
12459       return reloc_type == 1; /* R_TILEPRO_32.  */
12460     case EM_CYGNUS_V850:
12461     case EM_V850:
12462       return reloc_type == 6; /* R_V850_ABS32.  */
12463     case EM_V800:
12464       return reloc_type == 0x33; /* R_V810_WORD.  */
12465     case EM_VAX:
12466       return reloc_type == 1; /* R_VAX_32.  */
12467     case EM_VISIUM:
12468       return reloc_type == 3;  /* R_VISIUM_32. */
12469     case EM_WEBASSEMBLY:
12470       return reloc_type == 1;  /* R_WASM32_32.  */
12471     case EM_X86_64:
12472     case EM_L1OM:
12473     case EM_K1OM:
12474       return reloc_type == 10; /* R_X86_64_32.  */
12475     case EM_XC16X:
12476     case EM_C166:
12477       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12478     case EM_XGATE:
12479       return reloc_type == 4; /* R_XGATE_32.  */
12480     case EM_XSTORMY16:
12481       return reloc_type == 1; /* R_XSTROMY16_32.  */
12482     case EM_XTENSA_OLD:
12483     case EM_XTENSA:
12484       return reloc_type == 1; /* R_XTENSA_32.  */
12485     default:
12486       {
12487         static unsigned int prev_warn = 0;
12488
12489         /* Avoid repeating the same warning multiple times.  */
12490         if (prev_warn != filedata->file_header.e_machine)
12491           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12492                  filedata->file_header.e_machine);
12493         prev_warn = filedata->file_header.e_machine;
12494         return FALSE;
12495       }
12496     }
12497 }
12498
12499 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12500    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12501
12502 static bfd_boolean
12503 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12504 {
12505   switch (filedata->file_header.e_machine)
12506   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12507     {
12508     case EM_386:
12509     case EM_IAMCU:
12510       return reloc_type == 2;  /* R_386_PC32.  */
12511     case EM_68K:
12512       return reloc_type == 4;  /* R_68K_PC32.  */
12513     case EM_AARCH64:
12514       return reloc_type == 261; /* R_AARCH64_PREL32 */
12515     case EM_ADAPTEVA_EPIPHANY:
12516       return reloc_type == 6;
12517     case EM_ALPHA:
12518       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12519     case EM_ARC_COMPACT:
12520     case EM_ARC_COMPACT2:
12521       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12522     case EM_ARM:
12523       return reloc_type == 3;  /* R_ARM_REL32 */
12524     case EM_AVR_OLD:
12525     case EM_AVR:
12526       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12527     case EM_MICROBLAZE:
12528       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12529     case EM_OR1K:
12530       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12531     case EM_PARISC:
12532       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12533     case EM_PPC:
12534       return reloc_type == 26; /* R_PPC_REL32.  */
12535     case EM_PPC64:
12536       return reloc_type == 26; /* R_PPC64_REL32.  */
12537     case EM_S390_OLD:
12538     case EM_S390:
12539       return reloc_type == 5;  /* R_390_PC32.  */
12540     case EM_SH:
12541       return reloc_type == 2;  /* R_SH_REL32.  */
12542     case EM_SPARC32PLUS:
12543     case EM_SPARCV9:
12544     case EM_SPARC:
12545       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12546     case EM_SPU:
12547       return reloc_type == 13; /* R_SPU_REL32.  */
12548     case EM_TILEGX:
12549       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12550     case EM_TILEPRO:
12551       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12552     case EM_VISIUM:
12553       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12554     case EM_X86_64:
12555     case EM_L1OM:
12556     case EM_K1OM:
12557       return reloc_type == 2;  /* R_X86_64_PC32.  */
12558     case EM_XTENSA_OLD:
12559     case EM_XTENSA:
12560       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12561     default:
12562       /* Do not abort or issue an error message here.  Not all targets use
12563          pc-relative 32-bit relocs in their DWARF debug information and we
12564          have already tested for target coverage in is_32bit_abs_reloc.  A
12565          more helpful warning message will be generated by apply_relocations
12566          anyway, so just return.  */
12567       return FALSE;
12568     }
12569 }
12570
12571 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12572    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12573
12574 static bfd_boolean
12575 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12576 {
12577   switch (filedata->file_header.e_machine)
12578     {
12579     case EM_AARCH64:
12580       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12581     case EM_ALPHA:
12582       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12583     case EM_IA_64:
12584       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12585               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12586     case EM_PARISC:
12587       return reloc_type == 80; /* R_PARISC_DIR64.  */
12588     case EM_PPC64:
12589       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12590     case EM_RISCV:
12591       return reloc_type == 2; /* R_RISCV_64.  */
12592     case EM_SPARC32PLUS:
12593     case EM_SPARCV9:
12594     case EM_SPARC:
12595       return reloc_type == 32 /* R_SPARC_64.  */
12596         || reloc_type == 54; /* R_SPARC_UA64.  */
12597     case EM_X86_64:
12598     case EM_L1OM:
12599     case EM_K1OM:
12600       return reloc_type == 1; /* R_X86_64_64.  */
12601     case EM_S390_OLD:
12602     case EM_S390:
12603       return reloc_type == 22;  /* R_S390_64.  */
12604     case EM_TILEGX:
12605       return reloc_type == 1; /* R_TILEGX_64.  */
12606     case EM_MIPS:
12607       return reloc_type == 18;  /* R_MIPS_64.  */
12608     default:
12609       return FALSE;
12610     }
12611 }
12612
12613 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12614    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12615
12616 static bfd_boolean
12617 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12618 {
12619   switch (filedata->file_header.e_machine)
12620     {
12621     case EM_AARCH64:
12622       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12623     case EM_ALPHA:
12624       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12625     case EM_IA_64:
12626       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12627               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12628     case EM_PARISC:
12629       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12630     case EM_PPC64:
12631       return reloc_type == 44; /* R_PPC64_REL64.  */
12632     case EM_SPARC32PLUS:
12633     case EM_SPARCV9:
12634     case EM_SPARC:
12635       return reloc_type == 46; /* R_SPARC_DISP64.  */
12636     case EM_X86_64:
12637     case EM_L1OM:
12638     case EM_K1OM:
12639       return reloc_type == 24; /* R_X86_64_PC64.  */
12640     case EM_S390_OLD:
12641     case EM_S390:
12642       return reloc_type == 23;  /* R_S390_PC64.  */
12643     case EM_TILEGX:
12644       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12645     default:
12646       return FALSE;
12647     }
12648 }
12649
12650 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12651    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12652
12653 static bfd_boolean
12654 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12655 {
12656   switch (filedata->file_header.e_machine)
12657     {
12658     case EM_CYGNUS_MN10200:
12659     case EM_MN10200:
12660       return reloc_type == 4; /* R_MN10200_24.  */
12661     case EM_FT32:
12662       return reloc_type == 5; /* R_FT32_20.  */
12663     default:
12664       return FALSE;
12665     }
12666 }
12667
12668 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12669    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12670
12671 static bfd_boolean
12672 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12673 {
12674   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12675   switch (filedata->file_header.e_machine)
12676     {
12677     case EM_ARC:
12678     case EM_ARC_COMPACT:
12679     case EM_ARC_COMPACT2:
12680       return reloc_type == 2; /* R_ARC_16.  */
12681     case EM_ADAPTEVA_EPIPHANY:
12682       return reloc_type == 5;
12683     case EM_AVR_OLD:
12684     case EM_AVR:
12685       return reloc_type == 4; /* R_AVR_16.  */
12686     case EM_CYGNUS_D10V:
12687     case EM_D10V:
12688       return reloc_type == 3; /* R_D10V_16.  */
12689     case EM_FT32:
12690       return reloc_type == 2; /* R_FT32_16.  */
12691     case EM_H8S:
12692     case EM_H8_300:
12693     case EM_H8_300H:
12694       return reloc_type == R_H8_DIR16;
12695     case EM_IP2K_OLD:
12696     case EM_IP2K:
12697       return reloc_type == 1; /* R_IP2K_16.  */
12698     case EM_M32C_OLD:
12699     case EM_M32C:
12700       return reloc_type == 1; /* R_M32C_16 */
12701     case EM_CYGNUS_MN10200:
12702     case EM_MN10200:
12703       return reloc_type == 2; /* R_MN10200_16.  */
12704     case EM_CYGNUS_MN10300:
12705     case EM_MN10300:
12706       return reloc_type == 2; /* R_MN10300_16.  */
12707     case EM_MSP430:
12708       if (uses_msp430x_relocs (filedata))
12709         return reloc_type == 2; /* R_MSP430_ABS16.  */
12710       /* Fall through.  */
12711     case EM_MSP430_OLD:
12712       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12713     case EM_NDS32:
12714       return reloc_type == 19; /* R_NDS32_RELA.  */
12715     case EM_ALTERA_NIOS2:
12716       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12717     case EM_NIOS32:
12718       return reloc_type == 9; /* R_NIOS_16.  */
12719     case EM_OR1K:
12720       return reloc_type == 2; /* R_OR1K_16.  */
12721     case EM_RISCV:
12722       return reloc_type == 55; /* R_RISCV_SET16.  */
12723     case EM_TI_PRU:
12724       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12725     case EM_TI_C6000:
12726       return reloc_type == 2; /* R_C6000_ABS16.  */
12727     case EM_VISIUM:
12728       return reloc_type == 2; /* R_VISIUM_16. */
12729     case EM_XC16X:
12730     case EM_C166:
12731       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12732     case EM_XGATE:
12733       return reloc_type == 3; /* R_XGATE_16.  */
12734     default:
12735       return FALSE;
12736     }
12737 }
12738
12739 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12740    a 8-bit absolute RELA relocation used in DWARF debug sections.  */
12741
12742 static bfd_boolean
12743 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12744 {
12745   switch (filedata->file_header.e_machine)
12746     {
12747     case EM_RISCV:
12748       return reloc_type == 54; /* R_RISCV_SET8.  */
12749     default:
12750       return FALSE;
12751     }
12752 }
12753
12754 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12755    a 6-bit absolute RELA relocation used in DWARF debug sections.  */
12756
12757 static bfd_boolean
12758 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12759 {
12760   switch (filedata->file_header.e_machine)
12761     {
12762     case EM_RISCV:
12763       return reloc_type == 53; /* R_RISCV_SET6.  */
12764     default:
12765       return FALSE;
12766     }
12767 }
12768
12769 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12770    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12771
12772 static bfd_boolean
12773 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12774 {
12775   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12776   switch (filedata->file_header.e_machine)
12777     {
12778     case EM_RISCV:
12779       return reloc_type == 35; /* R_RISCV_ADD32.  */
12780     default:
12781       return FALSE;
12782     }
12783 }
12784
12785 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12786    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12787
12788 static bfd_boolean
12789 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12790 {
12791   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12792   switch (filedata->file_header.e_machine)
12793     {
12794     case EM_RISCV:
12795       return reloc_type == 39; /* R_RISCV_SUB32.  */
12796     default:
12797       return FALSE;
12798     }
12799 }
12800
12801 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12802    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12803
12804 static bfd_boolean
12805 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12806 {
12807   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12808   switch (filedata->file_header.e_machine)
12809     {
12810     case EM_RISCV:
12811       return reloc_type == 36; /* R_RISCV_ADD64.  */
12812     default:
12813       return FALSE;
12814     }
12815 }
12816
12817 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12818    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12819
12820 static bfd_boolean
12821 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12822 {
12823   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12824   switch (filedata->file_header.e_machine)
12825     {
12826     case EM_RISCV:
12827       return reloc_type == 40; /* R_RISCV_SUB64.  */
12828     default:
12829       return FALSE;
12830     }
12831 }
12832
12833 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12834    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12835
12836 static bfd_boolean
12837 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12838 {
12839   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12840   switch (filedata->file_header.e_machine)
12841     {
12842     case EM_RISCV:
12843       return reloc_type == 34; /* R_RISCV_ADD16.  */
12844     default:
12845       return FALSE;
12846     }
12847 }
12848
12849 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12850    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12851
12852 static bfd_boolean
12853 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12854 {
12855   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12856   switch (filedata->file_header.e_machine)
12857     {
12858     case EM_RISCV:
12859       return reloc_type == 38; /* R_RISCV_SUB16.  */
12860     default:
12861       return FALSE;
12862     }
12863 }
12864
12865 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12866    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12867
12868 static bfd_boolean
12869 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12870 {
12871   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12872   switch (filedata->file_header.e_machine)
12873     {
12874     case EM_RISCV:
12875       return reloc_type == 33; /* R_RISCV_ADD8.  */
12876     default:
12877       return FALSE;
12878     }
12879 }
12880
12881 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12882    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12883
12884 static bfd_boolean
12885 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12886 {
12887   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12888   switch (filedata->file_header.e_machine)
12889     {
12890     case EM_RISCV:
12891       return reloc_type == 37; /* R_RISCV_SUB8.  */
12892     default:
12893       return FALSE;
12894     }
12895 }
12896
12897 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12898    a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
12899
12900 static bfd_boolean
12901 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12902 {
12903   switch (filedata->file_header.e_machine)
12904     {
12905     case EM_RISCV:
12906       return reloc_type == 52; /* R_RISCV_SUB6.  */
12907     default:
12908       return FALSE;
12909     }
12910 }
12911
12912 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12913    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12914
12915 static bfd_boolean
12916 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12917 {
12918   switch (filedata->file_header.e_machine)
12919     {
12920     case EM_386:     /* R_386_NONE.  */
12921     case EM_68K:     /* R_68K_NONE.  */
12922     case EM_ADAPTEVA_EPIPHANY:
12923     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12924     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12925     case EM_ARC:     /* R_ARC_NONE.  */
12926     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12927     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12928     case EM_ARM:     /* R_ARM_NONE.  */
12929     case EM_C166:    /* R_XC16X_NONE.  */
12930     case EM_CRIS:    /* R_CRIS_NONE.  */
12931     case EM_FT32:    /* R_FT32_NONE.  */
12932     case EM_IA_64:   /* R_IA64_NONE.  */
12933     case EM_K1OM:    /* R_X86_64_NONE.  */
12934     case EM_L1OM:    /* R_X86_64_NONE.  */
12935     case EM_M32R:    /* R_M32R_NONE.  */
12936     case EM_MIPS:    /* R_MIPS_NONE.  */
12937     case EM_MN10300: /* R_MN10300_NONE.  */
12938     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12939     case EM_NIOS32:  /* R_NIOS_NONE.  */
12940     case EM_OR1K:    /* R_OR1K_NONE. */
12941     case EM_PARISC:  /* R_PARISC_NONE.  */
12942     case EM_PPC64:   /* R_PPC64_NONE.  */
12943     case EM_PPC:     /* R_PPC_NONE.  */
12944     case EM_RISCV:   /* R_RISCV_NONE.  */
12945     case EM_S390:    /* R_390_NONE.  */
12946     case EM_S390_OLD:
12947     case EM_SH:      /* R_SH_NONE.  */
12948     case EM_SPARC32PLUS:
12949     case EM_SPARC:   /* R_SPARC_NONE.  */
12950     case EM_SPARCV9:
12951     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12952     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12953     case EM_TI_C6000:/* R_C6000_NONE.  */
12954     case EM_X86_64:  /* R_X86_64_NONE.  */
12955     case EM_XC16X:
12956     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12957       return reloc_type == 0;
12958
12959     case EM_AARCH64:
12960       return reloc_type == 0 || reloc_type == 256;
12961     case EM_AVR_OLD:
12962     case EM_AVR:
12963       return (reloc_type == 0 /* R_AVR_NONE.  */
12964               || reloc_type == 30 /* R_AVR_DIFF8.  */
12965               || reloc_type == 31 /* R_AVR_DIFF16.  */
12966               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12967     case EM_METAG:
12968       return reloc_type == 3; /* R_METAG_NONE.  */
12969     case EM_NDS32:
12970       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12971               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12972               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12973               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12974               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12975     case EM_TI_PRU:
12976       return (reloc_type == 0       /* R_PRU_NONE.  */
12977               || reloc_type == 65   /* R_PRU_DIFF8.  */
12978               || reloc_type == 66   /* R_PRU_DIFF16.  */
12979               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12980     case EM_XTENSA_OLD:
12981     case EM_XTENSA:
12982       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12983               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12984               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12985               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12986     }
12987   return FALSE;
12988 }
12989
12990 /* Returns TRUE if there is a relocation against
12991    section NAME at OFFSET bytes.  */
12992
12993 bfd_boolean
12994 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12995 {
12996   Elf_Internal_Rela * relocs;
12997   Elf_Internal_Rela * rp;
12998
12999   if (dsec == NULL || dsec->reloc_info == NULL)
13000     return FALSE;
13001
13002   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13003
13004   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13005     if (rp->r_offset == offset)
13006       return TRUE;
13007
13008    return FALSE;
13009 }
13010
13011 /* Apply relocations to a section.
13012    Returns TRUE upon success, FALSE otherwise.
13013    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13014    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
13015    will be set to the number of relocs loaded.
13016
13017    Note: So far support has been added only for those relocations
13018    which can be found in debug sections. FIXME: Add support for
13019    more relocations ?  */
13020
13021 static bfd_boolean
13022 apply_relocations (Filedata *                 filedata,
13023                    const Elf_Internal_Shdr *  section,
13024                    unsigned char *            start,
13025                    bfd_size_type              size,
13026                    void **                    relocs_return,
13027                    unsigned long *            num_relocs_return)
13028 {
13029   Elf_Internal_Shdr * relsec;
13030   unsigned char * end = start + size;
13031   bfd_boolean res = TRUE;
13032
13033   if (relocs_return != NULL)
13034     {
13035       * (Elf_Internal_Rela **) relocs_return = NULL;
13036       * num_relocs_return = 0;
13037     }
13038
13039   if (filedata->file_header.e_type != ET_REL)
13040     /* No relocs to apply.  */
13041     return TRUE;
13042
13043   /* Find the reloc section associated with the section.  */
13044   for (relsec = filedata->section_headers;
13045        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13046        ++relsec)
13047     {
13048       bfd_boolean is_rela;
13049       unsigned long num_relocs;
13050       Elf_Internal_Rela * relocs;
13051       Elf_Internal_Rela * rp;
13052       Elf_Internal_Shdr * symsec;
13053       Elf_Internal_Sym * symtab;
13054       unsigned long num_syms;
13055       Elf_Internal_Sym * sym;
13056
13057       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13058           || relsec->sh_info >= filedata->file_header.e_shnum
13059           || filedata->section_headers + relsec->sh_info != section
13060           || relsec->sh_size == 0
13061           || relsec->sh_link >= filedata->file_header.e_shnum)
13062         continue;
13063
13064       is_rela = relsec->sh_type == SHT_RELA;
13065
13066       if (is_rela)
13067         {
13068           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13069                                   relsec->sh_size, & relocs, & num_relocs))
13070             return FALSE;
13071         }
13072       else
13073         {
13074           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13075                                  relsec->sh_size, & relocs, & num_relocs))
13076             return FALSE;
13077         }
13078
13079       /* SH uses RELA but uses in place value instead of the addend field.  */
13080       if (filedata->file_header.e_machine == EM_SH)
13081         is_rela = FALSE;
13082
13083       symsec = filedata->section_headers + relsec->sh_link;
13084       if (symsec->sh_type != SHT_SYMTAB
13085           && symsec->sh_type != SHT_DYNSYM)
13086         return FALSE;
13087       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13088
13089       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13090         {
13091           bfd_vma         addend;
13092           unsigned int    reloc_type;
13093           unsigned int    reloc_size;
13094           bfd_boolean     reloc_inplace = FALSE;
13095           bfd_boolean     reloc_subtract = FALSE;
13096           unsigned char * rloc;
13097           unsigned long   sym_index;
13098
13099           reloc_type = get_reloc_type (filedata, rp->r_info);
13100
13101           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13102             continue;
13103           else if (is_none_reloc (filedata, reloc_type))
13104             continue;
13105           else if (is_32bit_abs_reloc (filedata, reloc_type)
13106                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13107             reloc_size = 4;
13108           else if (is_64bit_abs_reloc (filedata, reloc_type)
13109                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13110             reloc_size = 8;
13111           else if (is_24bit_abs_reloc (filedata, reloc_type))
13112             reloc_size = 3;
13113           else if (is_16bit_abs_reloc (filedata, reloc_type))
13114             reloc_size = 2;
13115           else if (is_8bit_abs_reloc (filedata, reloc_type)
13116                    || is_6bit_abs_reloc (filedata, reloc_type))
13117             reloc_size = 1;
13118           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13119                                                                  reloc_type))
13120                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13121             {
13122               reloc_size = 4;
13123               reloc_inplace = TRUE;
13124             }
13125           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13126                                                                  reloc_type))
13127                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13128             {
13129               reloc_size = 8;
13130               reloc_inplace = TRUE;
13131             }
13132           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13133                                                                  reloc_type))
13134                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13135             {
13136               reloc_size = 2;
13137               reloc_inplace = TRUE;
13138             }
13139           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13140                                                                 reloc_type))
13141                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13142             {
13143               reloc_size = 1;
13144               reloc_inplace = TRUE;
13145             }
13146           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13147                                                                 reloc_type)))
13148             {
13149               reloc_size = 1;
13150               reloc_inplace = TRUE;
13151             }
13152           else
13153             {
13154               static unsigned int prev_reloc = 0;
13155
13156               if (reloc_type != prev_reloc)
13157                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13158                       reloc_type, printable_section_name (filedata, section));
13159               prev_reloc = reloc_type;
13160               res = FALSE;
13161               continue;
13162             }
13163
13164           rloc = start + rp->r_offset;
13165           if ((rloc + reloc_size) > end || (rloc < start))
13166             {
13167               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13168                     (unsigned long) rp->r_offset,
13169                     printable_section_name (filedata, section));
13170               res = FALSE;
13171               continue;
13172             }
13173
13174           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13175           if (sym_index >= num_syms)
13176             {
13177               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13178                     sym_index, printable_section_name (filedata, section));
13179               res = FALSE;
13180               continue;
13181             }
13182           sym = symtab + sym_index;
13183
13184           /* If the reloc has a symbol associated with it,
13185              make sure that it is of an appropriate type.
13186
13187              Relocations against symbols without type can happen.
13188              Gcc -feliminate-dwarf2-dups may generate symbols
13189              without type for debug info.
13190
13191              Icc generates relocations against function symbols
13192              instead of local labels.
13193
13194              Relocations against object symbols can happen, eg when
13195              referencing a global array.  For an example of this see
13196              the _clz.o binary in libgcc.a.  */
13197           if (sym != symtab
13198               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13199               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13200             {
13201               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13202                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13203                     printable_section_name (filedata, relsec),
13204                     (long int)(rp - relocs));
13205               res = FALSE;
13206               continue;
13207             }
13208
13209           addend = 0;
13210           if (is_rela)
13211             addend += rp->r_addend;
13212           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13213              partial_inplace.  */
13214           if (!is_rela
13215               || (filedata->file_header.e_machine == EM_XTENSA
13216                   && reloc_type == 1)
13217               || ((filedata->file_header.e_machine == EM_PJ
13218                    || filedata->file_header.e_machine == EM_PJ_OLD)
13219                   && reloc_type == 1)
13220               || ((filedata->file_header.e_machine == EM_D30V
13221                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13222                   && reloc_type == 12)
13223               || reloc_inplace)
13224             {
13225               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13226                 addend += byte_get (rloc, reloc_size) & 0x3f;
13227               else
13228                 addend += byte_get (rloc, reloc_size);
13229             }
13230
13231           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13232               || is_64bit_pcrel_reloc (filedata, reloc_type))
13233             {
13234               /* On HPPA, all pc-relative relocations are biased by 8.  */
13235               if (filedata->file_header.e_machine == EM_PARISC)
13236                 addend -= 8;
13237               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13238                         reloc_size);
13239             }
13240           else if (is_6bit_abs_reloc (filedata, reloc_type)
13241                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13242             {
13243               if (reloc_subtract)
13244                 addend -= sym->st_value;
13245               else
13246                 addend += sym->st_value;
13247               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13248               byte_put (rloc, addend, reloc_size);
13249             }
13250           else if (reloc_subtract)
13251             byte_put (rloc, addend - sym->st_value, reloc_size);
13252           else
13253             byte_put (rloc, addend + sym->st_value, reloc_size);
13254         }
13255
13256       free (symtab);
13257       /* Let the target specific reloc processing code know that
13258          we have finished with these relocs.  */
13259       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13260
13261       if (relocs_return)
13262         {
13263           * (Elf_Internal_Rela **) relocs_return = relocs;
13264           * num_relocs_return = num_relocs;
13265         }
13266       else
13267         free (relocs);
13268
13269       break;
13270     }
13271
13272   return res;
13273 }
13274
13275 #ifdef SUPPORT_DISASSEMBLY
13276 static bfd_boolean
13277 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13278 {
13279   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13280
13281   /* FIXME: XXX -- to be done --- XXX */
13282
13283   return TRUE;
13284 }
13285 #endif
13286
13287 /* Reads in the contents of SECTION from FILE, returning a pointer
13288    to a malloc'ed buffer or NULL if something went wrong.  */
13289
13290 static char *
13291 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13292 {
13293   bfd_size_type num_bytes = section->sh_size;
13294
13295   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13296     {
13297       printf (_("Section '%s' has no data to dump.\n"),
13298               printable_section_name (filedata, section));
13299       return NULL;
13300     }
13301
13302   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13303                              _("section contents"));
13304 }
13305
13306 /* Uncompresses a section that was compressed using zlib, in place.  */
13307
13308 static bfd_boolean
13309 uncompress_section_contents (unsigned char **   buffer,
13310                              dwarf_size_type    uncompressed_size,
13311                              dwarf_size_type *  size)
13312 {
13313   dwarf_size_type compressed_size = *size;
13314   unsigned char * compressed_buffer = *buffer;
13315   unsigned char * uncompressed_buffer;
13316   z_stream strm;
13317   int rc;
13318
13319   /* It is possible the section consists of several compressed
13320      buffers concatenated together, so we uncompress in a loop.  */
13321   /* PR 18313: The state field in the z_stream structure is supposed
13322      to be invisible to the user (ie us), but some compilers will
13323      still complain about it being used without initialisation.  So
13324      we first zero the entire z_stream structure and then set the fields
13325      that we need.  */
13326   memset (& strm, 0, sizeof strm);
13327   strm.avail_in = compressed_size;
13328   strm.next_in = (Bytef *) compressed_buffer;
13329   strm.avail_out = uncompressed_size;
13330   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13331
13332   rc = inflateInit (& strm);
13333   while (strm.avail_in > 0)
13334     {
13335       if (rc != Z_OK)
13336         goto fail;
13337       strm.next_out = ((Bytef *) uncompressed_buffer
13338                        + (uncompressed_size - strm.avail_out));
13339       rc = inflate (&strm, Z_FINISH);
13340       if (rc != Z_STREAM_END)
13341         goto fail;
13342       rc = inflateReset (& strm);
13343     }
13344   rc = inflateEnd (& strm);
13345   if (rc != Z_OK
13346       || strm.avail_out != 0)
13347     goto fail;
13348
13349   *buffer = uncompressed_buffer;
13350   *size = uncompressed_size;
13351   return TRUE;
13352
13353  fail:
13354   free (uncompressed_buffer);
13355   /* Indicate decompression failure.  */
13356   *buffer = NULL;
13357   return FALSE;
13358 }
13359
13360 static bfd_boolean
13361 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13362 {
13363   Elf_Internal_Shdr *  relsec;
13364   bfd_size_type        num_bytes;
13365   unsigned char *      data;
13366   unsigned char *      end;
13367   unsigned char *      real_start;
13368   unsigned char *      start;
13369   bfd_boolean          some_strings_shown;
13370
13371   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13372   if (start == NULL)
13373     /* PR 21820: Do not fail if the section was empty.  */
13374     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13375
13376   num_bytes = section->sh_size;
13377
13378   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13379
13380   if (decompress_dumps)
13381     {
13382       dwarf_size_type new_size = num_bytes;
13383       dwarf_size_type uncompressed_size = 0;
13384
13385       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13386         {
13387           Elf_Internal_Chdr chdr;
13388           unsigned int compression_header_size
13389             = get_compression_header (& chdr, (unsigned char *) start,
13390                                       num_bytes);
13391
13392           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13393             {
13394               warn (_("section '%s' has unsupported compress type: %d\n"),
13395                     printable_section_name (filedata, section), chdr.ch_type);
13396               return FALSE;
13397             }
13398           else if (chdr.ch_addralign != section->sh_addralign)
13399             {
13400               warn (_("compressed section '%s' is corrupted\n"),
13401                     printable_section_name (filedata, section));
13402               return FALSE;
13403             }
13404           uncompressed_size = chdr.ch_size;
13405           start += compression_header_size;
13406           new_size -= compression_header_size;
13407         }
13408       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13409         {
13410           /* Read the zlib header.  In this case, it should be "ZLIB"
13411              followed by the uncompressed section size, 8 bytes in
13412              big-endian order.  */
13413           uncompressed_size = start[4]; uncompressed_size <<= 8;
13414           uncompressed_size += start[5]; uncompressed_size <<= 8;
13415           uncompressed_size += start[6]; uncompressed_size <<= 8;
13416           uncompressed_size += start[7]; uncompressed_size <<= 8;
13417           uncompressed_size += start[8]; uncompressed_size <<= 8;
13418           uncompressed_size += start[9]; uncompressed_size <<= 8;
13419           uncompressed_size += start[10]; uncompressed_size <<= 8;
13420           uncompressed_size += start[11];
13421           start += 12;
13422           new_size -= 12;
13423         }
13424
13425       if (uncompressed_size)
13426         {
13427           if (uncompress_section_contents (& start,
13428                                            uncompressed_size, & new_size))
13429             num_bytes = new_size;
13430           else
13431             {
13432               error (_("Unable to decompress section %s\n"),
13433                      printable_section_name (filedata, section));
13434               return FALSE;
13435             }
13436         }
13437       else
13438         start = real_start;
13439     }
13440
13441   /* If the section being dumped has relocations against it the user might
13442      be expecting these relocations to have been applied.  Check for this
13443      case and issue a warning message in order to avoid confusion.
13444      FIXME: Maybe we ought to have an option that dumps a section with
13445      relocs applied ?  */
13446   for (relsec = filedata->section_headers;
13447        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13448        ++relsec)
13449     {
13450       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13451           || relsec->sh_info >= filedata->file_header.e_shnum
13452           || filedata->section_headers + relsec->sh_info != section
13453           || relsec->sh_size == 0
13454           || relsec->sh_link >= filedata->file_header.e_shnum)
13455         continue;
13456
13457       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13458       break;
13459     }
13460
13461   data = start;
13462   end  = start + num_bytes;
13463   some_strings_shown = FALSE;
13464
13465   while (data < end)
13466     {
13467       while (!ISPRINT (* data))
13468         if (++ data >= end)
13469           break;
13470
13471       if (data < end)
13472         {
13473           size_t maxlen = end - data;
13474
13475 #ifndef __MSVCRT__
13476           /* PR 11128: Use two separate invocations in order to work
13477              around bugs in the Solaris 8 implementation of printf.  */
13478           printf ("  [%6tx]  ", data - start);
13479 #else
13480           printf ("  [%6Ix]  ", (size_t) (data - start));
13481 #endif
13482           if (maxlen > 0)
13483             {
13484               print_symbol ((int) maxlen, (const char *) data);
13485               putchar ('\n');
13486               data += strnlen ((const char *) data, maxlen);
13487             }
13488           else
13489             {
13490               printf (_("<corrupt>\n"));
13491               data = end;
13492             }
13493           some_strings_shown = TRUE;
13494         }
13495     }
13496
13497   if (! some_strings_shown)
13498     printf (_("  No strings found in this section."));
13499
13500   free (real_start);
13501
13502   putchar ('\n');
13503   return TRUE;
13504 }
13505
13506 static bfd_boolean
13507 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13508                        Filedata *           filedata,
13509                        bfd_boolean          relocate)
13510 {
13511   Elf_Internal_Shdr * relsec;
13512   bfd_size_type       bytes;
13513   bfd_size_type       section_size;
13514   bfd_vma             addr;
13515   unsigned char *     data;
13516   unsigned char *     real_start;
13517   unsigned char *     start;
13518
13519   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13520   if (start == NULL)
13521     /* PR 21820: Do not fail if the section was empty.  */
13522     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13523
13524   section_size = section->sh_size;
13525
13526   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13527
13528   if (decompress_dumps)
13529     {
13530       dwarf_size_type new_size = section_size;
13531       dwarf_size_type uncompressed_size = 0;
13532
13533       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13534         {
13535           Elf_Internal_Chdr chdr;
13536           unsigned int compression_header_size
13537             = get_compression_header (& chdr, start, section_size);
13538
13539           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13540             {
13541               warn (_("section '%s' has unsupported compress type: %d\n"),
13542                     printable_section_name (filedata, section), chdr.ch_type);
13543               return FALSE;
13544             }
13545           else if (chdr.ch_addralign != section->sh_addralign)
13546             {
13547               warn (_("compressed section '%s' is corrupted\n"),
13548                     printable_section_name (filedata, section));
13549               return FALSE;
13550             }
13551           uncompressed_size = chdr.ch_size;
13552           start += compression_header_size;
13553           new_size -= compression_header_size;
13554         }
13555       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13556         {
13557           /* Read the zlib header.  In this case, it should be "ZLIB"
13558              followed by the uncompressed section size, 8 bytes in
13559              big-endian order.  */
13560           uncompressed_size = start[4]; uncompressed_size <<= 8;
13561           uncompressed_size += start[5]; uncompressed_size <<= 8;
13562           uncompressed_size += start[6]; uncompressed_size <<= 8;
13563           uncompressed_size += start[7]; uncompressed_size <<= 8;
13564           uncompressed_size += start[8]; uncompressed_size <<= 8;
13565           uncompressed_size += start[9]; uncompressed_size <<= 8;
13566           uncompressed_size += start[10]; uncompressed_size <<= 8;
13567           uncompressed_size += start[11];
13568           start += 12;
13569           new_size -= 12;
13570         }
13571
13572       if (uncompressed_size)
13573         {
13574           if (uncompress_section_contents (& start, uncompressed_size,
13575                                            & new_size))
13576             {
13577               section_size = new_size;
13578             }
13579           else
13580             {
13581               error (_("Unable to decompress section %s\n"),
13582                      printable_section_name (filedata, section));
13583               /* FIXME: Print the section anyway ?  */
13584               return FALSE;
13585             }
13586         }
13587       else
13588         start = real_start;
13589     }
13590
13591   if (relocate)
13592     {
13593       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13594         return FALSE;
13595     }
13596   else
13597     {
13598       /* If the section being dumped has relocations against it the user might
13599          be expecting these relocations to have been applied.  Check for this
13600          case and issue a warning message in order to avoid confusion.
13601          FIXME: Maybe we ought to have an option that dumps a section with
13602          relocs applied ?  */
13603       for (relsec = filedata->section_headers;
13604            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13605            ++relsec)
13606         {
13607           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13608               || relsec->sh_info >= filedata->file_header.e_shnum
13609               || filedata->section_headers + relsec->sh_info != section
13610               || relsec->sh_size == 0
13611               || relsec->sh_link >= filedata->file_header.e_shnum)
13612             continue;
13613
13614           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13615           break;
13616         }
13617     }
13618
13619   addr = section->sh_addr;
13620   bytes = section_size;
13621   data = start;
13622
13623   while (bytes)
13624     {
13625       int j;
13626       int k;
13627       int lbytes;
13628
13629       lbytes = (bytes > 16 ? 16 : bytes);
13630
13631       printf ("  0x%8.8lx ", (unsigned long) addr);
13632
13633       for (j = 0; j < 16; j++)
13634         {
13635           if (j < lbytes)
13636             printf ("%2.2x", data[j]);
13637           else
13638             printf ("  ");
13639
13640           if ((j & 3) == 3)
13641             printf (" ");
13642         }
13643
13644       for (j = 0; j < lbytes; j++)
13645         {
13646           k = data[j];
13647           if (k >= ' ' && k < 0x7f)
13648             printf ("%c", k);
13649           else
13650             printf (".");
13651         }
13652
13653       putchar ('\n');
13654
13655       data  += lbytes;
13656       addr  += lbytes;
13657       bytes -= lbytes;
13658     }
13659
13660   free (real_start);
13661
13662   putchar ('\n');
13663   return TRUE;
13664 }
13665
13666 static bfd_boolean
13667 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13668                              const Elf_Internal_Shdr *        sec,
13669                              void *                           data)
13670 {
13671   struct dwarf_section * section = &debug_displays [debug].section;
13672   char buf [64];
13673   Filedata * filedata = (Filedata *) data;
13674
13675   if (section->start != NULL)
13676     {
13677       /* If it is already loaded, do nothing.  */
13678       if (streq (section->filename, filedata->file_name))
13679         return TRUE;
13680       free (section->start);
13681     }
13682
13683   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13684   section->address = sec->sh_addr;
13685   section->user_data = NULL;
13686   section->filename = filedata->file_name;
13687   section->start = (unsigned char *) get_data (NULL, filedata,
13688                                                sec->sh_offset, 1,
13689                                                sec->sh_size, buf);
13690   if (section->start == NULL)
13691     section->size = 0;
13692   else
13693     {
13694       unsigned char *start = section->start;
13695       dwarf_size_type size = sec->sh_size;
13696       dwarf_size_type uncompressed_size = 0;
13697
13698       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13699         {
13700           Elf_Internal_Chdr chdr;
13701           unsigned int compression_header_size;
13702
13703           if (size < (is_32bit_elf
13704                       ? sizeof (Elf32_External_Chdr)
13705                       : sizeof (Elf64_External_Chdr)))
13706             {
13707               warn (_("compressed section %s is too small to contain a compression header"),
13708                     section->name);
13709               return FALSE;
13710             }
13711
13712           compression_header_size = get_compression_header (&chdr, start, size);
13713
13714           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13715             {
13716               warn (_("section '%s' has unsupported compress type: %d\n"),
13717                     section->name, chdr.ch_type);
13718               return FALSE;
13719             }
13720           else if (chdr.ch_addralign != sec->sh_addralign)
13721             {
13722               warn (_("compressed section '%s' is corrupted\n"),
13723                     section->name);
13724               return FALSE;
13725             }
13726           uncompressed_size = chdr.ch_size;
13727           start += compression_header_size;
13728           size -= compression_header_size;
13729         }
13730       else if (size > 12 && streq ((char *) start, "ZLIB"))
13731         {
13732           /* Read the zlib header.  In this case, it should be "ZLIB"
13733              followed by the uncompressed section size, 8 bytes in
13734              big-endian order.  */
13735           uncompressed_size = start[4]; uncompressed_size <<= 8;
13736           uncompressed_size += start[5]; uncompressed_size <<= 8;
13737           uncompressed_size += start[6]; uncompressed_size <<= 8;
13738           uncompressed_size += start[7]; uncompressed_size <<= 8;
13739           uncompressed_size += start[8]; uncompressed_size <<= 8;
13740           uncompressed_size += start[9]; uncompressed_size <<= 8;
13741           uncompressed_size += start[10]; uncompressed_size <<= 8;
13742           uncompressed_size += start[11];
13743           start += 12;
13744           size -= 12;
13745         }
13746
13747       if (uncompressed_size)
13748         {
13749           if (uncompress_section_contents (&start, uncompressed_size,
13750                                            &size))
13751             {
13752               /* Free the compressed buffer, update the section buffer
13753                  and the section size if uncompress is successful.  */
13754               free (section->start);
13755               section->start = start;
13756             }
13757           else
13758             {
13759               error (_("Unable to decompress section %s\n"),
13760                      printable_section_name (filedata, sec));
13761               return FALSE;
13762             }
13763         }
13764
13765       section->size = size;
13766     }
13767
13768   if (section->start == NULL)
13769     return FALSE;
13770
13771   if (debug_displays [debug].relocate)
13772     {
13773       if (! apply_relocations (filedata, sec, section->start, section->size,
13774                                & section->reloc_info, & section->num_relocs))
13775         return FALSE;
13776     }
13777   else
13778     {
13779       section->reloc_info = NULL;
13780       section->num_relocs = 0;
13781     }
13782
13783   return TRUE;
13784 }
13785
13786 /* If this is not NULL, load_debug_section will only look for sections
13787    within the list of sections given here.  */
13788 static unsigned int * section_subset = NULL;
13789
13790 bfd_boolean
13791 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13792 {
13793   struct dwarf_section * section = &debug_displays [debug].section;
13794   Elf_Internal_Shdr * sec;
13795   Filedata * filedata = (Filedata *) data;
13796
13797   /* Without section headers we cannot find any sections.  */
13798   if (filedata->section_headers == NULL)
13799     return FALSE;
13800
13801   if (filedata->string_table == NULL
13802       && filedata->file_header.e_shstrndx != SHN_UNDEF
13803       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13804     {
13805       Elf_Internal_Shdr * strs;
13806
13807       /* Read in the string table, so that we have section names to scan.  */
13808       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13809
13810       if (strs != NULL && strs->sh_size != 0)
13811         {
13812           filedata->string_table
13813             = (char *) get_data (NULL, filedata, strs->sh_offset,
13814                                  1, strs->sh_size, _("string table"));
13815
13816           filedata->string_table_length
13817             = filedata->string_table != NULL ? strs->sh_size : 0;
13818         }
13819     }
13820
13821   /* Locate the debug section.  */
13822   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13823   if (sec != NULL)
13824     section->name = section->uncompressed_name;
13825   else
13826     {
13827       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13828       if (sec != NULL)
13829         section->name = section->compressed_name;
13830     }
13831   if (sec == NULL)
13832     return FALSE;
13833
13834   /* If we're loading from a subset of sections, and we've loaded
13835      a section matching this name before, it's likely that it's a
13836      different one.  */
13837   if (section_subset != NULL)
13838     free_debug_section (debug);
13839
13840   return load_specific_debug_section (debug, sec, data);
13841 }
13842
13843 void
13844 free_debug_section (enum dwarf_section_display_enum debug)
13845 {
13846   struct dwarf_section * section = &debug_displays [debug].section;
13847
13848   if (section->start == NULL)
13849     return;
13850
13851   free ((char *) section->start);
13852   section->start = NULL;
13853   section->address = 0;
13854   section->size = 0;
13855 }
13856
13857 static bfd_boolean
13858 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13859 {
13860   char * name = SECTION_NAME (section);
13861   const char * print_name = printable_section_name (filedata, section);
13862   bfd_size_type length;
13863   bfd_boolean result = TRUE;
13864   int i;
13865
13866   length = section->sh_size;
13867   if (length == 0)
13868     {
13869       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13870       return TRUE;
13871     }
13872   if (section->sh_type == SHT_NOBITS)
13873     {
13874       /* There is no point in dumping the contents of a debugging section
13875          which has the NOBITS type - the bits in the file will be random.
13876          This can happen when a file containing a .eh_frame section is
13877          stripped with the --only-keep-debug command line option.  */
13878       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13879               print_name);
13880       return FALSE;
13881     }
13882
13883   if (const_strneq (name, ".gnu.linkonce.wi."))
13884     name = ".debug_info";
13885
13886   /* See if we know how to display the contents of this section.  */
13887   for (i = 0; i < max; i++)
13888     {
13889       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13890       struct dwarf_section_display *   display = debug_displays + i;
13891       struct dwarf_section *           sec = & display->section;
13892
13893       if (streq (sec->uncompressed_name, name)
13894           || (id == line && const_strneq (name, ".debug_line."))
13895           || streq (sec->compressed_name, name))
13896         {
13897           bfd_boolean secondary = (section != find_section (filedata, name));
13898
13899           if (secondary)
13900             free_debug_section (id);
13901
13902           if (i == line && const_strneq (name, ".debug_line."))
13903             sec->name = name;
13904           else if (streq (sec->uncompressed_name, name))
13905             sec->name = sec->uncompressed_name;
13906           else
13907             sec->name = sec->compressed_name;
13908
13909           if (load_specific_debug_section (id, section, filedata))
13910             {
13911               /* If this debug section is part of a CU/TU set in a .dwp file,
13912                  restrict load_debug_section to the sections in that set.  */
13913               section_subset = find_cu_tu_set (filedata, shndx);
13914
13915               result &= display->display (sec, filedata);
13916
13917               section_subset = NULL;
13918
13919               if (secondary || (id != info && id != abbrev))
13920                 free_debug_section (id);
13921             }
13922           break;
13923         }
13924     }
13925
13926   if (i == max)
13927     {
13928       printf (_("Unrecognized debug section: %s\n"), print_name);
13929       result = FALSE;
13930     }
13931
13932   return result;
13933 }
13934
13935 /* Set DUMP_SECTS for all sections where dumps were requested
13936    based on section name.  */
13937
13938 static void
13939 initialise_dumps_byname (Filedata * filedata)
13940 {
13941   struct dump_list_entry * cur;
13942
13943   for (cur = dump_sects_byname; cur; cur = cur->next)
13944     {
13945       unsigned int i;
13946       bfd_boolean any = FALSE;
13947
13948       for (i = 0; i < filedata->file_header.e_shnum; i++)
13949         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13950           {
13951             request_dump_bynumber (filedata, i, cur->type);
13952             any = TRUE;
13953           }
13954
13955       if (!any)
13956         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13957               cur->name);
13958     }
13959 }
13960
13961 static bfd_boolean
13962 process_section_contents (Filedata * filedata)
13963 {
13964   Elf_Internal_Shdr * section;
13965   unsigned int i;
13966   bfd_boolean res = TRUE;
13967
13968   if (! do_dump)
13969     return TRUE;
13970
13971   initialise_dumps_byname (filedata);
13972
13973   for (i = 0, section = filedata->section_headers;
13974        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13975        i++, section++)
13976     {
13977       dump_type dump = filedata->dump_sects[i];
13978
13979 #ifdef SUPPORT_DISASSEMBLY
13980       if (dump & DISASS_DUMP)
13981         {
13982           if (! disassemble_section (section, filedata))
13983             res = FALSE;
13984         }
13985 #endif
13986       if (dump & HEX_DUMP)
13987         {
13988           if (! dump_section_as_bytes (section, filedata, FALSE))
13989             res = FALSE;
13990         }
13991
13992       if (dump & RELOC_DUMP)
13993         {
13994           if (! dump_section_as_bytes (section, filedata, TRUE))
13995             res = FALSE;
13996         }
13997
13998       if (dump & STRING_DUMP)
13999         {
14000           if (! dump_section_as_strings (section, filedata))
14001             res = FALSE;
14002         }
14003
14004       if (dump & DEBUG_DUMP)
14005         {
14006           if (! display_debug_section (i, section, filedata))
14007             res = FALSE;
14008         }
14009     }
14010
14011   /* Check to see if the user requested a
14012      dump of a section that does not exist.  */
14013   while (i < filedata->num_dump_sects)
14014     {
14015       if (filedata->dump_sects[i])
14016         {
14017           warn (_("Section %d was not dumped because it does not exist!\n"), i);
14018           res = FALSE;
14019         }
14020       i++;
14021     }
14022
14023   return res;
14024 }
14025
14026 static void
14027 process_mips_fpe_exception (int mask)
14028 {
14029   if (mask)
14030     {
14031       bfd_boolean first = TRUE;
14032
14033       if (mask & OEX_FPU_INEX)
14034         fputs ("INEX", stdout), first = FALSE;
14035       if (mask & OEX_FPU_UFLO)
14036         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14037       if (mask & OEX_FPU_OFLO)
14038         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14039       if (mask & OEX_FPU_DIV0)
14040         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14041       if (mask & OEX_FPU_INVAL)
14042         printf ("%sINVAL", first ? "" : "|");
14043     }
14044   else
14045     fputs ("0", stdout);
14046 }
14047
14048 /* Display's the value of TAG at location P.  If TAG is
14049    greater than 0 it is assumed to be an unknown tag, and
14050    a message is printed to this effect.  Otherwise it is
14051    assumed that a message has already been printed.
14052
14053    If the bottom bit of TAG is set it assumed to have a
14054    string value, otherwise it is assumed to have an integer
14055    value.
14056
14057    Returns an updated P pointing to the first unread byte
14058    beyond the end of TAG's value.
14059
14060    Reads at or beyond END will not be made.  */
14061
14062 static unsigned char *
14063 display_tag_value (signed int tag,
14064                    unsigned char * p,
14065                    const unsigned char * const end)
14066 {
14067   unsigned long val;
14068
14069   if (tag > 0)
14070     printf ("  Tag_unknown_%d: ", tag);
14071
14072   if (p >= end)
14073     {
14074       warn (_("<corrupt tag>\n"));
14075     }
14076   else if (tag & 1)
14077     {
14078       /* PR 17531 file: 027-19978-0.004.  */
14079       size_t maxlen = (end - p) - 1;
14080
14081       putchar ('"');
14082       if (maxlen > 0)
14083         {
14084           print_symbol ((int) maxlen, (const char *) p);
14085           p += strnlen ((char *) p, maxlen) + 1;
14086         }
14087       else
14088         {
14089           printf (_("<corrupt string tag>"));
14090           p = (unsigned char *) end;
14091         }
14092       printf ("\"\n");
14093     }
14094   else
14095     {
14096       unsigned int len;
14097
14098       val = read_uleb128 (p, &len, end);
14099       p += len;
14100       printf ("%ld (0x%lx)\n", val, val);
14101     }
14102
14103   assert (p <= end);
14104   return p;
14105 }
14106
14107 /* ARC ABI attributes section.  */
14108
14109 static unsigned char *
14110 display_arc_attribute (unsigned char * p,
14111                        const unsigned char * const end)
14112 {
14113   unsigned int tag;
14114   unsigned int len;
14115   unsigned int val;
14116
14117   tag = read_uleb128 (p, &len, end);
14118   p += len;
14119
14120   switch (tag)
14121     {
14122     case Tag_ARC_PCS_config:
14123       val = read_uleb128 (p, &len, end);
14124       p += len;
14125       printf ("  Tag_ARC_PCS_config: ");
14126       switch (val)
14127         {
14128         case 0:
14129           printf (_("Absent/Non standard\n"));
14130           break;
14131         case 1:
14132           printf (_("Bare metal/mwdt\n"));
14133           break;
14134         case 2:
14135           printf (_("Bare metal/newlib\n"));
14136           break;
14137         case 3:
14138           printf (_("Linux/uclibc\n"));
14139           break;
14140         case 4:
14141           printf (_("Linux/glibc\n"));
14142           break;
14143         default:
14144           printf (_("Unknown\n"));
14145           break;
14146         }
14147       break;
14148
14149     case Tag_ARC_CPU_base:
14150       val = read_uleb128 (p, &len, end);
14151       p += len;
14152       printf ("  Tag_ARC_CPU_base: ");
14153       switch (val)
14154         {
14155         default:
14156         case TAG_CPU_NONE:
14157           printf (_("Absent\n"));
14158           break;
14159         case TAG_CPU_ARC6xx:
14160           printf ("ARC6xx\n");
14161           break;
14162         case TAG_CPU_ARC7xx:
14163           printf ("ARC7xx\n");
14164           break;
14165         case TAG_CPU_ARCEM:
14166           printf ("ARCEM\n");
14167           break;
14168         case TAG_CPU_ARCHS:
14169           printf ("ARCHS\n");
14170           break;
14171         }
14172       break;
14173
14174     case Tag_ARC_CPU_variation:
14175       val = read_uleb128 (p, &len, end);
14176       p += len;
14177       printf ("  Tag_ARC_CPU_variation: ");
14178       switch (val)
14179         {
14180         default:
14181           if (val > 0 && val < 16)
14182               printf ("Core%d\n", val);
14183           else
14184               printf ("Unknown\n");
14185           break;
14186
14187         case 0:
14188           printf (_("Absent\n"));
14189           break;
14190         }
14191       break;
14192
14193     case Tag_ARC_CPU_name:
14194       printf ("  Tag_ARC_CPU_name: ");
14195       p = display_tag_value (-1, p, end);
14196       break;
14197
14198     case Tag_ARC_ABI_rf16:
14199       val = read_uleb128 (p, &len, end);
14200       p += len;
14201       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14202       break;
14203
14204     case Tag_ARC_ABI_osver:
14205       val = read_uleb128 (p, &len, end);
14206       p += len;
14207       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14208       break;
14209
14210     case Tag_ARC_ABI_pic:
14211     case Tag_ARC_ABI_sda:
14212       val = read_uleb128 (p, &len, end);
14213       p += len;
14214       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14215               : "  Tag_ARC_ABI_pic: ");
14216       switch (val)
14217         {
14218         case 0:
14219           printf (_("Absent\n"));
14220           break;
14221         case 1:
14222           printf ("MWDT\n");
14223           break;
14224         case 2:
14225           printf ("GNU\n");
14226           break;
14227         default:
14228           printf (_("Unknown\n"));
14229           break;
14230         }
14231       break;
14232
14233     case Tag_ARC_ABI_tls:
14234       val = read_uleb128 (p, &len, end);
14235       p += len;
14236       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14237       break;
14238
14239     case Tag_ARC_ABI_enumsize:
14240       val = read_uleb128 (p, &len, end);
14241       p += len;
14242       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14243               _("smallest"));
14244       break;
14245
14246     case Tag_ARC_ABI_exceptions:
14247       val = read_uleb128 (p, &len, end);
14248       p += len;
14249       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14250               : _("default"));
14251       break;
14252
14253     case Tag_ARC_ABI_double_size:
14254       val = read_uleb128 (p, &len, end);
14255       p += len;
14256       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14257       break;
14258
14259     case Tag_ARC_ISA_config:
14260       printf ("  Tag_ARC_ISA_config: ");
14261       p = display_tag_value (-1, p, end);
14262       break;
14263
14264     case Tag_ARC_ISA_apex:
14265       printf ("  Tag_ARC_ISA_apex: ");
14266       p = display_tag_value (-1, p, end);
14267       break;
14268
14269     case Tag_ARC_ISA_mpy_option:
14270       val = read_uleb128 (p, &len, end);
14271       p += len;
14272       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14273       break;
14274
14275     case Tag_ARC_ATR_version:
14276       val = read_uleb128 (p, &len, end);
14277       p += len;
14278       printf ("  Tag_ARC_ATR_version: %d\n", val);
14279       break;
14280
14281     default:
14282       return display_tag_value (tag & 1, p, end);
14283     }
14284
14285   return p;
14286 }
14287
14288 /* ARM EABI attributes section.  */
14289 typedef struct
14290 {
14291   unsigned int tag;
14292   const char * name;
14293   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14294   unsigned int type;
14295   const char ** table;
14296 } arm_attr_public_tag;
14297
14298 static const char * arm_attr_tag_CPU_arch[] =
14299   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14300    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14301    "v8-M.mainline"};
14302 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14303 static const char * arm_attr_tag_THUMB_ISA_use[] =
14304   {"No", "Thumb-1", "Thumb-2", "Yes"};
14305 static const char * arm_attr_tag_FP_arch[] =
14306   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14307    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14308 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14309 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14310   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14311    "NEON for ARMv8.1"};
14312 static const char * arm_attr_tag_PCS_config[] =
14313   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14314    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14315 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14316   {"V6", "SB", "TLS", "Unused"};
14317 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14318   {"Absolute", "PC-relative", "SB-relative", "None"};
14319 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14320   {"Absolute", "PC-relative", "None"};
14321 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14322   {"None", "direct", "GOT-indirect"};
14323 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14324   {"None", "??? 1", "2", "??? 3", "4"};
14325 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14326 static const char * arm_attr_tag_ABI_FP_denormal[] =
14327   {"Unused", "Needed", "Sign only"};
14328 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14329 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14330 static const char * arm_attr_tag_ABI_FP_number_model[] =
14331   {"Unused", "Finite", "RTABI", "IEEE 754"};
14332 static const char * arm_attr_tag_ABI_enum_size[] =
14333   {"Unused", "small", "int", "forced to int"};
14334 static const char * arm_attr_tag_ABI_HardFP_use[] =
14335   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14336 static const char * arm_attr_tag_ABI_VFP_args[] =
14337   {"AAPCS", "VFP registers", "custom", "compatible"};
14338 static const char * arm_attr_tag_ABI_WMMX_args[] =
14339   {"AAPCS", "WMMX registers", "custom"};
14340 static const char * arm_attr_tag_ABI_optimization_goals[] =
14341   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14342     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14343 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14344   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14345     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14346 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14347 static const char * arm_attr_tag_FP_HP_extension[] =
14348   {"Not Allowed", "Allowed"};
14349 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14350   {"None", "IEEE 754", "Alternative Format"};
14351 static const char * arm_attr_tag_DSP_extension[] =
14352   {"Follow architecture", "Allowed"};
14353 static const char * arm_attr_tag_MPextension_use[] =
14354   {"Not Allowed", "Allowed"};
14355 static const char * arm_attr_tag_DIV_use[] =
14356   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14357     "Allowed in v7-A with integer division extension"};
14358 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14359 static const char * arm_attr_tag_Virtualization_use[] =
14360   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14361     "TrustZone and Virtualization Extensions"};
14362 static const char * arm_attr_tag_MPextension_use_legacy[] =
14363   {"Not Allowed", "Allowed"};
14364
14365 #define LOOKUP(id, name) \
14366   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14367 static arm_attr_public_tag arm_attr_public_tags[] =
14368 {
14369   {4, "CPU_raw_name", 1, NULL},
14370   {5, "CPU_name", 1, NULL},
14371   LOOKUP(6, CPU_arch),
14372   {7, "CPU_arch_profile", 0, NULL},
14373   LOOKUP(8, ARM_ISA_use),
14374   LOOKUP(9, THUMB_ISA_use),
14375   LOOKUP(10, FP_arch),
14376   LOOKUP(11, WMMX_arch),
14377   LOOKUP(12, Advanced_SIMD_arch),
14378   LOOKUP(13, PCS_config),
14379   LOOKUP(14, ABI_PCS_R9_use),
14380   LOOKUP(15, ABI_PCS_RW_data),
14381   LOOKUP(16, ABI_PCS_RO_data),
14382   LOOKUP(17, ABI_PCS_GOT_use),
14383   LOOKUP(18, ABI_PCS_wchar_t),
14384   LOOKUP(19, ABI_FP_rounding),
14385   LOOKUP(20, ABI_FP_denormal),
14386   LOOKUP(21, ABI_FP_exceptions),
14387   LOOKUP(22, ABI_FP_user_exceptions),
14388   LOOKUP(23, ABI_FP_number_model),
14389   {24, "ABI_align_needed", 0, NULL},
14390   {25, "ABI_align_preserved", 0, NULL},
14391   LOOKUP(26, ABI_enum_size),
14392   LOOKUP(27, ABI_HardFP_use),
14393   LOOKUP(28, ABI_VFP_args),
14394   LOOKUP(29, ABI_WMMX_args),
14395   LOOKUP(30, ABI_optimization_goals),
14396   LOOKUP(31, ABI_FP_optimization_goals),
14397   {32, "compatibility", 0, NULL},
14398   LOOKUP(34, CPU_unaligned_access),
14399   LOOKUP(36, FP_HP_extension),
14400   LOOKUP(38, ABI_FP_16bit_format),
14401   LOOKUP(42, MPextension_use),
14402   LOOKUP(44, DIV_use),
14403   LOOKUP(46, DSP_extension),
14404   {64, "nodefaults", 0, NULL},
14405   {65, "also_compatible_with", 0, NULL},
14406   LOOKUP(66, T2EE_use),
14407   {67, "conformance", 1, NULL},
14408   LOOKUP(68, Virtualization_use),
14409   LOOKUP(70, MPextension_use_legacy)
14410 };
14411 #undef LOOKUP
14412
14413 static unsigned char *
14414 display_arm_attribute (unsigned char * p,
14415                        const unsigned char * const end)
14416 {
14417   unsigned int tag;
14418   unsigned int len;
14419   unsigned int val;
14420   arm_attr_public_tag * attr;
14421   unsigned i;
14422   unsigned int type;
14423
14424   tag = read_uleb128 (p, &len, end);
14425   p += len;
14426   attr = NULL;
14427   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14428     {
14429       if (arm_attr_public_tags[i].tag == tag)
14430         {
14431           attr = &arm_attr_public_tags[i];
14432           break;
14433         }
14434     }
14435
14436   if (attr)
14437     {
14438       printf ("  Tag_%s: ", attr->name);
14439       switch (attr->type)
14440         {
14441         case 0:
14442           switch (tag)
14443             {
14444             case 7: /* Tag_CPU_arch_profile.  */
14445               val = read_uleb128 (p, &len, end);
14446               p += len;
14447               switch (val)
14448                 {
14449                 case 0: printf (_("None\n")); break;
14450                 case 'A': printf (_("Application\n")); break;
14451                 case 'R': printf (_("Realtime\n")); break;
14452                 case 'M': printf (_("Microcontroller\n")); break;
14453                 case 'S': printf (_("Application or Realtime\n")); break;
14454                 default: printf ("??? (%d)\n", val); break;
14455                 }
14456               break;
14457
14458             case 24: /* Tag_align_needed.  */
14459               val = read_uleb128 (p, &len, end);
14460               p += len;
14461               switch (val)
14462                 {
14463                 case 0: printf (_("None\n")); break;
14464                 case 1: printf (_("8-byte\n")); break;
14465                 case 2: printf (_("4-byte\n")); break;
14466                 case 3: printf ("??? 3\n"); break;
14467                 default:
14468                   if (val <= 12)
14469                     printf (_("8-byte and up to %d-byte extended\n"),
14470                             1 << val);
14471                   else
14472                     printf ("??? (%d)\n", val);
14473                   break;
14474                 }
14475               break;
14476
14477             case 25: /* Tag_align_preserved.  */
14478               val = read_uleb128 (p, &len, end);
14479               p += len;
14480               switch (val)
14481                 {
14482                 case 0: printf (_("None\n")); break;
14483                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14484                 case 2: printf (_("8-byte\n")); break;
14485                 case 3: printf ("??? 3\n"); break;
14486                 default:
14487                   if (val <= 12)
14488                     printf (_("8-byte and up to %d-byte extended\n"),
14489                             1 << val);
14490                   else
14491                     printf ("??? (%d)\n", val);
14492                   break;
14493                 }
14494               break;
14495
14496             case 32: /* Tag_compatibility.  */
14497               {
14498                 val = read_uleb128 (p, &len, end);
14499                 p += len;
14500                 printf (_("flag = %d, vendor = "), val);
14501                 if (p < end - 1)
14502                   {
14503                     size_t maxlen = (end - p) - 1;
14504
14505                     print_symbol ((int) maxlen, (const char *) p);
14506                     p += strnlen ((char *) p, maxlen) + 1;
14507                   }
14508                 else
14509                   {
14510                     printf (_("<corrupt>"));
14511                     p = (unsigned char *) end;
14512                   }
14513                 putchar ('\n');
14514               }
14515               break;
14516
14517             case 64: /* Tag_nodefaults.  */
14518               /* PR 17531: file: 001-505008-0.01.  */
14519               if (p < end)
14520                 p++;
14521               printf (_("True\n"));
14522               break;
14523
14524             case 65: /* Tag_also_compatible_with.  */
14525               val = read_uleb128 (p, &len, end);
14526               p += len;
14527               if (val == 6 /* Tag_CPU_arch.  */)
14528                 {
14529                   val = read_uleb128 (p, &len, end);
14530                   p += len;
14531                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14532                     printf ("??? (%d)\n", val);
14533                   else
14534                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14535                 }
14536               else
14537                 printf ("???\n");
14538               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14539                 ;
14540               break;
14541
14542             default:
14543               printf (_("<unknown: %d>\n"), tag);
14544               break;
14545             }
14546           return p;
14547
14548         case 1:
14549           return display_tag_value (-1, p, end);
14550         case 2:
14551           return display_tag_value (0, p, end);
14552
14553         default:
14554           assert (attr->type & 0x80);
14555           val = read_uleb128 (p, &len, end);
14556           p += len;
14557           type = attr->type & 0x7f;
14558           if (val >= type)
14559             printf ("??? (%d)\n", val);
14560           else
14561             printf ("%s\n", attr->table[val]);
14562           return p;
14563         }
14564     }
14565
14566   return display_tag_value (tag, p, end);
14567 }
14568
14569 static unsigned char *
14570 display_gnu_attribute (unsigned char * p,
14571                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14572                        const unsigned char * const end)
14573 {
14574   int tag;
14575   unsigned int len;
14576   unsigned int val;
14577
14578   tag = read_uleb128 (p, &len, end);
14579   p += len;
14580
14581   /* Tag_compatibility is the only generic GNU attribute defined at
14582      present.  */
14583   if (tag == 32)
14584     {
14585       val = read_uleb128 (p, &len, end);
14586       p += len;
14587
14588       printf (_("flag = %d, vendor = "), val);
14589       if (p == end)
14590         {
14591           printf (_("<corrupt>\n"));
14592           warn (_("corrupt vendor attribute\n"));
14593         }
14594       else
14595         {
14596           if (p < end - 1)
14597             {
14598               size_t maxlen = (end - p) - 1;
14599
14600               print_symbol ((int) maxlen, (const char *) p);
14601               p += strnlen ((char *) p, maxlen) + 1;
14602             }
14603           else
14604             {
14605               printf (_("<corrupt>"));
14606               p = (unsigned char *) end;
14607             }
14608           putchar ('\n');
14609         }
14610       return p;
14611     }
14612
14613   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14614     return display_proc_gnu_attribute (p, tag, end);
14615
14616   return display_tag_value (tag, p, end);
14617 }
14618
14619 static unsigned char *
14620 display_power_gnu_attribute (unsigned char * p,
14621                              unsigned int tag,
14622                              const unsigned char * const end)
14623 {
14624   unsigned int len;
14625   unsigned int val;
14626
14627   if (tag == Tag_GNU_Power_ABI_FP)
14628     {
14629       val = read_uleb128 (p, &len, end);
14630       p += len;
14631       printf ("  Tag_GNU_Power_ABI_FP: ");
14632       if (len == 0)
14633         {
14634           printf (_("<corrupt>\n"));
14635           return p;
14636         }
14637
14638       if (val > 15)
14639         printf ("(%#x), ", val);
14640
14641       switch (val & 3)
14642         {
14643         case 0:
14644           printf (_("unspecified hard/soft float, "));
14645           break;
14646         case 1:
14647           printf (_("hard float, "));
14648           break;
14649         case 2:
14650           printf (_("soft float, "));
14651           break;
14652         case 3:
14653           printf (_("single-precision hard float, "));
14654           break;
14655         }
14656
14657       switch (val & 0xC)
14658         {
14659         case 0:
14660           printf (_("unspecified long double\n"));
14661           break;
14662         case 4:
14663           printf (_("128-bit IBM long double\n"));
14664           break;
14665         case 8:
14666           printf (_("64-bit long double\n"));
14667           break;
14668         case 12:
14669           printf (_("128-bit IEEE long double\n"));
14670           break;
14671         }
14672       return p;
14673     }
14674
14675   if (tag == Tag_GNU_Power_ABI_Vector)
14676     {
14677       val = read_uleb128 (p, &len, end);
14678       p += len;
14679       printf ("  Tag_GNU_Power_ABI_Vector: ");
14680       if (len == 0)
14681         {
14682           printf (_("<corrupt>\n"));
14683           return p;
14684         }
14685
14686       if (val > 3)
14687         printf ("(%#x), ", val);
14688
14689       switch (val & 3)
14690         {
14691         case 0:
14692           printf (_("unspecified\n"));
14693           break;
14694         case 1:
14695           printf (_("generic\n"));
14696           break;
14697         case 2:
14698           printf ("AltiVec\n");
14699           break;
14700         case 3:
14701           printf ("SPE\n");
14702           break;
14703         }
14704       return p;
14705     }
14706
14707   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14708     {
14709       val = read_uleb128 (p, &len, end);
14710       p += len;
14711       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14712       if (len == 0)
14713         {
14714           printf (_("<corrupt>\n"));
14715           return p;
14716         }
14717
14718       if (val > 2)
14719         printf ("(%#x), ", val);
14720
14721       switch (val & 3)
14722         {
14723         case 0:
14724           printf (_("unspecified\n"));
14725           break;
14726         case 1:
14727           printf ("r3/r4\n");
14728           break;
14729         case 2:
14730           printf (_("memory\n"));
14731           break;
14732         case 3:
14733           printf ("???\n");
14734           break;
14735         }
14736       return p;
14737     }
14738
14739   return display_tag_value (tag & 1, p, end);
14740 }
14741
14742 static unsigned char *
14743 display_s390_gnu_attribute (unsigned char * p,
14744                             unsigned int tag,
14745                             const unsigned char * const end)
14746 {
14747   unsigned int len;
14748   int val;
14749
14750   if (tag == Tag_GNU_S390_ABI_Vector)
14751     {
14752       val = read_uleb128 (p, &len, end);
14753       p += len;
14754       printf ("  Tag_GNU_S390_ABI_Vector: ");
14755
14756       switch (val)
14757         {
14758         case 0:
14759           printf (_("any\n"));
14760           break;
14761         case 1:
14762           printf (_("software\n"));
14763           break;
14764         case 2:
14765           printf (_("hardware\n"));
14766           break;
14767         default:
14768           printf ("??? (%d)\n", val);
14769           break;
14770         }
14771       return p;
14772    }
14773
14774   return display_tag_value (tag & 1, p, end);
14775 }
14776
14777 static void
14778 display_sparc_hwcaps (unsigned int mask)
14779 {
14780   if (mask)
14781     {
14782       bfd_boolean first = TRUE;
14783
14784       if (mask & ELF_SPARC_HWCAP_MUL32)
14785         fputs ("mul32", stdout), first = FALSE;
14786       if (mask & ELF_SPARC_HWCAP_DIV32)
14787         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14788       if (mask & ELF_SPARC_HWCAP_FSMULD)
14789         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14790       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14791         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14792       if (mask & ELF_SPARC_HWCAP_POPC)
14793         printf ("%spopc", first ? "" : "|"), first = FALSE;
14794       if (mask & ELF_SPARC_HWCAP_VIS)
14795         printf ("%svis", first ? "" : "|"), first = FALSE;
14796       if (mask & ELF_SPARC_HWCAP_VIS2)
14797         printf ("%svis2", first ? "" : "|"), first = FALSE;
14798       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14799         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14800       if (mask & ELF_SPARC_HWCAP_FMAF)
14801         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14802       if (mask & ELF_SPARC_HWCAP_VIS3)
14803         printf ("%svis3", first ? "" : "|"), first = FALSE;
14804       if (mask & ELF_SPARC_HWCAP_HPC)
14805         printf ("%shpc", first ? "" : "|"), first = FALSE;
14806       if (mask & ELF_SPARC_HWCAP_RANDOM)
14807         printf ("%srandom", first ? "" : "|"), first = FALSE;
14808       if (mask & ELF_SPARC_HWCAP_TRANS)
14809         printf ("%strans", first ? "" : "|"), first = FALSE;
14810       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14811         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14812       if (mask & ELF_SPARC_HWCAP_IMA)
14813         printf ("%sima", first ? "" : "|"), first = FALSE;
14814       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14815         printf ("%scspare", first ? "" : "|"), first = FALSE;
14816     }
14817   else
14818     fputc ('0', stdout);
14819   fputc ('\n', stdout);
14820 }
14821
14822 static void
14823 display_sparc_hwcaps2 (unsigned int mask)
14824 {
14825   if (mask)
14826     {
14827       bfd_boolean first = TRUE;
14828
14829       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14830         fputs ("fjathplus", stdout), first = FALSE;
14831       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14832         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14833       if (mask & ELF_SPARC_HWCAP2_ADP)
14834         printf ("%sadp", first ? "" : "|"), first = FALSE;
14835       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14836         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14837       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14838         printf ("%smwait", first ? "" : "|"), first = FALSE;
14839       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14840         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14841       if (mask & ELF_SPARC_HWCAP2_XMONT)
14842         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14843       if (mask & ELF_SPARC_HWCAP2_NSEC)
14844         printf ("%snsec", first ? "" : "|"), first = FALSE;
14845       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14846         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14847       if (mask & ELF_SPARC_HWCAP2_FJDES)
14848         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14849       if (mask & ELF_SPARC_HWCAP2_FJAES)
14850         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14851     }
14852   else
14853     fputc ('0', stdout);
14854   fputc ('\n', stdout);
14855 }
14856
14857 static unsigned char *
14858 display_sparc_gnu_attribute (unsigned char * p,
14859                              unsigned int tag,
14860                              const unsigned char * const end)
14861 {
14862   unsigned int len;
14863   int val;
14864
14865   if (tag == Tag_GNU_Sparc_HWCAPS)
14866     {
14867       val = read_uleb128 (p, &len, end);
14868       p += len;
14869       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14870       display_sparc_hwcaps (val);
14871       return p;
14872     }
14873   if (tag == Tag_GNU_Sparc_HWCAPS2)
14874     {
14875       val = read_uleb128 (p, &len, end);
14876       p += len;
14877       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14878       display_sparc_hwcaps2 (val);
14879       return p;
14880     }
14881
14882   return display_tag_value (tag, p, end);
14883 }
14884
14885 static void
14886 print_mips_fp_abi_value (unsigned int val)
14887 {
14888   switch (val)
14889     {
14890     case Val_GNU_MIPS_ABI_FP_ANY:
14891       printf (_("Hard or soft float\n"));
14892       break;
14893     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14894       printf (_("Hard float (double precision)\n"));
14895       break;
14896     case Val_GNU_MIPS_ABI_FP_SINGLE:
14897       printf (_("Hard float (single precision)\n"));
14898       break;
14899     case Val_GNU_MIPS_ABI_FP_SOFT:
14900       printf (_("Soft float\n"));
14901       break;
14902     case Val_GNU_MIPS_ABI_FP_OLD_64:
14903       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14904       break;
14905     case Val_GNU_MIPS_ABI_FP_XX:
14906       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14907       break;
14908     case Val_GNU_MIPS_ABI_FP_64:
14909       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14910       break;
14911     case Val_GNU_MIPS_ABI_FP_64A:
14912       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14913       break;
14914     case Val_GNU_MIPS_ABI_FP_NAN2008:
14915       printf (_("NaN 2008 compatibility\n"));
14916       break;
14917     default:
14918       printf ("??? (%d)\n", val);
14919       break;
14920     }
14921 }
14922
14923 static unsigned char *
14924 display_mips_gnu_attribute (unsigned char * p,
14925                             unsigned int tag,
14926                             const unsigned char * const end)
14927 {
14928   if (tag == Tag_GNU_MIPS_ABI_FP)
14929     {
14930       unsigned int len;
14931       unsigned int val;
14932
14933       val = read_uleb128 (p, &len, end);
14934       p += len;
14935       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14936
14937       print_mips_fp_abi_value (val);
14938
14939       return p;
14940    }
14941
14942   if (tag == Tag_GNU_MIPS_ABI_MSA)
14943     {
14944       unsigned int len;
14945       unsigned int val;
14946
14947       val = read_uleb128 (p, &len, end);
14948       p += len;
14949       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14950
14951       switch (val)
14952         {
14953         case Val_GNU_MIPS_ABI_MSA_ANY:
14954           printf (_("Any MSA or not\n"));
14955           break;
14956         case Val_GNU_MIPS_ABI_MSA_128:
14957           printf (_("128-bit MSA\n"));
14958           break;
14959         default:
14960           printf ("??? (%d)\n", val);
14961           break;
14962         }
14963       return p;
14964     }
14965
14966   return display_tag_value (tag & 1, p, end);
14967 }
14968
14969 static unsigned char *
14970 display_tic6x_attribute (unsigned char * p,
14971                          const unsigned char * const end)
14972 {
14973   unsigned int tag;
14974   unsigned int len;
14975   int val;
14976
14977   tag = read_uleb128 (p, &len, end);
14978   p += len;
14979
14980   switch (tag)
14981     {
14982     case Tag_ISA:
14983       val = read_uleb128 (p, &len, end);
14984       p += len;
14985       printf ("  Tag_ISA: ");
14986
14987       switch (val)
14988         {
14989         case C6XABI_Tag_ISA_none:
14990           printf (_("None\n"));
14991           break;
14992         case C6XABI_Tag_ISA_C62X:
14993           printf ("C62x\n");
14994           break;
14995         case C6XABI_Tag_ISA_C67X:
14996           printf ("C67x\n");
14997           break;
14998         case C6XABI_Tag_ISA_C67XP:
14999           printf ("C67x+\n");
15000           break;
15001         case C6XABI_Tag_ISA_C64X:
15002           printf ("C64x\n");
15003           break;
15004         case C6XABI_Tag_ISA_C64XP:
15005           printf ("C64x+\n");
15006           break;
15007         case C6XABI_Tag_ISA_C674X:
15008           printf ("C674x\n");
15009           break;
15010         default:
15011           printf ("??? (%d)\n", val);
15012           break;
15013         }
15014       return p;
15015
15016     case Tag_ABI_wchar_t:
15017       val = read_uleb128 (p, &len, end);
15018       p += len;
15019       printf ("  Tag_ABI_wchar_t: ");
15020       switch (val)
15021         {
15022         case 0:
15023           printf (_("Not used\n"));
15024           break;
15025         case 1:
15026           printf (_("2 bytes\n"));
15027           break;
15028         case 2:
15029           printf (_("4 bytes\n"));
15030           break;
15031         default:
15032           printf ("??? (%d)\n", val);
15033           break;
15034         }
15035       return p;
15036
15037     case Tag_ABI_stack_align_needed:
15038       val = read_uleb128 (p, &len, end);
15039       p += len;
15040       printf ("  Tag_ABI_stack_align_needed: ");
15041       switch (val)
15042         {
15043         case 0:
15044           printf (_("8-byte\n"));
15045           break;
15046         case 1:
15047           printf (_("16-byte\n"));
15048           break;
15049         default:
15050           printf ("??? (%d)\n", val);
15051           break;
15052         }
15053       return p;
15054
15055     case Tag_ABI_stack_align_preserved:
15056       val = read_uleb128 (p, &len, end);
15057       p += len;
15058       printf ("  Tag_ABI_stack_align_preserved: ");
15059       switch (val)
15060         {
15061         case 0:
15062           printf (_("8-byte\n"));
15063           break;
15064         case 1:
15065           printf (_("16-byte\n"));
15066           break;
15067         default:
15068           printf ("??? (%d)\n", val);
15069           break;
15070         }
15071       return p;
15072
15073     case Tag_ABI_DSBT:
15074       val = read_uleb128 (p, &len, end);
15075       p += len;
15076       printf ("  Tag_ABI_DSBT: ");
15077       switch (val)
15078         {
15079         case 0:
15080           printf (_("DSBT addressing not used\n"));
15081           break;
15082         case 1:
15083           printf (_("DSBT addressing used\n"));
15084           break;
15085         default:
15086           printf ("??? (%d)\n", val);
15087           break;
15088         }
15089       return p;
15090
15091     case Tag_ABI_PID:
15092       val = read_uleb128 (p, &len, end);
15093       p += len;
15094       printf ("  Tag_ABI_PID: ");
15095       switch (val)
15096         {
15097         case 0:
15098           printf (_("Data addressing position-dependent\n"));
15099           break;
15100         case 1:
15101           printf (_("Data addressing position-independent, GOT near DP\n"));
15102           break;
15103         case 2:
15104           printf (_("Data addressing position-independent, GOT far from DP\n"));
15105           break;
15106         default:
15107           printf ("??? (%d)\n", val);
15108           break;
15109         }
15110       return p;
15111
15112     case Tag_ABI_PIC:
15113       val = read_uleb128 (p, &len, end);
15114       p += len;
15115       printf ("  Tag_ABI_PIC: ");
15116       switch (val)
15117         {
15118         case 0:
15119           printf (_("Code addressing position-dependent\n"));
15120           break;
15121         case 1:
15122           printf (_("Code addressing position-independent\n"));
15123           break;
15124         default:
15125           printf ("??? (%d)\n", val);
15126           break;
15127         }
15128       return p;
15129
15130     case Tag_ABI_array_object_alignment:
15131       val = read_uleb128 (p, &len, end);
15132       p += len;
15133       printf ("  Tag_ABI_array_object_alignment: ");
15134       switch (val)
15135         {
15136         case 0:
15137           printf (_("8-byte\n"));
15138           break;
15139         case 1:
15140           printf (_("4-byte\n"));
15141           break;
15142         case 2:
15143           printf (_("16-byte\n"));
15144           break;
15145         default:
15146           printf ("??? (%d)\n", val);
15147           break;
15148         }
15149       return p;
15150
15151     case Tag_ABI_array_object_align_expected:
15152       val = read_uleb128 (p, &len, end);
15153       p += len;
15154       printf ("  Tag_ABI_array_object_align_expected: ");
15155       switch (val)
15156         {
15157         case 0:
15158           printf (_("8-byte\n"));
15159           break;
15160         case 1:
15161           printf (_("4-byte\n"));
15162           break;
15163         case 2:
15164           printf (_("16-byte\n"));
15165           break;
15166         default:
15167           printf ("??? (%d)\n", val);
15168           break;
15169         }
15170       return p;
15171
15172     case Tag_ABI_compatibility:
15173       {
15174         val = read_uleb128 (p, &len, end);
15175         p += len;
15176         printf ("  Tag_ABI_compatibility: ");
15177         printf (_("flag = %d, vendor = "), val);
15178         if (p < end - 1)
15179           {
15180             size_t maxlen = (end - p) - 1;
15181
15182             print_symbol ((int) maxlen, (const char *) p);
15183             p += strnlen ((char *) p, maxlen) + 1;
15184           }
15185         else
15186           {
15187             printf (_("<corrupt>"));
15188             p = (unsigned char *) end;
15189           }
15190         putchar ('\n');
15191         return p;
15192       }
15193
15194     case Tag_ABI_conformance:
15195       {
15196         printf ("  Tag_ABI_conformance: \"");
15197         if (p < end - 1)
15198           {
15199             size_t maxlen = (end - p) - 1;
15200
15201             print_symbol ((int) maxlen, (const char *) p);
15202             p += strnlen ((char *) p, maxlen) + 1;
15203           }
15204         else
15205           {
15206             printf (_("<corrupt>"));
15207             p = (unsigned char *) end;
15208           }
15209         printf ("\"\n");
15210         return p;
15211       }
15212     }
15213
15214   return display_tag_value (tag, p, end);
15215 }
15216
15217 static void
15218 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15219 {
15220   unsigned long addr = 0;
15221   size_t bytes = end - p;
15222
15223   assert (end > p);
15224   while (bytes)
15225     {
15226       int j;
15227       int k;
15228       int lbytes = (bytes > 16 ? 16 : bytes);
15229
15230       printf ("  0x%8.8lx ", addr);
15231
15232       for (j = 0; j < 16; j++)
15233         {
15234           if (j < lbytes)
15235             printf ("%2.2x", p[j]);
15236           else
15237             printf ("  ");
15238
15239           if ((j & 3) == 3)
15240             printf (" ");
15241         }
15242
15243       for (j = 0; j < lbytes; j++)
15244         {
15245           k = p[j];
15246           if (k >= ' ' && k < 0x7f)
15247             printf ("%c", k);
15248           else
15249             printf (".");
15250         }
15251
15252       putchar ('\n');
15253
15254       p  += lbytes;
15255       bytes -= lbytes;
15256       addr += lbytes;
15257     }
15258
15259   putchar ('\n');
15260 }
15261
15262 static unsigned char *
15263 display_msp430x_attribute (unsigned char * p,
15264                            const unsigned char * const end)
15265 {
15266   unsigned int len;
15267   unsigned int val;
15268   unsigned int tag;
15269
15270   tag = read_uleb128 (p, & len, end);
15271   p += len;
15272
15273   switch (tag)
15274     {
15275     case OFBA_MSPABI_Tag_ISA:
15276       val = read_uleb128 (p, &len, end);
15277       p += len;
15278       printf ("  Tag_ISA: ");
15279       switch (val)
15280         {
15281         case 0: printf (_("None\n")); break;
15282         case 1: printf (_("MSP430\n")); break;
15283         case 2: printf (_("MSP430X\n")); break;
15284         default: printf ("??? (%d)\n", val); break;
15285         }
15286       break;
15287
15288     case OFBA_MSPABI_Tag_Code_Model:
15289       val = read_uleb128 (p, &len, end);
15290       p += len;
15291       printf ("  Tag_Code_Model: ");
15292       switch (val)
15293         {
15294         case 0: printf (_("None\n")); break;
15295         case 1: printf (_("Small\n")); break;
15296         case 2: printf (_("Large\n")); break;
15297         default: printf ("??? (%d)\n", val); break;
15298         }
15299       break;
15300
15301     case OFBA_MSPABI_Tag_Data_Model:
15302       val = read_uleb128 (p, &len, end);
15303       p += len;
15304       printf ("  Tag_Data_Model: ");
15305       switch (val)
15306         {
15307         case 0: printf (_("None\n")); break;
15308         case 1: printf (_("Small\n")); break;
15309         case 2: printf (_("Large\n")); break;
15310         case 3: printf (_("Restricted Large\n")); break;
15311         default: printf ("??? (%d)\n", val); break;
15312         }
15313       break;
15314
15315     default:
15316       printf (_("  <unknown tag %d>: "), tag);
15317
15318       if (tag & 1)
15319         {
15320           putchar ('"');
15321           if (p < end - 1)
15322             {
15323               size_t maxlen = (end - p) - 1;
15324
15325               print_symbol ((int) maxlen, (const char *) p);
15326               p += strnlen ((char *) p, maxlen) + 1;
15327             }
15328           else
15329             {
15330               printf (_("<corrupt>"));
15331               p = (unsigned char *) end;
15332             }
15333           printf ("\"\n");
15334         }
15335       else
15336         {
15337           val = read_uleb128 (p, &len, end);
15338           p += len;
15339           printf ("%d (0x%x)\n", val, val);
15340         }
15341       break;
15342    }
15343
15344   assert (p <= end);
15345   return p;
15346 }
15347
15348 static bfd_boolean
15349 process_attributes (Filedata * filedata,
15350                     const char * public_name,
15351                     unsigned int proc_type,
15352                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15353                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15354 {
15355   Elf_Internal_Shdr * sect;
15356   unsigned i;
15357   bfd_boolean res = TRUE;
15358
15359   /* Find the section header so that we get the size.  */
15360   for (i = 0, sect = filedata->section_headers;
15361        i < filedata->file_header.e_shnum;
15362        i++, sect++)
15363     {
15364       unsigned char * contents;
15365       unsigned char * p;
15366
15367       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15368         continue;
15369
15370       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15371                                              sect->sh_size, _("attributes"));
15372       if (contents == NULL)
15373         {
15374           res = FALSE;
15375           continue;
15376         }
15377
15378       p = contents;
15379       /* The first character is the version of the attributes.
15380          Currently only version 1, (aka 'A') is recognised here.  */
15381       if (*p != 'A')
15382         {
15383           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15384           res = FALSE;
15385         }
15386       else
15387         {
15388           bfd_vma section_len;
15389
15390           section_len = sect->sh_size - 1;
15391           p++;
15392
15393           while (section_len > 0)
15394             {
15395               bfd_vma attr_len;
15396               unsigned int namelen;
15397               bfd_boolean public_section;
15398               bfd_boolean gnu_section;
15399
15400               if (section_len <= 4)
15401                 {
15402                   error (_("Tag section ends prematurely\n"));
15403                   res = FALSE;
15404                   break;
15405                 }
15406               attr_len = byte_get (p, 4);
15407               p += 4;
15408
15409               if (attr_len > section_len)
15410                 {
15411                   error (_("Bad attribute length (%u > %u)\n"),
15412                           (unsigned) attr_len, (unsigned) section_len);
15413                   attr_len = section_len;
15414                   res = FALSE;
15415                 }
15416               /* PR 17531: file: 001-101425-0.004  */
15417               else if (attr_len < 5)
15418                 {
15419                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15420                   res = FALSE;
15421                   break;
15422                 }
15423
15424               section_len -= attr_len;
15425               attr_len -= 4;
15426
15427               namelen = strnlen ((char *) p, attr_len) + 1;
15428               if (namelen == 0 || namelen >= attr_len)
15429                 {
15430                   error (_("Corrupt attribute section name\n"));
15431                   res = FALSE;
15432                   break;
15433                 }
15434
15435               printf (_("Attribute Section: "));
15436               print_symbol (INT_MAX, (const char *) p);
15437               putchar ('\n');
15438
15439               if (public_name && streq ((char *) p, public_name))
15440                 public_section = TRUE;
15441               else
15442                 public_section = FALSE;
15443
15444               if (streq ((char *) p, "gnu"))
15445                 gnu_section = TRUE;
15446               else
15447                 gnu_section = FALSE;
15448
15449               p += namelen;
15450               attr_len -= namelen;
15451
15452               while (attr_len > 0 && p < contents + sect->sh_size)
15453                 {
15454                   int tag;
15455                   int val;
15456                   bfd_vma size;
15457                   unsigned char * end;
15458
15459                   /* PR binutils/17531: Safe handling of corrupt files.  */
15460                   if (attr_len < 6)
15461                     {
15462                       error (_("Unused bytes at end of section\n"));
15463                       res = FALSE;
15464                       section_len = 0;
15465                       break;
15466                     }
15467
15468                   tag = *(p++);
15469                   size = byte_get (p, 4);
15470                   if (size > attr_len)
15471                     {
15472                       error (_("Bad subsection length (%u > %u)\n"),
15473                               (unsigned) size, (unsigned) attr_len);
15474                       res = FALSE;
15475                       size = attr_len;
15476                     }
15477                   /* PR binutils/17531: Safe handling of corrupt files.  */
15478                   if (size < 6)
15479                     {
15480                       error (_("Bad subsection length (%u < 6)\n"),
15481                               (unsigned) size);
15482                       res = FALSE;
15483                       section_len = 0;
15484                       break;
15485                     }
15486
15487                   attr_len -= size;
15488                   end = p + size - 1;
15489                   assert (end <= contents + sect->sh_size);
15490                   p += 4;
15491
15492                   switch (tag)
15493                     {
15494                     case 1:
15495                       printf (_("File Attributes\n"));
15496                       break;
15497                     case 2:
15498                       printf (_("Section Attributes:"));
15499                       goto do_numlist;
15500                     case 3:
15501                       printf (_("Symbol Attributes:"));
15502                       /* Fall through.  */
15503                     do_numlist:
15504                       for (;;)
15505                         {
15506                           unsigned int j;
15507
15508                           val = read_uleb128 (p, &j, end);
15509                           p += j;
15510                           if (val == 0)
15511                             break;
15512                           printf (" %d", val);
15513                         }
15514                       printf ("\n");
15515                       break;
15516                     default:
15517                       printf (_("Unknown tag: %d\n"), tag);
15518                       public_section = FALSE;
15519                       break;
15520                     }
15521
15522                   if (public_section && display_pub_attribute != NULL)
15523                     {
15524                       while (p < end)
15525                         p = display_pub_attribute (p, end);
15526                       assert (p == end);
15527                     }
15528                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15529                     {
15530                       while (p < end)
15531                         p = display_gnu_attribute (p,
15532                                                    display_proc_gnu_attribute,
15533                                                    end);
15534                       assert (p == end);
15535                     }
15536                   else if (p < end)
15537                     {
15538                       printf (_("  Unknown attribute:\n"));
15539                       display_raw_attribute (p, end);
15540                       p = end;
15541                     }
15542                   else
15543                     attr_len = 0;
15544                 }
15545             }
15546         }
15547
15548       free (contents);
15549     }
15550
15551   return res;
15552 }
15553
15554 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15555    Print the Address, Access and Initial fields of an entry at VMA ADDR
15556    and return the VMA of the next entry, or -1 if there was a problem.
15557    Does not read from DATA_END or beyond.  */
15558
15559 static bfd_vma
15560 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15561                       unsigned char * data_end)
15562 {
15563   printf ("  ");
15564   print_vma (addr, LONG_HEX);
15565   printf (" ");
15566   if (addr < pltgot + 0xfff0)
15567     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15568   else
15569     printf ("%10s", "");
15570   printf (" ");
15571   if (data == NULL)
15572     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15573   else
15574     {
15575       bfd_vma entry;
15576       unsigned char * from = data + addr - pltgot;
15577
15578       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15579         {
15580           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15581           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15582           return (bfd_vma) -1;
15583         }
15584       else
15585         {
15586           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15587           print_vma (entry, LONG_HEX);
15588         }
15589     }
15590   return addr + (is_32bit_elf ? 4 : 8);
15591 }
15592
15593 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15594    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15595    ADDR and return the VMA of the next entry.  */
15596
15597 static bfd_vma
15598 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15599 {
15600   printf ("  ");
15601   print_vma (addr, LONG_HEX);
15602   printf (" ");
15603   if (data == NULL)
15604     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15605   else
15606     {
15607       bfd_vma entry;
15608
15609       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15610       print_vma (entry, LONG_HEX);
15611     }
15612   return addr + (is_32bit_elf ? 4 : 8);
15613 }
15614
15615 static void
15616 print_mips_ases (unsigned int mask)
15617 {
15618   if (mask & AFL_ASE_DSP)
15619     fputs ("\n\tDSP ASE", stdout);
15620   if (mask & AFL_ASE_DSPR2)
15621     fputs ("\n\tDSP R2 ASE", stdout);
15622   if (mask & AFL_ASE_DSPR3)
15623     fputs ("\n\tDSP R3 ASE", stdout);
15624   if (mask & AFL_ASE_EVA)
15625     fputs ("\n\tEnhanced VA Scheme", stdout);
15626   if (mask & AFL_ASE_MCU)
15627     fputs ("\n\tMCU (MicroController) ASE", stdout);
15628   if (mask & AFL_ASE_MDMX)
15629     fputs ("\n\tMDMX ASE", stdout);
15630   if (mask & AFL_ASE_MIPS3D)
15631     fputs ("\n\tMIPS-3D ASE", stdout);
15632   if (mask & AFL_ASE_MT)
15633     fputs ("\n\tMT ASE", stdout);
15634   if (mask & AFL_ASE_SMARTMIPS)
15635     fputs ("\n\tSmartMIPS ASE", stdout);
15636   if (mask & AFL_ASE_VIRT)
15637     fputs ("\n\tVZ ASE", stdout);
15638   if (mask & AFL_ASE_MSA)
15639     fputs ("\n\tMSA ASE", stdout);
15640   if (mask & AFL_ASE_MIPS16)
15641     fputs ("\n\tMIPS16 ASE", stdout);
15642   if (mask & AFL_ASE_MICROMIPS)
15643     fputs ("\n\tMICROMIPS ASE", stdout);
15644   if (mask & AFL_ASE_XPA)
15645     fputs ("\n\tXPA ASE", stdout);
15646   if (mask & AFL_ASE_MIPS16E2)
15647     fputs ("\n\tMIPS16e2 ASE", stdout);
15648   if (mask & AFL_ASE_CRC)
15649     fputs ("\n\tCRC ASE", stdout);
15650   if (mask & AFL_ASE_GINV)
15651     fputs ("\n\tGINV ASE", stdout);
15652   if (mask & AFL_ASE_LOONGSON_MMI)
15653     fputs ("\n\tLoongson MMI ASE", stdout);
15654   if (mask & AFL_ASE_LOONGSON_CAM)
15655     fputs ("\n\tLoongson CAM ASE", stdout);
15656   if (mask & AFL_ASE_LOONGSON_EXT)
15657     fputs ("\n\tLoongson EXT ASE", stdout);
15658   if (mask & AFL_ASE_LOONGSON_EXT2)
15659     fputs ("\n\tLoongson EXT2 ASE", stdout);
15660   if (mask == 0)
15661     fprintf (stdout, "\n\t%s", _("None"));
15662   else if ((mask & ~AFL_ASE_MASK) != 0)
15663     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15664 }
15665
15666 static void
15667 print_mips_isa_ext (unsigned int isa_ext)
15668 {
15669   switch (isa_ext)
15670     {
15671     case 0:
15672       fputs (_("None"), stdout);
15673       break;
15674     case AFL_EXT_XLR:
15675       fputs ("RMI XLR", stdout);
15676       break;
15677     case AFL_EXT_OCTEON3:
15678       fputs ("Cavium Networks Octeon3", stdout);
15679       break;
15680     case AFL_EXT_OCTEON2:
15681       fputs ("Cavium Networks Octeon2", stdout);
15682       break;
15683     case AFL_EXT_OCTEONP:
15684       fputs ("Cavium Networks OcteonP", stdout);
15685       break;
15686     case AFL_EXT_LOONGSON_3A:
15687       fputs ("Loongson 3A", stdout);
15688       break;
15689     case AFL_EXT_OCTEON:
15690       fputs ("Cavium Networks Octeon", stdout);
15691       break;
15692     case AFL_EXT_5900:
15693       fputs ("Toshiba R5900", stdout);
15694       break;
15695     case AFL_EXT_4650:
15696       fputs ("MIPS R4650", stdout);
15697       break;
15698     case AFL_EXT_4010:
15699       fputs ("LSI R4010", stdout);
15700       break;
15701     case AFL_EXT_4100:
15702       fputs ("NEC VR4100", stdout);
15703       break;
15704     case AFL_EXT_3900:
15705       fputs ("Toshiba R3900", stdout);
15706       break;
15707     case AFL_EXT_10000:
15708       fputs ("MIPS R10000", stdout);
15709       break;
15710     case AFL_EXT_SB1:
15711       fputs ("Broadcom SB-1", stdout);
15712       break;
15713     case AFL_EXT_4111:
15714       fputs ("NEC VR4111/VR4181", stdout);
15715       break;
15716     case AFL_EXT_4120:
15717       fputs ("NEC VR4120", stdout);
15718       break;
15719     case AFL_EXT_5400:
15720       fputs ("NEC VR5400", stdout);
15721       break;
15722     case AFL_EXT_5500:
15723       fputs ("NEC VR5500", stdout);
15724       break;
15725     case AFL_EXT_LOONGSON_2E:
15726       fputs ("ST Microelectronics Loongson 2E", stdout);
15727       break;
15728     case AFL_EXT_LOONGSON_2F:
15729       fputs ("ST Microelectronics Loongson 2F", stdout);
15730       break;
15731     case AFL_EXT_INTERAPTIV_MR2:
15732       fputs ("Imagination interAptiv MR2", stdout);
15733       break;
15734     default:
15735       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15736     }
15737 }
15738
15739 static signed int
15740 get_mips_reg_size (int reg_size)
15741 {
15742   return (reg_size == AFL_REG_NONE) ? 0
15743          : (reg_size == AFL_REG_32) ? 32
15744          : (reg_size == AFL_REG_64) ? 64
15745          : (reg_size == AFL_REG_128) ? 128
15746          : -1;
15747 }
15748
15749 static bfd_boolean
15750 process_mips_specific (Filedata * filedata)
15751 {
15752   Elf_Internal_Dyn * entry;
15753   Elf_Internal_Shdr *sect = NULL;
15754   size_t liblist_offset = 0;
15755   size_t liblistno = 0;
15756   size_t conflictsno = 0;
15757   size_t options_offset = 0;
15758   size_t conflicts_offset = 0;
15759   size_t pltrelsz = 0;
15760   size_t pltrel = 0;
15761   bfd_vma pltgot = 0;
15762   bfd_vma mips_pltgot = 0;
15763   bfd_vma jmprel = 0;
15764   bfd_vma local_gotno = 0;
15765   bfd_vma gotsym = 0;
15766   bfd_vma symtabno = 0;
15767   bfd_boolean res = TRUE;
15768
15769   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15770                             display_mips_gnu_attribute))
15771     res = FALSE;
15772
15773   sect = find_section (filedata, ".MIPS.abiflags");
15774
15775   if (sect != NULL)
15776     {
15777       Elf_External_ABIFlags_v0 *abiflags_ext;
15778       Elf_Internal_ABIFlags_v0 abiflags_in;
15779
15780       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15781         {
15782           error (_("Corrupt MIPS ABI Flags section.\n"));
15783           res = FALSE;
15784         }
15785       else
15786         {
15787           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15788                                    sect->sh_size, _("MIPS ABI Flags section"));
15789           if (abiflags_ext)
15790             {
15791               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15792               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15793               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15794               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15795               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15796               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15797               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15798               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15799               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15800               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15801               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15802
15803               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15804               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15805               if (abiflags_in.isa_rev > 1)
15806                 printf ("r%d", abiflags_in.isa_rev);
15807               printf ("\nGPR size: %d",
15808                       get_mips_reg_size (abiflags_in.gpr_size));
15809               printf ("\nCPR1 size: %d",
15810                       get_mips_reg_size (abiflags_in.cpr1_size));
15811               printf ("\nCPR2 size: %d",
15812                       get_mips_reg_size (abiflags_in.cpr2_size));
15813               fputs ("\nFP ABI: ", stdout);
15814               print_mips_fp_abi_value (abiflags_in.fp_abi);
15815               fputs ("ISA Extension: ", stdout);
15816               print_mips_isa_ext (abiflags_in.isa_ext);
15817               fputs ("\nASEs:", stdout);
15818               print_mips_ases (abiflags_in.ases);
15819               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15820               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15821               fputc ('\n', stdout);
15822               free (abiflags_ext);
15823             }
15824         }
15825     }
15826
15827   /* We have a lot of special sections.  Thanks SGI!  */
15828   if (dynamic_section == NULL)
15829     {
15830       /* No dynamic information available.  See if there is static GOT.  */
15831       sect = find_section (filedata, ".got");
15832       if (sect != NULL)
15833         {
15834           unsigned char *data_end;
15835           unsigned char *data;
15836           bfd_vma ent, end;
15837           int addr_size;
15838
15839           pltgot = sect->sh_addr;
15840
15841           ent = pltgot;
15842           addr_size = (is_32bit_elf ? 4 : 8);
15843           end = pltgot + sect->sh_size;
15844
15845           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15846                                              end - pltgot, 1,
15847                                              _("Global Offset Table data"));
15848           /* PR 12855: Null data is handled gracefully throughout.  */
15849           data_end = data + (end - pltgot);
15850
15851           printf (_("\nStatic GOT:\n"));
15852           printf (_(" Canonical gp value: "));
15853           print_vma (ent + 0x7ff0, LONG_HEX);
15854           printf ("\n\n");
15855
15856           /* In a dynamic binary GOT[0] is reserved for the dynamic
15857              loader to store the lazy resolver pointer, however in
15858              a static binary it may well have been omitted and GOT
15859              reduced to a table of addresses.
15860              PR 21344: Check for the entry being fully available
15861              before fetching it.  */
15862           if (data
15863               && data + ent - pltgot + addr_size <= data_end
15864               && byte_get (data + ent - pltgot, addr_size) == 0)
15865             {
15866               printf (_(" Reserved entries:\n"));
15867               printf (_("  %*s %10s %*s\n"),
15868                       addr_size * 2, _("Address"), _("Access"),
15869                       addr_size * 2, _("Value"));
15870               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15871               printf ("\n");
15872               if (ent == (bfd_vma) -1)
15873                 goto sgot_print_fail;
15874
15875               /* Check for the MSB of GOT[1] being set, identifying a
15876                  GNU object.  This entry will be used by some runtime
15877                  loaders, to store the module pointer.  Otherwise this
15878                  is an ordinary local entry.
15879                  PR 21344: Check for the entry being fully available
15880                  before fetching it.  */
15881               if (data
15882                   && data + ent - pltgot + addr_size <= data_end
15883                   && (byte_get (data + ent - pltgot, addr_size)
15884                       >> (addr_size * 8 - 1)) != 0)
15885                 {
15886                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15887                   printf ("\n");
15888                   if (ent == (bfd_vma) -1)
15889                     goto sgot_print_fail;
15890                 }
15891               printf ("\n");
15892             }
15893
15894           if (data != NULL && ent < end)
15895             {
15896               printf (_(" Local entries:\n"));
15897               printf ("  %*s %10s %*s\n",
15898                       addr_size * 2, _("Address"), _("Access"),
15899                       addr_size * 2, _("Value"));
15900               while (ent < end)
15901                 {
15902                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15903                   printf ("\n");
15904                   if (ent == (bfd_vma) -1)
15905                     goto sgot_print_fail;
15906                 }
15907               printf ("\n");
15908             }
15909
15910         sgot_print_fail:
15911           if (data)
15912             free (data);
15913         }
15914       return res;
15915     }
15916
15917   for (entry = dynamic_section;
15918        /* PR 17531 file: 012-50589-0.004.  */
15919        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15920        ++entry)
15921     switch (entry->d_tag)
15922       {
15923       case DT_MIPS_LIBLIST:
15924         liblist_offset
15925           = offset_from_vma (filedata, entry->d_un.d_val,
15926                              liblistno * sizeof (Elf32_External_Lib));
15927         break;
15928       case DT_MIPS_LIBLISTNO:
15929         liblistno = entry->d_un.d_val;
15930         break;
15931       case DT_MIPS_OPTIONS:
15932         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15933         break;
15934       case DT_MIPS_CONFLICT:
15935         conflicts_offset
15936           = offset_from_vma (filedata, entry->d_un.d_val,
15937                              conflictsno * sizeof (Elf32_External_Conflict));
15938         break;
15939       case DT_MIPS_CONFLICTNO:
15940         conflictsno = entry->d_un.d_val;
15941         break;
15942       case DT_PLTGOT:
15943         pltgot = entry->d_un.d_ptr;
15944         break;
15945       case DT_MIPS_LOCAL_GOTNO:
15946         local_gotno = entry->d_un.d_val;
15947         break;
15948       case DT_MIPS_GOTSYM:
15949         gotsym = entry->d_un.d_val;
15950         break;
15951       case DT_MIPS_SYMTABNO:
15952         symtabno = entry->d_un.d_val;
15953         break;
15954       case DT_MIPS_PLTGOT:
15955         mips_pltgot = entry->d_un.d_ptr;
15956         break;
15957       case DT_PLTREL:
15958         pltrel = entry->d_un.d_val;
15959         break;
15960       case DT_PLTRELSZ:
15961         pltrelsz = entry->d_un.d_val;
15962         break;
15963       case DT_JMPREL:
15964         jmprel = entry->d_un.d_ptr;
15965         break;
15966       default:
15967         break;
15968       }
15969
15970   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15971     {
15972       Elf32_External_Lib * elib;
15973       size_t cnt;
15974
15975       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15976                                               liblistno,
15977                                               sizeof (Elf32_External_Lib),
15978                                               _("liblist section data"));
15979       if (elib)
15980         {
15981           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15982                             "\nSection '.liblist' contains %lu entries:\n",
15983                             (unsigned long) liblistno),
15984                   (unsigned long) liblistno);
15985           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15986                  stdout);
15987
15988           for (cnt = 0; cnt < liblistno; ++cnt)
15989             {
15990               Elf32_Lib liblist;
15991               time_t atime;
15992               char timebuf[128];
15993               struct tm * tmp;
15994
15995               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15996               atime = BYTE_GET (elib[cnt].l_time_stamp);
15997               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15998               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15999               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16000
16001               tmp = gmtime (&atime);
16002               snprintf (timebuf, sizeof (timebuf),
16003                         "%04u-%02u-%02uT%02u:%02u:%02u",
16004                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16005                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16006
16007               printf ("%3lu: ", (unsigned long) cnt);
16008               if (VALID_DYNAMIC_NAME (liblist.l_name))
16009                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16010               else
16011                 printf (_("<corrupt: %9ld>"), liblist.l_name);
16012               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16013                       liblist.l_version);
16014
16015               if (liblist.l_flags == 0)
16016                 puts (_(" NONE"));
16017               else
16018                 {
16019                   static const struct
16020                   {
16021                     const char * name;
16022                     int bit;
16023                   }
16024                   l_flags_vals[] =
16025                   {
16026                     { " EXACT_MATCH", LL_EXACT_MATCH },
16027                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16028                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16029                     { " EXPORTS", LL_EXPORTS },
16030                     { " DELAY_LOAD", LL_DELAY_LOAD },
16031                     { " DELTA", LL_DELTA }
16032                   };
16033                   int flags = liblist.l_flags;
16034                   size_t fcnt;
16035
16036                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16037                     if ((flags & l_flags_vals[fcnt].bit) != 0)
16038                       {
16039                         fputs (l_flags_vals[fcnt].name, stdout);
16040                         flags ^= l_flags_vals[fcnt].bit;
16041                       }
16042                   if (flags != 0)
16043                     printf (" %#x", (unsigned int) flags);
16044
16045                   puts ("");
16046                 }
16047             }
16048
16049           free (elib);
16050         }
16051       else
16052         res = FALSE;
16053     }
16054
16055   if (options_offset != 0)
16056     {
16057       Elf_External_Options * eopt;
16058       Elf_Internal_Options * iopt;
16059       Elf_Internal_Options * option;
16060       size_t offset;
16061       int cnt;
16062       sect = filedata->section_headers;
16063
16064       /* Find the section header so that we get the size.  */
16065       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16066       /* PR 17533 file: 012-277276-0.004.  */
16067       if (sect == NULL)
16068         {
16069           error (_("No MIPS_OPTIONS header found\n"));
16070           return FALSE;
16071         }
16072
16073       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16074                                                 sect->sh_size, _("options"));
16075       if (eopt)
16076         {
16077           iopt = (Elf_Internal_Options *)
16078               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16079           if (iopt == NULL)
16080             {
16081               error (_("Out of memory allocating space for MIPS options\n"));
16082               return FALSE;
16083             }
16084
16085           offset = cnt = 0;
16086           option = iopt;
16087
16088           while (offset <= sect->sh_size - sizeof (* eopt))
16089             {
16090               Elf_External_Options * eoption;
16091
16092               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16093
16094               option->kind = BYTE_GET (eoption->kind);
16095               option->size = BYTE_GET (eoption->size);
16096               option->section = BYTE_GET (eoption->section);
16097               option->info = BYTE_GET (eoption->info);
16098
16099               /* PR 17531: file: ffa0fa3b.  */
16100               if (option->size < sizeof (* eopt)
16101                   || offset + option->size > sect->sh_size)
16102                 {
16103                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
16104                   return FALSE;
16105                 }
16106               offset += option->size;
16107
16108               ++option;
16109               ++cnt;
16110             }
16111
16112           printf (ngettext ("\nSection '%s' contains %d entry:\n",
16113                             "\nSection '%s' contains %d entries:\n",
16114                             cnt),
16115                   printable_section_name (filedata, sect), cnt);
16116
16117           option = iopt;
16118           offset = 0;
16119
16120           while (cnt-- > 0)
16121             {
16122               size_t len;
16123
16124               switch (option->kind)
16125                 {
16126                 case ODK_NULL:
16127                   /* This shouldn't happen.  */
16128                   printf (" NULL       %d %lx", option->section, option->info);
16129                   break;
16130                 case ODK_REGINFO:
16131                   printf (" REGINFO    ");
16132                   if (filedata->file_header.e_machine == EM_MIPS)
16133                     {
16134                       /* 32bit form.  */
16135                       Elf32_External_RegInfo * ereg;
16136                       Elf32_RegInfo reginfo;
16137
16138                       ereg = (Elf32_External_RegInfo *) (option + 1);
16139                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16140                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16141                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16142                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16143                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16144                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16145
16146                       printf ("GPR %08lx  GP 0x%lx\n",
16147                               reginfo.ri_gprmask,
16148                               (unsigned long) reginfo.ri_gp_value);
16149                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16150                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16151                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16152                     }
16153                   else
16154                     {
16155                       /* 64 bit form.  */
16156                       Elf64_External_RegInfo * ereg;
16157                       Elf64_Internal_RegInfo reginfo;
16158
16159                       ereg = (Elf64_External_RegInfo *) (option + 1);
16160                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
16161                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16162                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16163                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16164                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16165                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16166
16167                       printf ("GPR %08lx  GP 0x",
16168                               reginfo.ri_gprmask);
16169                       printf_vma (reginfo.ri_gp_value);
16170                       printf ("\n");
16171
16172                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16173                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16174                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16175                     }
16176                   ++option;
16177                   continue;
16178                 case ODK_EXCEPTIONS:
16179                   fputs (" EXCEPTIONS fpe_min(", stdout);
16180                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16181                   fputs (") fpe_max(", stdout);
16182                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16183                   fputs (")", stdout);
16184
16185                   if (option->info & OEX_PAGE0)
16186                     fputs (" PAGE0", stdout);
16187                   if (option->info & OEX_SMM)
16188                     fputs (" SMM", stdout);
16189                   if (option->info & OEX_FPDBUG)
16190                     fputs (" FPDBUG", stdout);
16191                   if (option->info & OEX_DISMISS)
16192                     fputs (" DISMISS", stdout);
16193                   break;
16194                 case ODK_PAD:
16195                   fputs (" PAD       ", stdout);
16196                   if (option->info & OPAD_PREFIX)
16197                     fputs (" PREFIX", stdout);
16198                   if (option->info & OPAD_POSTFIX)
16199                     fputs (" POSTFIX", stdout);
16200                   if (option->info & OPAD_SYMBOL)
16201                     fputs (" SYMBOL", stdout);
16202                   break;
16203                 case ODK_HWPATCH:
16204                   fputs (" HWPATCH   ", stdout);
16205                   if (option->info & OHW_R4KEOP)
16206                     fputs (" R4KEOP", stdout);
16207                   if (option->info & OHW_R8KPFETCH)
16208                     fputs (" R8KPFETCH", stdout);
16209                   if (option->info & OHW_R5KEOP)
16210                     fputs (" R5KEOP", stdout);
16211                   if (option->info & OHW_R5KCVTL)
16212                     fputs (" R5KCVTL", stdout);
16213                   break;
16214                 case ODK_FILL:
16215                   fputs (" FILL       ", stdout);
16216                   /* XXX Print content of info word?  */
16217                   break;
16218                 case ODK_TAGS:
16219                   fputs (" TAGS       ", stdout);
16220                   /* XXX Print content of info word?  */
16221                   break;
16222                 case ODK_HWAND:
16223                   fputs (" HWAND     ", stdout);
16224                   if (option->info & OHWA0_R4KEOP_CHECKED)
16225                     fputs (" R4KEOP_CHECKED", stdout);
16226                   if (option->info & OHWA0_R4KEOP_CLEAN)
16227                     fputs (" R4KEOP_CLEAN", stdout);
16228                   break;
16229                 case ODK_HWOR:
16230                   fputs (" HWOR      ", stdout);
16231                   if (option->info & OHWA0_R4KEOP_CHECKED)
16232                     fputs (" R4KEOP_CHECKED", stdout);
16233                   if (option->info & OHWA0_R4KEOP_CLEAN)
16234                     fputs (" R4KEOP_CLEAN", stdout);
16235                   break;
16236                 case ODK_GP_GROUP:
16237                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16238                           option->info & OGP_GROUP,
16239                           (option->info & OGP_SELF) >> 16);
16240                   break;
16241                 case ODK_IDENT:
16242                   printf (" IDENT     %#06lx  self-contained %#06lx",
16243                           option->info & OGP_GROUP,
16244                           (option->info & OGP_SELF) >> 16);
16245                   break;
16246                 default:
16247                   /* This shouldn't happen.  */
16248                   printf (" %3d ???     %d %lx",
16249                           option->kind, option->section, option->info);
16250                   break;
16251                 }
16252
16253               len = sizeof (* eopt);
16254               while (len < option->size)
16255                 {
16256                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16257
16258                   if (ISPRINT (datum))
16259                     printf ("%c", datum);
16260                   else
16261                     printf ("\\%03o", datum);
16262                   len ++;
16263                 }
16264               fputs ("\n", stdout);
16265
16266               offset += option->size;
16267               ++option;
16268             }
16269
16270           free (eopt);
16271         }
16272       else
16273         res = FALSE;
16274     }
16275
16276   if (conflicts_offset != 0 && conflictsno != 0)
16277     {
16278       Elf32_Conflict * iconf;
16279       size_t cnt;
16280
16281       if (dynamic_symbols == NULL)
16282         {
16283           error (_("conflict list found without a dynamic symbol table\n"));
16284           return FALSE;
16285         }
16286
16287       /* PR 21345 - print a slightly more helpful error message
16288          if we are sure that the cmalloc will fail.  */
16289       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16290         {
16291           error (_("Overlarge number of conflicts detected: %lx\n"),
16292                  (long) conflictsno);
16293           return FALSE;
16294         }
16295
16296       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16297       if (iconf == NULL)
16298         {
16299           error (_("Out of memory allocating space for dynamic conflicts\n"));
16300           return FALSE;
16301         }
16302
16303       if (is_32bit_elf)
16304         {
16305           Elf32_External_Conflict * econf32;
16306
16307           econf32 = (Elf32_External_Conflict *)
16308               get_data (NULL, filedata, conflicts_offset, conflictsno,
16309                         sizeof (* econf32), _("conflict"));
16310           if (!econf32)
16311             return FALSE;
16312
16313           for (cnt = 0; cnt < conflictsno; ++cnt)
16314             iconf[cnt] = BYTE_GET (econf32[cnt]);
16315
16316           free (econf32);
16317         }
16318       else
16319         {
16320           Elf64_External_Conflict * econf64;
16321
16322           econf64 = (Elf64_External_Conflict *)
16323               get_data (NULL, filedata, conflicts_offset, conflictsno,
16324                         sizeof (* econf64), _("conflict"));
16325           if (!econf64)
16326             return FALSE;
16327
16328           for (cnt = 0; cnt < conflictsno; ++cnt)
16329             iconf[cnt] = BYTE_GET (econf64[cnt]);
16330
16331           free (econf64);
16332         }
16333
16334       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16335                         "\nSection '.conflict' contains %lu entries:\n",
16336                         (unsigned long) conflictsno),
16337               (unsigned long) conflictsno);
16338       puts (_("  Num:    Index       Value  Name"));
16339
16340       for (cnt = 0; cnt < conflictsno; ++cnt)
16341         {
16342           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16343
16344           if (iconf[cnt] >= num_dynamic_syms)
16345             printf (_("<corrupt symbol index>"));
16346           else
16347             {
16348               Elf_Internal_Sym * psym;
16349
16350               psym = & dynamic_symbols[iconf[cnt]];
16351               print_vma (psym->st_value, FULL_HEX);
16352               putchar (' ');
16353               if (VALID_DYNAMIC_NAME (psym->st_name))
16354                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16355               else
16356                 printf (_("<corrupt: %14ld>"), psym->st_name);
16357             }
16358           putchar ('\n');
16359         }
16360
16361       free (iconf);
16362     }
16363
16364   if (pltgot != 0 && local_gotno != 0)
16365     {
16366       bfd_vma ent, local_end, global_end;
16367       size_t i, offset;
16368       unsigned char * data;
16369       unsigned char * data_end;
16370       int addr_size;
16371
16372       ent = pltgot;
16373       addr_size = (is_32bit_elf ? 4 : 8);
16374       local_end = pltgot + local_gotno * addr_size;
16375
16376       /* PR binutils/17533 file: 012-111227-0.004  */
16377       if (symtabno < gotsym)
16378         {
16379           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16380                  (unsigned long) gotsym, (unsigned long) symtabno);
16381           return FALSE;
16382         }
16383
16384       global_end = local_end + (symtabno - gotsym) * addr_size;
16385       /* PR 17531: file: 54c91a34.  */
16386       if (global_end < local_end)
16387         {
16388           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16389           return FALSE;
16390         }
16391
16392       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16393       data = (unsigned char *) get_data (NULL, filedata, offset,
16394                                          global_end - pltgot, 1,
16395                                          _("Global Offset Table data"));
16396       /* PR 12855: Null data is handled gracefully throughout.  */
16397       data_end = data + (global_end - pltgot);
16398
16399       printf (_("\nPrimary GOT:\n"));
16400       printf (_(" Canonical gp value: "));
16401       print_vma (pltgot + 0x7ff0, LONG_HEX);
16402       printf ("\n\n");
16403
16404       printf (_(" Reserved entries:\n"));
16405       printf (_("  %*s %10s %*s Purpose\n"),
16406               addr_size * 2, _("Address"), _("Access"),
16407               addr_size * 2, _("Initial"));
16408       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16409       printf (_(" Lazy resolver\n"));
16410       if (ent == (bfd_vma) -1)
16411         goto got_print_fail;
16412
16413       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16414          This entry will be used by some runtime loaders, to store the
16415          module pointer.  Otherwise this is an ordinary local entry.
16416          PR 21344: Check for the entry being fully available before
16417          fetching it.  */
16418       if (data
16419           && data + ent - pltgot + addr_size <= data_end
16420           && (byte_get (data + ent - pltgot, addr_size)
16421               >> (addr_size * 8 - 1)) != 0)
16422         {
16423           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16424           printf (_(" Module pointer (GNU extension)\n"));
16425           if (ent == (bfd_vma) -1)
16426             goto got_print_fail;
16427         }
16428       printf ("\n");
16429
16430       if (data != NULL && ent < local_end)
16431         {
16432           printf (_(" Local entries:\n"));
16433           printf ("  %*s %10s %*s\n",
16434                   addr_size * 2, _("Address"), _("Access"),
16435                   addr_size * 2, _("Initial"));
16436           while (ent < local_end)
16437             {
16438               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16439               printf ("\n");
16440               if (ent == (bfd_vma) -1)
16441                 goto got_print_fail;
16442             }
16443           printf ("\n");
16444         }
16445
16446       if (data != NULL && gotsym < symtabno)
16447         {
16448           int sym_width;
16449
16450           printf (_(" Global entries:\n"));
16451           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16452                   addr_size * 2, _("Address"),
16453                   _("Access"),
16454                   addr_size * 2, _("Initial"),
16455                   addr_size * 2, _("Sym.Val."),
16456                   _("Type"),
16457                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16458                   _("Ndx"), _("Name"));
16459
16460           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16461
16462           for (i = gotsym; i < symtabno; i++)
16463             {
16464               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16465               printf (" ");
16466
16467               if (dynamic_symbols == NULL)
16468                 printf (_("<no dynamic symbols>"));
16469               else if (i < num_dynamic_syms)
16470                 {
16471                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16472
16473                   print_vma (psym->st_value, LONG_HEX);
16474                   printf (" %-7s %3s ",
16475                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16476                           get_symbol_index_type (filedata, psym->st_shndx));
16477
16478                   if (VALID_DYNAMIC_NAME (psym->st_name))
16479                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16480                   else
16481                     printf (_("<corrupt: %14ld>"), psym->st_name);
16482                 }
16483               else
16484                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16485                         (unsigned long) i);
16486
16487               printf ("\n");
16488               if (ent == (bfd_vma) -1)
16489                 break;
16490             }
16491           printf ("\n");
16492         }
16493
16494     got_print_fail:
16495       if (data)
16496         free (data);
16497     }
16498
16499   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16500     {
16501       bfd_vma ent, end;
16502       size_t offset, rel_offset;
16503       unsigned long count, i;
16504       unsigned char * data;
16505       int addr_size, sym_width;
16506       Elf_Internal_Rela * rels;
16507
16508       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16509       if (pltrel == DT_RELA)
16510         {
16511           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16512             return FALSE;
16513         }
16514       else
16515         {
16516           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16517             return FALSE;
16518         }
16519
16520       ent = mips_pltgot;
16521       addr_size = (is_32bit_elf ? 4 : 8);
16522       end = mips_pltgot + (2 + count) * addr_size;
16523
16524       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16525       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16526                                          1, _("Procedure Linkage Table data"));
16527       if (data == NULL)
16528         return FALSE;
16529
16530       printf ("\nPLT GOT:\n\n");
16531       printf (_(" Reserved entries:\n"));
16532       printf (_("  %*s %*s Purpose\n"),
16533               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16534       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16535       printf (_(" PLT lazy resolver\n"));
16536       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16537       printf (_(" Module pointer\n"));
16538       printf ("\n");
16539
16540       printf (_(" Entries:\n"));
16541       printf ("  %*s %*s %*s %-7s %3s %s\n",
16542               addr_size * 2, _("Address"),
16543               addr_size * 2, _("Initial"),
16544               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16545       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16546       for (i = 0; i < count; i++)
16547         {
16548           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16549
16550           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16551           printf (" ");
16552
16553           if (idx >= num_dynamic_syms)
16554             printf (_("<corrupt symbol index: %lu>"), idx);
16555           else
16556             {
16557               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16558
16559               print_vma (psym->st_value, LONG_HEX);
16560               printf (" %-7s %3s ",
16561                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16562                       get_symbol_index_type (filedata, psym->st_shndx));
16563               if (VALID_DYNAMIC_NAME (psym->st_name))
16564                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16565               else
16566                 printf (_("<corrupt: %14ld>"), psym->st_name);
16567             }
16568           printf ("\n");
16569         }
16570       printf ("\n");
16571
16572       if (data)
16573         free (data);
16574       free (rels);
16575     }
16576
16577   return res;
16578 }
16579
16580 static bfd_boolean
16581 process_nds32_specific (Filedata * filedata)
16582 {
16583   Elf_Internal_Shdr *sect = NULL;
16584
16585   sect = find_section (filedata, ".nds32_e_flags");
16586   if (sect != NULL)
16587     {
16588       unsigned int *flag;
16589
16590       printf ("\nNDS32 elf flags section:\n");
16591       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16592                        sect->sh_size, _("NDS32 elf flags section"));
16593
16594       if (! flag)
16595         return FALSE;
16596
16597       switch ((*flag) & 0x3)
16598         {
16599         case 0:
16600           printf ("(VEC_SIZE):\tNo entry.\n");
16601           break;
16602         case 1:
16603           printf ("(VEC_SIZE):\t4 bytes\n");
16604           break;
16605         case 2:
16606           printf ("(VEC_SIZE):\t16 bytes\n");
16607           break;
16608         case 3:
16609           printf ("(VEC_SIZE):\treserved\n");
16610           break;
16611         }
16612     }
16613
16614   return TRUE;
16615 }
16616
16617 static bfd_boolean
16618 process_gnu_liblist (Filedata * filedata)
16619 {
16620   Elf_Internal_Shdr * section;
16621   Elf_Internal_Shdr * string_sec;
16622   Elf32_External_Lib * elib;
16623   char * strtab;
16624   size_t strtab_size;
16625   size_t cnt;
16626   unsigned long num_liblist;
16627   unsigned i;
16628   bfd_boolean res = TRUE;
16629
16630   if (! do_arch)
16631     return TRUE;
16632
16633   for (i = 0, section = filedata->section_headers;
16634        i < filedata->file_header.e_shnum;
16635        i++, section++)
16636     {
16637       switch (section->sh_type)
16638         {
16639         case SHT_GNU_LIBLIST:
16640           if (section->sh_link >= filedata->file_header.e_shnum)
16641             break;
16642
16643           elib = (Elf32_External_Lib *)
16644               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16645                         _("liblist section data"));
16646
16647           if (elib == NULL)
16648             {
16649               res = FALSE;
16650               break;
16651             }
16652
16653           string_sec = filedata->section_headers + section->sh_link;
16654           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16655                                       string_sec->sh_size,
16656                                       _("liblist string table"));
16657           if (strtab == NULL
16658               || section->sh_entsize != sizeof (Elf32_External_Lib))
16659             {
16660               free (elib);
16661               free (strtab);
16662               res = FALSE;
16663               break;
16664             }
16665           strtab_size = string_sec->sh_size;
16666
16667           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16668           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16669                             "\nLibrary list section '%s' contains %lu entries:\n",
16670                             num_liblist),
16671                   printable_section_name (filedata, section),
16672                   num_liblist);
16673
16674           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16675
16676           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16677                ++cnt)
16678             {
16679               Elf32_Lib liblist;
16680               time_t atime;
16681               char timebuf[128];
16682               struct tm * tmp;
16683
16684               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16685               atime = BYTE_GET (elib[cnt].l_time_stamp);
16686               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16687               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16688               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16689
16690               tmp = gmtime (&atime);
16691               snprintf (timebuf, sizeof (timebuf),
16692                         "%04u-%02u-%02uT%02u:%02u:%02u",
16693                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16694                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16695
16696               printf ("%3lu: ", (unsigned long) cnt);
16697               if (do_wide)
16698                 printf ("%-20s", liblist.l_name < strtab_size
16699                         ? strtab + liblist.l_name : _("<corrupt>"));
16700               else
16701                 printf ("%-20.20s", liblist.l_name < strtab_size
16702                         ? strtab + liblist.l_name : _("<corrupt>"));
16703               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16704                       liblist.l_version, liblist.l_flags);
16705             }
16706
16707           free (elib);
16708           free (strtab);
16709         }
16710     }
16711
16712   return res;
16713 }
16714
16715 static const char *
16716 get_note_type (Filedata * filedata, unsigned e_type)
16717 {
16718   static char buff[64];
16719
16720   if (filedata->file_header.e_type == ET_CORE)
16721     switch (e_type)
16722       {
16723       case NT_AUXV:
16724         return _("NT_AUXV (auxiliary vector)");
16725       case NT_PRSTATUS:
16726         return _("NT_PRSTATUS (prstatus structure)");
16727       case NT_FPREGSET:
16728         return _("NT_FPREGSET (floating point registers)");
16729       case NT_PRPSINFO:
16730         return _("NT_PRPSINFO (prpsinfo structure)");
16731       case NT_TASKSTRUCT:
16732         return _("NT_TASKSTRUCT (task structure)");
16733       case NT_PRXFPREG:
16734         return _("NT_PRXFPREG (user_xfpregs structure)");
16735       case NT_PPC_VMX:
16736         return _("NT_PPC_VMX (ppc Altivec registers)");
16737       case NT_PPC_VSX:
16738         return _("NT_PPC_VSX (ppc VSX registers)");
16739       case NT_PPC_TAR:
16740         return _("NT_PPC_TAR (ppc TAR register)");
16741       case NT_PPC_PPR:
16742         return _("NT_PPC_PPR (ppc PPR register)");
16743       case NT_PPC_DSCR:
16744         return _("NT_PPC_DSCR (ppc DSCR register)");
16745       case NT_PPC_EBB:
16746         return _("NT_PPC_EBB (ppc EBB registers)");
16747       case NT_PPC_PMU:
16748         return _("NT_PPC_PMU (ppc PMU registers)");
16749       case NT_PPC_TM_CGPR:
16750         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16751       case NT_PPC_TM_CFPR:
16752         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16753       case NT_PPC_TM_CVMX:
16754         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16755       case NT_PPC_TM_CVSX:
16756         return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16757       case NT_PPC_TM_SPR:
16758         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16759       case NT_PPC_TM_CTAR:
16760         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16761       case NT_PPC_TM_CPPR:
16762         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16763       case NT_PPC_TM_CDSCR:
16764         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16765       case NT_386_TLS:
16766         return _("NT_386_TLS (x86 TLS information)");
16767       case NT_386_IOPERM:
16768         return _("NT_386_IOPERM (x86 I/O permissions)");
16769       case NT_X86_XSTATE:
16770         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16771       case NT_S390_HIGH_GPRS:
16772         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16773       case NT_S390_TIMER:
16774         return _("NT_S390_TIMER (s390 timer register)");
16775       case NT_S390_TODCMP:
16776         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16777       case NT_S390_TODPREG:
16778         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16779       case NT_S390_CTRS:
16780         return _("NT_S390_CTRS (s390 control registers)");
16781       case NT_S390_PREFIX:
16782         return _("NT_S390_PREFIX (s390 prefix register)");
16783       case NT_S390_LAST_BREAK:
16784         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16785       case NT_S390_SYSTEM_CALL:
16786         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16787       case NT_S390_TDB:
16788         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16789       case NT_S390_VXRS_LOW:
16790         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16791       case NT_S390_VXRS_HIGH:
16792         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16793       case NT_S390_GS_CB:
16794         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16795       case NT_S390_GS_BC:
16796         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16797       case NT_ARM_VFP:
16798         return _("NT_ARM_VFP (arm VFP registers)");
16799       case NT_ARM_TLS:
16800         return _("NT_ARM_TLS (AArch TLS registers)");
16801       case NT_ARM_HW_BREAK:
16802         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16803       case NT_ARM_HW_WATCH:
16804         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16805       case NT_PSTATUS:
16806         return _("NT_PSTATUS (pstatus structure)");
16807       case NT_FPREGS:
16808         return _("NT_FPREGS (floating point registers)");
16809       case NT_PSINFO:
16810         return _("NT_PSINFO (psinfo structure)");
16811       case NT_LWPSTATUS:
16812         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16813       case NT_LWPSINFO:
16814         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16815       case NT_WIN32PSTATUS:
16816         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16817       case NT_SIGINFO:
16818         return _("NT_SIGINFO (siginfo_t data)");
16819       case NT_FILE:
16820         return _("NT_FILE (mapped files)");
16821       default:
16822         break;
16823       }
16824   else
16825     switch (e_type)
16826       {
16827       case NT_VERSION:
16828         return _("NT_VERSION (version)");
16829       case NT_ARCH:
16830         return _("NT_ARCH (architecture)");
16831       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16832         return _("OPEN");
16833       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16834         return _("func");
16835       default:
16836         break;
16837       }
16838
16839   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16840   return buff;
16841 }
16842
16843 static bfd_boolean
16844 print_core_note (Elf_Internal_Note *pnote)
16845 {
16846   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16847   bfd_vma count, page_size;
16848   unsigned char *descdata, *filenames, *descend;
16849
16850   if (pnote->type != NT_FILE)
16851     {
16852       if (do_wide)
16853         printf ("\n");
16854       return TRUE;
16855     }
16856
16857 #ifndef BFD64
16858   if (!is_32bit_elf)
16859     {
16860       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16861       /* Still "successful".  */
16862       return TRUE;
16863     }
16864 #endif
16865
16866   if (pnote->descsz < 2 * addr_size)
16867     {
16868       error (_("    Malformed note - too short for header\n"));
16869       return FALSE;
16870     }
16871
16872   descdata = (unsigned char *) pnote->descdata;
16873   descend = descdata + pnote->descsz;
16874
16875   if (descdata[pnote->descsz - 1] != '\0')
16876     {
16877       error (_("    Malformed note - does not end with \\0\n"));
16878       return FALSE;
16879     }
16880
16881   count = byte_get (descdata, addr_size);
16882   descdata += addr_size;
16883
16884   page_size = byte_get (descdata, addr_size);
16885   descdata += addr_size;
16886
16887   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16888       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16889     {
16890       error (_("    Malformed note - too short for supplied file count\n"));
16891       return FALSE;
16892     }
16893
16894   printf (_("    Page size: "));
16895   print_vma (page_size, DEC);
16896   printf ("\n");
16897
16898   printf (_("    %*s%*s%*s\n"),
16899           (int) (2 + 2 * addr_size), _("Start"),
16900           (int) (4 + 2 * addr_size), _("End"),
16901           (int) (4 + 2 * addr_size), _("Page Offset"));
16902   filenames = descdata + count * 3 * addr_size;
16903   while (count-- > 0)
16904     {
16905       bfd_vma start, end, file_ofs;
16906
16907       if (filenames == descend)
16908         {
16909           error (_("    Malformed note - filenames end too early\n"));
16910           return FALSE;
16911         }
16912
16913       start = byte_get (descdata, addr_size);
16914       descdata += addr_size;
16915       end = byte_get (descdata, addr_size);
16916       descdata += addr_size;
16917       file_ofs = byte_get (descdata, addr_size);
16918       descdata += addr_size;
16919
16920       printf ("    ");
16921       print_vma (start, FULL_HEX);
16922       printf ("  ");
16923       print_vma (end, FULL_HEX);
16924       printf ("  ");
16925       print_vma (file_ofs, FULL_HEX);
16926       printf ("\n        %s\n", filenames);
16927
16928       filenames += 1 + strlen ((char *) filenames);
16929     }
16930
16931   return TRUE;
16932 }
16933
16934 static const char *
16935 get_gnu_elf_note_type (unsigned e_type)
16936 {
16937   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16938   switch (e_type)
16939     {
16940     case NT_GNU_ABI_TAG:
16941       return _("NT_GNU_ABI_TAG (ABI version tag)");
16942     case NT_GNU_HWCAP:
16943       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16944     case NT_GNU_BUILD_ID:
16945       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16946     case NT_GNU_GOLD_VERSION:
16947       return _("NT_GNU_GOLD_VERSION (gold version)");
16948     case NT_GNU_PROPERTY_TYPE_0:
16949       return _("NT_GNU_PROPERTY_TYPE_0");
16950     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16951       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16952     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16953       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16954     default:
16955       {
16956         static char buff[64];
16957
16958         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16959         return buff;
16960       }
16961     }
16962 }
16963
16964 static void
16965 decode_x86_compat_isa (unsigned int bitmask)
16966 {
16967   while (bitmask)
16968     {
16969       unsigned int bit = bitmask & (- bitmask);
16970
16971       bitmask &= ~ bit;
16972       switch (bit)
16973         {
16974         case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
16975           printf ("i486");
16976           break;
16977         case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
16978           printf ("586");
16979           break;
16980         case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
16981           printf ("686");
16982           break;
16983         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
16984           printf ("SSE");
16985           break;
16986         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
16987           printf ("SSE2");
16988           break;
16989         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
16990           printf ("SSE3");
16991           break;
16992         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
16993           printf ("SSSE3");
16994           break;
16995         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
16996           printf ("SSE4_1");
16997           break;
16998         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
16999           printf ("SSE4_2");
17000           break;
17001         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17002           printf ("AVX");
17003           break;
17004         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17005           printf ("AVX2");
17006           break;
17007         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17008           printf ("AVX512F");
17009           break;
17010         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17011           printf ("AVX512CD");
17012           break;
17013         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17014           printf ("AVX512ER");
17015           break;
17016         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17017           printf ("AVX512PF");
17018           break;
17019         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17020           printf ("AVX512VL");
17021           break;
17022         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17023           printf ("AVX512DQ");
17024           break;
17025         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17026           printf ("AVX512BW");
17027           break;
17028         default:
17029           printf (_("<unknown: %x>"), bit);
17030           break;
17031         }
17032       if (bitmask)
17033         printf (", ");
17034     }
17035 }
17036
17037 static void
17038 decode_x86_isa (unsigned int bitmask)
17039 {
17040   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17041     {
17042       printf (_("<None>"));
17043       return;
17044     }
17045   else
17046     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17047
17048   while (bitmask)
17049     {
17050       unsigned int bit = bitmask & (- bitmask);
17051
17052       bitmask &= ~ bit;
17053       switch (bit)
17054         {
17055         case GNU_PROPERTY_X86_ISA_1_CMOV:
17056           printf ("CMOV");
17057           break;
17058         case GNU_PROPERTY_X86_ISA_1_SSE:
17059           printf ("SSE");
17060           break;
17061         case GNU_PROPERTY_X86_ISA_1_SSE2:
17062           printf ("SSE2");
17063           break;
17064         case GNU_PROPERTY_X86_ISA_1_SSE3:
17065           printf ("SSE3");
17066           break;
17067         case GNU_PROPERTY_X86_ISA_1_SSSE3:
17068           printf ("SSSE3");
17069           break;
17070         case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17071           printf ("SSE4_1");
17072           break;
17073         case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17074           printf ("SSE4_2");
17075           break;
17076         case GNU_PROPERTY_X86_ISA_1_AVX:
17077           printf ("AVX");
17078           break;
17079         case GNU_PROPERTY_X86_ISA_1_AVX2:
17080           printf ("AVX2");
17081           break;
17082         case GNU_PROPERTY_X86_ISA_1_FMA:
17083           printf ("FMA");
17084           break;
17085         case GNU_PROPERTY_X86_ISA_1_AVX512F:
17086           printf ("AVX512F");
17087           break;
17088         case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17089           printf ("AVX512CD");
17090           break;
17091         case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17092           printf ("AVX512ER");
17093           break;
17094         case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17095           printf ("AVX512PF");
17096           break;
17097         case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17098           printf ("AVX512VL");
17099           break;
17100         case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17101           printf ("AVX512DQ");
17102           break;
17103         case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17104           printf ("AVX512BW");
17105           break;
17106         case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17107           printf ("AVX512_4FMAPS");
17108           break;
17109         case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17110           printf ("AVX512_4VNNIW");
17111           break;
17112         case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17113           printf ("AVX512_BITALG");
17114           break;
17115         case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17116           printf ("AVX512_IFMA");
17117           break;
17118         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17119           printf ("AVX512_VBMI");
17120           break;
17121         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17122           printf ("AVX512_VBMI2");
17123           break;
17124         case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17125           printf ("AVX512_VNNI");
17126           break;
17127         default:
17128           printf (_("<unknown: %x>"), bit);
17129           break;
17130         }
17131       if (bitmask)
17132         printf (", ");
17133     }
17134 }
17135
17136 static void
17137 decode_x86_feature_1 (unsigned int bitmask)
17138 {
17139   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17140     {
17141       printf (_("<None>"));
17142       return;
17143     }
17144   else
17145     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17146
17147   while (bitmask)
17148     {
17149       unsigned int bit = bitmask & (- bitmask);
17150
17151       bitmask &= ~ bit;
17152       switch (bit)
17153         {
17154         case GNU_PROPERTY_X86_FEATURE_1_IBT:
17155           printf ("IBT");
17156           break;
17157         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17158           printf ("SHSTK");
17159           break;
17160         default:
17161           printf (_("<unknown: %x>"), bit);
17162           break;
17163         }
17164       if (bitmask)
17165         printf (", ");
17166     }
17167 }
17168
17169 static void
17170 decode_x86_feature_2 (unsigned int bitmask)
17171 {
17172   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17173     {
17174       printf (_("<None>"));
17175       return;
17176     }
17177   else
17178     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17179
17180   while (bitmask)
17181     {
17182       unsigned int bit = bitmask & (- bitmask);
17183
17184       bitmask &= ~ bit;
17185       switch (bit)
17186         {
17187         case GNU_PROPERTY_X86_FEATURE_2_X86:
17188           printf ("x86");
17189           break;
17190         case GNU_PROPERTY_X86_FEATURE_2_X87:
17191           printf ("x87");
17192           break;
17193         case GNU_PROPERTY_X86_FEATURE_2_MMX:
17194           printf ("MMX");
17195           break;
17196         case GNU_PROPERTY_X86_FEATURE_2_XMM:
17197           printf ("XMM");
17198           break;
17199         case GNU_PROPERTY_X86_FEATURE_2_YMM:
17200           printf ("YMM");
17201           break;
17202         case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17203           printf ("ZMM");
17204           break;
17205         case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17206           printf ("FXSR");
17207           break;
17208         case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17209           printf ("XSAVE");
17210           break;
17211         case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17212           printf ("XSAVEOPT");
17213           break;
17214         case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17215           printf ("XSAVEC");
17216           break;
17217         default:
17218           printf (_("<unknown: %x>"), bit);
17219           break;
17220         }
17221       if (bitmask)
17222         printf (", ");
17223     }
17224 }
17225
17226 static void
17227 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17228 {
17229   unsigned char * ptr = (unsigned char *) pnote->descdata;
17230   unsigned char * ptr_end = ptr + pnote->descsz;
17231   unsigned int    size = is_32bit_elf ? 4 : 8;
17232
17233   printf (_("      Properties: "));
17234
17235   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17236     {
17237       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17238       return;
17239     }
17240
17241   while (ptr < ptr_end)
17242     {
17243       unsigned int j;
17244       unsigned int type;
17245       unsigned int datasz;
17246
17247       if ((size_t) (ptr_end - ptr) < 8)
17248         {
17249           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17250           break;
17251         }
17252
17253       type = byte_get (ptr, 4);
17254       datasz = byte_get (ptr + 4, 4);
17255
17256       ptr += 8;
17257
17258       if (datasz > (size_t) (ptr_end - ptr))
17259         {
17260           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17261                   type, datasz);
17262           break;
17263         }
17264
17265       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17266         {
17267           if (filedata->file_header.e_machine == EM_X86_64
17268               || filedata->file_header.e_machine == EM_IAMCU
17269               || filedata->file_header.e_machine == EM_386)
17270             {
17271               unsigned int bitmask;
17272
17273               if (datasz == 4)
17274                 {
17275                   bitmask = byte_get (ptr, 4);
17276                   if ((filedata->file_header.e_type == ET_EXEC
17277                        || filedata->file_header.e_type == ET_DYN)
17278                       && !(bitmask & GNU_PROPERTY_X86_UINT32_VALID))
17279                     printf ("Invalid ");
17280                 }
17281               else
17282                 bitmask = 0;
17283
17284               switch (type)
17285                 {
17286                 case GNU_PROPERTY_X86_ISA_1_USED:
17287                   if (datasz != 4)
17288                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17289                             datasz);
17290                   else
17291                     {
17292                       printf ("x86 ISA used: ");
17293                       decode_x86_isa (bitmask);
17294                     }
17295                   goto next;
17296
17297                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17298                   if (datasz != 4)
17299                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17300                             datasz);
17301                   else
17302                     {
17303                       printf ("x86 ISA needed: ");
17304                       decode_x86_isa (bitmask);
17305                     }
17306                   goto next;
17307
17308                 case GNU_PROPERTY_X86_FEATURE_1_AND:
17309                   if (datasz != 4)
17310                     printf (_("x86 feature: <corrupt length: %#x> "),
17311                             datasz);
17312                   else
17313                     {
17314                       printf ("x86 feature: ");
17315                       decode_x86_feature_1 (bitmask);
17316                     }
17317                   goto next;
17318
17319                 case GNU_PROPERTY_X86_FEATURE_2_USED:
17320                   if (datasz != 4)
17321                     printf (_("x86 feature used: <corrupt length: %#x> "),
17322                             datasz);
17323                   else
17324                     {
17325                       printf ("x86 feature used: ");
17326                       decode_x86_feature_2 (bitmask);
17327                     }
17328                   goto next;
17329
17330                 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17331                   if (datasz != 4)
17332                     printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17333                   else
17334                     {
17335                       printf ("x86 feature needed: ");
17336                       decode_x86_feature_2 (bitmask);
17337                     }
17338                   goto next;
17339
17340                 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17341                   if (datasz != 4)
17342                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17343                             datasz);
17344                   else
17345                     {
17346                       printf ("x86 ISA used: ");
17347                       decode_x86_compat_isa (bitmask);
17348                     }
17349                   goto next;
17350
17351                 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17352                   if (datasz != 4)
17353                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17354                             datasz);
17355                   else
17356                     {
17357                       printf ("x86 ISA needed: ");
17358                       decode_x86_compat_isa (bitmask);
17359                     }
17360                   goto next;
17361
17362                 default:
17363                   break;
17364                 }
17365             }
17366         }
17367       else
17368         {
17369           switch (type)
17370             {
17371             case GNU_PROPERTY_STACK_SIZE:
17372               printf (_("stack size: "));
17373               if (datasz != size)
17374                 printf (_("<corrupt length: %#x> "), datasz);
17375               else
17376                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17377               goto next;
17378
17379             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17380               printf ("no copy on protected ");
17381               if (datasz)
17382                 printf (_("<corrupt length: %#x> "), datasz);
17383               goto next;
17384
17385             default:
17386               break;
17387             }
17388         }
17389
17390       if (type < GNU_PROPERTY_LOPROC)
17391         printf (_("<unknown type %#x data: "), type);
17392       else if (type < GNU_PROPERTY_LOUSER)
17393         printf (_("<procesor-specific type %#x data: "), type);
17394       else
17395         printf (_("<application-specific type %#x data: "), type);
17396       for (j = 0; j < datasz; ++j)
17397         printf ("%02x ", ptr[j] & 0xff);
17398       printf (">");
17399
17400 next:
17401       ptr += ((datasz + (size - 1)) & ~ (size - 1));
17402       if (ptr == ptr_end)
17403         break;
17404
17405       if (do_wide)
17406         printf (", ");
17407       else
17408         printf ("\n\t");
17409     }
17410
17411   printf ("\n");
17412 }
17413
17414 static bfd_boolean
17415 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17416 {
17417   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17418   switch (pnote->type)
17419     {
17420     case NT_GNU_BUILD_ID:
17421       {
17422         unsigned long i;
17423
17424         printf (_("    Build ID: "));
17425         for (i = 0; i < pnote->descsz; ++i)
17426           printf ("%02x", pnote->descdata[i] & 0xff);
17427         printf ("\n");
17428       }
17429       break;
17430
17431     case NT_GNU_ABI_TAG:
17432       {
17433         unsigned long os, major, minor, subminor;
17434         const char *osname;
17435
17436         /* PR 17531: file: 030-599401-0.004.  */
17437         if (pnote->descsz < 16)
17438           {
17439             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17440             break;
17441           }
17442
17443         os = byte_get ((unsigned char *) pnote->descdata, 4);
17444         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17445         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17446         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17447
17448         switch (os)
17449           {
17450           case GNU_ABI_TAG_LINUX:
17451             osname = "Linux";
17452             break;
17453           case GNU_ABI_TAG_HURD:
17454             osname = "Hurd";
17455             break;
17456           case GNU_ABI_TAG_SOLARIS:
17457             osname = "Solaris";
17458             break;
17459           case GNU_ABI_TAG_FREEBSD:
17460             osname = "FreeBSD";
17461             break;
17462           case GNU_ABI_TAG_NETBSD:
17463             osname = "NetBSD";
17464             break;
17465           case GNU_ABI_TAG_SYLLABLE:
17466             osname = "Syllable";
17467             break;
17468           case GNU_ABI_TAG_NACL:
17469             osname = "NaCl";
17470             break;
17471           default:
17472             osname = "Unknown";
17473             break;
17474           }
17475
17476         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17477                 major, minor, subminor);
17478       }
17479       break;
17480
17481     case NT_GNU_GOLD_VERSION:
17482       {
17483         unsigned long i;
17484
17485         printf (_("    Version: "));
17486         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17487           printf ("%c", pnote->descdata[i]);
17488         printf ("\n");
17489       }
17490       break;
17491
17492     case NT_GNU_HWCAP:
17493       {
17494         unsigned long num_entries, mask;
17495
17496         /* Hardware capabilities information.  Word 0 is the number of entries.
17497            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17498            is a series of entries, where each entry is a single byte followed
17499            by a nul terminated string.  The byte gives the bit number to test
17500            if enabled in the bitmask.  */
17501         printf (_("      Hardware Capabilities: "));
17502         if (pnote->descsz < 8)
17503           {
17504             error (_("<corrupt GNU_HWCAP>\n"));
17505             return FALSE;
17506           }
17507         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17508         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17509         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17510         /* FIXME: Add code to display the entries... */
17511       }
17512       break;
17513
17514     case NT_GNU_PROPERTY_TYPE_0:
17515       print_gnu_property_note (filedata, pnote);
17516       break;
17517
17518     default:
17519       /* Handle unrecognised types.  An error message should have already been
17520          created by get_gnu_elf_note_type(), so all that we need to do is to
17521          display the data.  */
17522       {
17523         unsigned long i;
17524
17525         printf (_("    Description data: "));
17526         for (i = 0; i < pnote->descsz; ++i)
17527           printf ("%02x ", pnote->descdata[i] & 0xff);
17528         printf ("\n");
17529       }
17530       break;
17531     }
17532
17533   return TRUE;
17534 }
17535
17536 static const char *
17537 get_v850_elf_note_type (enum v850_notes n_type)
17538 {
17539   static char buff[64];
17540
17541   switch (n_type)
17542     {
17543     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17544     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17545     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17546     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17547     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17548     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17549     default:
17550       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17551       return buff;
17552     }
17553 }
17554
17555 static bfd_boolean
17556 print_v850_note (Elf_Internal_Note * pnote)
17557 {
17558   unsigned int val;
17559
17560   if (pnote->descsz != 4)
17561     return FALSE;
17562
17563   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17564
17565   if (val == 0)
17566     {
17567       printf (_("not set\n"));
17568       return TRUE;
17569     }
17570
17571   switch (pnote->type)
17572     {
17573     case V850_NOTE_ALIGNMENT:
17574       switch (val)
17575         {
17576         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17577         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17578         }
17579       break;
17580
17581     case V850_NOTE_DATA_SIZE:
17582       switch (val)
17583         {
17584         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17585         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17586         }
17587       break;
17588
17589     case V850_NOTE_FPU_INFO:
17590       switch (val)
17591         {
17592         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17593         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17594         }
17595       break;
17596
17597     case V850_NOTE_MMU_INFO:
17598     case V850_NOTE_CACHE_INFO:
17599     case V850_NOTE_SIMD_INFO:
17600       if (val == EF_RH850_SIMD)
17601         {
17602           printf (_("yes\n"));
17603           return TRUE;
17604         }
17605       break;
17606
17607     default:
17608       /* An 'unknown note type' message will already have been displayed.  */
17609       break;
17610     }
17611
17612   printf (_("unknown value: %x\n"), val);
17613   return FALSE;
17614 }
17615
17616 static bfd_boolean
17617 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17618 {
17619   unsigned int version;
17620
17621   switch (pnote->type)
17622     {
17623     case NT_NETBSD_IDENT:
17624       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17625       if ((version / 10000) % 100)
17626         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17627                 version, version / 100000000, (version / 1000000) % 100,
17628                 (version / 10000) % 100 > 26 ? "Z" : "",
17629                 'A' + (version / 10000) % 26);
17630       else
17631         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17632                 version, version / 100000000, (version / 1000000) % 100,
17633                 (version / 100) % 100);
17634       return TRUE;
17635
17636     case NT_NETBSD_MARCH:
17637       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17638               pnote->descdata);
17639       return TRUE;
17640
17641     default:
17642       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17643               pnote->type);
17644       return FALSE;
17645     }
17646 }
17647
17648 static const char *
17649 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17650 {
17651   switch (e_type)
17652     {
17653     case NT_FREEBSD_THRMISC:
17654       return _("NT_THRMISC (thrmisc structure)");
17655     case NT_FREEBSD_PROCSTAT_PROC:
17656       return _("NT_PROCSTAT_PROC (proc data)");
17657     case NT_FREEBSD_PROCSTAT_FILES:
17658       return _("NT_PROCSTAT_FILES (files data)");
17659     case NT_FREEBSD_PROCSTAT_VMMAP:
17660       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17661     case NT_FREEBSD_PROCSTAT_GROUPS:
17662       return _("NT_PROCSTAT_GROUPS (groups data)");
17663     case NT_FREEBSD_PROCSTAT_UMASK:
17664       return _("NT_PROCSTAT_UMASK (umask data)");
17665     case NT_FREEBSD_PROCSTAT_RLIMIT:
17666       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17667     case NT_FREEBSD_PROCSTAT_OSREL:
17668       return _("NT_PROCSTAT_OSREL (osreldate data)");
17669     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17670       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17671     case NT_FREEBSD_PROCSTAT_AUXV:
17672       return _("NT_PROCSTAT_AUXV (auxv data)");
17673     case NT_FREEBSD_PTLWPINFO:
17674       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17675     }
17676   return get_note_type (filedata, e_type);
17677 }
17678
17679 static const char *
17680 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17681 {
17682   static char buff[64];
17683
17684   if (e_type == NT_NETBSDCORE_PROCINFO)
17685     return _("NetBSD procinfo structure");
17686
17687   /* As of Jan 2002 there are no other machine-independent notes
17688      defined for NetBSD core files.  If the note type is less
17689      than the start of the machine-dependent note types, we don't
17690      understand it.  */
17691
17692   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17693     {
17694       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17695       return buff;
17696     }
17697
17698   switch (filedata->file_header.e_machine)
17699     {
17700     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17701        and PT_GETFPREGS == mach+2.  */
17702
17703     case EM_OLD_ALPHA:
17704     case EM_ALPHA:
17705     case EM_SPARC:
17706     case EM_SPARC32PLUS:
17707     case EM_SPARCV9:
17708       switch (e_type)
17709         {
17710         case NT_NETBSDCORE_FIRSTMACH + 0:
17711           return _("PT_GETREGS (reg structure)");
17712         case NT_NETBSDCORE_FIRSTMACH + 2:
17713           return _("PT_GETFPREGS (fpreg structure)");
17714         default:
17715           break;
17716         }
17717       break;
17718
17719     /* On all other arch's, PT_GETREGS == mach+1 and
17720        PT_GETFPREGS == mach+3.  */
17721     default:
17722       switch (e_type)
17723         {
17724         case NT_NETBSDCORE_FIRSTMACH + 1:
17725           return _("PT_GETREGS (reg structure)");
17726         case NT_NETBSDCORE_FIRSTMACH + 3:
17727           return _("PT_GETFPREGS (fpreg structure)");
17728         default:
17729           break;
17730         }
17731     }
17732
17733   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17734             e_type - NT_NETBSDCORE_FIRSTMACH);
17735   return buff;
17736 }
17737
17738 static const char *
17739 get_stapsdt_note_type (unsigned e_type)
17740 {
17741   static char buff[64];
17742
17743   switch (e_type)
17744     {
17745     case NT_STAPSDT:
17746       return _("NT_STAPSDT (SystemTap probe descriptors)");
17747
17748     default:
17749       break;
17750     }
17751
17752   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17753   return buff;
17754 }
17755
17756 static bfd_boolean
17757 print_stapsdt_note (Elf_Internal_Note *pnote)
17758 {
17759   int addr_size = is_32bit_elf ? 4 : 8;
17760   char *data = pnote->descdata;
17761   char *data_end = pnote->descdata + pnote->descsz;
17762   bfd_vma pc, base_addr, semaphore;
17763   char *provider, *probe, *arg_fmt;
17764
17765   pc = byte_get ((unsigned char *) data, addr_size);
17766   data += addr_size;
17767   base_addr = byte_get ((unsigned char *) data, addr_size);
17768   data += addr_size;
17769   semaphore = byte_get ((unsigned char *) data, addr_size);
17770   data += addr_size;
17771
17772   provider = data;
17773   data += strlen (data) + 1;
17774   probe = data;
17775   data += strlen (data) + 1;
17776   arg_fmt = data;
17777   data += strlen (data) + 1;
17778
17779   printf (_("    Provider: %s\n"), provider);
17780   printf (_("    Name: %s\n"), probe);
17781   printf (_("    Location: "));
17782   print_vma (pc, FULL_HEX);
17783   printf (_(", Base: "));
17784   print_vma (base_addr, FULL_HEX);
17785   printf (_(", Semaphore: "));
17786   print_vma (semaphore, FULL_HEX);
17787   printf ("\n");
17788   printf (_("    Arguments: %s\n"), arg_fmt);
17789
17790   return data == data_end;
17791 }
17792
17793 static const char *
17794 get_ia64_vms_note_type (unsigned e_type)
17795 {
17796   static char buff[64];
17797
17798   switch (e_type)
17799     {
17800     case NT_VMS_MHD:
17801       return _("NT_VMS_MHD (module header)");
17802     case NT_VMS_LNM:
17803       return _("NT_VMS_LNM (language name)");
17804     case NT_VMS_SRC:
17805       return _("NT_VMS_SRC (source files)");
17806     case NT_VMS_TITLE:
17807       return "NT_VMS_TITLE";
17808     case NT_VMS_EIDC:
17809       return _("NT_VMS_EIDC (consistency check)");
17810     case NT_VMS_FPMODE:
17811       return _("NT_VMS_FPMODE (FP mode)");
17812     case NT_VMS_LINKTIME:
17813       return "NT_VMS_LINKTIME";
17814     case NT_VMS_IMGNAM:
17815       return _("NT_VMS_IMGNAM (image name)");
17816     case NT_VMS_IMGID:
17817       return _("NT_VMS_IMGID (image id)");
17818     case NT_VMS_LINKID:
17819       return _("NT_VMS_LINKID (link id)");
17820     case NT_VMS_IMGBID:
17821       return _("NT_VMS_IMGBID (build id)");
17822     case NT_VMS_GSTNAM:
17823       return _("NT_VMS_GSTNAM (sym table name)");
17824     case NT_VMS_ORIG_DYN:
17825       return "NT_VMS_ORIG_DYN";
17826     case NT_VMS_PATCHTIME:
17827       return "NT_VMS_PATCHTIME";
17828     default:
17829       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17830       return buff;
17831     }
17832 }
17833
17834 static bfd_boolean
17835 print_ia64_vms_note (Elf_Internal_Note * pnote)
17836 {
17837   switch (pnote->type)
17838     {
17839     case NT_VMS_MHD:
17840       if (pnote->descsz > 36)
17841         {
17842           size_t l = strlen (pnote->descdata + 34);
17843           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17844           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17845           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17846           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17847         }
17848       else
17849         printf (_("    Invalid size\n"));
17850       break;
17851     case NT_VMS_LNM:
17852       printf (_("   Language: %s\n"), pnote->descdata);
17853       break;
17854 #ifdef BFD64
17855     case NT_VMS_FPMODE:
17856       printf (_("   Floating Point mode: "));
17857       printf ("0x%016" BFD_VMA_FMT "x\n",
17858               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17859       break;
17860     case NT_VMS_LINKTIME:
17861       printf (_("   Link time: "));
17862       print_vms_time
17863         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17864       printf ("\n");
17865       break;
17866     case NT_VMS_PATCHTIME:
17867       printf (_("   Patch time: "));
17868       print_vms_time
17869         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17870       printf ("\n");
17871       break;
17872     case NT_VMS_ORIG_DYN:
17873       printf (_("   Major id: %u,  minor id: %u\n"),
17874               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17875               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17876       printf (_("   Last modified  : "));
17877       print_vms_time
17878         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17879       printf (_("\n   Link flags  : "));
17880       printf ("0x%016" BFD_VMA_FMT "x\n",
17881               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17882       printf (_("   Header flags: 0x%08x\n"),
17883               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17884       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17885       break;
17886 #endif
17887     case NT_VMS_IMGNAM:
17888       printf (_("    Image name: %s\n"), pnote->descdata);
17889       break;
17890     case NT_VMS_GSTNAM:
17891       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17892       break;
17893     case NT_VMS_IMGID:
17894       printf (_("    Image id: %s\n"), pnote->descdata);
17895       break;
17896     case NT_VMS_LINKID:
17897       printf (_("    Linker id: %s\n"), pnote->descdata);
17898       break;
17899     default:
17900       return FALSE;
17901     }
17902   return TRUE;
17903 }
17904
17905 /* Find the symbol associated with a build attribute that is attached
17906    to address OFFSET.  If PNAME is non-NULL then store the name of
17907    the symbol (if found) in the provided pointer,  Returns NULL if a
17908    symbol could not be found.  */
17909
17910 static Elf_Internal_Sym *
17911 get_symbol_for_build_attribute (Filedata *       filedata,
17912                                 unsigned long    offset,
17913                                 bfd_boolean      is_open_attr,
17914                                 const char **    pname)
17915 {
17916   static Filedata *         saved_filedata = NULL;
17917   static char *             strtab;
17918   static unsigned long      strtablen;
17919   static Elf_Internal_Sym * symtab;
17920   static unsigned long      nsyms;
17921   Elf_Internal_Sym *        saved_sym = NULL;
17922   Elf_Internal_Sym *        sym;
17923
17924   if (filedata->section_headers != NULL
17925       && (saved_filedata == NULL || filedata != saved_filedata))
17926     {
17927       Elf_Internal_Shdr * symsec;
17928
17929       /* Load the symbol and string sections.  */
17930       for (symsec = filedata->section_headers;
17931            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17932            symsec ++)
17933         {
17934           if (symsec->sh_type == SHT_SYMTAB)
17935             {
17936               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17937
17938               if (symsec->sh_link < filedata->file_header.e_shnum)
17939                 {
17940                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17941
17942                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17943                                               1, strtab_sec->sh_size,
17944                                               _("string table"));
17945                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17946                 }
17947             }
17948         }
17949       saved_filedata = filedata;
17950     }
17951
17952   if (symtab == NULL || strtab == NULL)
17953     return NULL;
17954
17955   /* Find a symbol whose value matches offset.  */
17956   for (sym = symtab; sym < symtab + nsyms; sym ++)
17957     if (sym->st_value == offset)
17958       {
17959         if (sym->st_name >= strtablen)
17960           /* Huh ?  This should not happen.  */
17961           continue;
17962
17963         if (strtab[sym->st_name] == 0)
17964           continue;
17965
17966         /* The AArch64 and ARM architectures define mapping symbols
17967            (eg $d, $x, $t) which we want to ignore.  */
17968         if (strtab[sym->st_name] == '$'
17969             && strtab[sym->st_name + 1] != 0
17970             && strtab[sym->st_name + 2] == 0)
17971           continue;
17972
17973         if (is_open_attr)
17974           {
17975             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17976                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17977                FUNC symbols entirely.  */
17978             switch (ELF_ST_TYPE (sym->st_info))
17979               {
17980               case STT_OBJECT:
17981               case STT_FILE:
17982                 saved_sym = sym;
17983                 if (sym->st_size)
17984                   {
17985                     /* If the symbol has a size associated
17986                        with it then we can stop searching.  */
17987                     sym = symtab + nsyms;
17988                   }
17989                 continue;
17990
17991               case STT_FUNC:
17992                 /* Ignore function symbols.  */
17993                 continue;
17994
17995               default:
17996                 break;
17997               }
17998
17999             switch (ELF_ST_BIND (sym->st_info))
18000               {
18001               case STB_GLOBAL:
18002                 if (saved_sym == NULL
18003                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18004                   saved_sym = sym;
18005                 break;
18006
18007               case STB_LOCAL:
18008                 if (saved_sym == NULL)
18009                   saved_sym = sym;
18010                 break;
18011
18012               default:
18013                 break;
18014               }
18015           }
18016         else
18017           {
18018             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18019               continue;
18020
18021             saved_sym = sym;
18022             break;
18023           }
18024       }
18025
18026   if (saved_sym && pname)
18027     * pname = strtab + saved_sym->st_name;
18028
18029   return saved_sym;
18030 }
18031
18032 /* Returns true iff addr1 and addr2 are in the same section.  */
18033
18034 static bfd_boolean
18035 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18036 {
18037   Elf_Internal_Shdr * a1;
18038   Elf_Internal_Shdr * a2;
18039
18040   a1 = find_section_by_address (filedata, addr1);
18041   a2 = find_section_by_address (filedata, addr2);
18042
18043   return a1 == a2 && a1 != NULL;
18044 }
18045
18046 static bfd_boolean
18047 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
18048                                        Filedata *           filedata)
18049 {
18050   static unsigned long  global_offset = 0;
18051   static unsigned long  global_end = 0;
18052   static unsigned long  func_offset = 0;
18053   static unsigned long  func_end = 0;
18054
18055   Elf_Internal_Sym *    sym;
18056   const char *          name;
18057   unsigned long         start;
18058   unsigned long         end;
18059   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18060
18061   switch (pnote->descsz)
18062     {
18063     case 0:
18064       /* A zero-length description means that the range of
18065          the previous note of the same type should be used.  */
18066       if (is_open_attr)
18067         {
18068           if (global_end > global_offset)
18069             printf (_("    Applies to region from %#lx to %#lx\n"),
18070                     global_offset, global_end);
18071           else
18072             printf (_("    Applies to region from %#lx\n"), global_offset);
18073         }
18074       else
18075         {
18076           if (func_end > func_offset)
18077             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18078           else
18079             printf (_("    Applies to region from %#lx\n"), func_offset);
18080         }
18081       return TRUE;
18082
18083     case 4:
18084       start = byte_get ((unsigned char *) pnote->descdata, 4);
18085       end = 0;
18086       break;
18087
18088     case 8:
18089       if (is_32bit_elf)
18090         {
18091           /* FIXME: We should check that version 3+ notes are being used here...  */
18092           start = byte_get ((unsigned char *) pnote->descdata, 4);
18093           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18094         }
18095       else
18096         {
18097           start = byte_get ((unsigned char *) pnote->descdata, 8);
18098           end = 0;
18099         }
18100       break;
18101
18102     case 16:
18103       start = byte_get ((unsigned char *) pnote->descdata, 8);
18104       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18105       break;
18106
18107     default:
18108       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
18109       printf (_("    <invalid descsz>"));
18110       return FALSE;
18111     }
18112
18113   name = NULL;
18114   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18115   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18116      in order to avoid them being confused with the start address of the
18117      first function in the file...  */
18118   if (sym == NULL && is_open_attr)
18119     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18120                                           & name);
18121
18122   if (end == 0 && sym != NULL && sym->st_size > 0)
18123     end = start + sym->st_size;
18124
18125   if (is_open_attr)
18126     {
18127       /* FIXME: Need to properly allow for section alignment.
18128          16 is just the alignment used on x86_64.  */
18129       if (global_end > 0
18130           && start > BFD_ALIGN (global_end, 16)
18131           /* Build notes are not guaranteed to be organised in order of
18132              increasing address, but we should find the all of the notes
18133              for one section in the same place.  */
18134           && same_section (filedata, start, global_end))
18135         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18136               global_end + 1, start - 1);
18137
18138       printf (_("    Applies to region from %#lx"), start);
18139       global_offset = start;
18140
18141       if (end)
18142         {
18143           printf (_(" to %#lx"), end);
18144           global_end = end;
18145         }
18146     }
18147   else
18148     {
18149       printf (_("    Applies to region from %#lx"), start);
18150       func_offset = start;
18151
18152       if (end)
18153         {
18154           printf (_(" to %#lx"), end);
18155           func_end = end;
18156         }
18157     }
18158
18159   if (sym && name)
18160     printf (_(" (%s)"), name);
18161
18162   printf ("\n");
18163   return TRUE;
18164 }
18165
18166 static bfd_boolean
18167 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18168 {
18169   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18170   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18171   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18172   char         name_type;
18173   char         name_attribute;
18174   const char * expected_types;
18175   const char * name = pnote->namedata;
18176   const char * text;
18177   signed int   left;
18178
18179   if (name == NULL || pnote->namesz < 2)
18180     {
18181       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18182       print_symbol (-20, _("  <corrupt name>"));
18183       return FALSE;
18184     }
18185
18186   if (do_wide)
18187     left = 28;
18188   else
18189     left = 20;
18190
18191   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
18192   if (name[0] == 'G' && name[1] == 'A')
18193     {
18194       if (pnote->namesz < 4)
18195         {
18196           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18197           print_symbol (-20, _("  <corrupt name>"));
18198           return FALSE;
18199         }
18200
18201       printf ("GA");
18202       name += 2;
18203       left -= 2;
18204     }
18205
18206   switch ((name_type = * name))
18207     {
18208     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18209     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18210     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18211     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18212       printf ("%c", * name);
18213       left --;
18214       break;
18215     default:
18216       error (_("unrecognised attribute type in name field: %d\n"), name_type);
18217       print_symbol (-20, _("<unknown name type>"));
18218       return FALSE;
18219     }
18220
18221   ++ name;
18222   text = NULL;
18223
18224   switch ((name_attribute = * name))
18225     {
18226     case GNU_BUILD_ATTRIBUTE_VERSION:
18227       text = _("<version>");
18228       expected_types = string_expected;
18229       ++ name;
18230       break;
18231     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18232       text = _("<stack prot>");
18233       expected_types = "!+*";
18234       ++ name;
18235       break;
18236     case GNU_BUILD_ATTRIBUTE_RELRO:
18237       text = _("<relro>");
18238       expected_types = bool_expected;
18239       ++ name;
18240       break;
18241     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18242       text = _("<stack size>");
18243       expected_types = number_expected;
18244       ++ name;
18245       break;
18246     case GNU_BUILD_ATTRIBUTE_TOOL:
18247       text = _("<tool>");
18248       expected_types = string_expected;
18249       ++ name;
18250       break;
18251     case GNU_BUILD_ATTRIBUTE_ABI:
18252       text = _("<ABI>");
18253       expected_types = "$*";
18254       ++ name;
18255       break;
18256     case GNU_BUILD_ATTRIBUTE_PIC:
18257       text = _("<PIC>");
18258       expected_types = number_expected;
18259       ++ name;
18260       break;
18261     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18262       text = _("<short enum>");
18263       expected_types = bool_expected;
18264       ++ name;
18265       break;
18266     default:
18267       if (ISPRINT (* name))
18268         {
18269           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18270
18271           if (len > left && ! do_wide)
18272             len = left;
18273           printf ("%.*s:", len, name);
18274           left -= len;
18275           name += len;
18276         }
18277       else
18278         {
18279           static char tmpbuf [128];
18280
18281           error (_("unrecognised byte in name field: %d\n"), * name);
18282           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18283           text = tmpbuf;
18284           name ++;
18285         }
18286       expected_types = "*$!+";
18287       break;
18288     }
18289
18290   if (text)
18291     left -= printf ("%s", text);
18292
18293   if (strchr (expected_types, name_type) == NULL)
18294     warn (_("attribute does not have an expected type (%c)\n"), name_type);
18295
18296   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18297     {
18298       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18299              (unsigned long) pnote->namesz,
18300              (long) (name - pnote->namedata));
18301       return FALSE;
18302     }
18303
18304   if (left < 1 && ! do_wide)
18305     return TRUE;
18306
18307   switch (name_type)
18308     {
18309     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18310       {
18311         unsigned int        bytes;
18312         unsigned long long  val = 0;
18313         unsigned int        shift = 0;
18314         char *              decoded = NULL;
18315
18316         bytes = pnote->namesz - (name - pnote->namedata);
18317         if (bytes > 0)
18318           /* The -1 is because the name field is always 0 terminated, and we
18319              want to be able to ensure that the shift in the while loop below
18320              will not overflow.  */
18321           -- bytes;
18322
18323         if (bytes > sizeof (val))
18324           {
18325             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18326                    bytes);
18327             bytes = sizeof (val);
18328           }
18329         /* We do not bother to warn if bytes == 0 as this can
18330            happen with some early versions of the gcc plugin.  */
18331
18332         while (bytes --)
18333           {
18334             unsigned long byte = (* name ++) & 0xff;
18335
18336             val |= byte << shift;
18337             shift += 8;
18338           }
18339
18340         switch (name_attribute)
18341           {
18342           case GNU_BUILD_ATTRIBUTE_PIC:
18343             switch (val)
18344               {
18345               case 0: decoded = "static"; break;
18346               case 1: decoded = "pic"; break;
18347               case 2: decoded = "PIC"; break;
18348               case 3: decoded = "pie"; break;
18349               case 4: decoded = "PIE"; break;
18350               default: break;
18351               }
18352             break;
18353           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18354             switch (val)
18355               {
18356                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
18357               case 0: decoded = "off"; break;
18358               case 1: decoded = "on"; break;
18359               case 2: decoded = "all"; break;
18360               case 3: decoded = "strong"; break;
18361               case 4: decoded = "explicit"; break;
18362               default: break;
18363               }
18364             break;
18365           default:
18366             break;
18367           }
18368
18369         if (decoded != NULL)
18370           {
18371             print_symbol (-left, decoded);
18372             left = 0;
18373           }
18374         else if (val == 0)
18375           {
18376             printf ("0x0");
18377             left -= 3;
18378           }
18379         else
18380           {
18381             if (do_wide)
18382               left -= printf ("0x%llx", val);
18383             else
18384               left -= printf ("0x%-.*llx", left, val);
18385           }
18386       }
18387       break;
18388     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18389       left -= print_symbol (- left, name);
18390       break;
18391     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18392       left -= print_symbol (- left, "true");
18393       break;
18394     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18395       left -= print_symbol (- left, "false");
18396       break;
18397     }
18398
18399   if (do_wide && left > 0)
18400     printf ("%-*s", left, " ");
18401
18402   return TRUE;
18403 }
18404
18405 /* Note that by the ELF standard, the name field is already null byte
18406    terminated, and namesz includes the terminating null byte.
18407    I.E. the value of namesz for the name "FSF" is 4.
18408
18409    If the value of namesz is zero, there is no name present.  */
18410
18411 static bfd_boolean
18412 process_note (Elf_Internal_Note *  pnote,
18413               Filedata *           filedata)
18414 {
18415   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18416   const char * nt;
18417
18418   if (pnote->namesz == 0)
18419     /* If there is no note name, then use the default set of
18420        note type strings.  */
18421     nt = get_note_type (filedata, pnote->type);
18422
18423   else if (const_strneq (pnote->namedata, "GNU"))
18424     /* GNU-specific object file notes.  */
18425     nt = get_gnu_elf_note_type (pnote->type);
18426
18427   else if (const_strneq (pnote->namedata, "FreeBSD"))
18428     /* FreeBSD-specific core file notes.  */
18429     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18430
18431   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18432     /* NetBSD-specific core file notes.  */
18433     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18434
18435   else if (const_strneq (pnote->namedata, "NetBSD"))
18436     /* NetBSD-specific core file notes.  */
18437     return process_netbsd_elf_note (pnote);
18438
18439   else if (strneq (pnote->namedata, "SPU/", 4))
18440     {
18441       /* SPU-specific core file notes.  */
18442       nt = pnote->namedata + 4;
18443       name = "SPU";
18444     }
18445
18446   else if (const_strneq (pnote->namedata, "IPF/VMS"))
18447     /* VMS/ia64-specific file notes.  */
18448     nt = get_ia64_vms_note_type (pnote->type);
18449
18450   else if (const_strneq (pnote->namedata, "stapsdt"))
18451     nt = get_stapsdt_note_type (pnote->type);
18452
18453   else
18454     /* Don't recognize this note name; just use the default set of
18455        note type strings.  */
18456     nt = get_note_type (filedata, pnote->type);
18457
18458   printf ("  ");
18459
18460   if (((const_strneq (pnote->namedata, "GA")
18461         && strchr ("*$!+", pnote->namedata[2]) != NULL)
18462        || strchr ("*$!+", pnote->namedata[0]) != NULL)
18463       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18464           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18465     print_gnu_build_attribute_name (pnote);
18466   else
18467     print_symbol (-20, name);
18468
18469   if (do_wide)
18470     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18471   else
18472     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18473
18474   if (const_strneq (pnote->namedata, "IPF/VMS"))
18475     return print_ia64_vms_note (pnote);
18476   else if (const_strneq (pnote->namedata, "GNU"))
18477     return print_gnu_note (filedata, pnote);
18478   else if (const_strneq (pnote->namedata, "stapsdt"))
18479     return print_stapsdt_note (pnote);
18480   else if (const_strneq (pnote->namedata, "CORE"))
18481     return print_core_note (pnote);
18482   else if (((const_strneq (pnote->namedata, "GA")
18483              && strchr ("*$!+", pnote->namedata[2]) != NULL)
18484             || strchr ("*$!+", pnote->namedata[0]) != NULL)
18485            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18486                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18487     return print_gnu_build_attribute_description (pnote, filedata);
18488
18489   if (pnote->descsz)
18490     {
18491       unsigned long i;
18492
18493       printf (_("   description data: "));
18494       for (i = 0; i < pnote->descsz; i++)
18495         printf ("%02x ", pnote->descdata[i]);
18496       if (!do_wide)
18497         printf ("\n");
18498     }
18499
18500   if (do_wide)
18501     printf ("\n");
18502
18503   return TRUE;
18504 }
18505
18506 static bfd_boolean
18507 process_notes_at (Filedata *           filedata,
18508                   Elf_Internal_Shdr *  section,
18509                   bfd_vma              offset,
18510                   bfd_vma              length,
18511                   bfd_vma              align)
18512 {
18513   Elf_External_Note * pnotes;
18514   Elf_External_Note * external;
18515   char *              end;
18516   bfd_boolean         res = TRUE;
18517
18518   if (length <= 0)
18519     return FALSE;
18520
18521   if (section)
18522     {
18523       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18524       if (pnotes)
18525         {
18526           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18527             return FALSE;
18528         }
18529     }
18530   else
18531     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18532                                              _("notes"));
18533
18534   if (pnotes == NULL)
18535     return FALSE;
18536
18537   external = pnotes;
18538
18539   if (section)
18540     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18541   else
18542     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18543             (unsigned long) offset, (unsigned long) length);
18544
18545   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18546      specifies that notes should be aligned to 4 bytes in 32-bit
18547      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18548      we also support 4 byte alignment in 64-bit objects.  If section
18549      alignment is less than 4, we treate alignment as 4 bytes.   */
18550   if (align < 4)
18551     align = 4;
18552   else if (align != 4 && align != 8)
18553     {
18554       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18555             (long) align);
18556       return FALSE;
18557     }
18558
18559   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18560
18561   end = (char *) pnotes + length;
18562   while ((char *) external < end)
18563     {
18564       Elf_Internal_Note inote;
18565       size_t min_notesz;
18566       char * next;
18567       char * temp = NULL;
18568       size_t data_remaining = end - (char *) external;
18569
18570       if (!is_ia64_vms (filedata))
18571         {
18572           /* PR binutils/15191
18573              Make sure that there is enough data to read.  */
18574           min_notesz = offsetof (Elf_External_Note, name);
18575           if (data_remaining < min_notesz)
18576             {
18577               warn (ngettext ("Corrupt note: only %ld byte remains, "
18578                               "not enough for a full note\n",
18579                               "Corrupt note: only %ld bytes remain, "
18580                               "not enough for a full note\n",
18581                               data_remaining),
18582                     (long) data_remaining);
18583               break;
18584             }
18585           data_remaining -= min_notesz;
18586
18587           inote.type     = BYTE_GET (external->type);
18588           inote.namesz   = BYTE_GET (external->namesz);
18589           inote.namedata = external->name;
18590           inote.descsz   = BYTE_GET (external->descsz);
18591           inote.descdata = ((char *) external
18592                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18593           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18594           next = ((char *) external
18595                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18596         }
18597       else
18598         {
18599           Elf64_External_VMS_Note *vms_external;
18600
18601           /* PR binutils/15191
18602              Make sure that there is enough data to read.  */
18603           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18604           if (data_remaining < min_notesz)
18605             {
18606               warn (ngettext ("Corrupt note: only %ld byte remains, "
18607                               "not enough for a full note\n",
18608                               "Corrupt note: only %ld bytes remain, "
18609                               "not enough for a full note\n",
18610                               data_remaining),
18611                     (long) data_remaining);
18612               break;
18613             }
18614           data_remaining -= min_notesz;
18615
18616           vms_external = (Elf64_External_VMS_Note *) external;
18617           inote.type     = BYTE_GET (vms_external->type);
18618           inote.namesz   = BYTE_GET (vms_external->namesz);
18619           inote.namedata = vms_external->name;
18620           inote.descsz   = BYTE_GET (vms_external->descsz);
18621           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18622           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18623           next = inote.descdata + align_power (inote.descsz, 3);
18624         }
18625
18626       /* PR 17531: file: 3443835e.  */
18627       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18628       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18629           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18630           || (size_t) (next - inote.descdata) < inote.descsz
18631           || ((size_t) (next - inote.descdata)
18632               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18633         {
18634           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18635                 (unsigned long) ((char *) external - (char *) pnotes));
18636           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18637                 inote.type, inote.namesz, inote.descsz, (int) align);
18638           break;
18639         }
18640
18641       external = (Elf_External_Note *) next;
18642
18643       /* Verify that name is null terminated.  It appears that at least
18644          one version of Linux (RedHat 6.0) generates corefiles that don't
18645          comply with the ELF spec by failing to include the null byte in
18646          namesz.  */
18647       if (inote.namedata[inote.namesz - 1] != '\0')
18648         {
18649           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18650             {
18651               temp = (char *) malloc (inote.namesz + 1);
18652               if (temp == NULL)
18653                 {
18654                   error (_("Out of memory allocating space for inote name\n"));
18655                   res = FALSE;
18656                   break;
18657                 }
18658
18659               memcpy (temp, inote.namedata, inote.namesz);
18660               inote.namedata = temp;
18661             }
18662           inote.namedata[inote.namesz] = 0;
18663         }
18664
18665       if (! process_note (& inote, filedata))
18666         res = FALSE;
18667
18668       if (temp != NULL)
18669         {
18670           free (temp);
18671           temp = NULL;
18672         }
18673     }
18674
18675   free (pnotes);
18676
18677   return res;
18678 }
18679
18680 static bfd_boolean
18681 process_corefile_note_segments (Filedata * filedata)
18682 {
18683   Elf_Internal_Phdr * segment;
18684   unsigned int i;
18685   bfd_boolean res = TRUE;
18686
18687   if (! get_program_headers (filedata))
18688     return TRUE;
18689
18690   for (i = 0, segment = filedata->program_headers;
18691        i < filedata->file_header.e_phnum;
18692        i++, segment++)
18693     {
18694       if (segment->p_type == PT_NOTE)
18695         if (! process_notes_at (filedata, NULL,
18696                                 (bfd_vma) segment->p_offset,
18697                                 (bfd_vma) segment->p_filesz,
18698                                 (bfd_vma) segment->p_align))
18699           res = FALSE;
18700     }
18701
18702   return res;
18703 }
18704
18705 static bfd_boolean
18706 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18707 {
18708   Elf_External_Note * pnotes;
18709   Elf_External_Note * external;
18710   char * end;
18711   bfd_boolean res = TRUE;
18712
18713   if (length <= 0)
18714     return FALSE;
18715
18716   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18717                                            _("v850 notes"));
18718   if (pnotes == NULL)
18719     return FALSE;
18720
18721   external = pnotes;
18722   end = (char*) pnotes + length;
18723
18724   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18725           (unsigned long) offset, (unsigned long) length);
18726
18727   while ((char *) external + sizeof (Elf_External_Note) < end)
18728     {
18729       Elf_External_Note * next;
18730       Elf_Internal_Note inote;
18731
18732       inote.type     = BYTE_GET (external->type);
18733       inote.namesz   = BYTE_GET (external->namesz);
18734       inote.namedata = external->name;
18735       inote.descsz   = BYTE_GET (external->descsz);
18736       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18737       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18738
18739       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18740         {
18741           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18742           inote.descdata = inote.namedata;
18743           inote.namesz   = 0;
18744         }
18745
18746       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18747
18748       if (   ((char *) next > end)
18749           || ((char *) next <  (char *) pnotes))
18750         {
18751           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18752                 (unsigned long) ((char *) external - (char *) pnotes));
18753           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18754                 inote.type, inote.namesz, inote.descsz);
18755           break;
18756         }
18757
18758       external = next;
18759
18760       /* Prevent out-of-bounds indexing.  */
18761       if (   inote.namedata + inote.namesz > end
18762           || inote.namedata + inote.namesz < inote.namedata)
18763         {
18764           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18765                 (unsigned long) ((char *) external - (char *) pnotes));
18766           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18767                 inote.type, inote.namesz, inote.descsz);
18768           break;
18769         }
18770
18771       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18772
18773       if (! print_v850_note (& inote))
18774         {
18775           res = FALSE;
18776           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18777                   inote.namesz, inote.descsz);
18778         }
18779     }
18780
18781   free (pnotes);
18782
18783   return res;
18784 }
18785
18786 static bfd_boolean
18787 process_note_sections (Filedata * filedata)
18788 {
18789   Elf_Internal_Shdr * section;
18790   unsigned long i;
18791   unsigned int n = 0;
18792   bfd_boolean res = TRUE;
18793
18794   for (i = 0, section = filedata->section_headers;
18795        i < filedata->file_header.e_shnum && section != NULL;
18796        i++, section++)
18797     {
18798       if (section->sh_type == SHT_NOTE)
18799         {
18800           if (! process_notes_at (filedata, section,
18801                                   (bfd_vma) section->sh_offset,
18802                                   (bfd_vma) section->sh_size,
18803                                   (bfd_vma) section->sh_addralign))
18804             res = FALSE;
18805           n++;
18806         }
18807
18808       if ((   filedata->file_header.e_machine == EM_V800
18809            || filedata->file_header.e_machine == EM_V850
18810            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18811           && section->sh_type == SHT_RENESAS_INFO)
18812         {
18813           if (! process_v850_notes (filedata,
18814                                     (bfd_vma) section->sh_offset,
18815                                     (bfd_vma) section->sh_size))
18816             res = FALSE;
18817           n++;
18818         }
18819     }
18820
18821   if (n == 0)
18822     /* Try processing NOTE segments instead.  */
18823     return process_corefile_note_segments (filedata);
18824
18825   return res;
18826 }
18827
18828 static bfd_boolean
18829 process_notes (Filedata * filedata)
18830 {
18831   /* If we have not been asked to display the notes then do nothing.  */
18832   if (! do_notes)
18833     return TRUE;
18834
18835   if (filedata->file_header.e_type != ET_CORE)
18836     return process_note_sections (filedata);
18837
18838   /* No program headers means no NOTE segment.  */
18839   if (filedata->file_header.e_phnum > 0)
18840     return process_corefile_note_segments (filedata);
18841
18842   printf (_("No note segments present in the core file.\n"));
18843   return TRUE;
18844 }
18845
18846 static unsigned char *
18847 display_public_gnu_attributes (unsigned char * start,
18848                                const unsigned char * const end)
18849 {
18850   printf (_("  Unknown GNU attribute: %s\n"), start);
18851
18852   start += strnlen ((char *) start, end - start);
18853   display_raw_attribute (start, end);
18854
18855   return (unsigned char *) end;
18856 }
18857
18858 static unsigned char *
18859 display_generic_attribute (unsigned char * start,
18860                            unsigned int tag,
18861                            const unsigned char * const end)
18862 {
18863   if (tag == 0)
18864     return (unsigned char *) end;
18865
18866   return display_tag_value (tag, start, end);
18867 }
18868
18869 static bfd_boolean
18870 process_arch_specific (Filedata * filedata)
18871 {
18872   if (! do_arch)
18873     return TRUE;
18874
18875   switch (filedata->file_header.e_machine)
18876     {
18877     case EM_ARC:
18878     case EM_ARC_COMPACT:
18879     case EM_ARC_COMPACT2:
18880       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18881                                  display_arc_attribute,
18882                                  display_generic_attribute);
18883     case EM_ARM:
18884       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18885                                  display_arm_attribute,
18886                                  display_generic_attribute);
18887
18888     case EM_MIPS:
18889     case EM_MIPS_RS3_LE:
18890       return process_mips_specific (filedata);
18891
18892     case EM_MSP430:
18893      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18894                                 display_msp430x_attribute,
18895                                 display_generic_attribute);
18896
18897     case EM_NDS32:
18898       return process_nds32_specific (filedata);
18899
18900     case EM_PPC:
18901     case EM_PPC64:
18902       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18903                                  display_power_gnu_attribute);
18904
18905     case EM_S390:
18906     case EM_S390_OLD:
18907       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18908                                  display_s390_gnu_attribute);
18909
18910     case EM_SPARC:
18911     case EM_SPARC32PLUS:
18912     case EM_SPARCV9:
18913       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18914                                  display_sparc_gnu_attribute);
18915
18916     case EM_TI_C6000:
18917       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18918                                  display_tic6x_attribute,
18919                                  display_generic_attribute);
18920
18921     default:
18922       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18923                                  display_public_gnu_attributes,
18924                                  display_generic_attribute);
18925     }
18926 }
18927
18928 static bfd_boolean
18929 get_file_header (Filedata * filedata)
18930 {
18931   /* Read in the identity array.  */
18932   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18933     return FALSE;
18934
18935   /* Determine how to read the rest of the header.  */
18936   switch (filedata->file_header.e_ident[EI_DATA])
18937     {
18938     default:
18939     case ELFDATANONE:
18940     case ELFDATA2LSB:
18941       byte_get = byte_get_little_endian;
18942       byte_put = byte_put_little_endian;
18943       break;
18944     case ELFDATA2MSB:
18945       byte_get = byte_get_big_endian;
18946       byte_put = byte_put_big_endian;
18947       break;
18948     }
18949
18950   /* For now we only support 32 bit and 64 bit ELF files.  */
18951   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18952
18953   /* Read in the rest of the header.  */
18954   if (is_32bit_elf)
18955     {
18956       Elf32_External_Ehdr ehdr32;
18957
18958       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18959         return FALSE;
18960
18961       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18962       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18963       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18964       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18965       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18966       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18967       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18968       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18969       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18970       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18971       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18972       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18973       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18974     }
18975   else
18976     {
18977       Elf64_External_Ehdr ehdr64;
18978
18979       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18980          we will not be able to cope with the 64bit data found in
18981          64 ELF files.  Detect this now and abort before we start
18982          overwriting things.  */
18983       if (sizeof (bfd_vma) < 8)
18984         {
18985           error (_("This instance of readelf has been built without support for a\n\
18986 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18987           return FALSE;
18988         }
18989
18990       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18991         return FALSE;
18992
18993       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18994       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18995       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18996       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18997       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18998       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18999       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
19000       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
19001       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19002       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
19003       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19004       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
19005       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
19006     }
19007
19008   if (filedata->file_header.e_shoff)
19009     {
19010       /* There may be some extensions in the first section header.  Don't
19011          bomb if we can't read it.  */
19012       if (is_32bit_elf)
19013         get_32bit_section_headers (filedata, TRUE);
19014       else
19015         get_64bit_section_headers (filedata, TRUE);
19016     }
19017
19018   return TRUE;
19019 }
19020
19021 static void
19022 close_file (Filedata * filedata)
19023 {
19024   if (filedata)
19025     {
19026       if (filedata->handle)
19027         fclose (filedata->handle);
19028       free (filedata);
19029     }
19030 }
19031
19032 void
19033 close_debug_file (void * data)
19034 {
19035   close_file ((Filedata *) data);
19036 }
19037
19038 static Filedata *
19039 open_file (const char * pathname)
19040 {
19041   struct stat  statbuf;
19042   Filedata *   filedata = NULL;
19043
19044   if (stat (pathname, & statbuf) < 0
19045       || ! S_ISREG (statbuf.st_mode))
19046     goto fail;
19047
19048   filedata = calloc (1, sizeof * filedata);
19049   if (filedata == NULL)
19050     goto fail;
19051
19052   filedata->handle = fopen (pathname, "rb");
19053   if (filedata->handle == NULL)
19054     goto fail;
19055
19056   filedata->file_size = (bfd_size_type) statbuf.st_size;
19057   filedata->file_name = pathname;
19058
19059   if (! get_file_header (filedata))
19060     goto fail;
19061
19062   if (filedata->file_header.e_shoff)
19063     {
19064       bfd_boolean res;
19065
19066       /* Read the section headers again, this time for real.  */
19067       if (is_32bit_elf)
19068         res = get_32bit_section_headers (filedata, FALSE);
19069       else
19070         res = get_64bit_section_headers (filedata, FALSE);
19071
19072       if (!res)
19073         goto fail;
19074     }
19075
19076   return filedata;
19077
19078  fail:
19079   if (filedata)
19080     {
19081       if (filedata->handle)
19082         fclose (filedata->handle);
19083       free (filedata);
19084     }
19085   return NULL;
19086 }
19087
19088 void *
19089 open_debug_file (const char * pathname)
19090 {
19091   return open_file (pathname);
19092 }
19093
19094 /* Process one ELF object file according to the command line options.
19095    This file may actually be stored in an archive.  The file is
19096    positioned at the start of the ELF object.  Returns TRUE if no
19097    problems were encountered, FALSE otherwise.  */
19098
19099 static bfd_boolean
19100 process_object (Filedata * filedata)
19101 {
19102   Filedata * separates;
19103   unsigned int i;
19104   bfd_boolean res = TRUE;
19105
19106   if (! get_file_header (filedata))
19107     {
19108       error (_("%s: Failed to read file header\n"), filedata->file_name);
19109       return FALSE;
19110     }
19111
19112   /* Initialise per file variables.  */
19113   for (i = ARRAY_SIZE (version_info); i--;)
19114     version_info[i] = 0;
19115
19116   for (i = ARRAY_SIZE (dynamic_info); i--;)
19117     dynamic_info[i] = 0;
19118   dynamic_info_DT_GNU_HASH = 0;
19119
19120   /* Process the file.  */
19121   if (show_name)
19122     printf (_("\nFile: %s\n"), filedata->file_name);
19123
19124   /* Initialise the dump_sects array from the cmdline_dump_sects array.
19125      Note we do this even if cmdline_dump_sects is empty because we
19126      must make sure that the dump_sets array is zeroed out before each
19127      object file is processed.  */
19128   if (filedata->num_dump_sects > cmdline.num_dump_sects)
19129     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19130
19131   if (cmdline.num_dump_sects > 0)
19132     {
19133       if (filedata->num_dump_sects == 0)
19134         /* A sneaky way of allocating the dump_sects array.  */
19135         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19136
19137       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19138       memcpy (filedata->dump_sects, cmdline.dump_sects,
19139               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19140     }
19141
19142   if (! process_file_header (filedata))
19143     return FALSE;
19144
19145   if (! process_section_headers (filedata))
19146     {
19147       /* Without loaded section headers we cannot process lots of things.  */
19148       do_unwind = do_version = do_dump = do_arch = FALSE;
19149
19150       if (! do_using_dynamic)
19151         do_syms = do_dyn_syms = do_reloc = FALSE;
19152     }
19153
19154   if (! process_section_groups (filedata))
19155     /* Without loaded section groups we cannot process unwind.  */
19156     do_unwind = FALSE;
19157
19158   if (process_program_headers (filedata))
19159     process_dynamic_section (filedata);
19160   else
19161     res = FALSE;
19162
19163   if (! process_relocs (filedata))
19164     res = FALSE;
19165
19166   if (! process_unwind (filedata))
19167     res = FALSE;
19168
19169   if (! process_symbol_table (filedata))
19170     res = FALSE;
19171
19172   if (! process_syminfo (filedata))
19173     res = FALSE;
19174
19175   if (! process_version_sections (filedata))
19176     res = FALSE;
19177
19178   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19179     separates = load_separate_debug_file (filedata, filedata->file_name);
19180   else
19181     separates = NULL;
19182
19183   if (! process_section_contents (filedata))
19184     res = FALSE;
19185
19186   if (separates)
19187     {
19188       if (! process_section_headers (separates))
19189         res = FALSE;
19190       else if (! process_section_contents (separates))
19191         res = FALSE;
19192     }
19193
19194   if (! process_notes (filedata))
19195     res = FALSE;
19196
19197   if (! process_gnu_liblist (filedata))
19198     res = FALSE;
19199
19200   if (! process_arch_specific (filedata))
19201     res = FALSE;
19202
19203   free (filedata->program_headers);
19204   filedata->program_headers = NULL;
19205
19206   free (filedata->section_headers);
19207   filedata->section_headers = NULL;
19208
19209   free (filedata->string_table);
19210   filedata->string_table = NULL;
19211   filedata->string_table_length = 0;
19212
19213   if (dynamic_strings)
19214     {
19215       free (dynamic_strings);
19216       dynamic_strings = NULL;
19217       dynamic_strings_length = 0;
19218     }
19219
19220   if (dynamic_symbols)
19221     {
19222       free (dynamic_symbols);
19223       dynamic_symbols = NULL;
19224       num_dynamic_syms = 0;
19225     }
19226
19227   if (dynamic_syminfo)
19228     {
19229       free (dynamic_syminfo);
19230       dynamic_syminfo = NULL;
19231     }
19232
19233   if (dynamic_section)
19234     {
19235       free (dynamic_section);
19236       dynamic_section = NULL;
19237     }
19238
19239   if (section_headers_groups)
19240     {
19241       free (section_headers_groups);
19242       section_headers_groups = NULL;
19243     }
19244
19245   if (section_groups)
19246     {
19247       struct group_list * g;
19248       struct group_list * next;
19249
19250       for (i = 0; i < group_count; i++)
19251         {
19252           for (g = section_groups [i].root; g != NULL; g = next)
19253             {
19254               next = g->next;
19255               free (g);
19256             }
19257         }
19258
19259       free (section_groups);
19260       section_groups = NULL;
19261     }
19262
19263   free_debug_memory ();
19264
19265   return res;
19266 }
19267
19268 /* Process an ELF archive.
19269    On entry the file is positioned just after the ARMAG string.
19270    Returns TRUE upon success, FALSE otherwise.  */
19271
19272 static bfd_boolean
19273 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19274 {
19275   struct archive_info arch;
19276   struct archive_info nested_arch;
19277   size_t got;
19278   bfd_boolean ret = TRUE;
19279
19280   show_name = TRUE;
19281
19282   /* The ARCH structure is used to hold information about this archive.  */
19283   arch.file_name = NULL;
19284   arch.file = NULL;
19285   arch.index_array = NULL;
19286   arch.sym_table = NULL;
19287   arch.longnames = NULL;
19288
19289   /* The NESTED_ARCH structure is used as a single-item cache of information
19290      about a nested archive (when members of a thin archive reside within
19291      another regular archive file).  */
19292   nested_arch.file_name = NULL;
19293   nested_arch.file = NULL;
19294   nested_arch.index_array = NULL;
19295   nested_arch.sym_table = NULL;
19296   nested_arch.longnames = NULL;
19297
19298   if (setup_archive (&arch, filedata->file_name, filedata->handle,
19299                      is_thin_archive, do_archive_index) != 0)
19300     {
19301       ret = FALSE;
19302       goto out;
19303     }
19304
19305   if (do_archive_index)
19306     {
19307       if (arch.sym_table == NULL)
19308         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19309       else
19310         {
19311           unsigned long i, l;
19312           unsigned long current_pos;
19313
19314           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19315                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19316
19317           current_pos = ftell (filedata->handle);
19318
19319           for (i = l = 0; i < arch.index_num; i++)
19320             {
19321               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19322                 {
19323                   char * member_name;
19324
19325                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19326
19327                   if (member_name != NULL)
19328                     {
19329                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19330
19331                       if (qualified_name != NULL)
19332                         {
19333                           printf (_("Contents of binary %s at offset "), qualified_name);
19334                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
19335                           putchar ('\n');
19336                           free (qualified_name);
19337                         }
19338                     }
19339                 }
19340
19341               if (l >= arch.sym_size)
19342                 {
19343                   error (_("%s: end of the symbol table reached before the end of the index\n"),
19344                          filedata->file_name);
19345                   ret = FALSE;
19346                   break;
19347                 }
19348               /* PR 17531: file: 0b6630b2.  */
19349               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19350               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19351             }
19352
19353           if (arch.uses_64bit_indices)
19354             l = (l + 7) & ~ 7;
19355           else
19356             l += l & 1;
19357
19358           if (l < arch.sym_size)
19359             {
19360               error (ngettext ("%s: %ld byte remains in the symbol table, "
19361                                "but without corresponding entries in "
19362                                "the index table\n",
19363                                "%s: %ld bytes remain in the symbol table, "
19364                                "but without corresponding entries in "
19365                                "the index table\n",
19366                                arch.sym_size - l),
19367                      filedata->file_name, arch.sym_size - l);
19368               ret = FALSE;
19369             }
19370
19371           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19372             {
19373               error (_("%s: failed to seek back to start of object files in the archive\n"),
19374                      filedata->file_name);
19375               ret = FALSE;
19376               goto out;
19377             }
19378         }
19379
19380       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19381           && !do_segments && !do_header && !do_dump && !do_version
19382           && !do_histogram && !do_debugging && !do_arch && !do_notes
19383           && !do_section_groups && !do_dyn_syms)
19384         {
19385           ret = TRUE; /* Archive index only.  */
19386           goto out;
19387         }
19388     }
19389
19390   while (1)
19391     {
19392       char * name;
19393       size_t namelen;
19394       char * qualified_name;
19395
19396       /* Read the next archive header.  */
19397       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19398         {
19399           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
19400           return FALSE;
19401         }
19402       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19403       if (got != sizeof arch.arhdr)
19404         {
19405           if (got == 0)
19406             break;
19407           error (_("%s: failed to read archive header\n"), filedata->file_name);
19408           ret = FALSE;
19409           break;
19410         }
19411       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19412         {
19413           error (_("%s: did not find a valid archive header\n"), arch.file_name);
19414           ret = FALSE;
19415           break;
19416         }
19417
19418       arch.next_arhdr_offset += sizeof arch.arhdr;
19419
19420       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19421       if (archive_file_size & 01)
19422         ++archive_file_size;
19423
19424       name = get_archive_member_name (&arch, &nested_arch);
19425       if (name == NULL)
19426         {
19427           error (_("%s: bad archive file name\n"), filedata->file_name);
19428           ret = FALSE;
19429           break;
19430         }
19431       namelen = strlen (name);
19432
19433       qualified_name = make_qualified_name (&arch, &nested_arch, name);
19434       if (qualified_name == NULL)
19435         {
19436           error (_("%s: bad archive file name\n"), filedata->file_name);
19437           ret = FALSE;
19438           break;
19439         }
19440
19441       if (is_thin_archive && arch.nested_member_origin == 0)
19442         {
19443           /* This is a proxy for an external member of a thin archive.  */
19444           Filedata * member_filedata;
19445           char * member_file_name = adjust_relative_path
19446             (filedata->file_name, name, namelen);
19447
19448           if (member_file_name == NULL)
19449             {
19450               ret = FALSE;
19451               break;
19452             }
19453
19454           member_filedata = open_file (member_file_name);
19455           if (member_filedata == NULL)
19456             {
19457               error (_("Input file '%s' is not readable.\n"), member_file_name);
19458               free (member_file_name);
19459               ret = FALSE;
19460               break;
19461             }
19462
19463           archive_file_offset = arch.nested_member_origin;
19464           member_filedata->file_name = qualified_name;
19465
19466           if (! process_object (member_filedata))
19467             ret = FALSE;
19468
19469           close_file (member_filedata);
19470           free (member_file_name);
19471         }
19472       else if (is_thin_archive)
19473         {
19474           Filedata thin_filedata;
19475
19476           memset (&thin_filedata, 0, sizeof (thin_filedata));
19477
19478           /* PR 15140: Allow for corrupt thin archives.  */
19479           if (nested_arch.file == NULL)
19480             {
19481               error (_("%s: contains corrupt thin archive: %s\n"),
19482                      filedata->file_name, name);
19483               ret = FALSE;
19484               break;
19485             }
19486
19487           /* This is a proxy for a member of a nested archive.  */
19488           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19489
19490           /* The nested archive file will have been opened and setup by
19491              get_archive_member_name.  */
19492           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19493             {
19494               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19495               ret = FALSE;
19496               break;
19497             }
19498
19499           thin_filedata.handle = nested_arch.file;
19500           thin_filedata.file_name = qualified_name;
19501
19502           if (! process_object (& thin_filedata))
19503             ret = FALSE;
19504         }
19505       else
19506         {
19507           archive_file_offset = arch.next_arhdr_offset;
19508           arch.next_arhdr_offset += archive_file_size;
19509
19510           filedata->file_name = qualified_name;
19511           if (! process_object (filedata))
19512             ret = FALSE;
19513         }
19514
19515       if (filedata->dump_sects != NULL)
19516         {
19517           free (filedata->dump_sects);
19518           filedata->dump_sects = NULL;
19519           filedata->num_dump_sects = 0;
19520         }
19521
19522       free (qualified_name);
19523     }
19524
19525  out:
19526   if (nested_arch.file != NULL)
19527     fclose (nested_arch.file);
19528   release_archive (&nested_arch);
19529   release_archive (&arch);
19530
19531   return ret;
19532 }
19533
19534 static bfd_boolean
19535 process_file (char * file_name)
19536 {
19537   Filedata * filedata = NULL;
19538   struct stat statbuf;
19539   char armag[SARMAG];
19540   bfd_boolean ret = TRUE;
19541
19542   if (stat (file_name, &statbuf) < 0)
19543     {
19544       if (errno == ENOENT)
19545         error (_("'%s': No such file\n"), file_name);
19546       else
19547         error (_("Could not locate '%s'.  System error message: %s\n"),
19548                file_name, strerror (errno));
19549       return FALSE;
19550     }
19551
19552   if (! S_ISREG (statbuf.st_mode))
19553     {
19554       error (_("'%s' is not an ordinary file\n"), file_name);
19555       return FALSE;
19556     }
19557
19558   filedata = calloc (1, sizeof * filedata);
19559   if (filedata == NULL)
19560     {
19561       error (_("Out of memory allocating file data structure\n"));
19562       return FALSE;
19563     }
19564
19565   filedata->file_name = file_name;
19566   filedata->handle = fopen (file_name, "rb");
19567   if (filedata->handle == NULL)
19568     {
19569       error (_("Input file '%s' is not readable.\n"), file_name);
19570       free (filedata);
19571       return FALSE;
19572     }
19573
19574   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19575     {
19576       error (_("%s: Failed to read file's magic number\n"), file_name);
19577       fclose (filedata->handle);
19578       free (filedata);
19579       return FALSE;
19580     }
19581
19582   filedata->file_size = (bfd_size_type) statbuf.st_size;
19583
19584   if (memcmp (armag, ARMAG, SARMAG) == 0)
19585     {
19586       if (! process_archive (filedata, FALSE))
19587         ret = FALSE;
19588     }
19589   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19590     {
19591       if ( ! process_archive (filedata, TRUE))
19592         ret = FALSE;
19593     }
19594   else
19595     {
19596       if (do_archive_index)
19597         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19598                file_name);
19599
19600       rewind (filedata->handle);
19601       archive_file_size = archive_file_offset = 0;
19602
19603       if (! process_object (filedata))
19604         ret = FALSE;
19605     }
19606
19607   fclose (filedata->handle);
19608   free (filedata);
19609
19610   return ret;
19611 }
19612
19613 #ifdef SUPPORT_DISASSEMBLY
19614 /* Needed by the i386 disassembler.  For extra credit, someone could
19615    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19616    symbols.  */
19617
19618 void
19619 print_address (unsigned int addr, FILE * outfile)
19620 {
19621   fprintf (outfile,"0x%8.8x", addr);
19622 }
19623
19624 /* Needed by the i386 disassembler.  */
19625
19626 void
19627 db_task_printsym (unsigned int addr)
19628 {
19629   print_address (addr, stderr);
19630 }
19631 #endif
19632
19633 int
19634 main (int argc, char ** argv)
19635 {
19636   int err;
19637
19638 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19639   setlocale (LC_MESSAGES, "");
19640 #endif
19641 #if defined (HAVE_SETLOCALE)
19642   setlocale (LC_CTYPE, "");
19643 #endif
19644   bindtextdomain (PACKAGE, LOCALEDIR);
19645   textdomain (PACKAGE);
19646
19647   expandargv (&argc, &argv);
19648
19649   cmdline.file_name = "<cmdline>";
19650   parse_args (& cmdline, argc, argv);
19651
19652   if (optind < (argc - 1))
19653     show_name = TRUE;
19654   else if (optind >= argc)
19655     {
19656       warn (_("Nothing to do.\n"));
19657       usage (stderr);
19658     }
19659
19660   err = FALSE;
19661   while (optind < argc)
19662     if (! process_file (argv[optind++]))
19663       err = TRUE;
19664
19665   if (cmdline.dump_sects != NULL)
19666     free (cmdline.dump_sects);
19667
19668   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19669 }