binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2018 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #include <zlib.h>
  47 #ifdef HAVE_WCHAR_H
  48 #include <wchar.h>
  49 #endif
  50
  51 #if __GNUC__ >= 2
  52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  53    as this will allow us to read in and parse 64bit and 32bit ELF files.
  54    Only do this if we believe that the compiler can support a 64 bit
  55    data type.  For now we only rely on GCC being able to do this.  */
  56 #define BFD64
  57 #endif
  58
  59 #include "bfd.h"
  60 #include "bucomm.h"
  61 #include "elfcomm.h"
  62 #include "dwarf.h"
  63
  64 #include "elf/common.h"
  65 #include "elf/external.h"
  66 #include "elf/internal.h"
  67
  68
  69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  70    we can obtain the H8 reloc numbers.  We need these for the
  71    get_reloc_size() function.  We include h8.h again after defining
  72    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  73
  74 #include "elf/h8.h"
  75 #undef _ELF_H8_H
  76
  77 /* Undo the effects of #including reloc-macros.h.  */
  78
  79 #undef START_RELOC_NUMBERS
  80 #undef RELOC_NUMBER
  81 #undef FAKE_RELOC
  82 #undef EMPTY_RELOC
  83 #undef END_RELOC_NUMBERS
  84 #undef _RELOC_MACROS_H
  85
  86 /* The following headers use the elf/reloc-macros.h file to
  87    automatically generate relocation recognition functions
  88    such as elf_mips_reloc_type()  */
  89
  90 #define RELOC_MACROS_GEN_FUNC
  91
  92 #include "elf/aarch64.h"
  93 #include "elf/alpha.h"
  94 #include "elf/arc.h"
  95 #include "elf/arm.h"
  96 #include "elf/avr.h"
  97 #include "elf/bfin.h"
  98 #include "elf/cr16.h"
  99 #include "elf/cris.h"
 100 #include "elf/crx.h"
 101 #include "elf/d10v.h"
 102 #include "elf/d30v.h"
 103 #include "elf/dlx.h"
 104 #include "elf/epiphany.h"
 105 #include "elf/fr30.h"
 106 #include "elf/frv.h"
 107 #include "elf/ft32.h"
 108 #include "elf/h8.h"
 109 #include "elf/hppa.h"
 110 #include "elf/i386.h"
 111 #include "elf/i370.h"
 112 #include "elf/i860.h"
 113 #include "elf/i960.h"
 114 #include "elf/ia64.h"
 115 #include "elf/ip2k.h"
 116 #include "elf/lm32.h"
 117 #include "elf/iq2000.h"
 118 #include "elf/m32c.h"
 119 #include "elf/m32r.h"
 120 #include "elf/m68k.h"
 121 #include "elf/m68hc11.h"
 122 #include "elf/mcore.h"
 123 #include "elf/mep.h"
 124 #include "elf/metag.h"
 125 #include "elf/microblaze.h"
 126 #include "elf/mips.h"
 127 #include "elf/mmix.h"
 128 #include "elf/mn10200.h"
 129 #include "elf/mn10300.h"
 130 #include "elf/moxie.h"
 131 #include "elf/mt.h"
 132 #include "elf/msp430.h"
 133 #include "elf/nds32.h"
 134 #include "elf/nios2.h"
 135 #include "elf/or1k.h"
 136 #include "elf/pj.h"
 137 #include "elf/ppc.h"
 138 #include "elf/ppc64.h"
 139 #include "elf/pru.h"
 140 #include "elf/riscv.h"
 141 #include "elf/rl78.h"
 142 #include "elf/rx.h"
 143 #include "elf/s390.h"
 144 #include "elf/score.h"
 145 #include "elf/sh.h"
 146 #include "elf/sparc.h"
 147 #include "elf/spu.h"
 148 #include "elf/tic6x.h"
 149 #include "elf/tilegx.h"
 150 #include "elf/tilepro.h"
 151 #include "elf/v850.h"
 152 #include "elf/vax.h"
 153 #include "elf/visium.h"
 154 #include "elf/wasm32.h"
 155 #include "elf/x86-64.h"
 156 #include "elf/xc16x.h"
 157 #include "elf/xgate.h"
 158 #include "elf/xstormy16.h"
 159 #include "elf/xtensa.h"
 160
 161 #include "getopt.h"
 162 #include "libiberty.h"
 163 #include "safe-ctype.h"
 164 #include "filenames.h"
 165
 166 #ifndef offsetof
 167 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 168 #endif
 169
 170 typedef struct elf_section_list
 171 {
 172   Elf_Internal_Shdr *        hdr;
 173   struct elf_section_list *  next;
 174 } elf_section_list;
 175
 176 /* Flag bits indicating particular types of dump.  */
 177 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 178 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 179 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 180 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 181 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 182
 183 typedef unsigned char dump_type;
 184
 185 /* A linked list of the section names for which dumps were requested.  */
 186 struct dump_list_entry
 187 {
 188   char *                    name;
 189   dump_type                 type;
 190   struct dump_list_entry *  next;
 191 };
 192
 193 typedef struct filedata
 194 {
 195   const char *         file_name;
 196   FILE *               handle;
 197   bfd_size_type        file_size;
 198   Elf_Internal_Ehdr    file_header;
 199   Elf_Internal_Shdr *  section_headers;
 200   Elf_Internal_Phdr *  program_headers;
 201   char *               string_table;
 202   unsigned long        string_table_length;
 203   /* A dynamic array of flags indicating for which sections a dump of
 204      some kind has been requested.  It is reset on a per-object file
 205      basis and then initialised from the cmdline_dump_sects array,
 206      the results of interpreting the -w switch, and the
 207      dump_sects_byname list.  */
 208   dump_type *          dump_sects;
 209   unsigned int         num_dump_sects;
 210 } Filedata;
 211
 212 char * program_name = "readelf";
 213
 214 static unsigned long archive_file_offset;
 215 static unsigned long archive_file_size;
 216 static unsigned long dynamic_addr;
 217 static bfd_size_type dynamic_size;
 218 static size_t dynamic_nent;
 219 static char * dynamic_strings;
 220 static unsigned long dynamic_strings_length;
 221 static unsigned long num_dynamic_syms;
 222 static Elf_Internal_Sym * dynamic_symbols;
 223 static Elf_Internal_Syminfo * dynamic_syminfo;
 224 static unsigned long dynamic_syminfo_offset;
 225 static unsigned int dynamic_syminfo_nent;
 226 static char program_interpreter[PATH_MAX];
 227 static bfd_vma dynamic_info[DT_ENCODING];
 228 static bfd_vma dynamic_info_DT_GNU_HASH;
 229 static bfd_vma version_info[16];
 230 static Elf_Internal_Dyn *  dynamic_section;
 231 static elf_section_list * symtab_shndx_list;
 232 static bfd_boolean show_name = FALSE;
 233 static bfd_boolean do_dynamic = FALSE;
 234 static bfd_boolean do_syms = FALSE;
 235 static bfd_boolean do_dyn_syms = FALSE;
 236 static bfd_boolean do_reloc = FALSE;
 237 static bfd_boolean do_sections = FALSE;
 238 static bfd_boolean do_section_groups = FALSE;
 239 static bfd_boolean do_section_details = FALSE;
 240 static bfd_boolean do_segments = FALSE;
 241 static bfd_boolean do_unwind = FALSE;
 242 static bfd_boolean do_using_dynamic = FALSE;
 243 static bfd_boolean do_header = FALSE;
 244 static bfd_boolean do_dump = FALSE;
 245 static bfd_boolean do_version = FALSE;
 246 static bfd_boolean do_histogram = FALSE;
 247 static bfd_boolean do_debugging = FALSE;
 248 static bfd_boolean do_arch = FALSE;
 249 static bfd_boolean do_notes = FALSE;
 250 static bfd_boolean do_archive_index = FALSE;
 251 static bfd_boolean is_32bit_elf = FALSE;
 252 static bfd_boolean decompress_dumps = FALSE;
 253
 254 struct group_list
 255 {
 256   struct group_list *  next;
 257   unsigned int         section_index;
 258 };
 259
 260 struct group
 261 {
 262   struct group_list *  root;
 263   unsigned int         group_index;
 264 };
 265
 266 static size_t           group_count;
 267 static struct group *   section_groups;
 268 static struct group **  section_headers_groups;
 269
 270 /* A dynamic array of flags indicating for which sections a dump
 271    has been requested via command line switches.  */
 272 static Filedata         cmdline;
 273
 274 static struct dump_list_entry * dump_sects_byname;
 275
 276 /* How to print a vma value.  */
 277 typedef enum print_mode
 278 {
 279   HEX,
 280   DEC,
 281   DEC_5,
 282   UNSIGNED,
 283   PREFIX_HEX,
 284   FULL_HEX,
 285   LONG_HEX
 286 }
 287 print_mode;
 288
 289 /* Versioned symbol info.  */
 290 enum versioned_symbol_info
 291 {
 292   symbol_undefined,
 293   symbol_hidden,
 294   symbol_public
 295 };
 296
 297 static const char * get_symbol_version_string
 298   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 299    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 300
 301 #define UNKNOWN -1
 302
 303 #define SECTION_NAME(X)                                         \
 304   ((X) == NULL ? _("<none>")                                    \
 305    : filedata->string_table == NULL ? _("<no-strings>")         \
 306    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 307   : filedata->string_table + (X)->sh_name))
 308
 309 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 310
 311 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 312   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 313    : get_64bit_elf_symbols (file, section, sym_count))
 314
 315 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 316 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 317    already been called and verified that the string exists.  */
 318 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 319
 320 #define REMOVE_ARCH_BITS(ADDR)                  \
 321   do                                            \
 322     {                                           \
 323       if (filedata->file_header.e_machine == EM_ARM)    \
 324         (ADDR) &= ~1;                           \
 325     }                                           \
 326   while (0)
 327 \f
 328 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 329    BFD_FMA_FMT can't be used in translated strings.  */
 330
 331 static const char *
 332 bfd_vmatoa (char *fmtch, bfd_vma value)
 333 {
 334   /* bfd_vmatoa is used more then once in a printf call for output.
 335      Cycle through an array of buffers.  */
 336   static int buf_pos = 0;
 337   static struct bfd_vmatoa_buf
 338   {
 339     char place[64];
 340   } buf[4];
 341   char *ret;
 342   char fmt[32];
 343
 344   ret = buf[buf_pos++].place;
 345   buf_pos %= ARRAY_SIZE (buf);
 346
 347   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 348   snprintf (ret, sizeof (buf[0].place), fmt, value);
 349   return ret;
 350 }
 351
 352 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 353    OFFSET + the offset of the current archive member, if we are examining an
 354    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 355    allocate a buffer using malloc and fill that.  In either case return the
 356    pointer to the start of the retrieved data or NULL if something went wrong.
 357    If something does go wrong and REASON is not NULL then emit an error
 358    message using REASON as part of the context.  */
 359
 360 static void *
 361 get_data (void *         var,
 362           Filedata *     filedata,
 363           unsigned long  offset,
 364           bfd_size_type  size,
 365           bfd_size_type  nmemb,
 366           const char *   reason)
 367 {
 368   void * mvar;
 369   bfd_size_type amt = size * nmemb;
 370
 371   if (size == 0 || nmemb == 0)
 372     return NULL;
 373
 374   /* If the size_t type is smaller than the bfd_size_type, eg because
 375      you are building a 32-bit tool on a 64-bit host, then make sure
 376      that when the sizes are cast to (size_t) no information is lost.  */
 377   if (sizeof (size_t) < sizeof (bfd_size_type)
 378       && (   (bfd_size_type) ((size_t) size) != size
 379           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 380     {
 381       if (reason)
 382         error (_("Size truncation prevents reading %s"
 383                  " elements of size %s for %s\n"),
 384                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 385       return NULL;
 386     }
 387
 388   /* Check for size overflow.  */
 389   if (amt < nmemb)
 390     {
 391       if (reason)
 392         error (_("Size overflow prevents reading %s"
 393                  " elements of size %s for %s\n"),
 394                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 395       return NULL;
 396     }
 397
 398   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 399      attempting to allocate memory when the read is bound to fail.  */
 400   if (amt > filedata->file_size
 401       || offset + archive_file_offset + amt > filedata->file_size)
 402     {
 403       if (reason)
 404         error (_("Reading %s bytes extends past end of file for %s\n"),
 405                bfd_vmatoa ("u", amt), reason);
 406       return NULL;
 407     }
 408
 409   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 410     {
 411       if (reason)
 412         error (_("Unable to seek to 0x%lx for %s\n"),
 413                archive_file_offset + offset, reason);
 414       return NULL;
 415     }
 416
 417   mvar = var;
 418   if (mvar == NULL)
 419     {
 420       /* Check for overflow.  */
 421       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 422         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 423         mvar = malloc ((size_t) amt + 1);
 424
 425       if (mvar == NULL)
 426         {
 427           if (reason)
 428             error (_("Out of memory allocating %s bytes for %s\n"),
 429                    bfd_vmatoa ("u", amt), reason);
 430           return NULL;
 431         }
 432
 433       ((char *) mvar)[amt] = '\0';
 434     }
 435
 436   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 437     {
 438       if (reason)
 439         error (_("Unable to read in %s bytes of %s\n"),
 440                bfd_vmatoa ("u", amt), reason);
 441       if (mvar != var)
 442         free (mvar);
 443       return NULL;
 444     }
 445
 446   return mvar;
 447 }
 448
 449 /* Print a VMA value in the MODE specified.
 450    Returns the number of characters displayed.  */
 451
 452 static unsigned int
 453 print_vma (bfd_vma vma, print_mode mode)
 454 {
 455   unsigned int nc = 0;
 456
 457   switch (mode)
 458     {
 459     case FULL_HEX:
 460       nc = printf ("0x");
 461       /* Fall through.  */
 462     case LONG_HEX:
 463 #ifdef BFD64
 464       if (is_32bit_elf)
 465         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 466 #endif
 467       printf_vma (vma);
 468       return nc + 16;
 469
 470     case DEC_5:
 471       if (vma <= 99999)
 472         return printf ("%5" BFD_VMA_FMT "d", vma);
 473       /* Fall through.  */
 474     case PREFIX_HEX:
 475       nc = printf ("0x");
 476       /* Fall through.  */
 477     case HEX:
 478       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 479
 480     case DEC:
 481       return printf ("%" BFD_VMA_FMT "d", vma);
 482
 483     case UNSIGNED:
 484       return printf ("%" BFD_VMA_FMT "u", vma);
 485
 486     default:
 487       /* FIXME: Report unrecognised mode ?  */
 488       return 0;
 489     }
 490 }
 491
 492 /* Display a symbol on stdout.  Handles the display of control characters and
 493    multibye characters (assuming the host environment supports them).
 494
 495    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 496
 497    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 498    padding as necessary.
 499
 500    Returns the number of emitted characters.  */
 501
 502 static unsigned int
 503 print_symbol (signed int width, const char *symbol)
 504 {
 505   bfd_boolean extra_padding = FALSE;
 506   signed int num_printed = 0;
 507 #ifdef HAVE_MBSTATE_T
 508   mbstate_t state;
 509 #endif
 510   unsigned int width_remaining;
 511
 512   if (width < 0)
 513     {
 514       /* Keep the width positive.  This helps the code below.  */
 515       width = - width;
 516       extra_padding = TRUE;
 517     }
 518   else if (width == 0)
 519     return 0;
 520
 521   if (do_wide)
 522     /* Set the remaining width to a very large value.
 523        This simplifies the code below.  */
 524     width_remaining = INT_MAX;
 525   else
 526     width_remaining = width;
 527
 528 #ifdef HAVE_MBSTATE_T
 529   /* Initialise the multibyte conversion state.  */
 530   memset (& state, 0, sizeof (state));
 531 #endif
 532
 533   while (width_remaining)
 534     {
 535       size_t  n;
 536       const char c = *symbol++;
 537
 538       if (c == 0)
 539         break;
 540
 541       /* Do not print control characters directly as they can affect terminal
 542          settings.  Such characters usually appear in the names generated
 543          by the assembler for local labels.  */
 544       if (ISCNTRL (c))
 545         {
 546           if (width_remaining < 2)
 547             break;
 548
 549           printf ("^%c", c + 0x40);
 550           width_remaining -= 2;
 551           num_printed += 2;
 552         }
 553       else if (ISPRINT (c))
 554         {
 555           putchar (c);
 556           width_remaining --;
 557           num_printed ++;
 558         }
 559       else
 560         {
 561 #ifdef HAVE_MBSTATE_T
 562           wchar_t w;
 563 #endif
 564           /* Let printf do the hard work of displaying multibyte characters.  */
 565           printf ("%.1s", symbol - 1);
 566           width_remaining --;
 567           num_printed ++;
 568
 569 #ifdef HAVE_MBSTATE_T
 570           /* Try to find out how many bytes made up the character that was
 571              just printed.  Advance the symbol pointer past the bytes that
 572              were displayed.  */
 573           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 574 #else
 575           n = 1;
 576 #endif
 577           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 578             symbol += (n - 1);
 579         }
 580     }
 581
 582   if (extra_padding && num_printed < width)
 583     {
 584       /* Fill in the remaining spaces.  */
 585       printf ("%-*s", width - num_printed, " ");
 586       num_printed = width;
 587     }
 588
 589   return num_printed;
 590 }
 591
 592 /* Returns a pointer to a static buffer containing a printable version of
 593    the given section's name.  Like print_symbol, except that it does not try
 594    to print multibyte characters, it just interprets them as hex values.  */
 595
 596 static const char *
 597 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 598 {
 599 #define MAX_PRINT_SEC_NAME_LEN 128
 600   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 601   const char * name = SECTION_NAME (sec);
 602   char *       buf = sec_name_buf;
 603   char         c;
 604   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 605
 606   while ((c = * name ++) != 0)
 607     {
 608       if (ISCNTRL (c))
 609         {
 610           if (remaining < 2)
 611             break;
 612
 613           * buf ++ = '^';
 614           * buf ++ = c + 0x40;
 615           remaining -= 2;
 616         }
 617       else if (ISPRINT (c))
 618         {
 619           * buf ++ = c;
 620           remaining -= 1;
 621         }
 622       else
 623         {
 624           static char hex[17] = "0123456789ABCDEF";
 625
 626           if (remaining < 4)
 627             break;
 628           * buf ++ = '<';
 629           * buf ++ = hex[(c & 0xf0) >> 4];
 630           * buf ++ = hex[c & 0x0f];
 631           * buf ++ = '>';
 632           remaining -= 4;
 633         }
 634
 635       if (remaining == 0)
 636         break;
 637     }
 638
 639   * buf = 0;
 640   return sec_name_buf;
 641 }
 642
 643 static const char *
 644 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 645 {
 646   if (ndx >= filedata->file_header.e_shnum)
 647     return _("<corrupt>");
 648
 649   return printable_section_name (filedata, filedata->section_headers + ndx);
 650 }
 651
 652 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 653
 654 static Elf_Internal_Shdr *
 655 find_section (Filedata * filedata, const char * name)
 656 {
 657   unsigned int i;
 658
 659   if (filedata->section_headers == NULL)
 660     return NULL;
 661
 662   for (i = 0; i < filedata->file_header.e_shnum; i++)
 663     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 664       return filedata->section_headers + i;
 665
 666   return NULL;
 667 }
 668
 669 /* Return a pointer to a section containing ADDR, or NULL if no such
 670    section exists.  */
 671
 672 static Elf_Internal_Shdr *
 673 find_section_by_address (Filedata * filedata, bfd_vma addr)
 674 {
 675   unsigned int i;
 676
 677   if (filedata->section_headers == NULL)
 678     return NULL;
 679
 680   for (i = 0; i < filedata->file_header.e_shnum; i++)
 681     {
 682       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 683
 684       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 685         return sec;
 686     }
 687
 688   return NULL;
 689 }
 690
 691 static Elf_Internal_Shdr *
 692 find_section_by_type (Filedata * filedata, unsigned int type)
 693 {
 694   unsigned int i;
 695
 696   if (filedata->section_headers == NULL)
 697     return NULL;
 698
 699   for (i = 0; i < filedata->file_header.e_shnum; i++)
 700     {
 701       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 702
 703       if (sec->sh_type == type)
 704         return sec;
 705     }
 706
 707   return NULL;
 708 }
 709
 710 /* Return a pointer to section NAME, or NULL if no such section exists,
 711    restricted to the list of sections given in SET.  */
 712
 713 static Elf_Internal_Shdr *
 714 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 715 {
 716   unsigned int i;
 717
 718   if (filedata->section_headers == NULL)
 719     return NULL;
 720
 721   if (set != NULL)
 722     {
 723       while ((i = *set++) > 0)
 724         {
 725           /* See PR 21156 for a reproducer.  */
 726           if (i >= filedata->file_header.e_shnum)
 727             continue; /* FIXME: Should we issue an error message ?  */
 728
 729           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 730             return filedata->section_headers + i;
 731         }
 732     }
 733
 734   return find_section (filedata, name);
 735 }
 736
 737 /* Read an unsigned LEB128 encoded value from DATA.
 738    Set *LENGTH_RETURN to the number of bytes read.  */
 739
 740 static inline unsigned long
 741 read_uleb128 (unsigned char * data,
 742               unsigned int * length_return,
 743               const unsigned char * const end)
 744 {
 745   return read_leb128 (data, length_return, FALSE, end);
 746 }
 747
 748 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 749    This OS has so many departures from the ELF standard that we test it at
 750    many places.  */
 751
 752 static inline bfd_boolean
 753 is_ia64_vms (Filedata * filedata)
 754 {
 755   return filedata->file_header.e_machine == EM_IA_64
 756     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 757 }
 758
 759 /* Guess the relocation size commonly used by the specific machines.  */
 760
 761 static bfd_boolean
 762 guess_is_rela (unsigned int e_machine)
 763 {
 764   switch (e_machine)
 765     {
 766       /* Targets that use REL relocations.  */
 767     case EM_386:
 768     case EM_IAMCU:
 769     case EM_960:
 770     case EM_ARM:
 771     case EM_D10V:
 772     case EM_CYGNUS_D10V:
 773     case EM_DLX:
 774     case EM_MIPS:
 775     case EM_MIPS_RS3_LE:
 776     case EM_CYGNUS_M32R:
 777     case EM_SCORE:
 778     case EM_XGATE:
 779       return FALSE;
 780
 781       /* Targets that use RELA relocations.  */
 782     case EM_68K:
 783     case EM_860:
 784     case EM_AARCH64:
 785     case EM_ADAPTEVA_EPIPHANY:
 786     case EM_ALPHA:
 787     case EM_ALTERA_NIOS2:
 788     case EM_ARC:
 789     case EM_ARC_COMPACT:
 790     case EM_ARC_COMPACT2:
 791     case EM_AVR:
 792     case EM_AVR_OLD:
 793     case EM_BLACKFIN:
 794     case EM_CR16:
 795     case EM_CRIS:
 796     case EM_CRX:
 797     case EM_D30V:
 798     case EM_CYGNUS_D30V:
 799     case EM_FR30:
 800     case EM_FT32:
 801     case EM_CYGNUS_FR30:
 802     case EM_CYGNUS_FRV:
 803     case EM_H8S:
 804     case EM_H8_300:
 805     case EM_H8_300H:
 806     case EM_IA_64:
 807     case EM_IP2K:
 808     case EM_IP2K_OLD:
 809     case EM_IQ2000:
 810     case EM_LATTICEMICO32:
 811     case EM_M32C_OLD:
 812     case EM_M32C:
 813     case EM_M32R:
 814     case EM_MCORE:
 815     case EM_CYGNUS_MEP:
 816     case EM_METAG:
 817     case EM_MMIX:
 818     case EM_MN10200:
 819     case EM_CYGNUS_MN10200:
 820     case EM_MN10300:
 821     case EM_CYGNUS_MN10300:
 822     case EM_MOXIE:
 823     case EM_MSP430:
 824     case EM_MSP430_OLD:
 825     case EM_MT:
 826     case EM_NDS32:
 827     case EM_NIOS32:
 828     case EM_OR1K:
 829     case EM_PPC64:
 830     case EM_PPC:
 831     case EM_TI_PRU:
 832     case EM_RISCV:
 833     case EM_RL78:
 834     case EM_RX:
 835     case EM_S390:
 836     case EM_S390_OLD:
 837     case EM_SH:
 838     case EM_SPARC:
 839     case EM_SPARC32PLUS:
 840     case EM_SPARCV9:
 841     case EM_SPU:
 842     case EM_TI_C6000:
 843     case EM_TILEGX:
 844     case EM_TILEPRO:
 845     case EM_V800:
 846     case EM_V850:
 847     case EM_CYGNUS_V850:
 848     case EM_VAX:
 849     case EM_VISIUM:
 850     case EM_X86_64:
 851     case EM_L1OM:
 852     case EM_K1OM:
 853     case EM_XSTORMY16:
 854     case EM_XTENSA:
 855     case EM_XTENSA_OLD:
 856     case EM_MICROBLAZE:
 857     case EM_MICROBLAZE_OLD:
 858     case EM_WEBASSEMBLY:
 859       return TRUE;
 860
 861     case EM_68HC05:
 862     case EM_68HC08:
 863     case EM_68HC11:
 864     case EM_68HC16:
 865     case EM_FX66:
 866     case EM_ME16:
 867     case EM_MMA:
 868     case EM_NCPU:
 869     case EM_NDR1:
 870     case EM_PCP:
 871     case EM_ST100:
 872     case EM_ST19:
 873     case EM_ST7:
 874     case EM_ST9PLUS:
 875     case EM_STARCORE:
 876     case EM_SVX:
 877     case EM_TINYJ:
 878     default:
 879       warn (_("Don't know about relocations on this machine architecture\n"));
 880       return FALSE;
 881     }
 882 }
 883
 884 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 885    Returns TRUE upon success, FALSE otherwise.  If successful then a
 886    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 887    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 888    responsibility to free the allocated buffer.  */
 889
 890 static bfd_boolean
 891 slurp_rela_relocs (Filedata *            filedata,
 892                    unsigned long         rel_offset,
 893                    unsigned long         rel_size,
 894                    Elf_Internal_Rela **  relasp,
 895                    unsigned long *       nrelasp)
 896 {
 897   Elf_Internal_Rela * relas;
 898   size_t nrelas;
 899   unsigned int i;
 900
 901   if (is_32bit_elf)
 902     {
 903       Elf32_External_Rela * erelas;
 904
 905       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 906                                                  rel_size, _("32-bit relocation data"));
 907       if (!erelas)
 908         return FALSE;
 909
 910       nrelas = rel_size / sizeof (Elf32_External_Rela);
 911
 912       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 913                                              sizeof (Elf_Internal_Rela));
 914
 915       if (relas == NULL)
 916         {
 917           free (erelas);
 918           error (_("out of memory parsing relocs\n"));
 919           return FALSE;
 920         }
 921
 922       for (i = 0; i < nrelas; i++)
 923         {
 924           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 925           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 926           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 927         }
 928
 929       free (erelas);
 930     }
 931   else
 932     {
 933       Elf64_External_Rela * erelas;
 934
 935       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 936                                                  rel_size, _("64-bit relocation data"));
 937       if (!erelas)
 938         return FALSE;
 939
 940       nrelas = rel_size / sizeof (Elf64_External_Rela);
 941
 942       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 943                                              sizeof (Elf_Internal_Rela));
 944
 945       if (relas == NULL)
 946         {
 947           free (erelas);
 948           error (_("out of memory parsing relocs\n"));
 949           return FALSE;
 950         }
 951
 952       for (i = 0; i < nrelas; i++)
 953         {
 954           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 955           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 956           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 957
 958           /* The #ifdef BFD64 below is to prevent a compile time
 959              warning.  We know that if we do not have a 64 bit data
 960              type that we will never execute this code anyway.  */
 961 #ifdef BFD64
 962           if (filedata->file_header.e_machine == EM_MIPS
 963               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 964             {
 965               /* In little-endian objects, r_info isn't really a
 966                  64-bit little-endian value: it has a 32-bit
 967                  little-endian symbol index followed by four
 968                  individual byte fields.  Reorder INFO
 969                  accordingly.  */
 970               bfd_vma inf = relas[i].r_info;
 971               inf = (((inf & 0xffffffff) << 32)
 972                       | ((inf >> 56) & 0xff)
 973                       | ((inf >> 40) & 0xff00)
 974                       | ((inf >> 24) & 0xff0000)
 975                       | ((inf >> 8) & 0xff000000));
 976               relas[i].r_info = inf;
 977             }
 978 #endif /* BFD64 */
 979         }
 980
 981       free (erelas);
 982     }
 983
 984   *relasp = relas;
 985   *nrelasp = nrelas;
 986   return TRUE;
 987 }
 988
 989 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 990    Returns TRUE upon success, FALSE otherwise.  If successful then a
 991    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 992    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 993    responsibility to free the allocated buffer.  */
 994
 995 static bfd_boolean
 996 slurp_rel_relocs (Filedata *            filedata,
 997                   unsigned long         rel_offset,
 998                   unsigned long         rel_size,
 999                   Elf_Internal_Rela **  relsp,
1000                   unsigned long *       nrelsp)
1001 {
1002   Elf_Internal_Rela * rels;
1003   size_t nrels;
1004   unsigned int i;
1005
1006   if (is_32bit_elf)
1007     {
1008       Elf32_External_Rel * erels;
1009
1010       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1011                                                rel_size, _("32-bit relocation data"));
1012       if (!erels)
1013         return FALSE;
1014
1015       nrels = rel_size / sizeof (Elf32_External_Rel);
1016
1017       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1018
1019       if (rels == NULL)
1020         {
1021           free (erels);
1022           error (_("out of memory parsing relocs\n"));
1023           return FALSE;
1024         }
1025
1026       for (i = 0; i < nrels; i++)
1027         {
1028           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1029           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1030           rels[i].r_addend = 0;
1031         }
1032
1033       free (erels);
1034     }
1035   else
1036     {
1037       Elf64_External_Rel * erels;
1038
1039       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1040                                                rel_size, _("64-bit relocation data"));
1041       if (!erels)
1042         return FALSE;
1043
1044       nrels = rel_size / sizeof (Elf64_External_Rel);
1045
1046       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1047
1048       if (rels == NULL)
1049         {
1050           free (erels);
1051           error (_("out of memory parsing relocs\n"));
1052           return FALSE;
1053         }
1054
1055       for (i = 0; i < nrels; i++)
1056         {
1057           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1058           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1059           rels[i].r_addend = 0;
1060
1061           /* The #ifdef BFD64 below is to prevent a compile time
1062              warning.  We know that if we do not have a 64 bit data
1063              type that we will never execute this code anyway.  */
1064 #ifdef BFD64
1065           if (filedata->file_header.e_machine == EM_MIPS
1066               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1067             {
1068               /* In little-endian objects, r_info isn't really a
1069                  64-bit little-endian value: it has a 32-bit
1070                  little-endian symbol index followed by four
1071                  individual byte fields.  Reorder INFO
1072                  accordingly.  */
1073               bfd_vma inf = rels[i].r_info;
1074               inf = (((inf & 0xffffffff) << 32)
1075                      | ((inf >> 56) & 0xff)
1076                      | ((inf >> 40) & 0xff00)
1077                      | ((inf >> 24) & 0xff0000)
1078                      | ((inf >> 8) & 0xff000000));
1079               rels[i].r_info = inf;
1080             }
1081 #endif /* BFD64 */
1082         }
1083
1084       free (erels);
1085     }
1086
1087   *relsp = rels;
1088   *nrelsp = nrels;
1089   return TRUE;
1090 }
1091
1092 /* Returns the reloc type extracted from the reloc info field.  */
1093
1094 static unsigned int
1095 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1096 {
1097   if (is_32bit_elf)
1098     return ELF32_R_TYPE (reloc_info);
1099
1100   switch (filedata->file_header.e_machine)
1101     {
1102     case EM_MIPS:
1103       /* Note: We assume that reloc_info has already been adjusted for us.  */
1104       return ELF64_MIPS_R_TYPE (reloc_info);
1105
1106     case EM_SPARCV9:
1107       return ELF64_R_TYPE_ID (reloc_info);
1108
1109     default:
1110       return ELF64_R_TYPE (reloc_info);
1111     }
1112 }
1113
1114 /* Return the symbol index extracted from the reloc info field.  */
1115
1116 static bfd_vma
1117 get_reloc_symindex (bfd_vma reloc_info)
1118 {
1119   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1120 }
1121
1122 static inline bfd_boolean
1123 uses_msp430x_relocs (Filedata * filedata)
1124 {
1125   return
1126     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1127     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1128     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1129         /* TI compiler uses ELFOSABI_NONE.  */
1130         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1131 }
1132
1133 /* Display the contents of the relocation data found at the specified
1134    offset.  */
1135
1136 static bfd_boolean
1137 dump_relocations (Filedata *          filedata,
1138                   unsigned long       rel_offset,
1139                   unsigned long       rel_size,
1140                   Elf_Internal_Sym *  symtab,
1141                   unsigned long       nsyms,
1142                   char *              strtab,
1143                   unsigned long       strtablen,
1144                   int                 is_rela,
1145                   bfd_boolean         is_dynsym)
1146 {
1147   unsigned long i;
1148   Elf_Internal_Rela * rels;
1149   bfd_boolean res = TRUE;
1150
1151   if (is_rela == UNKNOWN)
1152     is_rela = guess_is_rela (filedata->file_header.e_machine);
1153
1154   if (is_rela)
1155     {
1156       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1157         return FALSE;
1158     }
1159   else
1160     {
1161       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1162         return FALSE;
1163     }
1164
1165   if (is_32bit_elf)
1166     {
1167       if (is_rela)
1168         {
1169           if (do_wide)
1170             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1171           else
1172             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1173         }
1174       else
1175         {
1176           if (do_wide)
1177             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1178           else
1179             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1180         }
1181     }
1182   else
1183     {
1184       if (is_rela)
1185         {
1186           if (do_wide)
1187             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1188           else
1189             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1190         }
1191       else
1192         {
1193           if (do_wide)
1194             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1195           else
1196             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1197         }
1198     }
1199
1200   for (i = 0; i < rel_size; i++)
1201     {
1202       const char * rtype;
1203       bfd_vma offset;
1204       bfd_vma inf;
1205       bfd_vma symtab_index;
1206       bfd_vma type;
1207
1208       offset = rels[i].r_offset;
1209       inf    = rels[i].r_info;
1210
1211       type = get_reloc_type (filedata, inf);
1212       symtab_index = get_reloc_symindex  (inf);
1213
1214       if (is_32bit_elf)
1215         {
1216           printf ("%8.8lx  %8.8lx ",
1217                   (unsigned long) offset & 0xffffffff,
1218                   (unsigned long) inf & 0xffffffff);
1219         }
1220       else
1221         {
1222 #if BFD_HOST_64BIT_LONG
1223           printf (do_wide
1224                   ? "%16.16lx  %16.16lx "
1225                   : "%12.12lx  %12.12lx ",
1226                   offset, inf);
1227 #elif BFD_HOST_64BIT_LONG_LONG
1228 #ifndef __MSVCRT__
1229           printf (do_wide
1230                   ? "%16.16llx  %16.16llx "
1231                   : "%12.12llx  %12.12llx ",
1232                   offset, inf);
1233 #else
1234           printf (do_wide
1235                   ? "%16.16I64x  %16.16I64x "
1236                   : "%12.12I64x  %12.12I64x ",
1237                   offset, inf);
1238 #endif
1239 #else
1240           printf (do_wide
1241                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1242                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1243                   _bfd_int64_high (offset),
1244                   _bfd_int64_low (offset),
1245                   _bfd_int64_high (inf),
1246                   _bfd_int64_low (inf));
1247 #endif
1248         }
1249
1250       switch (filedata->file_header.e_machine)
1251         {
1252         default:
1253           rtype = NULL;
1254           break;
1255
1256         case EM_AARCH64:
1257           rtype = elf_aarch64_reloc_type (type);
1258           break;
1259
1260         case EM_M32R:
1261         case EM_CYGNUS_M32R:
1262           rtype = elf_m32r_reloc_type (type);
1263           break;
1264
1265         case EM_386:
1266         case EM_IAMCU:
1267           rtype = elf_i386_reloc_type (type);
1268           break;
1269
1270         case EM_68HC11:
1271         case EM_68HC12:
1272           rtype = elf_m68hc11_reloc_type (type);
1273           break;
1274
1275         case EM_68K:
1276           rtype = elf_m68k_reloc_type (type);
1277           break;
1278
1279         case EM_960:
1280           rtype = elf_i960_reloc_type (type);
1281           break;
1282
1283         case EM_AVR:
1284         case EM_AVR_OLD:
1285           rtype = elf_avr_reloc_type (type);
1286           break;
1287
1288         case EM_OLD_SPARCV9:
1289         case EM_SPARC32PLUS:
1290         case EM_SPARCV9:
1291         case EM_SPARC:
1292           rtype = elf_sparc_reloc_type (type);
1293           break;
1294
1295         case EM_SPU:
1296           rtype = elf_spu_reloc_type (type);
1297           break;
1298
1299         case EM_V800:
1300           rtype = v800_reloc_type (type);
1301           break;
1302         case EM_V850:
1303         case EM_CYGNUS_V850:
1304           rtype = v850_reloc_type (type);
1305           break;
1306
1307         case EM_D10V:
1308         case EM_CYGNUS_D10V:
1309           rtype = elf_d10v_reloc_type (type);
1310           break;
1311
1312         case EM_D30V:
1313         case EM_CYGNUS_D30V:
1314           rtype = elf_d30v_reloc_type (type);
1315           break;
1316
1317         case EM_DLX:
1318           rtype = elf_dlx_reloc_type (type);
1319           break;
1320
1321         case EM_SH:
1322           rtype = elf_sh_reloc_type (type);
1323           break;
1324
1325         case EM_MN10300:
1326         case EM_CYGNUS_MN10300:
1327           rtype = elf_mn10300_reloc_type (type);
1328           break;
1329
1330         case EM_MN10200:
1331         case EM_CYGNUS_MN10200:
1332           rtype = elf_mn10200_reloc_type (type);
1333           break;
1334
1335         case EM_FR30:
1336         case EM_CYGNUS_FR30:
1337           rtype = elf_fr30_reloc_type (type);
1338           break;
1339
1340         case EM_CYGNUS_FRV:
1341           rtype = elf_frv_reloc_type (type);
1342           break;
1343
1344         case EM_FT32:
1345           rtype = elf_ft32_reloc_type (type);
1346           break;
1347
1348         case EM_MCORE:
1349           rtype = elf_mcore_reloc_type (type);
1350           break;
1351
1352         case EM_MMIX:
1353           rtype = elf_mmix_reloc_type (type);
1354           break;
1355
1356         case EM_MOXIE:
1357           rtype = elf_moxie_reloc_type (type);
1358           break;
1359
1360         case EM_MSP430:
1361           if (uses_msp430x_relocs (filedata))
1362             {
1363               rtype = elf_msp430x_reloc_type (type);
1364               break;
1365             }
1366           /* Fall through.  */
1367         case EM_MSP430_OLD:
1368           rtype = elf_msp430_reloc_type (type);
1369           break;
1370
1371         case EM_NDS32:
1372           rtype = elf_nds32_reloc_type (type);
1373           break;
1374
1375         case EM_PPC:
1376           rtype = elf_ppc_reloc_type (type);
1377           break;
1378
1379         case EM_PPC64:
1380           rtype = elf_ppc64_reloc_type (type);
1381           break;
1382
1383         case EM_MIPS:
1384         case EM_MIPS_RS3_LE:
1385           rtype = elf_mips_reloc_type (type);
1386           break;
1387
1388         case EM_RISCV:
1389           rtype = elf_riscv_reloc_type (type);
1390           break;
1391
1392         case EM_ALPHA:
1393           rtype = elf_alpha_reloc_type (type);
1394           break;
1395
1396         case EM_ARM:
1397           rtype = elf_arm_reloc_type (type);
1398           break;
1399
1400         case EM_ARC:
1401         case EM_ARC_COMPACT:
1402         case EM_ARC_COMPACT2:
1403           rtype = elf_arc_reloc_type (type);
1404           break;
1405
1406         case EM_PARISC:
1407           rtype = elf_hppa_reloc_type (type);
1408           break;
1409
1410         case EM_H8_300:
1411         case EM_H8_300H:
1412         case EM_H8S:
1413           rtype = elf_h8_reloc_type (type);
1414           break;
1415
1416         case EM_OR1K:
1417           rtype = elf_or1k_reloc_type (type);
1418           break;
1419
1420         case EM_PJ:
1421         case EM_PJ_OLD:
1422           rtype = elf_pj_reloc_type (type);
1423           break;
1424         case EM_IA_64:
1425           rtype = elf_ia64_reloc_type (type);
1426           break;
1427
1428         case EM_CRIS:
1429           rtype = elf_cris_reloc_type (type);
1430           break;
1431
1432         case EM_860:
1433           rtype = elf_i860_reloc_type (type);
1434           break;
1435
1436         case EM_X86_64:
1437         case EM_L1OM:
1438         case EM_K1OM:
1439           rtype = elf_x86_64_reloc_type (type);
1440           break;
1441
1442         case EM_S370:
1443           rtype = i370_reloc_type (type);
1444           break;
1445
1446         case EM_S390_OLD:
1447         case EM_S390:
1448           rtype = elf_s390_reloc_type (type);
1449           break;
1450
1451         case EM_SCORE:
1452           rtype = elf_score_reloc_type (type);
1453           break;
1454
1455         case EM_XSTORMY16:
1456           rtype = elf_xstormy16_reloc_type (type);
1457           break;
1458
1459         case EM_CRX:
1460           rtype = elf_crx_reloc_type (type);
1461           break;
1462
1463         case EM_VAX:
1464           rtype = elf_vax_reloc_type (type);
1465           break;
1466
1467         case EM_VISIUM:
1468           rtype = elf_visium_reloc_type (type);
1469           break;
1470
1471         case EM_ADAPTEVA_EPIPHANY:
1472           rtype = elf_epiphany_reloc_type (type);
1473           break;
1474
1475         case EM_IP2K:
1476         case EM_IP2K_OLD:
1477           rtype = elf_ip2k_reloc_type (type);
1478           break;
1479
1480         case EM_IQ2000:
1481           rtype = elf_iq2000_reloc_type (type);
1482           break;
1483
1484         case EM_XTENSA_OLD:
1485         case EM_XTENSA:
1486           rtype = elf_xtensa_reloc_type (type);
1487           break;
1488
1489         case EM_LATTICEMICO32:
1490           rtype = elf_lm32_reloc_type (type);
1491           break;
1492
1493         case EM_M32C_OLD:
1494         case EM_M32C:
1495           rtype = elf_m32c_reloc_type (type);
1496           break;
1497
1498         case EM_MT:
1499           rtype = elf_mt_reloc_type (type);
1500           break;
1501
1502         case EM_BLACKFIN:
1503           rtype = elf_bfin_reloc_type (type);
1504           break;
1505
1506         case EM_CYGNUS_MEP:
1507           rtype = elf_mep_reloc_type (type);
1508           break;
1509
1510         case EM_CR16:
1511           rtype = elf_cr16_reloc_type (type);
1512           break;
1513
1514         case EM_MICROBLAZE:
1515         case EM_MICROBLAZE_OLD:
1516           rtype = elf_microblaze_reloc_type (type);
1517           break;
1518
1519         case EM_RL78:
1520           rtype = elf_rl78_reloc_type (type);
1521           break;
1522
1523         case EM_RX:
1524           rtype = elf_rx_reloc_type (type);
1525           break;
1526
1527         case EM_METAG:
1528           rtype = elf_metag_reloc_type (type);
1529           break;
1530
1531         case EM_XC16X:
1532         case EM_C166:
1533           rtype = elf_xc16x_reloc_type (type);
1534           break;
1535
1536         case EM_TI_C6000:
1537           rtype = elf_tic6x_reloc_type (type);
1538           break;
1539
1540         case EM_TILEGX:
1541           rtype = elf_tilegx_reloc_type (type);
1542           break;
1543
1544         case EM_TILEPRO:
1545           rtype = elf_tilepro_reloc_type (type);
1546           break;
1547
1548         case EM_WEBASSEMBLY:
1549           rtype = elf_wasm32_reloc_type (type);
1550           break;
1551
1552         case EM_XGATE:
1553           rtype = elf_xgate_reloc_type (type);
1554           break;
1555
1556         case EM_ALTERA_NIOS2:
1557           rtype = elf_nios2_reloc_type (type);
1558           break;
1559
1560         case EM_TI_PRU:
1561           rtype = elf_pru_reloc_type (type);
1562           break;
1563         }
1564
1565       if (rtype == NULL)
1566         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1567       else
1568         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1569
1570       if (filedata->file_header.e_machine == EM_ALPHA
1571           && rtype != NULL
1572           && streq (rtype, "R_ALPHA_LITUSE")
1573           && is_rela)
1574         {
1575           switch (rels[i].r_addend)
1576             {
1577             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1578             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1579             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1580             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1581             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1582             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1583             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1584             default: rtype = NULL;
1585             }
1586
1587           if (rtype)
1588             printf (" (%s)", rtype);
1589           else
1590             {
1591               putchar (' ');
1592               printf (_("<unknown addend: %lx>"),
1593                       (unsigned long) rels[i].r_addend);
1594               res = FALSE;
1595             }
1596         }
1597       else if (symtab_index)
1598         {
1599           if (symtab == NULL || symtab_index >= nsyms)
1600             {
1601               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1602               res = FALSE;
1603             }
1604           else
1605             {
1606               Elf_Internal_Sym * psym;
1607               const char * version_string;
1608               enum versioned_symbol_info sym_info;
1609               unsigned short vna_other;
1610
1611               psym = symtab + symtab_index;
1612
1613               version_string
1614                 = get_symbol_version_string (filedata, is_dynsym,
1615                                              strtab, strtablen,
1616                                              symtab_index,
1617                                              psym,
1618                                              &sym_info,
1619                                              &vna_other);
1620
1621               printf (" ");
1622
1623               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1624                 {
1625                   const char * name;
1626                   unsigned int len;
1627                   unsigned int width = is_32bit_elf ? 8 : 14;
1628
1629                   /* Relocations against GNU_IFUNC symbols do not use the value
1630                      of the symbol as the address to relocate against.  Instead
1631                      they invoke the function named by the symbol and use its
1632                      result as the address for relocation.
1633
1634                      To indicate this to the user, do not display the value of
1635                      the symbol in the "Symbols's Value" field.  Instead show
1636                      its name followed by () as a hint that the symbol is
1637                      invoked.  */
1638
1639                   if (strtab == NULL
1640                       || psym->st_name == 0
1641                       || psym->st_name >= strtablen)
1642                     name = "??";
1643                   else
1644                     name = strtab + psym->st_name;
1645
1646                   len = print_symbol (width, name);
1647                   if (version_string)
1648                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1649                             version_string);
1650                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1651                 }
1652               else
1653                 {
1654                   print_vma (psym->st_value, LONG_HEX);
1655
1656                   printf (is_32bit_elf ? "   " : " ");
1657                 }
1658
1659               if (psym->st_name == 0)
1660                 {
1661                   const char * sec_name = "<null>";
1662                   char name_buf[40];
1663
1664                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1665                     {
1666                       if (psym->st_shndx < filedata->file_header.e_shnum)
1667                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1668                       else if (psym->st_shndx == SHN_ABS)
1669                         sec_name = "ABS";
1670                       else if (psym->st_shndx == SHN_COMMON)
1671                         sec_name = "COMMON";
1672                       else if ((filedata->file_header.e_machine == EM_MIPS
1673                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1674                                || (filedata->file_header.e_machine == EM_TI_C6000
1675                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1676                         sec_name = "SCOMMON";
1677                       else if (filedata->file_header.e_machine == EM_MIPS
1678                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1679                         sec_name = "SUNDEF";
1680                       else if ((filedata->file_header.e_machine == EM_X86_64
1681                                 || filedata->file_header.e_machine == EM_L1OM
1682                                 || filedata->file_header.e_machine == EM_K1OM)
1683                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1684                         sec_name = "LARGE_COMMON";
1685                       else if (filedata->file_header.e_machine == EM_IA_64
1686                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1687                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1688                         sec_name = "ANSI_COM";
1689                       else if (is_ia64_vms (filedata)
1690                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1691                         sec_name = "VMS_SYMVEC";
1692                       else
1693                         {
1694                           sprintf (name_buf, "<section 0x%x>",
1695                                    (unsigned int) psym->st_shndx);
1696                           sec_name = name_buf;
1697                         }
1698                     }
1699                   print_symbol (22, sec_name);
1700                 }
1701               else if (strtab == NULL)
1702                 printf (_("<string table index: %3ld>"), psym->st_name);
1703               else if (psym->st_name >= strtablen)
1704                 {
1705                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1706                   res = FALSE;
1707                 }
1708               else
1709                 {
1710                   print_symbol (22, strtab + psym->st_name);
1711                   if (version_string)
1712                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1713                             version_string);
1714                 }
1715
1716               if (is_rela)
1717                 {
1718                   bfd_vma off = rels[i].r_addend;
1719
1720                   if ((bfd_signed_vma) off < 0)
1721                     printf (" - %" BFD_VMA_FMT "x", - off);
1722                   else
1723                     printf (" + %" BFD_VMA_FMT "x", off);
1724                 }
1725             }
1726         }
1727       else if (is_rela)
1728         {
1729           bfd_vma off = rels[i].r_addend;
1730
1731           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1732           if ((bfd_signed_vma) off < 0)
1733             printf ("-%" BFD_VMA_FMT "x", - off);
1734           else
1735             printf ("%" BFD_VMA_FMT "x", off);
1736         }
1737
1738       if (filedata->file_header.e_machine == EM_SPARCV9
1739           && rtype != NULL
1740           && streq (rtype, "R_SPARC_OLO10"))
1741         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1742
1743       putchar ('\n');
1744
1745 #ifdef BFD64
1746       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1747         {
1748           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1749           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1750           const char * rtype2 = elf_mips_reloc_type (type2);
1751           const char * rtype3 = elf_mips_reloc_type (type3);
1752
1753           printf ("                    Type2: ");
1754
1755           if (rtype2 == NULL)
1756             printf (_("unrecognized: %-7lx"),
1757                     (unsigned long) type2 & 0xffffffff);
1758           else
1759             printf ("%-17.17s", rtype2);
1760
1761           printf ("\n                    Type3: ");
1762
1763           if (rtype3 == NULL)
1764             printf (_("unrecognized: %-7lx"),
1765                     (unsigned long) type3 & 0xffffffff);
1766           else
1767             printf ("%-17.17s", rtype3);
1768
1769           putchar ('\n');
1770         }
1771 #endif /* BFD64 */
1772     }
1773
1774   free (rels);
1775
1776   return res;
1777 }
1778
1779 static const char *
1780 get_mips_dynamic_type (unsigned long type)
1781 {
1782   switch (type)
1783     {
1784     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1785     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1786     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1787     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1788     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1789     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1790     case DT_MIPS_MSYM: return "MIPS_MSYM";
1791     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1792     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1793     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1794     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1795     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1796     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1797     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1798     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1799     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1800     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1801     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1802     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1803     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1804     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1805     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1806     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1807     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1808     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1809     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1810     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1811     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1812     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1813     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1814     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1815     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1816     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1817     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1818     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1819     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1820     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1821     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1822     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1823     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1824     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1825     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1826     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1827     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1828     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1829     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1830     default:
1831       return NULL;
1832     }
1833 }
1834
1835 static const char *
1836 get_sparc64_dynamic_type (unsigned long type)
1837 {
1838   switch (type)
1839     {
1840     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1841     default:
1842       return NULL;
1843     }
1844 }
1845
1846 static const char *
1847 get_ppc_dynamic_type (unsigned long type)
1848 {
1849   switch (type)
1850     {
1851     case DT_PPC_GOT:    return "PPC_GOT";
1852     case DT_PPC_OPT:    return "PPC_OPT";
1853     default:
1854       return NULL;
1855     }
1856 }
1857
1858 static const char *
1859 get_ppc64_dynamic_type (unsigned long type)
1860 {
1861   switch (type)
1862     {
1863     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1864     case DT_PPC64_OPD:    return "PPC64_OPD";
1865     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1866     case DT_PPC64_OPT:    return "PPC64_OPT";
1867     default:
1868       return NULL;
1869     }
1870 }
1871
1872 static const char *
1873 get_parisc_dynamic_type (unsigned long type)
1874 {
1875   switch (type)
1876     {
1877     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1878     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1879     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1880     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1881     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1882     case DT_HP_PREINIT:         return "HP_PREINIT";
1883     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1884     case DT_HP_NEEDED:          return "HP_NEEDED";
1885     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1886     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1887     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1888     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1889     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1890     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1891     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1892     case DT_HP_FILTERED:        return "HP_FILTERED";
1893     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1894     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1895     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1896     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1897     case DT_PLT:                return "PLT";
1898     case DT_PLT_SIZE:           return "PLT_SIZE";
1899     case DT_DLT:                return "DLT";
1900     case DT_DLT_SIZE:           return "DLT_SIZE";
1901     default:
1902       return NULL;
1903     }
1904 }
1905
1906 static const char *
1907 get_ia64_dynamic_type (unsigned long type)
1908 {
1909   switch (type)
1910     {
1911     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1912     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1913     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1914     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1915     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1916     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1917     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1918     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1919     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1920     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1921     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1922     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1923     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1924     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1925     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1926     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1927     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1928     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1929     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1930     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1931     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1932     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1933     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1934     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1935     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1936     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1937     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1938     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1939     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1940     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1941     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1942     default:
1943       return NULL;
1944     }
1945 }
1946
1947 static const char *
1948 get_solaris_section_type (unsigned long type)
1949 {
1950   switch (type)
1951     {
1952     case 0x6fffffee: return "SUNW_ancillary";
1953     case 0x6fffffef: return "SUNW_capchain";
1954     case 0x6ffffff0: return "SUNW_capinfo";
1955     case 0x6ffffff1: return "SUNW_symsort";
1956     case 0x6ffffff2: return "SUNW_tlssort";
1957     case 0x6ffffff3: return "SUNW_LDYNSYM";
1958     case 0x6ffffff4: return "SUNW_dof";
1959     case 0x6ffffff5: return "SUNW_cap";
1960     case 0x6ffffff6: return "SUNW_SIGNATURE";
1961     case 0x6ffffff7: return "SUNW_ANNOTATE";
1962     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1963     case 0x6ffffff9: return "SUNW_DEBUG";
1964     case 0x6ffffffa: return "SUNW_move";
1965     case 0x6ffffffb: return "SUNW_COMDAT";
1966     case 0x6ffffffc: return "SUNW_syminfo";
1967     case 0x6ffffffd: return "SUNW_verdef";
1968     case 0x6ffffffe: return "SUNW_verneed";
1969     case 0x6fffffff: return "SUNW_versym";
1970     case 0x70000000: return "SPARC_GOTDATA";
1971     default: return NULL;
1972     }
1973 }
1974
1975 static const char *
1976 get_alpha_dynamic_type (unsigned long type)
1977 {
1978   switch (type)
1979     {
1980     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1981     default: return NULL;
1982     }
1983 }
1984
1985 static const char *
1986 get_score_dynamic_type (unsigned long type)
1987 {
1988   switch (type)
1989     {
1990     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1991     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1992     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1993     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1994     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1995     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1996     default:                    return NULL;
1997     }
1998 }
1999
2000 static const char *
2001 get_tic6x_dynamic_type (unsigned long type)
2002 {
2003   switch (type)
2004     {
2005     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2006     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2007     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2008     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2009     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2010     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2011     default:                   return NULL;
2012     }
2013 }
2014
2015 static const char *
2016 get_nios2_dynamic_type (unsigned long type)
2017 {
2018   switch (type)
2019     {
2020     case DT_NIOS2_GP: return "NIOS2_GP";
2021     default:          return NULL;
2022     }
2023 }
2024
2025 static const char *
2026 get_solaris_dynamic_type (unsigned long type)
2027 {
2028   switch (type)
2029     {
2030     case 0x6000000d: return "SUNW_AUXILIARY";
2031     case 0x6000000e: return "SUNW_RTLDINF";
2032     case 0x6000000f: return "SUNW_FILTER";
2033     case 0x60000010: return "SUNW_CAP";
2034     case 0x60000011: return "SUNW_SYMTAB";
2035     case 0x60000012: return "SUNW_SYMSZ";
2036     case 0x60000013: return "SUNW_SORTENT";
2037     case 0x60000014: return "SUNW_SYMSORT";
2038     case 0x60000015: return "SUNW_SYMSORTSZ";
2039     case 0x60000016: return "SUNW_TLSSORT";
2040     case 0x60000017: return "SUNW_TLSSORTSZ";
2041     case 0x60000018: return "SUNW_CAPINFO";
2042     case 0x60000019: return "SUNW_STRPAD";
2043     case 0x6000001a: return "SUNW_CAPCHAIN";
2044     case 0x6000001b: return "SUNW_LDMACH";
2045     case 0x6000001d: return "SUNW_CAPCHAINENT";
2046     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2047     case 0x60000021: return "SUNW_PARENT";
2048     case 0x60000023: return "SUNW_ASLR";
2049     case 0x60000025: return "SUNW_RELAX";
2050     case 0x60000029: return "SUNW_NXHEAP";
2051     case 0x6000002b: return "SUNW_NXSTACK";
2052
2053     case 0x70000001: return "SPARC_REGISTER";
2054     case 0x7ffffffd: return "AUXILIARY";
2055     case 0x7ffffffe: return "USED";
2056     case 0x7fffffff: return "FILTER";
2057
2058     default: return NULL;
2059     }
2060 }
2061
2062 static const char *
2063 get_dynamic_type (Filedata * filedata, unsigned long type)
2064 {
2065   static char buff[64];
2066
2067   switch (type)
2068     {
2069     case DT_NULL:       return "NULL";
2070     case DT_NEEDED:     return "NEEDED";
2071     case DT_PLTRELSZ:   return "PLTRELSZ";
2072     case DT_PLTGOT:     return "PLTGOT";
2073     case DT_HASH:       return "HASH";
2074     case DT_STRTAB:     return "STRTAB";
2075     case DT_SYMTAB:     return "SYMTAB";
2076     case DT_RELA:       return "RELA";
2077     case DT_RELASZ:     return "RELASZ";
2078     case DT_RELAENT:    return "RELAENT";
2079     case DT_STRSZ:      return "STRSZ";
2080     case DT_SYMENT:     return "SYMENT";
2081     case DT_INIT:       return "INIT";
2082     case DT_FINI:       return "FINI";
2083     case DT_SONAME:     return "SONAME";
2084     case DT_RPATH:      return "RPATH";
2085     case DT_SYMBOLIC:   return "SYMBOLIC";
2086     case DT_REL:        return "REL";
2087     case DT_RELSZ:      return "RELSZ";
2088     case DT_RELENT:     return "RELENT";
2089     case DT_PLTREL:     return "PLTREL";
2090     case DT_DEBUG:      return "DEBUG";
2091     case DT_TEXTREL:    return "TEXTREL";
2092     case DT_JMPREL:     return "JMPREL";
2093     case DT_BIND_NOW:   return "BIND_NOW";
2094     case DT_INIT_ARRAY: return "INIT_ARRAY";
2095     case DT_FINI_ARRAY: return "FINI_ARRAY";
2096     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2097     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2098     case DT_RUNPATH:    return "RUNPATH";
2099     case DT_FLAGS:      return "FLAGS";
2100
2101     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2102     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2103     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2104
2105     case DT_CHECKSUM:   return "CHECKSUM";
2106     case DT_PLTPADSZ:   return "PLTPADSZ";
2107     case DT_MOVEENT:    return "MOVEENT";
2108     case DT_MOVESZ:     return "MOVESZ";
2109     case DT_FEATURE:    return "FEATURE";
2110     case DT_POSFLAG_1:  return "POSFLAG_1";
2111     case DT_SYMINSZ:    return "SYMINSZ";
2112     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2113
2114     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2115     case DT_CONFIG:     return "CONFIG";
2116     case DT_DEPAUDIT:   return "DEPAUDIT";
2117     case DT_AUDIT:      return "AUDIT";
2118     case DT_PLTPAD:     return "PLTPAD";
2119     case DT_MOVETAB:    return "MOVETAB";
2120     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2121
2122     case DT_VERSYM:     return "VERSYM";
2123
2124     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2125     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2126     case DT_RELACOUNT:  return "RELACOUNT";
2127     case DT_RELCOUNT:   return "RELCOUNT";
2128     case DT_FLAGS_1:    return "FLAGS_1";
2129     case DT_VERDEF:     return "VERDEF";
2130     case DT_VERDEFNUM:  return "VERDEFNUM";
2131     case DT_VERNEED:    return "VERNEED";
2132     case DT_VERNEEDNUM: return "VERNEEDNUM";
2133
2134     case DT_AUXILIARY:  return "AUXILIARY";
2135     case DT_USED:       return "USED";
2136     case DT_FILTER:     return "FILTER";
2137
2138     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2139     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2140     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2141     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2142     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2143     case DT_GNU_HASH:   return "GNU_HASH";
2144
2145     default:
2146       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2147         {
2148           const char * result;
2149
2150           switch (filedata->file_header.e_machine)
2151             {
2152             case EM_MIPS:
2153             case EM_MIPS_RS3_LE:
2154               result = get_mips_dynamic_type (type);
2155               break;
2156             case EM_SPARCV9:
2157               result = get_sparc64_dynamic_type (type);
2158               break;
2159             case EM_PPC:
2160               result = get_ppc_dynamic_type (type);
2161               break;
2162             case EM_PPC64:
2163               result = get_ppc64_dynamic_type (type);
2164               break;
2165             case EM_IA_64:
2166               result = get_ia64_dynamic_type (type);
2167               break;
2168             case EM_ALPHA:
2169               result = get_alpha_dynamic_type (type);
2170               break;
2171             case EM_SCORE:
2172               result = get_score_dynamic_type (type);
2173               break;
2174             case EM_TI_C6000:
2175               result = get_tic6x_dynamic_type (type);
2176               break;
2177             case EM_ALTERA_NIOS2:
2178               result = get_nios2_dynamic_type (type);
2179               break;
2180             default:
2181               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2182                 result = get_solaris_dynamic_type (type);
2183               else
2184                 result = NULL;
2185               break;
2186             }
2187
2188           if (result != NULL)
2189             return result;
2190
2191           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2192         }
2193       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2194                || (filedata->file_header.e_machine == EM_PARISC
2195                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2196         {
2197           const char * result;
2198
2199           switch (filedata->file_header.e_machine)
2200             {
2201             case EM_PARISC:
2202               result = get_parisc_dynamic_type (type);
2203               break;
2204             case EM_IA_64:
2205               result = get_ia64_dynamic_type (type);
2206               break;
2207             default:
2208               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2209                 result = get_solaris_dynamic_type (type);
2210               else
2211                 result = NULL;
2212               break;
2213             }
2214
2215           if (result != NULL)
2216             return result;
2217
2218           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2219                     type);
2220         }
2221       else
2222         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2223
2224       return buff;
2225     }
2226 }
2227
2228 static char *
2229 get_file_type (unsigned e_type)
2230 {
2231   static char buff[32];
2232
2233   switch (e_type)
2234     {
2235     case ET_NONE: return _("NONE (None)");
2236     case ET_REL:  return _("REL (Relocatable file)");
2237     case ET_EXEC: return _("EXEC (Executable file)");
2238     case ET_DYN:  return _("DYN (Shared object file)");
2239     case ET_CORE: return _("CORE (Core file)");
2240
2241     default:
2242       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2243         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2244       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2245         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2246       else
2247         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2248       return buff;
2249     }
2250 }
2251
2252 static char *
2253 get_machine_name (unsigned e_machine)
2254 {
2255   static char buff[64]; /* XXX */
2256
2257   switch (e_machine)
2258     {
2259       /* Please keep this switch table sorted by increasing EM_ value.  */
2260       /* 0 */
2261     case EM_NONE:               return _("None");
2262     case EM_M32:                return "WE32100";
2263     case EM_SPARC:              return "Sparc";
2264     case EM_386:                return "Intel 80386";
2265     case EM_68K:                return "MC68000";
2266     case EM_88K:                return "MC88000";
2267     case EM_IAMCU:              return "Intel MCU";
2268     case EM_860:                return "Intel 80860";
2269     case EM_MIPS:               return "MIPS R3000";
2270     case EM_S370:               return "IBM System/370";
2271       /* 10 */
2272     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2273     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2274     case EM_PARISC:             return "HPPA";
2275     case EM_VPP550:             return "Fujitsu VPP500";
2276     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2277     case EM_960:                return "Intel 80960";
2278     case EM_PPC:                return "PowerPC";
2279       /* 20 */
2280     case EM_PPC64:              return "PowerPC64";
2281     case EM_S390_OLD:
2282     case EM_S390:               return "IBM S/390";
2283     case EM_SPU:                return "SPU";
2284       /* 30 */
2285     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2286     case EM_FR20:               return "Fujitsu FR20";
2287     case EM_RH32:               return "TRW RH32";
2288     case EM_MCORE:              return "MCORE";
2289       /* 40 */
2290     case EM_ARM:                return "ARM";
2291     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2292     case EM_SH:                 return "Renesas / SuperH SH";
2293     case EM_SPARCV9:            return "Sparc v9";
2294     case EM_TRICORE:            return "Siemens Tricore";
2295     case EM_ARC:                return "ARC";
2296     case EM_H8_300:             return "Renesas H8/300";
2297     case EM_H8_300H:            return "Renesas H8/300H";
2298     case EM_H8S:                return "Renesas H8S";
2299     case EM_H8_500:             return "Renesas H8/500";
2300       /* 50 */
2301     case EM_IA_64:              return "Intel IA-64";
2302     case EM_MIPS_X:             return "Stanford MIPS-X";
2303     case EM_COLDFIRE:           return "Motorola Coldfire";
2304     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2305     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2306     case EM_PCP:                return "Siemens PCP";
2307     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2308     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2309     case EM_STARCORE:           return "Motorola Star*Core processor";
2310     case EM_ME16:               return "Toyota ME16 processor";
2311       /* 60 */
2312     case EM_ST100:              return "STMicroelectronics ST100 processor";
2313     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2314     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2315     case EM_PDSP:               return "Sony DSP processor";
2316     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2317     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2318     case EM_FX66:               return "Siemens FX66 microcontroller";
2319     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2320     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2321     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2322       /* 70 */
2323     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2324     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2325     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2326     case EM_SVX:                return "Silicon Graphics SVx";
2327     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2328     case EM_VAX:                return "Digital VAX";
2329     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2330     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2331     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2332     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2333       /* 80 */
2334     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2335     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2336     case EM_PRISM:              return "Vitesse Prism";
2337     case EM_AVR_OLD:
2338     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2339     case EM_CYGNUS_FR30:
2340     case EM_FR30:               return "Fujitsu FR30";
2341     case EM_CYGNUS_D10V:
2342     case EM_D10V:               return "d10v";
2343     case EM_CYGNUS_D30V:
2344     case EM_D30V:               return "d30v";
2345     case EM_CYGNUS_V850:
2346     case EM_V850:               return "Renesas V850";
2347     case EM_CYGNUS_M32R:
2348     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2349     case EM_CYGNUS_MN10300:
2350     case EM_MN10300:            return "mn10300";
2351       /* 90 */
2352     case EM_CYGNUS_MN10200:
2353     case EM_MN10200:            return "mn10200";
2354     case EM_PJ:                 return "picoJava";
2355     case EM_OR1K:               return "OpenRISC 1000";
2356     case EM_ARC_COMPACT:        return "ARCompact";
2357     case EM_XTENSA_OLD:
2358     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2359     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2360     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2361     case EM_NS32K:              return "National Semiconductor 32000 series";
2362     case EM_TPC:                return "Tenor Network TPC processor";
2363     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2364       /* 100 */
2365     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2366     case EM_IP2K_OLD:
2367     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2368     case EM_MAX:                return "MAX Processor";
2369     case EM_CR:                 return "National Semiconductor CompactRISC";
2370     case EM_F2MC16:             return "Fujitsu F2MC16";
2371     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2372     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2373     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2374     case EM_SEP:                return "Sharp embedded microprocessor";
2375     case EM_ARCA:               return "Arca RISC microprocessor";
2376       /* 110 */
2377     case EM_UNICORE:            return "Unicore";
2378     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2379     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2380     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2381     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2382     case EM_XGATE:              return "Motorola XGATE embedded processor";
2383     case EM_C166:
2384     case EM_XC16X:              return "Infineon Technologies xc16x";
2385     case EM_M16C:               return "Renesas M16C series microprocessors";
2386     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2387     case EM_CE:                 return "Freescale Communication Engine RISC core";
2388       /* 120 */
2389     case EM_M32C:               return "Renesas M32c";
2390       /* 130 */
2391     case EM_TSK3000:            return "Altium TSK3000 core";
2392     case EM_RS08:               return "Freescale RS08 embedded processor";
2393     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2394     case EM_SCORE:              return "SUNPLUS S+Core";
2395     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2396     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2397     case EM_LATTICEMICO32:      return "Lattice Mico32";
2398     case EM_SE_C17:             return "Seiko Epson C17 family";
2399       /* 140 */
2400     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2401     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2402     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2403     case EM_TI_PRU:             return "TI PRU I/O processor";
2404       /* 160 */
2405     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2406     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2407     case EM_R32C:               return "Renesas R32C series microprocessors";
2408     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2409     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2410     case EM_8051:               return "Intel 8051 and variants";
2411     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2412     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2413     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2414     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2415       /* 170 */
2416     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2417     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2418     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2419     case EM_RX:                 return "Renesas RX";
2420     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2421     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2422     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2423     case EM_CR16:
2424     case EM_MICROBLAZE:
2425     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2426     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2427     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2428       /* 180 */
2429     case EM_L1OM:               return "Intel L1OM";
2430     case EM_K1OM:               return "Intel K1OM";
2431     case EM_INTEL182:           return "Intel (reserved)";
2432     case EM_AARCH64:            return "AArch64";
2433     case EM_ARM184:             return "ARM (reserved)";
2434     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2435     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2436     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2437     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2438       /* 190 */
2439     case EM_CUDA:               return "NVIDIA CUDA architecture";
2440     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2441     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2442     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2443     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2444     case EM_ARC_COMPACT2:       return "ARCv2";
2445     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2446     case EM_RL78:               return "Renesas RL78";
2447     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2448     case EM_78K0R:              return "Renesas 78K0R";
2449       /* 200 */
2450     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2451     case EM_BA1:                return "Beyond BA1 CPU architecture";
2452     case EM_BA2:                return "Beyond BA2 CPU architecture";
2453     case EM_XCORE:              return "XMOS xCORE processor family";
2454     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2455       /* 210 */
2456     case EM_KM32:               return "KM211 KM32 32-bit processor";
2457     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2458     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2459     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2460     case EM_KVARC:              return "KM211 KVARC processor";
2461     case EM_CDP:                return "Paneve CDP architecture family";
2462     case EM_COGE:               return "Cognitive Smart Memory Processor";
2463     case EM_COOL:               return "Bluechip Systems CoolEngine";
2464     case EM_NORC:               return "Nanoradio Optimized RISC";
2465     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2466       /* 220 */
2467     case EM_Z80:                return "Zilog Z80";
2468     case EM_VISIUM:             return "CDS VISIUMcore processor";
2469     case EM_FT32:               return "FTDI Chip FT32";
2470     case EM_MOXIE:              return "Moxie";
2471     case EM_AMDGPU:             return "AMD GPU";
2472     case EM_RISCV:              return "RISC-V";
2473     case EM_LANAI:              return "Lanai 32-bit processor";
2474     case EM_BPF:                return "Linux BPF";
2475
2476       /* Large numbers...  */
2477     case EM_MT:                 return "Morpho Techologies MT processor";
2478     case EM_ALPHA:              return "Alpha";
2479     case EM_WEBASSEMBLY:        return "Web Assembly";
2480     case EM_DLX:                return "OpenDLX";
2481     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2482     case EM_IQ2000:             return "Vitesse IQ2000";
2483     case EM_M32C_OLD:
2484     case EM_NIOS32:             return "Altera Nios";
2485     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2486     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2487     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2488
2489     default:
2490       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2491       return buff;
2492     }
2493 }
2494
2495 static void
2496 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2497 {
2498   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2499      other compilers don't a specific architecture type in the e_flags, and
2500      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2501      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2502      architectures.
2503
2504      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2505      but also sets a specific architecture type in the e_flags field.
2506
2507      However, when decoding the flags we don't worry if we see an
2508      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2509      ARCEM architecture type.  */
2510
2511   switch (e_flags & EF_ARC_MACH_MSK)
2512     {
2513       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2514     case EF_ARC_CPU_ARCV2EM:
2515       strcat (buf, ", ARC EM");
2516       break;
2517     case EF_ARC_CPU_ARCV2HS:
2518       strcat (buf, ", ARC HS");
2519       break;
2520
2521       /* We only expect these to occur for EM_ARC_COMPACT.  */
2522     case E_ARC_MACH_ARC600:
2523       strcat (buf, ", ARC600");
2524       break;
2525     case E_ARC_MACH_ARC601:
2526       strcat (buf, ", ARC601");
2527       break;
2528     case E_ARC_MACH_ARC700:
2529       strcat (buf, ", ARC700");
2530       break;
2531
2532       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2533          new ELF with new architecture being read by an old version of
2534          readelf, or (c) An ELF built with non-GNU compiler that does not
2535          set the architecture in the e_flags.  */
2536     default:
2537       if (e_machine == EM_ARC_COMPACT)
2538         strcat (buf, ", Unknown ARCompact");
2539       else
2540         strcat (buf, ", Unknown ARC");
2541       break;
2542     }
2543
2544   switch (e_flags & EF_ARC_OSABI_MSK)
2545     {
2546     case E_ARC_OSABI_ORIG:
2547       strcat (buf, ", (ABI:legacy)");
2548       break;
2549     case E_ARC_OSABI_V2:
2550       strcat (buf, ", (ABI:v2)");
2551       break;
2552       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2553     case E_ARC_OSABI_V3:
2554       strcat (buf, ", v3 no-legacy-syscalls ABI");
2555       break;
2556     case E_ARC_OSABI_V4:
2557       strcat (buf, ", v4 ABI");
2558       break;
2559     default:
2560       strcat (buf, ", unrecognised ARC OSABI flag");
2561       break;
2562     }
2563 }
2564
2565 static void
2566 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2567 {
2568   unsigned eabi;
2569   bfd_boolean unknown = FALSE;
2570
2571   eabi = EF_ARM_EABI_VERSION (e_flags);
2572   e_flags &= ~ EF_ARM_EABIMASK;
2573
2574   /* Handle "generic" ARM flags.  */
2575   if (e_flags & EF_ARM_RELEXEC)
2576     {
2577       strcat (buf, ", relocatable executable");
2578       e_flags &= ~ EF_ARM_RELEXEC;
2579     }
2580
2581   if (e_flags & EF_ARM_PIC)
2582     {
2583       strcat (buf, ", position independent");
2584       e_flags &= ~ EF_ARM_PIC;
2585     }
2586
2587   /* Now handle EABI specific flags.  */
2588   switch (eabi)
2589     {
2590     default:
2591       strcat (buf, ", <unrecognized EABI>");
2592       if (e_flags)
2593         unknown = TRUE;
2594       break;
2595
2596     case EF_ARM_EABI_VER1:
2597       strcat (buf, ", Version1 EABI");
2598       while (e_flags)
2599         {
2600           unsigned flag;
2601
2602           /* Process flags one bit at a time.  */
2603           flag = e_flags & - e_flags;
2604           e_flags &= ~ flag;
2605
2606           switch (flag)
2607             {
2608             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2609               strcat (buf, ", sorted symbol tables");
2610               break;
2611
2612             default:
2613               unknown = TRUE;
2614               break;
2615             }
2616         }
2617       break;
2618
2619     case EF_ARM_EABI_VER2:
2620       strcat (buf, ", Version2 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             case EF_ARM_DYNSYMSUSESEGIDX:
2636               strcat (buf, ", dynamic symbols use segment index");
2637               break;
2638
2639             case EF_ARM_MAPSYMSFIRST:
2640               strcat (buf, ", mapping symbols precede others");
2641               break;
2642
2643             default:
2644               unknown = TRUE;
2645               break;
2646             }
2647         }
2648       break;
2649
2650     case EF_ARM_EABI_VER3:
2651       strcat (buf, ", Version3 EABI");
2652       break;
2653
2654     case EF_ARM_EABI_VER4:
2655       strcat (buf, ", Version4 EABI");
2656       while (e_flags)
2657         {
2658           unsigned flag;
2659
2660           /* Process flags one bit at a time.  */
2661           flag = e_flags & - e_flags;
2662           e_flags &= ~ flag;
2663
2664           switch (flag)
2665             {
2666             case EF_ARM_BE8:
2667               strcat (buf, ", BE8");
2668               break;
2669
2670             case EF_ARM_LE8:
2671               strcat (buf, ", LE8");
2672               break;
2673
2674             default:
2675               unknown = TRUE;
2676               break;
2677             }
2678         }
2679       break;
2680
2681     case EF_ARM_EABI_VER5:
2682       strcat (buf, ", Version5 EABI");
2683       while (e_flags)
2684         {
2685           unsigned flag;
2686
2687           /* Process flags one bit at a time.  */
2688           flag = e_flags & - e_flags;
2689           e_flags &= ~ flag;
2690
2691           switch (flag)
2692             {
2693             case EF_ARM_BE8:
2694               strcat (buf, ", BE8");
2695               break;
2696
2697             case EF_ARM_LE8:
2698               strcat (buf, ", LE8");
2699               break;
2700
2701             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2702               strcat (buf, ", soft-float ABI");
2703               break;
2704
2705             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2706               strcat (buf, ", hard-float ABI");
2707               break;
2708
2709             default:
2710               unknown = TRUE;
2711               break;
2712             }
2713         }
2714       break;
2715
2716     case EF_ARM_EABI_UNKNOWN:
2717       strcat (buf, ", GNU EABI");
2718       while (e_flags)
2719         {
2720           unsigned flag;
2721
2722           /* Process flags one bit at a time.  */
2723           flag = e_flags & - e_flags;
2724           e_flags &= ~ flag;
2725
2726           switch (flag)
2727             {
2728             case EF_ARM_INTERWORK:
2729               strcat (buf, ", interworking enabled");
2730               break;
2731
2732             case EF_ARM_APCS_26:
2733               strcat (buf, ", uses APCS/26");
2734               break;
2735
2736             case EF_ARM_APCS_FLOAT:
2737               strcat (buf, ", uses APCS/float");
2738               break;
2739
2740             case EF_ARM_PIC:
2741               strcat (buf, ", position independent");
2742               break;
2743
2744             case EF_ARM_ALIGN8:
2745               strcat (buf, ", 8 bit structure alignment");
2746               break;
2747
2748             case EF_ARM_NEW_ABI:
2749               strcat (buf, ", uses new ABI");
2750               break;
2751
2752             case EF_ARM_OLD_ABI:
2753               strcat (buf, ", uses old ABI");
2754               break;
2755
2756             case EF_ARM_SOFT_FLOAT:
2757               strcat (buf, ", software FP");
2758               break;
2759
2760             case EF_ARM_VFP_FLOAT:
2761               strcat (buf, ", VFP");
2762               break;
2763
2764             case EF_ARM_MAVERICK_FLOAT:
2765               strcat (buf, ", Maverick FP");
2766               break;
2767
2768             default:
2769               unknown = TRUE;
2770               break;
2771             }
2772         }
2773     }
2774
2775   if (unknown)
2776     strcat (buf,_(", <unknown>"));
2777 }
2778
2779 static void
2780 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2781 {
2782   --size; /* Leave space for null terminator.  */
2783
2784   switch (e_flags & EF_AVR_MACH)
2785     {
2786     case E_AVR_MACH_AVR1:
2787       strncat (buf, ", avr:1", size);
2788       break;
2789     case E_AVR_MACH_AVR2:
2790       strncat (buf, ", avr:2", size);
2791       break;
2792     case E_AVR_MACH_AVR25:
2793       strncat (buf, ", avr:25", size);
2794       break;
2795     case E_AVR_MACH_AVR3:
2796       strncat (buf, ", avr:3", size);
2797       break;
2798     case E_AVR_MACH_AVR31:
2799       strncat (buf, ", avr:31", size);
2800       break;
2801     case E_AVR_MACH_AVR35:
2802       strncat (buf, ", avr:35", size);
2803       break;
2804     case E_AVR_MACH_AVR4:
2805       strncat (buf, ", avr:4", size);
2806       break;
2807     case E_AVR_MACH_AVR5:
2808       strncat (buf, ", avr:5", size);
2809       break;
2810     case E_AVR_MACH_AVR51:
2811       strncat (buf, ", avr:51", size);
2812       break;
2813     case E_AVR_MACH_AVR6:
2814       strncat (buf, ", avr:6", size);
2815       break;
2816     case E_AVR_MACH_AVRTINY:
2817       strncat (buf, ", avr:100", size);
2818       break;
2819     case E_AVR_MACH_XMEGA1:
2820       strncat (buf, ", avr:101", size);
2821       break;
2822     case E_AVR_MACH_XMEGA2:
2823       strncat (buf, ", avr:102", size);
2824       break;
2825     case E_AVR_MACH_XMEGA3:
2826       strncat (buf, ", avr:103", size);
2827       break;
2828     case E_AVR_MACH_XMEGA4:
2829       strncat (buf, ", avr:104", size);
2830       break;
2831     case E_AVR_MACH_XMEGA5:
2832       strncat (buf, ", avr:105", size);
2833       break;
2834     case E_AVR_MACH_XMEGA6:
2835       strncat (buf, ", avr:106", size);
2836       break;
2837     case E_AVR_MACH_XMEGA7:
2838       strncat (buf, ", avr:107", size);
2839       break;
2840     default:
2841       strncat (buf, ", avr:<unknown>", size);
2842       break;
2843     }
2844
2845   size -= strlen (buf);
2846   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2847     strncat (buf, ", link-relax", size);
2848 }
2849
2850 static void
2851 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2852 {
2853   unsigned abi;
2854   unsigned arch;
2855   unsigned config;
2856   unsigned version;
2857   bfd_boolean has_fpu = FALSE;
2858   unsigned int r = 0;
2859
2860   static const char *ABI_STRINGS[] =
2861   {
2862     "ABI v0", /* use r5 as return register; only used in N1213HC */
2863     "ABI v1", /* use r0 as return register */
2864     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2865     "ABI v2fp", /* for FPU */
2866     "AABI",
2867     "ABI2 FP+"
2868   };
2869   static const char *VER_STRINGS[] =
2870   {
2871     "Andes ELF V1.3 or older",
2872     "Andes ELF V1.3.1",
2873     "Andes ELF V1.4"
2874   };
2875   static const char *ARCH_STRINGS[] =
2876   {
2877     "",
2878     "Andes Star v1.0",
2879     "Andes Star v2.0",
2880     "Andes Star v3.0",
2881     "Andes Star v3.0m"
2882   };
2883
2884   abi = EF_NDS_ABI & e_flags;
2885   arch = EF_NDS_ARCH & e_flags;
2886   config = EF_NDS_INST & e_flags;
2887   version = EF_NDS32_ELF_VERSION & e_flags;
2888
2889   memset (buf, 0, size);
2890
2891   switch (abi)
2892     {
2893     case E_NDS_ABI_V0:
2894     case E_NDS_ABI_V1:
2895     case E_NDS_ABI_V2:
2896     case E_NDS_ABI_V2FP:
2897     case E_NDS_ABI_AABI:
2898     case E_NDS_ABI_V2FP_PLUS:
2899       /* In case there are holes in the array.  */
2900       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2901       break;
2902
2903     default:
2904       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2905       break;
2906     }
2907
2908   switch (version)
2909     {
2910     case E_NDS32_ELF_VER_1_2:
2911     case E_NDS32_ELF_VER_1_3:
2912     case E_NDS32_ELF_VER_1_4:
2913       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2914       break;
2915
2916     default:
2917       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2918       break;
2919     }
2920
2921   if (E_NDS_ABI_V0 == abi)
2922     {
2923       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2924       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2925       if (arch == E_NDS_ARCH_STAR_V1_0)
2926         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2927       return;
2928     }
2929
2930   switch (arch)
2931     {
2932     case E_NDS_ARCH_STAR_V1_0:
2933     case E_NDS_ARCH_STAR_V2_0:
2934     case E_NDS_ARCH_STAR_V3_0:
2935     case E_NDS_ARCH_STAR_V3_M:
2936       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2937       break;
2938
2939     default:
2940       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2941       /* ARCH version determines how the e_flags are interpreted.
2942          If it is unknown, we cannot proceed.  */
2943       return;
2944     }
2945
2946   /* Newer ABI; Now handle architecture specific flags.  */
2947   if (arch == E_NDS_ARCH_STAR_V1_0)
2948     {
2949       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2950         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2951
2952       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2953         r += snprintf (buf + r, size -r, ", MAC");
2954
2955       if (config & E_NDS32_HAS_DIV_INST)
2956         r += snprintf (buf + r, size -r, ", DIV");
2957
2958       if (config & E_NDS32_HAS_16BIT_INST)
2959         r += snprintf (buf + r, size -r, ", 16b");
2960     }
2961   else
2962     {
2963       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2964         {
2965           if (version <= E_NDS32_ELF_VER_1_3)
2966             r += snprintf (buf + r, size -r, ", [B8]");
2967           else
2968             r += snprintf (buf + r, size -r, ", EX9");
2969         }
2970
2971       if (config & E_NDS32_HAS_MAC_DX_INST)
2972         r += snprintf (buf + r, size -r, ", MAC_DX");
2973
2974       if (config & E_NDS32_HAS_DIV_DX_INST)
2975         r += snprintf (buf + r, size -r, ", DIV_DX");
2976
2977       if (config & E_NDS32_HAS_16BIT_INST)
2978         {
2979           if (version <= E_NDS32_ELF_VER_1_3)
2980             r += snprintf (buf + r, size -r, ", 16b");
2981           else
2982             r += snprintf (buf + r, size -r, ", IFC");
2983         }
2984     }
2985
2986   if (config & E_NDS32_HAS_EXT_INST)
2987     r += snprintf (buf + r, size -r, ", PERF1");
2988
2989   if (config & E_NDS32_HAS_EXT2_INST)
2990     r += snprintf (buf + r, size -r, ", PERF2");
2991
2992   if (config & E_NDS32_HAS_FPU_INST)
2993     {
2994       has_fpu = TRUE;
2995       r += snprintf (buf + r, size -r, ", FPU_SP");
2996     }
2997
2998   if (config & E_NDS32_HAS_FPU_DP_INST)
2999     {
3000       has_fpu = TRUE;
3001       r += snprintf (buf + r, size -r, ", FPU_DP");
3002     }
3003
3004   if (config & E_NDS32_HAS_FPU_MAC_INST)
3005     {
3006       has_fpu = TRUE;
3007       r += snprintf (buf + r, size -r, ", FPU_MAC");
3008     }
3009
3010   if (has_fpu)
3011     {
3012       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3013         {
3014         case E_NDS32_FPU_REG_8SP_4DP:
3015           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3016           break;
3017         case E_NDS32_FPU_REG_16SP_8DP:
3018           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3019           break;
3020         case E_NDS32_FPU_REG_32SP_16DP:
3021           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3022           break;
3023         case E_NDS32_FPU_REG_32SP_32DP:
3024           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3025           break;
3026         }
3027     }
3028
3029   if (config & E_NDS32_HAS_AUDIO_INST)
3030     r += snprintf (buf + r, size -r, ", AUDIO");
3031
3032   if (config & E_NDS32_HAS_STRING_INST)
3033     r += snprintf (buf + r, size -r, ", STR");
3034
3035   if (config & E_NDS32_HAS_REDUCED_REGS)
3036     r += snprintf (buf + r, size -r, ", 16REG");
3037
3038   if (config & E_NDS32_HAS_VIDEO_INST)
3039     {
3040       if (version <= E_NDS32_ELF_VER_1_3)
3041         r += snprintf (buf + r, size -r, ", VIDEO");
3042       else
3043         r += snprintf (buf + r, size -r, ", SATURATION");
3044     }
3045
3046   if (config & E_NDS32_HAS_ENCRIPT_INST)
3047     r += snprintf (buf + r, size -r, ", ENCRP");
3048
3049   if (config & E_NDS32_HAS_L2C_INST)
3050     r += snprintf (buf + r, size -r, ", L2C");
3051 }
3052
3053 static char *
3054 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3055 {
3056   static char buf[1024];
3057
3058   buf[0] = '\0';
3059
3060   if (e_flags)
3061     {
3062       switch (e_machine)
3063         {
3064         default:
3065           break;
3066
3067         case EM_ARC_COMPACT2:
3068         case EM_ARC_COMPACT:
3069           decode_ARC_machine_flags (e_flags, e_machine, buf);
3070           break;
3071
3072         case EM_ARM:
3073           decode_ARM_machine_flags (e_flags, buf);
3074           break;
3075
3076         case EM_AVR:
3077           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3078           break;
3079
3080         case EM_BLACKFIN:
3081           if (e_flags & EF_BFIN_PIC)
3082             strcat (buf, ", PIC");
3083
3084           if (e_flags & EF_BFIN_FDPIC)
3085             strcat (buf, ", FDPIC");
3086
3087           if (e_flags & EF_BFIN_CODE_IN_L1)
3088             strcat (buf, ", code in L1");
3089
3090           if (e_flags & EF_BFIN_DATA_IN_L1)
3091             strcat (buf, ", data in L1");
3092
3093           break;
3094
3095         case EM_CYGNUS_FRV:
3096           switch (e_flags & EF_FRV_CPU_MASK)
3097             {
3098             case EF_FRV_CPU_GENERIC:
3099               break;
3100
3101             default:
3102               strcat (buf, ", fr???");
3103               break;
3104
3105             case EF_FRV_CPU_FR300:
3106               strcat (buf, ", fr300");
3107               break;
3108
3109             case EF_FRV_CPU_FR400:
3110               strcat (buf, ", fr400");
3111               break;
3112             case EF_FRV_CPU_FR405:
3113               strcat (buf, ", fr405");
3114               break;
3115
3116             case EF_FRV_CPU_FR450:
3117               strcat (buf, ", fr450");
3118               break;
3119
3120             case EF_FRV_CPU_FR500:
3121               strcat (buf, ", fr500");
3122               break;
3123             case EF_FRV_CPU_FR550:
3124               strcat (buf, ", fr550");
3125               break;
3126
3127             case EF_FRV_CPU_SIMPLE:
3128               strcat (buf, ", simple");
3129               break;
3130             case EF_FRV_CPU_TOMCAT:
3131               strcat (buf, ", tomcat");
3132               break;
3133             }
3134           break;
3135
3136         case EM_68K:
3137           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3138             strcat (buf, ", m68000");
3139           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3140             strcat (buf, ", cpu32");
3141           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3142             strcat (buf, ", fido_a");
3143           else
3144             {
3145               char const * isa = _("unknown");
3146               char const * mac = _("unknown mac");
3147               char const * additional = NULL;
3148
3149               switch (e_flags & EF_M68K_CF_ISA_MASK)
3150                 {
3151                 case EF_M68K_CF_ISA_A_NODIV:
3152                   isa = "A";
3153                   additional = ", nodiv";
3154                   break;
3155                 case EF_M68K_CF_ISA_A:
3156                   isa = "A";
3157                   break;
3158                 case EF_M68K_CF_ISA_A_PLUS:
3159                   isa = "A+";
3160                   break;
3161                 case EF_M68K_CF_ISA_B_NOUSP:
3162                   isa = "B";
3163                   additional = ", nousp";
3164                   break;
3165                 case EF_M68K_CF_ISA_B:
3166                   isa = "B";
3167                   break;
3168                 case EF_M68K_CF_ISA_C:
3169                   isa = "C";
3170                   break;
3171                 case EF_M68K_CF_ISA_C_NODIV:
3172                   isa = "C";
3173                   additional = ", nodiv";
3174                   break;
3175                 }
3176               strcat (buf, ", cf, isa ");
3177               strcat (buf, isa);
3178               if (additional)
3179                 strcat (buf, additional);
3180               if (e_flags & EF_M68K_CF_FLOAT)
3181                 strcat (buf, ", float");
3182               switch (e_flags & EF_M68K_CF_MAC_MASK)
3183                 {
3184                 case 0:
3185                   mac = NULL;
3186                   break;
3187                 case EF_M68K_CF_MAC:
3188                   mac = "mac";
3189                   break;
3190                 case EF_M68K_CF_EMAC:
3191                   mac = "emac";
3192                   break;
3193                 case EF_M68K_CF_EMAC_B:
3194                   mac = "emac_b";
3195                   break;
3196                 }
3197               if (mac)
3198                 {
3199                   strcat (buf, ", ");
3200                   strcat (buf, mac);
3201                 }
3202             }
3203           break;
3204
3205         case EM_CYGNUS_MEP:
3206           switch (e_flags & EF_MEP_CPU_MASK)
3207             {
3208             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3209             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3210             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3211             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3212             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3213             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3214             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3215             }
3216
3217           switch (e_flags & EF_MEP_COP_MASK)
3218             {
3219             case EF_MEP_COP_NONE: break;
3220             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3221             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3222             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3223             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3224             default: strcat (buf, _("<unknown MeP copro type>")); break;
3225             }
3226
3227           if (e_flags & EF_MEP_LIBRARY)
3228             strcat (buf, ", Built for Library");
3229
3230           if (e_flags & EF_MEP_INDEX_MASK)
3231             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3232                      e_flags & EF_MEP_INDEX_MASK);
3233
3234           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3235             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3236                      e_flags & ~ EF_MEP_ALL_FLAGS);
3237           break;
3238
3239         case EM_PPC:
3240           if (e_flags & EF_PPC_EMB)
3241             strcat (buf, ", emb");
3242
3243           if (e_flags & EF_PPC_RELOCATABLE)
3244             strcat (buf, _(", relocatable"));
3245
3246           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3247             strcat (buf, _(", relocatable-lib"));
3248           break;
3249
3250         case EM_PPC64:
3251           if (e_flags & EF_PPC64_ABI)
3252             {
3253               char abi[] = ", abiv0";
3254
3255               abi[6] += e_flags & EF_PPC64_ABI;
3256               strcat (buf, abi);
3257             }
3258           break;
3259
3260         case EM_V800:
3261           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3262             strcat (buf, ", RH850 ABI");
3263
3264           if (e_flags & EF_V800_850E3)
3265             strcat (buf, ", V3 architecture");
3266
3267           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3268             strcat (buf, ", FPU not used");
3269
3270           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3271             strcat (buf, ", regmode: COMMON");
3272
3273           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3274             strcat (buf, ", r4 not used");
3275
3276           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3277             strcat (buf, ", r30 not used");
3278
3279           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3280             strcat (buf, ", r5 not used");
3281
3282           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3283             strcat (buf, ", r2 not used");
3284
3285           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3286             {
3287               switch (e_flags & - e_flags)
3288                 {
3289                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3290                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3291                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3292                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3293                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3294                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3295                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3296                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3297                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3298                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3299                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3300                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3301                 default: break;
3302                 }
3303             }
3304           break;
3305
3306         case EM_V850:
3307         case EM_CYGNUS_V850:
3308           switch (e_flags & EF_V850_ARCH)
3309             {
3310             case E_V850E3V5_ARCH:
3311               strcat (buf, ", v850e3v5");
3312               break;
3313             case E_V850E2V3_ARCH:
3314               strcat (buf, ", v850e2v3");
3315               break;
3316             case E_V850E2_ARCH:
3317               strcat (buf, ", v850e2");
3318               break;
3319             case E_V850E1_ARCH:
3320               strcat (buf, ", v850e1");
3321               break;
3322             case E_V850E_ARCH:
3323               strcat (buf, ", v850e");
3324               break;
3325             case E_V850_ARCH:
3326               strcat (buf, ", v850");
3327               break;
3328             default:
3329               strcat (buf, _(", unknown v850 architecture variant"));
3330               break;
3331             }
3332           break;
3333
3334         case EM_M32R:
3335         case EM_CYGNUS_M32R:
3336           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3337             strcat (buf, ", m32r");
3338           break;
3339
3340         case EM_MIPS:
3341         case EM_MIPS_RS3_LE:
3342           if (e_flags & EF_MIPS_NOREORDER)
3343             strcat (buf, ", noreorder");
3344
3345           if (e_flags & EF_MIPS_PIC)
3346             strcat (buf, ", pic");
3347
3348           if (e_flags & EF_MIPS_CPIC)
3349             strcat (buf, ", cpic");
3350
3351           if (e_flags & EF_MIPS_UCODE)
3352             strcat (buf, ", ugen_reserved");
3353
3354           if (e_flags & EF_MIPS_ABI2)
3355             strcat (buf, ", abi2");
3356
3357           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3358             strcat (buf, ", odk first");
3359
3360           if (e_flags & EF_MIPS_32BITMODE)
3361             strcat (buf, ", 32bitmode");
3362
3363           if (e_flags & EF_MIPS_NAN2008)
3364             strcat (buf, ", nan2008");
3365
3366           if (e_flags & EF_MIPS_FP64)
3367             strcat (buf, ", fp64");
3368
3369           switch ((e_flags & EF_MIPS_MACH))
3370             {
3371             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3372             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3373             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3374             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3375             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3376             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3377             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3378             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3379             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3380             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3381             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3382             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3383             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3384             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3385             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3386             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3387             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3388             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3389             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3390             case 0:
3391             /* We simply ignore the field in this case to avoid confusion:
3392                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3393                extension.  */
3394               break;
3395             default: strcat (buf, _(", unknown CPU")); break;
3396             }
3397
3398           switch ((e_flags & EF_MIPS_ABI))
3399             {
3400             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3401             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3402             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3403             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3404             case 0:
3405             /* We simply ignore the field in this case to avoid confusion:
3406                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3407                This means it is likely to be an o32 file, but not for
3408                sure.  */
3409               break;
3410             default: strcat (buf, _(", unknown ABI")); break;
3411             }
3412
3413           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3414             strcat (buf, ", mdmx");
3415
3416           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3417             strcat (buf, ", mips16");
3418
3419           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3420             strcat (buf, ", micromips");
3421
3422           switch ((e_flags & EF_MIPS_ARCH))
3423             {
3424             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3425             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3426             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3427             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3428             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3429             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3430             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3431             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3432             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3433             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3434             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3435             default: strcat (buf, _(", unknown ISA")); break;
3436             }
3437           break;
3438
3439         case EM_NDS32:
3440           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3441           break;
3442
3443         case EM_RISCV:
3444           if (e_flags & EF_RISCV_RVC)
3445             strcat (buf, ", RVC");
3446
3447           switch (e_flags & EF_RISCV_FLOAT_ABI)
3448             {
3449             case EF_RISCV_FLOAT_ABI_SOFT:
3450               strcat (buf, ", soft-float ABI");
3451               break;
3452
3453             case EF_RISCV_FLOAT_ABI_SINGLE:
3454               strcat (buf, ", single-float ABI");
3455               break;
3456
3457             case EF_RISCV_FLOAT_ABI_DOUBLE:
3458               strcat (buf, ", double-float ABI");
3459               break;
3460
3461             case EF_RISCV_FLOAT_ABI_QUAD:
3462               strcat (buf, ", quad-float ABI");
3463               break;
3464             }
3465           break;
3466
3467         case EM_SH:
3468           switch ((e_flags & EF_SH_MACH_MASK))
3469             {
3470             case EF_SH1: strcat (buf, ", sh1"); break;
3471             case EF_SH2: strcat (buf, ", sh2"); break;
3472             case EF_SH3: strcat (buf, ", sh3"); break;
3473             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3474             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3475             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3476             case EF_SH3E: strcat (buf, ", sh3e"); break;
3477             case EF_SH4: strcat (buf, ", sh4"); break;
3478             case EF_SH5: strcat (buf, ", sh5"); break;
3479             case EF_SH2E: strcat (buf, ", sh2e"); break;
3480             case EF_SH4A: strcat (buf, ", sh4a"); break;
3481             case EF_SH2A: strcat (buf, ", sh2a"); break;
3482             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3483             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3484             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3485             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3486             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3487             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3488             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3489             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3490             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3491             default: strcat (buf, _(", unknown ISA")); break;
3492             }
3493
3494           if (e_flags & EF_SH_PIC)
3495             strcat (buf, ", pic");
3496
3497           if (e_flags & EF_SH_FDPIC)
3498             strcat (buf, ", fdpic");
3499           break;
3500
3501         case EM_OR1K:
3502           if (e_flags & EF_OR1K_NODELAY)
3503             strcat (buf, ", no delay");
3504           break;
3505
3506         case EM_SPARCV9:
3507           if (e_flags & EF_SPARC_32PLUS)
3508             strcat (buf, ", v8+");
3509
3510           if (e_flags & EF_SPARC_SUN_US1)
3511             strcat (buf, ", ultrasparcI");
3512
3513           if (e_flags & EF_SPARC_SUN_US3)
3514             strcat (buf, ", ultrasparcIII");
3515
3516           if (e_flags & EF_SPARC_HAL_R1)
3517             strcat (buf, ", halr1");
3518
3519           if (e_flags & EF_SPARC_LEDATA)
3520             strcat (buf, ", ledata");
3521
3522           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3523             strcat (buf, ", tso");
3524
3525           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3526             strcat (buf, ", pso");
3527
3528           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3529             strcat (buf, ", rmo");
3530           break;
3531
3532         case EM_PARISC:
3533           switch (e_flags & EF_PARISC_ARCH)
3534             {
3535             case EFA_PARISC_1_0:
3536               strcpy (buf, ", PA-RISC 1.0");
3537               break;
3538             case EFA_PARISC_1_1:
3539               strcpy (buf, ", PA-RISC 1.1");
3540               break;
3541             case EFA_PARISC_2_0:
3542               strcpy (buf, ", PA-RISC 2.0");
3543               break;
3544             default:
3545               break;
3546             }
3547           if (e_flags & EF_PARISC_TRAPNIL)
3548             strcat (buf, ", trapnil");
3549           if (e_flags & EF_PARISC_EXT)
3550             strcat (buf, ", ext");
3551           if (e_flags & EF_PARISC_LSB)
3552             strcat (buf, ", lsb");
3553           if (e_flags & EF_PARISC_WIDE)
3554             strcat (buf, ", wide");
3555           if (e_flags & EF_PARISC_NO_KABP)
3556             strcat (buf, ", no kabp");
3557           if (e_flags & EF_PARISC_LAZYSWAP)
3558             strcat (buf, ", lazyswap");
3559           break;
3560
3561         case EM_PJ:
3562         case EM_PJ_OLD:
3563           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3564             strcat (buf, ", new calling convention");
3565
3566           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3567             strcat (buf, ", gnu calling convention");
3568           break;
3569
3570         case EM_IA_64:
3571           if ((e_flags & EF_IA_64_ABI64))
3572             strcat (buf, ", 64-bit");
3573           else
3574             strcat (buf, ", 32-bit");
3575           if ((e_flags & EF_IA_64_REDUCEDFP))
3576             strcat (buf, ", reduced fp model");
3577           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3578             strcat (buf, ", no function descriptors, constant gp");
3579           else if ((e_flags & EF_IA_64_CONS_GP))
3580             strcat (buf, ", constant gp");
3581           if ((e_flags & EF_IA_64_ABSOLUTE))
3582             strcat (buf, ", absolute");
3583           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3584             {
3585               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3586                 strcat (buf, ", vms_linkages");
3587               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3588                 {
3589                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3590                   break;
3591                 case EF_IA_64_VMS_COMCOD_WARNING:
3592                   strcat (buf, ", warning");
3593                   break;
3594                 case EF_IA_64_VMS_COMCOD_ERROR:
3595                   strcat (buf, ", error");
3596                   break;
3597                 case EF_IA_64_VMS_COMCOD_ABORT:
3598                   strcat (buf, ", abort");
3599                   break;
3600                 default:
3601                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3602                         e_flags & EF_IA_64_VMS_COMCOD);
3603                   strcat (buf, ", <unknown>");
3604                 }
3605             }
3606           break;
3607
3608         case EM_VAX:
3609           if ((e_flags & EF_VAX_NONPIC))
3610             strcat (buf, ", non-PIC");
3611           if ((e_flags & EF_VAX_DFLOAT))
3612             strcat (buf, ", D-Float");
3613           if ((e_flags & EF_VAX_GFLOAT))
3614             strcat (buf, ", G-Float");
3615           break;
3616
3617         case EM_VISIUM:
3618           if (e_flags & EF_VISIUM_ARCH_MCM)
3619             strcat (buf, ", mcm");
3620           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3621             strcat (buf, ", mcm24");
3622           if (e_flags & EF_VISIUM_ARCH_GR6)
3623             strcat (buf, ", gr6");
3624           break;
3625
3626         case EM_RL78:
3627           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3628             {
3629             case E_FLAG_RL78_ANY_CPU: break;
3630             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3631             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3632             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3633             }
3634           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3635             strcat (buf, ", 64-bit doubles");
3636           break;
3637
3638         case EM_RX:
3639           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3640             strcat (buf, ", 64-bit doubles");
3641           if (e_flags & E_FLAG_RX_DSP)
3642             strcat (buf, ", dsp");
3643           if (e_flags & E_FLAG_RX_PID)
3644             strcat (buf, ", pid");
3645           if (e_flags & E_FLAG_RX_ABI)
3646             strcat (buf, ", RX ABI");
3647           if (e_flags & E_FLAG_RX_SINSNS_SET)
3648             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3649                     ? ", uses String instructions" : ", bans String instructions");
3650           if (e_flags & E_FLAG_RX_V2)
3651             strcat (buf, ", V2");
3652           break;
3653
3654         case EM_S390:
3655           if (e_flags & EF_S390_HIGH_GPRS)
3656             strcat (buf, ", highgprs");
3657           break;
3658
3659         case EM_TI_C6000:
3660           if ((e_flags & EF_C6000_REL))
3661             strcat (buf, ", relocatable module");
3662           break;
3663
3664         case EM_MSP430:
3665           strcat (buf, _(": architecture variant: "));
3666           switch (e_flags & EF_MSP430_MACH)
3667             {
3668             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3669             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3670             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3671             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3672             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3673             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3674             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3675             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3676             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3677             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3678             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3679             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3680             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3681             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3682             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3683             default:
3684               strcat (buf, _(": unknown")); break;
3685             }
3686
3687           if (e_flags & ~ EF_MSP430_MACH)
3688             strcat (buf, _(": unknown extra flag bits also present"));
3689         }
3690     }
3691
3692   return buf;
3693 }
3694
3695 static const char *
3696 get_osabi_name (Filedata * filedata, unsigned int osabi)
3697 {
3698   static char buff[32];
3699
3700   switch (osabi)
3701     {
3702     case ELFOSABI_NONE:         return "UNIX - System V";
3703     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3704     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3705     case ELFOSABI_GNU:          return "UNIX - GNU";
3706     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3707     case ELFOSABI_AIX:          return "UNIX - AIX";
3708     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3709     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3710     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3711     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3712     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3713     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3714     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3715     case ELFOSABI_AROS:         return "AROS";
3716     case ELFOSABI_FENIXOS:      return "FenixOS";
3717     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3718     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3719     default:
3720       if (osabi >= 64)
3721         switch (filedata->file_header.e_machine)
3722           {
3723           case EM_ARM:
3724             switch (osabi)
3725               {
3726               case ELFOSABI_ARM:        return "ARM";
3727               case ELFOSABI_ARM_FDPIC:  return "ARM FDPIC";
3728               default:
3729                 break;
3730               }
3731             break;
3732
3733           case EM_MSP430:
3734           case EM_MSP430_OLD:
3735           case EM_VISIUM:
3736             switch (osabi)
3737               {
3738               case ELFOSABI_STANDALONE: return _("Standalone App");
3739               default:
3740                 break;
3741               }
3742             break;
3743
3744           case EM_TI_C6000:
3745             switch (osabi)
3746               {
3747               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3748               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3749               default:
3750                 break;
3751               }
3752             break;
3753
3754           default:
3755             break;
3756           }
3757       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3758       return buff;
3759     }
3760 }
3761
3762 static const char *
3763 get_aarch64_segment_type (unsigned long type)
3764 {
3765   switch (type)
3766     {
3767     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3768     default:                  return NULL;
3769     }
3770 }
3771
3772 static const char *
3773 get_arm_segment_type (unsigned long type)
3774 {
3775   switch (type)
3776     {
3777     case PT_ARM_EXIDX: return "EXIDX";
3778     default:           return NULL;
3779     }
3780 }
3781
3782 static const char *
3783 get_s390_segment_type (unsigned long type)
3784 {
3785   switch (type)
3786     {
3787     case PT_S390_PGSTE: return "S390_PGSTE";
3788     default:            return NULL;
3789     }
3790 }
3791
3792 static const char *
3793 get_mips_segment_type (unsigned long type)
3794 {
3795   switch (type)
3796     {
3797     case PT_MIPS_REGINFO:   return "REGINFO";
3798     case PT_MIPS_RTPROC:    return "RTPROC";
3799     case PT_MIPS_OPTIONS:   return "OPTIONS";
3800     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3801     default:                return NULL;
3802     }
3803 }
3804
3805 static const char *
3806 get_parisc_segment_type (unsigned long type)
3807 {
3808   switch (type)
3809     {
3810     case PT_HP_TLS:             return "HP_TLS";
3811     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3812     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3813     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3814     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3815     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3816     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3817     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3818     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3819     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3820     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3821     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3822     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3823     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3824     case PT_HP_STACK:           return "HP_STACK";
3825     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3826     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3827     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3828     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3829     default:                    return NULL;
3830     }
3831 }
3832
3833 static const char *
3834 get_ia64_segment_type (unsigned long type)
3835 {
3836   switch (type)
3837     {
3838     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3839     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3840     case PT_HP_TLS:             return "HP_TLS";
3841     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3842     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3843     case PT_IA_64_HP_STACK:     return "HP_STACK";
3844     default:                    return NULL;
3845     }
3846 }
3847
3848 static const char *
3849 get_tic6x_segment_type (unsigned long type)
3850 {
3851   switch (type)
3852     {
3853     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3854     default:               return NULL;
3855     }
3856 }
3857
3858 static const char *
3859 get_solaris_segment_type (unsigned long type)
3860 {
3861   switch (type)
3862     {
3863     case 0x6464e550: return "PT_SUNW_UNWIND";
3864     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3865     case 0x6ffffff7: return "PT_LOSUNW";
3866     case 0x6ffffffa: return "PT_SUNWBSS";
3867     case 0x6ffffffb: return "PT_SUNWSTACK";
3868     case 0x6ffffffc: return "PT_SUNWDTRACE";
3869     case 0x6ffffffd: return "PT_SUNWCAP";
3870     case 0x6fffffff: return "PT_HISUNW";
3871     default:         return NULL;
3872     }
3873 }
3874
3875 static const char *
3876 get_segment_type (Filedata * filedata, unsigned long p_type)
3877 {
3878   static char buff[32];
3879
3880   switch (p_type)
3881     {
3882     case PT_NULL:       return "NULL";
3883     case PT_LOAD:       return "LOAD";
3884     case PT_DYNAMIC:    return "DYNAMIC";
3885     case PT_INTERP:     return "INTERP";
3886     case PT_NOTE:       return "NOTE";
3887     case PT_SHLIB:      return "SHLIB";
3888     case PT_PHDR:       return "PHDR";
3889     case PT_TLS:        return "TLS";
3890     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3891     case PT_GNU_STACK:  return "GNU_STACK";
3892     case PT_GNU_RELRO:  return "GNU_RELRO";
3893
3894     default:
3895       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3896         {
3897           sprintf (buff, "GNU_MBIND+%#lx",
3898                    p_type - PT_GNU_MBIND_LO);
3899         }
3900       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3901         {
3902           const char * result;
3903
3904           switch (filedata->file_header.e_machine)
3905             {
3906             case EM_AARCH64:
3907               result = get_aarch64_segment_type (p_type);
3908               break;
3909             case EM_ARM:
3910               result = get_arm_segment_type (p_type);
3911               break;
3912             case EM_MIPS:
3913             case EM_MIPS_RS3_LE:
3914               result = get_mips_segment_type (p_type);
3915               break;
3916             case EM_PARISC:
3917               result = get_parisc_segment_type (p_type);
3918               break;
3919             case EM_IA_64:
3920               result = get_ia64_segment_type (p_type);
3921               break;
3922             case EM_TI_C6000:
3923               result = get_tic6x_segment_type (p_type);
3924               break;
3925             case EM_S390:
3926             case EM_S390_OLD:
3927               result = get_s390_segment_type (p_type);
3928               break;
3929             default:
3930               result = NULL;
3931               break;
3932             }
3933
3934           if (result != NULL)
3935             return result;
3936
3937           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3938         }
3939       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3940         {
3941           const char * result;
3942
3943           switch (filedata->file_header.e_machine)
3944             {
3945             case EM_PARISC:
3946               result = get_parisc_segment_type (p_type);
3947               break;
3948             case EM_IA_64:
3949               result = get_ia64_segment_type (p_type);
3950               break;
3951             default:
3952               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3953                 result = get_solaris_segment_type (p_type);
3954               else
3955                 result = NULL;
3956               break;
3957             }
3958
3959           if (result != NULL)
3960             return result;
3961
3962           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3963         }
3964       else
3965         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3966
3967       return buff;
3968     }
3969 }
3970
3971 static const char *
3972 get_arc_section_type_name (unsigned int sh_type)
3973 {
3974   switch (sh_type)
3975     {
3976     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
3977     default:
3978       break;
3979     }
3980   return NULL;
3981 }
3982
3983 static const char *
3984 get_mips_section_type_name (unsigned int sh_type)
3985 {
3986   switch (sh_type)
3987     {
3988     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3989     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3990     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3991     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3992     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3993     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3994     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3995     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3996     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3997     case SHT_MIPS_RELD:          return "MIPS_RELD";
3998     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3999     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
4000     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
4001     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
4002     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
4003     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
4004     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
4005     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
4006     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
4007     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4008     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4009     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4010     case SHT_MIPS_LINE:          return "MIPS_LINE";
4011     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4012     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4013     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4014     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4015     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4016     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4017     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4018     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4019     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4020     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4021     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4022     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4023     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4024     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4025     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4026     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4027     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4028     default:
4029       break;
4030     }
4031   return NULL;
4032 }
4033
4034 static const char *
4035 get_parisc_section_type_name (unsigned int sh_type)
4036 {
4037   switch (sh_type)
4038     {
4039     case SHT_PARISC_EXT:        return "PARISC_EXT";
4040     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4041     case SHT_PARISC_DOC:        return "PARISC_DOC";
4042     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4043     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4044     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4045     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4046     default:                    return NULL;
4047     }
4048 }
4049
4050 static const char *
4051 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4052 {
4053   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4054   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4055     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4056
4057   switch (sh_type)
4058     {
4059     case SHT_IA_64_EXT:                return "IA_64_EXT";
4060     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4061     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4062     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4063     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4064     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4065     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4066     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4067     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4068     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4069     default:
4070       break;
4071     }
4072   return NULL;
4073 }
4074
4075 static const char *
4076 get_x86_64_section_type_name (unsigned int sh_type)
4077 {
4078   switch (sh_type)
4079     {
4080     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4081     default:                    return NULL;
4082     }
4083 }
4084
4085 static const char *
4086 get_aarch64_section_type_name (unsigned int sh_type)
4087 {
4088   switch (sh_type)
4089     {
4090     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4091     default:                     return NULL;
4092     }
4093 }
4094
4095 static const char *
4096 get_arm_section_type_name (unsigned int sh_type)
4097 {
4098   switch (sh_type)
4099     {
4100     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4101     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4102     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4103     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4104     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4105     default:                      return NULL;
4106     }
4107 }
4108
4109 static const char *
4110 get_tic6x_section_type_name (unsigned int sh_type)
4111 {
4112   switch (sh_type)
4113     {
4114     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4115     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4116     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4117     case SHT_TI_ICODE:          return "TI_ICODE";
4118     case SHT_TI_XREF:           return "TI_XREF";
4119     case SHT_TI_HANDLER:        return "TI_HANDLER";
4120     case SHT_TI_INITINFO:       return "TI_INITINFO";
4121     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4122     default:                    return NULL;
4123     }
4124 }
4125
4126 static const char *
4127 get_msp430x_section_type_name (unsigned int sh_type)
4128 {
4129   switch (sh_type)
4130     {
4131     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4132     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4133     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4134     default:                      return NULL;
4135     }
4136 }
4137
4138 static const char *
4139 get_v850_section_type_name (unsigned int sh_type)
4140 {
4141   switch (sh_type)
4142     {
4143     case SHT_V850_SCOMMON:  return "V850 Small Common";
4144     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4145     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4146     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4147     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4148     default:                return NULL;
4149     }
4150 }
4151
4152 static const char *
4153 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4154 {
4155   static char buff[32];
4156   const char * result;
4157
4158   switch (sh_type)
4159     {
4160     case SHT_NULL:              return "NULL";
4161     case SHT_PROGBITS:          return "PROGBITS";
4162     case SHT_SYMTAB:            return "SYMTAB";
4163     case SHT_STRTAB:            return "STRTAB";
4164     case SHT_RELA:              return "RELA";
4165     case SHT_HASH:              return "HASH";
4166     case SHT_DYNAMIC:           return "DYNAMIC";
4167     case SHT_NOTE:              return "NOTE";
4168     case SHT_NOBITS:            return "NOBITS";
4169     case SHT_REL:               return "REL";
4170     case SHT_SHLIB:             return "SHLIB";
4171     case SHT_DYNSYM:            return "DYNSYM";
4172     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4173     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4174     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4175     case SHT_GNU_HASH:          return "GNU_HASH";
4176     case SHT_GROUP:             return "GROUP";
4177     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
4178     case SHT_GNU_verdef:        return "VERDEF";
4179     case SHT_GNU_verneed:       return "VERNEED";
4180     case SHT_GNU_versym:        return "VERSYM";
4181     case 0x6ffffff0:            return "VERSYM";
4182     case 0x6ffffffc:            return "VERDEF";
4183     case 0x7ffffffd:            return "AUXILIARY";
4184     case 0x7fffffff:            return "FILTER";
4185     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4186
4187     default:
4188       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4189         {
4190           switch (filedata->file_header.e_machine)
4191             {
4192             case EM_ARC:
4193             case EM_ARC_COMPACT:
4194             case EM_ARC_COMPACT2:
4195               result = get_arc_section_type_name (sh_type);
4196               break;
4197             case EM_MIPS:
4198             case EM_MIPS_RS3_LE:
4199               result = get_mips_section_type_name (sh_type);
4200               break;
4201             case EM_PARISC:
4202               result = get_parisc_section_type_name (sh_type);
4203               break;
4204             case EM_IA_64:
4205               result = get_ia64_section_type_name (filedata, sh_type);
4206               break;
4207             case EM_X86_64:
4208             case EM_L1OM:
4209             case EM_K1OM:
4210               result = get_x86_64_section_type_name (sh_type);
4211               break;
4212             case EM_AARCH64:
4213               result = get_aarch64_section_type_name (sh_type);
4214               break;
4215             case EM_ARM:
4216               result = get_arm_section_type_name (sh_type);
4217               break;
4218             case EM_TI_C6000:
4219               result = get_tic6x_section_type_name (sh_type);
4220               break;
4221             case EM_MSP430:
4222               result = get_msp430x_section_type_name (sh_type);
4223               break;
4224             case EM_V800:
4225             case EM_V850:
4226             case EM_CYGNUS_V850:
4227               result = get_v850_section_type_name (sh_type);
4228               break;
4229             default:
4230               result = NULL;
4231               break;
4232             }
4233
4234           if (result != NULL)
4235             return result;
4236
4237           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4238         }
4239       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4240         {
4241           switch (filedata->file_header.e_machine)
4242             {
4243             case EM_IA_64:
4244               result = get_ia64_section_type_name (filedata, sh_type);
4245               break;
4246             default:
4247               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4248                 result = get_solaris_section_type (sh_type);
4249               else
4250                 {
4251                   switch (sh_type)
4252                     {
4253                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4254                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4255                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4256                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4257                     default:
4258                       result = NULL;
4259                       break;
4260                     }
4261                 }
4262               break;
4263             }
4264
4265           if (result != NULL)
4266             return result;
4267
4268           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4269         }
4270       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4271         {
4272           switch (filedata->file_header.e_machine)
4273             {
4274             case EM_V800:
4275             case EM_V850:
4276             case EM_CYGNUS_V850:
4277               result = get_v850_section_type_name (sh_type);
4278               break;
4279             default:
4280               result = NULL;
4281               break;
4282             }
4283
4284           if (result != NULL)
4285             return result;
4286
4287           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4288         }
4289       else
4290         /* This message is probably going to be displayed in a 15
4291            character wide field, so put the hex value first.  */
4292         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4293
4294       return buff;
4295     }
4296 }
4297
4298 #define OPTION_DEBUG_DUMP       512
4299 #define OPTION_DYN_SYMS         513
4300 #define OPTION_DWARF_DEPTH      514
4301 #define OPTION_DWARF_START      515
4302 #define OPTION_DWARF_CHECK      516
4303
4304 static struct option options[] =
4305 {
4306   {"all",              no_argument, 0, 'a'},
4307   {"file-header",      no_argument, 0, 'h'},
4308   {"program-headers",  no_argument, 0, 'l'},
4309   {"headers",          no_argument, 0, 'e'},
4310   {"histogram",        no_argument, 0, 'I'},
4311   {"segments",         no_argument, 0, 'l'},
4312   {"sections",         no_argument, 0, 'S'},
4313   {"section-headers",  no_argument, 0, 'S'},
4314   {"section-groups",   no_argument, 0, 'g'},
4315   {"section-details",  no_argument, 0, 't'},
4316   {"full-section-name",no_argument, 0, 'N'},
4317   {"symbols",          no_argument, 0, 's'},
4318   {"syms",             no_argument, 0, 's'},
4319   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4320   {"relocs",           no_argument, 0, 'r'},
4321   {"notes",            no_argument, 0, 'n'},
4322   {"dynamic",          no_argument, 0, 'd'},
4323   {"arch-specific",    no_argument, 0, 'A'},
4324   {"version-info",     no_argument, 0, 'V'},
4325   {"use-dynamic",      no_argument, 0, 'D'},
4326   {"unwind",           no_argument, 0, 'u'},
4327   {"archive-index",    no_argument, 0, 'c'},
4328   {"hex-dump",         required_argument, 0, 'x'},
4329   {"relocated-dump",   required_argument, 0, 'R'},
4330   {"string-dump",      required_argument, 0, 'p'},
4331   {"decompress",       no_argument, 0, 'z'},
4332 #ifdef SUPPORT_DISASSEMBLY
4333   {"instruction-dump", required_argument, 0, 'i'},
4334 #endif
4335   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4336
4337   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4338   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4339   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4340
4341   {"version",          no_argument, 0, 'v'},
4342   {"wide",             no_argument, 0, 'W'},
4343   {"help",             no_argument, 0, 'H'},
4344   {0,                  no_argument, 0, 0}
4345 };
4346
4347 static void
4348 usage (FILE * stream)
4349 {
4350   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4351   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4352   fprintf (stream, _(" Options are:\n\
4353   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4354   -h --file-header       Display the ELF file header\n\
4355   -l --program-headers   Display the program headers\n\
4356      --segments          An alias for --program-headers\n\
4357   -S --section-headers   Display the sections' header\n\
4358      --sections          An alias for --section-headers\n\
4359   -g --section-groups    Display the section groups\n\
4360   -t --section-details   Display the section details\n\
4361   -e --headers           Equivalent to: -h -l -S\n\
4362   -s --syms              Display the symbol table\n\
4363      --symbols           An alias for --syms\n\
4364   --dyn-syms             Display the dynamic symbol table\n\
4365   -n --notes             Display the core notes (if present)\n\
4366   -r --relocs            Display the relocations (if present)\n\
4367   -u --unwind            Display the unwind info (if present)\n\
4368   -d --dynamic           Display the dynamic section (if present)\n\
4369   -V --version-info      Display the version sections (if present)\n\
4370   -A --arch-specific     Display architecture specific information (if any)\n\
4371   -c --archive-index     Display the symbol/file index in an archive\n\
4372   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4373   -x --hex-dump=<number|name>\n\
4374                          Dump the contents of section <number|name> as bytes\n\
4375   -p --string-dump=<number|name>\n\
4376                          Dump the contents of section <number|name> as strings\n\
4377   -R --relocated-dump=<number|name>\n\
4378                          Dump the contents of section <number|name> as relocated bytes\n\
4379   -z --decompress        Decompress section before dumping it\n\
4380   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4381   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4382                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4383                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4384                =addr,=cu_index,=links,=follow-links]\n\
4385                          Display the contents of DWARF debug sections\n"));
4386   fprintf (stream, _("\
4387   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4388   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4389                          or deeper\n"));
4390 #ifdef SUPPORT_DISASSEMBLY
4391   fprintf (stream, _("\
4392   -i --instruction-dump=<number|name>\n\
4393                          Disassemble the contents of section <number|name>\n"));
4394 #endif
4395   fprintf (stream, _("\
4396   -I --histogram         Display histogram of bucket list lengths\n\
4397   -W --wide              Allow output width to exceed 80 characters\n\
4398   @<file>                Read options from <file>\n\
4399   -H --help              Display this information\n\
4400   -v --version           Display the version number of readelf\n"));
4401
4402   if (REPORT_BUGS_TO[0] && stream == stdout)
4403     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4404
4405   exit (stream == stdout ? 0 : 1);
4406 }
4407
4408 /* Record the fact that the user wants the contents of section number
4409    SECTION to be displayed using the method(s) encoded as flags bits
4410    in TYPE.  Note, TYPE can be zero if we are creating the array for
4411    the first time.  */
4412
4413 static void
4414 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4415 {
4416   if (section >= filedata->num_dump_sects)
4417     {
4418       dump_type * new_dump_sects;
4419
4420       new_dump_sects = (dump_type *) calloc (section + 1,
4421                                              sizeof (* new_dump_sects));
4422
4423       if (new_dump_sects == NULL)
4424         error (_("Out of memory allocating dump request table.\n"));
4425       else
4426         {
4427           if (filedata->dump_sects)
4428             {
4429               /* Copy current flag settings.  */
4430               memcpy (new_dump_sects, filedata->dump_sects,
4431                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4432
4433               free (filedata->dump_sects);
4434             }
4435
4436           filedata->dump_sects = new_dump_sects;
4437           filedata->num_dump_sects = section + 1;
4438         }
4439     }
4440
4441   if (filedata->dump_sects)
4442     filedata->dump_sects[section] |= type;
4443 }
4444
4445 /* Request a dump by section name.  */
4446
4447 static void
4448 request_dump_byname (const char * section, dump_type type)
4449 {
4450   struct dump_list_entry * new_request;
4451
4452   new_request = (struct dump_list_entry *)
4453       malloc (sizeof (struct dump_list_entry));
4454   if (!new_request)
4455     error (_("Out of memory allocating dump request table.\n"));
4456
4457   new_request->name = strdup (section);
4458   if (!new_request->name)
4459     error (_("Out of memory allocating dump request table.\n"));
4460
4461   new_request->type = type;
4462
4463   new_request->next = dump_sects_byname;
4464   dump_sects_byname = new_request;
4465 }
4466
4467 static inline void
4468 request_dump (Filedata * filedata, dump_type type)
4469 {
4470   int section;
4471   char * cp;
4472
4473   do_dump++;
4474   section = strtoul (optarg, & cp, 0);
4475
4476   if (! *cp && section >= 0)
4477     request_dump_bynumber (filedata, section, type);
4478   else
4479     request_dump_byname (optarg, type);
4480 }
4481
4482 static void
4483 parse_args (Filedata * filedata, int argc, char ** argv)
4484 {
4485   int c;
4486
4487   if (argc < 2)
4488     usage (stderr);
4489
4490   while ((c = getopt_long
4491           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4492     {
4493       switch (c)
4494         {
4495         case 0:
4496           /* Long options.  */
4497           break;
4498         case 'H':
4499           usage (stdout);
4500           break;
4501
4502         case 'a':
4503           do_syms = TRUE;
4504           do_reloc = TRUE;
4505           do_unwind = TRUE;
4506           do_dynamic = TRUE;
4507           do_header = TRUE;
4508           do_sections = TRUE;
4509           do_section_groups = TRUE;
4510           do_segments = TRUE;
4511           do_version = TRUE;
4512           do_histogram = TRUE;
4513           do_arch = TRUE;
4514           do_notes = TRUE;
4515           break;
4516         case 'g':
4517           do_section_groups = TRUE;
4518           break;
4519         case 't':
4520         case 'N':
4521           do_sections = TRUE;
4522           do_section_details = TRUE;
4523           break;
4524         case 'e':
4525           do_header = TRUE;
4526           do_sections = TRUE;
4527           do_segments = TRUE;
4528           break;
4529         case 'A':
4530           do_arch = TRUE;
4531           break;
4532         case 'D':
4533           do_using_dynamic = TRUE;
4534           break;
4535         case 'r':
4536           do_reloc = TRUE;
4537           break;
4538         case 'u':
4539           do_unwind = TRUE;
4540           break;
4541         case 'h':
4542           do_header = TRUE;
4543           break;
4544         case 'l':
4545           do_segments = TRUE;
4546           break;
4547         case 's':
4548           do_syms = TRUE;
4549           break;
4550         case 'S':
4551           do_sections = TRUE;
4552           break;
4553         case 'd':
4554           do_dynamic = TRUE;
4555           break;
4556         case 'I':
4557           do_histogram = TRUE;
4558           break;
4559         case 'n':
4560           do_notes = TRUE;
4561           break;
4562         case 'c':
4563           do_archive_index = TRUE;
4564           break;
4565         case 'x':
4566           request_dump (filedata, HEX_DUMP);
4567           break;
4568         case 'p':
4569           request_dump (filedata, STRING_DUMP);
4570           break;
4571         case 'R':
4572           request_dump (filedata, RELOC_DUMP);
4573           break;
4574         case 'z':
4575           decompress_dumps = TRUE;
4576           break;
4577         case 'w':
4578           do_dump = TRUE;
4579           if (optarg == 0)
4580             {
4581               do_debugging = TRUE;
4582               dwarf_select_sections_all ();
4583             }
4584           else
4585             {
4586               do_debugging = FALSE;
4587               dwarf_select_sections_by_letters (optarg);
4588             }
4589           break;
4590         case OPTION_DEBUG_DUMP:
4591           do_dump = TRUE;
4592           if (optarg == 0)
4593             do_debugging = TRUE;
4594           else
4595             {
4596               do_debugging = FALSE;
4597               dwarf_select_sections_by_names (optarg);
4598             }
4599           break;
4600         case OPTION_DWARF_DEPTH:
4601           {
4602             char *cp;
4603
4604             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4605           }
4606           break;
4607         case OPTION_DWARF_START:
4608           {
4609             char *cp;
4610
4611             dwarf_start_die = strtoul (optarg, & cp, 0);
4612           }
4613           break;
4614         case OPTION_DWARF_CHECK:
4615           dwarf_check = TRUE;
4616           break;
4617         case OPTION_DYN_SYMS:
4618           do_dyn_syms = TRUE;
4619           break;
4620 #ifdef SUPPORT_DISASSEMBLY
4621         case 'i':
4622           request_dump (filedata, DISASS_DUMP);
4623           break;
4624 #endif
4625         case 'v':
4626           print_version (program_name);
4627           break;
4628         case 'V':
4629           do_version = TRUE;
4630           break;
4631         case 'W':
4632           do_wide = TRUE;
4633           break;
4634         default:
4635           /* xgettext:c-format */
4636           error (_("Invalid option '-%c'\n"), c);
4637           /* Fall through.  */
4638         case '?':
4639           usage (stderr);
4640         }
4641     }
4642
4643   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4644       && !do_segments && !do_header && !do_dump && !do_version
4645       && !do_histogram && !do_debugging && !do_arch && !do_notes
4646       && !do_section_groups && !do_archive_index
4647       && !do_dyn_syms)
4648     usage (stderr);
4649 }
4650
4651 static const char *
4652 get_elf_class (unsigned int elf_class)
4653 {
4654   static char buff[32];
4655
4656   switch (elf_class)
4657     {
4658     case ELFCLASSNONE: return _("none");
4659     case ELFCLASS32:   return "ELF32";
4660     case ELFCLASS64:   return "ELF64";
4661     default:
4662       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4663       return buff;
4664     }
4665 }
4666
4667 static const char *
4668 get_data_encoding (unsigned int encoding)
4669 {
4670   static char buff[32];
4671
4672   switch (encoding)
4673     {
4674     case ELFDATANONE: return _("none");
4675     case ELFDATA2LSB: return _("2's complement, little endian");
4676     case ELFDATA2MSB: return _("2's complement, big endian");
4677     default:
4678       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4679       return buff;
4680     }
4681 }
4682
4683 /* Decode the data held in 'filedata->file_header'.  */
4684
4685 static bfd_boolean
4686 process_file_header (Filedata * filedata)
4687 {
4688   Elf_Internal_Ehdr * header = & filedata->file_header;
4689
4690   if (   header->e_ident[EI_MAG0] != ELFMAG0
4691       || header->e_ident[EI_MAG1] != ELFMAG1
4692       || header->e_ident[EI_MAG2] != ELFMAG2
4693       || header->e_ident[EI_MAG3] != ELFMAG3)
4694     {
4695       error
4696         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4697       return FALSE;
4698     }
4699
4700   init_dwarf_regnames (header->e_machine);
4701
4702   if (do_header)
4703     {
4704       unsigned i;
4705
4706       printf (_("ELF Header:\n"));
4707       printf (_("  Magic:   "));
4708       for (i = 0; i < EI_NIDENT; i++)
4709         printf ("%2.2x ", header->e_ident[i]);
4710       printf ("\n");
4711       printf (_("  Class:                             %s\n"),
4712               get_elf_class (header->e_ident[EI_CLASS]));
4713       printf (_("  Data:                              %s\n"),
4714               get_data_encoding (header->e_ident[EI_DATA]));
4715       printf (_("  Version:                           %d %s\n"),
4716               header->e_ident[EI_VERSION],
4717               (header->e_ident[EI_VERSION] == EV_CURRENT
4718                ? "(current)"
4719                : (header->e_ident[EI_VERSION] != EV_NONE
4720                   ? _("<unknown: %lx>")
4721                   : "")));
4722       printf (_("  OS/ABI:                            %s\n"),
4723               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4724       printf (_("  ABI Version:                       %d\n"),
4725               header->e_ident[EI_ABIVERSION]);
4726       printf (_("  Type:                              %s\n"),
4727               get_file_type (header->e_type));
4728       printf (_("  Machine:                           %s\n"),
4729               get_machine_name (header->e_machine));
4730       printf (_("  Version:                           0x%lx\n"),
4731               (unsigned long) header->e_version);
4732
4733       printf (_("  Entry point address:               "));
4734       print_vma ((bfd_vma) header->e_entry, PREFIX_HEX);
4735       printf (_("\n  Start of program headers:          "));
4736       print_vma ((bfd_vma) header->e_phoff, DEC);
4737       printf (_(" (bytes into file)\n  Start of section headers:          "));
4738       print_vma ((bfd_vma) header->e_shoff, DEC);
4739       printf (_(" (bytes into file)\n"));
4740
4741       printf (_("  Flags:                             0x%lx%s\n"),
4742               (unsigned long) header->e_flags,
4743               get_machine_flags (filedata, header->e_flags, header->e_machine));
4744       printf (_("  Size of this header:               %ld (bytes)\n"),
4745               (long) header->e_ehsize);
4746       printf (_("  Size of program headers:           %ld (bytes)\n"),
4747               (long) header->e_phentsize);
4748       printf (_("  Number of program headers:         %ld"),
4749               (long) header->e_phnum);
4750       if (filedata->section_headers != NULL
4751           && header->e_phnum == PN_XNUM
4752           && filedata->section_headers[0].sh_info != 0)
4753         printf (" (%ld)", (long) filedata->section_headers[0].sh_info);
4754       putc ('\n', stdout);
4755       printf (_("  Size of section headers:           %ld (bytes)\n"),
4756               (long) header->e_shentsize);
4757       printf (_("  Number of section headers:         %ld"),
4758               (long) header->e_shnum);
4759       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4760         printf (" (%ld)", (long) filedata->section_headers[0].sh_size);
4761       putc ('\n', stdout);
4762       printf (_("  Section header string table index: %ld"),
4763               (long) header->e_shstrndx);
4764       if (filedata->section_headers != NULL
4765           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4766         printf (" (%u)", filedata->section_headers[0].sh_link);
4767       else if (header->e_shstrndx != SHN_UNDEF
4768                && header->e_shstrndx >= header->e_shnum)
4769         printf (_(" <corrupt: out of range>"));
4770       putc ('\n', stdout);
4771     }
4772
4773   if (filedata->section_headers != NULL)
4774     {
4775       if (header->e_phnum == PN_XNUM
4776           && filedata->section_headers[0].sh_info != 0)
4777         header->e_phnum = filedata->section_headers[0].sh_info;
4778       if (header->e_shnum == SHN_UNDEF)
4779         header->e_shnum = filedata->section_headers[0].sh_size;
4780       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4781         header->e_shstrndx = filedata->section_headers[0].sh_link;
4782       if (header->e_shstrndx >= header->e_shnum)
4783         header->e_shstrndx = SHN_UNDEF;
4784       free (filedata->section_headers);
4785       filedata->section_headers = NULL;
4786     }
4787
4788   return TRUE;
4789 }
4790
4791 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4792    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4793
4794 static bfd_boolean
4795 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4796 {
4797   Elf32_External_Phdr * phdrs;
4798   Elf32_External_Phdr * external;
4799   Elf_Internal_Phdr *   internal;
4800   unsigned int i;
4801   unsigned int size = filedata->file_header.e_phentsize;
4802   unsigned int num  = filedata->file_header.e_phnum;
4803
4804   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4805   if (size == 0 || num == 0)
4806     return FALSE;
4807   if (size < sizeof * phdrs)
4808     {
4809       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4810       return FALSE;
4811     }
4812   if (size > sizeof * phdrs)
4813     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4814
4815   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4816                                             size, num, _("program headers"));
4817   if (phdrs == NULL)
4818     return FALSE;
4819
4820   for (i = 0, internal = pheaders, external = phdrs;
4821        i < filedata->file_header.e_phnum;
4822        i++, internal++, external++)
4823     {
4824       internal->p_type   = BYTE_GET (external->p_type);
4825       internal->p_offset = BYTE_GET (external->p_offset);
4826       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4827       internal->p_paddr  = BYTE_GET (external->p_paddr);
4828       internal->p_filesz = BYTE_GET (external->p_filesz);
4829       internal->p_memsz  = BYTE_GET (external->p_memsz);
4830       internal->p_flags  = BYTE_GET (external->p_flags);
4831       internal->p_align  = BYTE_GET (external->p_align);
4832     }
4833
4834   free (phdrs);
4835   return TRUE;
4836 }
4837
4838 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4839    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4840
4841 static bfd_boolean
4842 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4843 {
4844   Elf64_External_Phdr * phdrs;
4845   Elf64_External_Phdr * external;
4846   Elf_Internal_Phdr *   internal;
4847   unsigned int i;
4848   unsigned int size = filedata->file_header.e_phentsize;
4849   unsigned int num  = filedata->file_header.e_phnum;
4850
4851   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4852   if (size == 0 || num == 0)
4853     return FALSE;
4854   if (size < sizeof * phdrs)
4855     {
4856       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4857       return FALSE;
4858     }
4859   if (size > sizeof * phdrs)
4860     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4861
4862   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4863                                             size, num, _("program headers"));
4864   if (!phdrs)
4865     return FALSE;
4866
4867   for (i = 0, internal = pheaders, external = phdrs;
4868        i < filedata->file_header.e_phnum;
4869        i++, internal++, external++)
4870     {
4871       internal->p_type   = BYTE_GET (external->p_type);
4872       internal->p_flags  = BYTE_GET (external->p_flags);
4873       internal->p_offset = BYTE_GET (external->p_offset);
4874       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4875       internal->p_paddr  = BYTE_GET (external->p_paddr);
4876       internal->p_filesz = BYTE_GET (external->p_filesz);
4877       internal->p_memsz  = BYTE_GET (external->p_memsz);
4878       internal->p_align  = BYTE_GET (external->p_align);
4879     }
4880
4881   free (phdrs);
4882   return TRUE;
4883 }
4884
4885 /* Returns TRUE if the program headers were read into `program_headers'.  */
4886
4887 static bfd_boolean
4888 get_program_headers (Filedata * filedata)
4889 {
4890   Elf_Internal_Phdr * phdrs;
4891
4892   /* Check cache of prior read.  */
4893   if (filedata->program_headers != NULL)
4894     return TRUE;
4895
4896   /* Be kind to memory checkers by looking for
4897      e_phnum values which we know must be invalid.  */
4898   if (filedata->file_header.e_phnum
4899       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4900       >= filedata->file_size)
4901     {
4902       error (_("Too many program headers - %#x - the file is not that big\n"),
4903              filedata->file_header.e_phnum);
4904       return FALSE;
4905     }
4906
4907   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4908                                          sizeof (Elf_Internal_Phdr));
4909   if (phdrs == NULL)
4910     {
4911       error (_("Out of memory reading %u program headers\n"),
4912              filedata->file_header.e_phnum);
4913       return FALSE;
4914     }
4915
4916   if (is_32bit_elf
4917       ? get_32bit_program_headers (filedata, phdrs)
4918       : get_64bit_program_headers (filedata, phdrs))
4919     {
4920       filedata->program_headers = phdrs;
4921       return TRUE;
4922     }
4923
4924   free (phdrs);
4925   return FALSE;
4926 }
4927
4928 /* Returns TRUE if the program headers were loaded.  */
4929
4930 static bfd_boolean
4931 process_program_headers (Filedata * filedata)
4932 {
4933   Elf_Internal_Phdr * segment;
4934   unsigned int i;
4935   Elf_Internal_Phdr * previous_load = NULL;
4936
4937   if (filedata->file_header.e_phnum == 0)
4938     {
4939       /* PR binutils/12467.  */
4940       if (filedata->file_header.e_phoff != 0)
4941         {
4942           warn (_("possibly corrupt ELF header - it has a non-zero program"
4943                   " header offset, but no program headers\n"));
4944           return FALSE;
4945         }
4946       else if (do_segments)
4947         printf (_("\nThere are no program headers in this file.\n"));
4948       return TRUE;
4949     }
4950
4951   if (do_segments && !do_header)
4952     {
4953       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
4954       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
4955       printf (ngettext ("There is %d program header, starting at offset %s\n",
4956                         "There are %d program headers, starting at offset %s\n",
4957                         filedata->file_header.e_phnum),
4958               filedata->file_header.e_phnum,
4959               bfd_vmatoa ("u", filedata->file_header.e_phoff));
4960     }
4961
4962   if (! get_program_headers (filedata))
4963     return TRUE;
4964
4965   if (do_segments)
4966     {
4967       if (filedata->file_header.e_phnum > 1)
4968         printf (_("\nProgram Headers:\n"));
4969       else
4970         printf (_("\nProgram Headers:\n"));
4971
4972       if (is_32bit_elf)
4973         printf
4974           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4975       else if (do_wide)
4976         printf
4977           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4978       else
4979         {
4980           printf
4981             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4982           printf
4983             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4984         }
4985     }
4986
4987   dynamic_addr = 0;
4988   dynamic_size = 0;
4989
4990   for (i = 0, segment = filedata->program_headers;
4991        i < filedata->file_header.e_phnum;
4992        i++, segment++)
4993     {
4994       if (do_segments)
4995         {
4996           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
4997
4998           if (is_32bit_elf)
4999             {
5000               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5001               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5002               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5003               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5004               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5005               printf ("%c%c%c ",
5006                       (segment->p_flags & PF_R ? 'R' : ' '),
5007                       (segment->p_flags & PF_W ? 'W' : ' '),
5008                       (segment->p_flags & PF_X ? 'E' : ' '));
5009               printf ("%#lx", (unsigned long) segment->p_align);
5010             }
5011           else if (do_wide)
5012             {
5013               if ((unsigned long) segment->p_offset == segment->p_offset)
5014                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5015               else
5016                 {
5017                   print_vma (segment->p_offset, FULL_HEX);
5018                   putchar (' ');
5019                 }
5020
5021               print_vma (segment->p_vaddr, FULL_HEX);
5022               putchar (' ');
5023               print_vma (segment->p_paddr, FULL_HEX);
5024               putchar (' ');
5025
5026               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5027                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5028               else
5029                 {
5030                   print_vma (segment->p_filesz, FULL_HEX);
5031                   putchar (' ');
5032                 }
5033
5034               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5035                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5036               else
5037                 {
5038                   print_vma (segment->p_memsz, FULL_HEX);
5039                 }
5040
5041               printf (" %c%c%c ",
5042                       (segment->p_flags & PF_R ? 'R' : ' '),
5043                       (segment->p_flags & PF_W ? 'W' : ' '),
5044                       (segment->p_flags & PF_X ? 'E' : ' '));
5045
5046               if ((unsigned long) segment->p_align == segment->p_align)
5047                 printf ("%#lx", (unsigned long) segment->p_align);
5048               else
5049                 {
5050                   print_vma (segment->p_align, PREFIX_HEX);
5051                 }
5052             }
5053           else
5054             {
5055               print_vma (segment->p_offset, FULL_HEX);
5056               putchar (' ');
5057               print_vma (segment->p_vaddr, FULL_HEX);
5058               putchar (' ');
5059               print_vma (segment->p_paddr, FULL_HEX);
5060               printf ("\n                 ");
5061               print_vma (segment->p_filesz, FULL_HEX);
5062               putchar (' ');
5063               print_vma (segment->p_memsz, FULL_HEX);
5064               printf ("  %c%c%c    ",
5065                       (segment->p_flags & PF_R ? 'R' : ' '),
5066                       (segment->p_flags & PF_W ? 'W' : ' '),
5067                       (segment->p_flags & PF_X ? 'E' : ' '));
5068               print_vma (segment->p_align, PREFIX_HEX);
5069             }
5070
5071           putc ('\n', stdout);
5072         }
5073
5074       switch (segment->p_type)
5075         {
5076         case PT_LOAD:
5077 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5078          required by the ELF standard, several programs, including the Linux
5079          kernel, make use of non-ordered segments.  */
5080           if (previous_load
5081               && previous_load->p_vaddr > segment->p_vaddr)
5082             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5083 #endif
5084           if (segment->p_memsz < segment->p_filesz)
5085             error (_("the segment's file size is larger than its memory size\n"));
5086           previous_load = segment;
5087           break;
5088
5089         case PT_PHDR:
5090           /* PR 20815 - Verify that the program header is loaded into memory.  */
5091           if (i > 0 && previous_load != NULL)
5092             error (_("the PHDR segment must occur before any LOAD segment\n"));
5093           if (filedata->file_header.e_machine != EM_PARISC)
5094             {
5095               unsigned int j;
5096
5097               for (j = 1; j < filedata->file_header.e_phnum; j++)
5098                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5099                     && (filedata->program_headers[j].p_vaddr
5100                         + filedata->program_headers[j].p_memsz)
5101                     >= (segment->p_vaddr + segment->p_filesz))
5102                   break;
5103               if (j == filedata->file_header.e_phnum)
5104                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5105             }
5106           break;
5107
5108         case PT_DYNAMIC:
5109           if (dynamic_addr)
5110             error (_("more than one dynamic segment\n"));
5111
5112           /* By default, assume that the .dynamic section is the first
5113              section in the DYNAMIC segment.  */
5114           dynamic_addr = segment->p_offset;
5115           dynamic_size = segment->p_filesz;
5116
5117           /* Try to locate the .dynamic section. If there is
5118              a section header table, we can easily locate it.  */
5119           if (filedata->section_headers != NULL)
5120             {
5121               Elf_Internal_Shdr * sec;
5122
5123               sec = find_section (filedata, ".dynamic");
5124               if (sec == NULL || sec->sh_size == 0)
5125                 {
5126                   /* A corresponding .dynamic section is expected, but on
5127                      IA-64/OpenVMS it is OK for it to be missing.  */
5128                   if (!is_ia64_vms (filedata))
5129                     error (_("no .dynamic section in the dynamic segment\n"));
5130                   break;
5131                 }
5132
5133               if (sec->sh_type == SHT_NOBITS)
5134                 {
5135                   dynamic_size = 0;
5136                   break;
5137                 }
5138
5139               dynamic_addr = sec->sh_offset;
5140               dynamic_size = sec->sh_size;
5141
5142               if (dynamic_addr < segment->p_offset
5143                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5144                 warn (_("the .dynamic section is not contained"
5145                         " within the dynamic segment\n"));
5146               else if (dynamic_addr > segment->p_offset)
5147                 warn (_("the .dynamic section is not the first section"
5148                         " in the dynamic segment.\n"));
5149             }
5150
5151           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5152              segment.  Check this after matching against the section headers
5153              so we don't warn on debuginfo file (which have NOBITS .dynamic
5154              sections).  */
5155           if (dynamic_addr + dynamic_size >= filedata->file_size)
5156             {
5157               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5158               dynamic_addr = dynamic_size = 0;
5159             }
5160           break;
5161
5162         case PT_INTERP:
5163           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5164                      SEEK_SET))
5165             error (_("Unable to find program interpreter name\n"));
5166           else
5167             {
5168               char fmt [32];
5169               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5170
5171               if (ret >= (int) sizeof (fmt) || ret < 0)
5172                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5173
5174               program_interpreter[0] = 0;
5175               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5176                 error (_("Unable to read program interpreter name\n"));
5177
5178               if (do_segments)
5179                 printf (_("      [Requesting program interpreter: %s]\n"),
5180                     program_interpreter);
5181             }
5182           break;
5183         }
5184     }
5185
5186   if (do_segments
5187       && filedata->section_headers != NULL
5188       && filedata->string_table != NULL)
5189     {
5190       printf (_("\n Section to Segment mapping:\n"));
5191       printf (_("  Segment Sections...\n"));
5192
5193       for (i = 0; i < filedata->file_header.e_phnum; i++)
5194         {
5195           unsigned int j;
5196           Elf_Internal_Shdr * section;
5197
5198           segment = filedata->program_headers + i;
5199           section = filedata->section_headers + 1;
5200
5201           printf ("   %2.2d     ", i);
5202
5203           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5204             {
5205               if (!ELF_TBSS_SPECIAL (section, segment)
5206                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5207                 printf ("%s ", printable_section_name (filedata, section));
5208             }
5209
5210           putc ('\n',stdout);
5211         }
5212     }
5213
5214   return TRUE;
5215 }
5216
5217
5218 /* Find the file offset corresponding to VMA by using the program headers.  */
5219
5220 static long
5221 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5222 {
5223   Elf_Internal_Phdr * seg;
5224
5225   if (! get_program_headers (filedata))
5226     {
5227       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5228       return (long) vma;
5229     }
5230
5231   for (seg = filedata->program_headers;
5232        seg < filedata->program_headers + filedata->file_header.e_phnum;
5233        ++seg)
5234     {
5235       if (seg->p_type != PT_LOAD)
5236         continue;
5237
5238       if (vma >= (seg->p_vaddr & -seg->p_align)
5239           && vma + size <= seg->p_vaddr + seg->p_filesz)
5240         return vma - seg->p_vaddr + seg->p_offset;
5241     }
5242
5243   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5244         (unsigned long) vma);
5245   return (long) vma;
5246 }
5247
5248
5249 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5250    If PROBE is true, this is just a probe and we do not generate any error
5251    messages if the load fails.  */
5252
5253 static bfd_boolean
5254 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5255 {
5256   Elf32_External_Shdr * shdrs;
5257   Elf_Internal_Shdr *   internal;
5258   unsigned int          i;
5259   unsigned int          size = filedata->file_header.e_shentsize;
5260   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5261
5262   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5263   if (size == 0 || num == 0)
5264     return FALSE;
5265   if (size < sizeof * shdrs)
5266     {
5267       if (! probe)
5268         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5269       return FALSE;
5270     }
5271   if (!probe && size > sizeof * shdrs)
5272     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5273
5274   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5275                                             size, num,
5276                                             probe ? NULL : _("section headers"));
5277   if (shdrs == NULL)
5278     return FALSE;
5279
5280   free (filedata->section_headers);
5281   filedata->section_headers = (Elf_Internal_Shdr *)
5282     cmalloc (num, sizeof (Elf_Internal_Shdr));
5283   if (filedata->section_headers == NULL)
5284     {
5285       if (!probe)
5286         error (_("Out of memory reading %u section headers\n"), num);
5287       return FALSE;
5288     }
5289
5290   for (i = 0, internal = filedata->section_headers;
5291        i < num;
5292        i++, internal++)
5293     {
5294       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5295       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5296       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5297       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5298       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5299       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5300       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5301       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5302       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5303       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5304       if (!probe && internal->sh_link > num)
5305         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5306       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5307         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5308     }
5309
5310   free (shdrs);
5311   return TRUE;
5312 }
5313
5314 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5315
5316 static bfd_boolean
5317 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5318 {
5319   Elf64_External_Shdr *  shdrs;
5320   Elf_Internal_Shdr *    internal;
5321   unsigned int           i;
5322   unsigned int           size = filedata->file_header.e_shentsize;
5323   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5324
5325   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5326   if (size == 0 || num == 0)
5327     return FALSE;
5328
5329   if (size < sizeof * shdrs)
5330     {
5331       if (! probe)
5332         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5333       return FALSE;
5334     }
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 = (Elf64_External_Shdr *) get_data (NULL, filedata,
5340                                             filedata->file_header.e_shoff,
5341                                             size, num,
5342                                             probe ? NULL : _("section headers"));
5343   if (shdrs == NULL)
5344     return FALSE;
5345
5346   free (filedata->section_headers);
5347   filedata->section_headers = (Elf_Internal_Shdr *)
5348     cmalloc (num, sizeof (Elf_Internal_Shdr));
5349   if (filedata->section_headers == NULL)
5350     {
5351       if (! probe)
5352         error (_("Out of memory reading %u section headers\n"), num);
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_size      = BYTE_GET (shdrs[i].sh_size);
5365       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5366       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5367       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5368       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5369       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
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 static Elf_Internal_Sym *
5381 get_32bit_elf_symbols (Filedata *           filedata,
5382                        Elf_Internal_Shdr *  section,
5383                        unsigned long *      num_syms_return)
5384 {
5385   unsigned long number = 0;
5386   Elf32_External_Sym * esyms = NULL;
5387   Elf_External_Sym_Shndx * shndx = NULL;
5388   Elf_Internal_Sym * isyms = NULL;
5389   Elf_Internal_Sym * psym;
5390   unsigned int j;
5391
5392   if (section->sh_size == 0)
5393     {
5394       if (num_syms_return != NULL)
5395         * num_syms_return = 0;
5396       return NULL;
5397     }
5398
5399   /* Run some sanity checks first.  */
5400   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5401     {
5402       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5403              printable_section_name (filedata, section),
5404              (unsigned long) section->sh_entsize);
5405       goto exit_point;
5406     }
5407
5408   if (section->sh_size > filedata->file_size)
5409     {
5410       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5411              printable_section_name (filedata, section),
5412              (unsigned long) section->sh_size);
5413       goto exit_point;
5414     }
5415
5416   number = section->sh_size / section->sh_entsize;
5417
5418   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5419     {
5420       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5421              (unsigned long) section->sh_size,
5422              printable_section_name (filedata, section),
5423              (unsigned long) section->sh_entsize);
5424       goto exit_point;
5425     }
5426
5427   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5428                                            section->sh_size, _("symbols"));
5429   if (esyms == NULL)
5430     goto exit_point;
5431
5432   {
5433     elf_section_list * entry;
5434
5435     shndx = NULL;
5436     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5437       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5438         {
5439           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5440                                                        entry->hdr->sh_offset,
5441                                                        1, entry->hdr->sh_size,
5442                                                        _("symbol table section indicies"));
5443           if (shndx == NULL)
5444             goto exit_point;
5445           /* PR17531: file: heap-buffer-overflow */
5446           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5447             {
5448               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5449                      printable_section_name (filedata, entry->hdr),
5450                      (unsigned long) entry->hdr->sh_size,
5451                      (unsigned long) section->sh_size);
5452               goto exit_point;
5453             }
5454         }
5455   }
5456
5457   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5458
5459   if (isyms == NULL)
5460     {
5461       error (_("Out of memory reading %lu symbols\n"),
5462              (unsigned long) number);
5463       goto exit_point;
5464     }
5465
5466   for (j = 0, psym = isyms; j < number; j++, psym++)
5467     {
5468       psym->st_name  = BYTE_GET (esyms[j].st_name);
5469       psym->st_value = BYTE_GET (esyms[j].st_value);
5470       psym->st_size  = BYTE_GET (esyms[j].st_size);
5471       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5472       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5473         psym->st_shndx
5474           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5475       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5476         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5477       psym->st_info  = BYTE_GET (esyms[j].st_info);
5478       psym->st_other = BYTE_GET (esyms[j].st_other);
5479     }
5480
5481  exit_point:
5482   if (shndx != NULL)
5483     free (shndx);
5484   if (esyms != NULL)
5485     free (esyms);
5486
5487   if (num_syms_return != NULL)
5488     * num_syms_return = isyms == NULL ? 0 : number;
5489
5490   return isyms;
5491 }
5492
5493 static Elf_Internal_Sym *
5494 get_64bit_elf_symbols (Filedata *           filedata,
5495                        Elf_Internal_Shdr *  section,
5496                        unsigned long *      num_syms_return)
5497 {
5498   unsigned long number = 0;
5499   Elf64_External_Sym * esyms = NULL;
5500   Elf_External_Sym_Shndx * shndx = NULL;
5501   Elf_Internal_Sym * isyms = NULL;
5502   Elf_Internal_Sym * psym;
5503   unsigned int j;
5504
5505   if (section->sh_size == 0)
5506     {
5507       if (num_syms_return != NULL)
5508         * num_syms_return = 0;
5509       return NULL;
5510     }
5511
5512   /* Run some sanity checks first.  */
5513   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5514     {
5515       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5516              printable_section_name (filedata, section),
5517              (unsigned long) section->sh_entsize);
5518       goto exit_point;
5519     }
5520
5521   if (section->sh_size > filedata->file_size)
5522     {
5523       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5524              printable_section_name (filedata, section),
5525              (unsigned long) section->sh_size);
5526       goto exit_point;
5527     }
5528
5529   number = section->sh_size / section->sh_entsize;
5530
5531   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5532     {
5533       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5534              (unsigned long) section->sh_size,
5535              printable_section_name (filedata, section),
5536              (unsigned long) section->sh_entsize);
5537       goto exit_point;
5538     }
5539
5540   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5541                                            section->sh_size, _("symbols"));
5542   if (!esyms)
5543     goto exit_point;
5544
5545   {
5546     elf_section_list * entry;
5547
5548     shndx = NULL;
5549     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5550       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5551         {
5552           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5553                                                        entry->hdr->sh_offset,
5554                                                        1, entry->hdr->sh_size,
5555                                                        _("symbol table section indicies"));
5556           if (shndx == NULL)
5557             goto exit_point;
5558           /* PR17531: file: heap-buffer-overflow */
5559           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5560             {
5561               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5562                      printable_section_name (filedata, entry->hdr),
5563                      (unsigned long) entry->hdr->sh_size,
5564                      (unsigned long) section->sh_size);
5565               goto exit_point;
5566             }
5567         }
5568   }
5569
5570   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5571
5572   if (isyms == NULL)
5573     {
5574       error (_("Out of memory reading %lu symbols\n"),
5575              (unsigned long) number);
5576       goto exit_point;
5577     }
5578
5579   for (j = 0, psym = isyms; j < number; j++, psym++)
5580     {
5581       psym->st_name  = BYTE_GET (esyms[j].st_name);
5582       psym->st_info  = BYTE_GET (esyms[j].st_info);
5583       psym->st_other = BYTE_GET (esyms[j].st_other);
5584       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5585
5586       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5587         psym->st_shndx
5588           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5589       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5590         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5591
5592       psym->st_value = BYTE_GET (esyms[j].st_value);
5593       psym->st_size  = BYTE_GET (esyms[j].st_size);
5594     }
5595
5596  exit_point:
5597   if (shndx != NULL)
5598     free (shndx);
5599   if (esyms != NULL)
5600     free (esyms);
5601
5602   if (num_syms_return != NULL)
5603     * num_syms_return = isyms == NULL ? 0 : number;
5604
5605   return isyms;
5606 }
5607
5608 static const char *
5609 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5610 {
5611   static char buff[1024];
5612   char * p = buff;
5613   unsigned int field_size = is_32bit_elf ? 8 : 16;
5614   signed int sindex;
5615   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5616   bfd_vma os_flags = 0;
5617   bfd_vma proc_flags = 0;
5618   bfd_vma unknown_flags = 0;
5619   static const struct
5620     {
5621       const char * str;
5622       unsigned int len;
5623     }
5624   flags [] =
5625     {
5626       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5627       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5628       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5629       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5630       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5631       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5632       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5633       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5634       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5635       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5636       /* IA-64 specific.  */
5637       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5638       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5639       /* IA-64 OpenVMS specific.  */
5640       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5641       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5642       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5643       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5644       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5645       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5646       /* Generic.  */
5647       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5648       /* SPARC specific.  */
5649       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5650       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5651       /* ARM specific.  */
5652       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5653       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5654       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5655       /* GNU specific.  */
5656       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5657       /* VLE specific.  */
5658       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5659     };
5660
5661   if (do_section_details)
5662     {
5663       sprintf (buff, "[%*.*lx]: ",
5664                field_size, field_size, (unsigned long) sh_flags);
5665       p += field_size + 4;
5666     }
5667
5668   while (sh_flags)
5669     {
5670       bfd_vma flag;
5671
5672       flag = sh_flags & - sh_flags;
5673       sh_flags &= ~ flag;
5674
5675       if (do_section_details)
5676         {
5677           switch (flag)
5678             {
5679             case SHF_WRITE:             sindex = 0; break;
5680             case SHF_ALLOC:             sindex = 1; break;
5681             case SHF_EXECINSTR:         sindex = 2; break;
5682             case SHF_MERGE:             sindex = 3; break;
5683             case SHF_STRINGS:           sindex = 4; break;
5684             case SHF_INFO_LINK:         sindex = 5; break;
5685             case SHF_LINK_ORDER:        sindex = 6; break;
5686             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5687             case SHF_GROUP:             sindex = 8; break;
5688             case SHF_TLS:               sindex = 9; break;
5689             case SHF_EXCLUDE:           sindex = 18; break;
5690             case SHF_COMPRESSED:        sindex = 20; break;
5691             case SHF_GNU_MBIND:         sindex = 24; break;
5692
5693             default:
5694               sindex = -1;
5695               switch (filedata->file_header.e_machine)
5696                 {
5697                 case EM_IA_64:
5698                   if (flag == SHF_IA_64_SHORT)
5699                     sindex = 10;
5700                   else if (flag == SHF_IA_64_NORECOV)
5701                     sindex = 11;
5702 #ifdef BFD64
5703                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5704                     switch (flag)
5705                       {
5706                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5707                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5708                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5709                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5710                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5711                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5712                       default:                        break;
5713                       }
5714 #endif
5715                   break;
5716
5717                 case EM_386:
5718                 case EM_IAMCU:
5719                 case EM_X86_64:
5720                 case EM_L1OM:
5721                 case EM_K1OM:
5722                 case EM_OLD_SPARCV9:
5723                 case EM_SPARC32PLUS:
5724                 case EM_SPARCV9:
5725                 case EM_SPARC:
5726                   if (flag == SHF_ORDERED)
5727                     sindex = 19;
5728                   break;
5729
5730                 case EM_ARM:
5731                   switch (flag)
5732                     {
5733                     case SHF_ENTRYSECT: sindex = 21; break;
5734                     case SHF_ARM_PURECODE: sindex = 22; break;
5735                     case SHF_COMDEF: sindex = 23; break;
5736                     default: break;
5737                     }
5738                   break;
5739                 case EM_PPC:
5740                   if (flag == SHF_PPC_VLE)
5741                     sindex = 25;
5742                   break;
5743
5744                 default:
5745                   break;
5746                 }
5747             }
5748
5749           if (sindex != -1)
5750             {
5751               if (p != buff + field_size + 4)
5752                 {
5753                   if (size < (10 + 2))
5754                     {
5755                       warn (_("Internal error: not enough buffer room for section flag info"));
5756                       return _("<unknown>");
5757                     }
5758                   size -= 2;
5759                   *p++ = ',';
5760                   *p++ = ' ';
5761                 }
5762
5763               size -= flags [sindex].len;
5764               p = stpcpy (p, flags [sindex].str);
5765             }
5766           else if (flag & SHF_MASKOS)
5767             os_flags |= flag;
5768           else if (flag & SHF_MASKPROC)
5769             proc_flags |= flag;
5770           else
5771             unknown_flags |= flag;
5772         }
5773       else
5774         {
5775           switch (flag)
5776             {
5777             case SHF_WRITE:             *p = 'W'; break;
5778             case SHF_ALLOC:             *p = 'A'; break;
5779             case SHF_EXECINSTR:         *p = 'X'; break;
5780             case SHF_MERGE:             *p = 'M'; break;
5781             case SHF_STRINGS:           *p = 'S'; break;
5782             case SHF_INFO_LINK:         *p = 'I'; break;
5783             case SHF_LINK_ORDER:        *p = 'L'; break;
5784             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5785             case SHF_GROUP:             *p = 'G'; break;
5786             case SHF_TLS:               *p = 'T'; break;
5787             case SHF_EXCLUDE:           *p = 'E'; break;
5788             case SHF_COMPRESSED:        *p = 'C'; break;
5789             case SHF_GNU_MBIND:         *p = 'D'; break;
5790
5791             default:
5792               if ((filedata->file_header.e_machine == EM_X86_64
5793                    || filedata->file_header.e_machine == EM_L1OM
5794                    || filedata->file_header.e_machine == EM_K1OM)
5795                   && flag == SHF_X86_64_LARGE)
5796                 *p = 'l';
5797               else if (filedata->file_header.e_machine == EM_ARM
5798                        && flag == SHF_ARM_PURECODE)
5799                   *p = 'y';
5800               else if (filedata->file_header.e_machine == EM_PPC
5801                        && flag == SHF_PPC_VLE)
5802                   *p = 'v';
5803               else if (flag & SHF_MASKOS)
5804                 {
5805                   *p = 'o';
5806                   sh_flags &= ~ SHF_MASKOS;
5807                 }
5808               else if (flag & SHF_MASKPROC)
5809                 {
5810                   *p = 'p';
5811                   sh_flags &= ~ SHF_MASKPROC;
5812                 }
5813               else
5814                 *p = 'x';
5815               break;
5816             }
5817           p++;
5818         }
5819     }
5820
5821   if (do_section_details)
5822     {
5823       if (os_flags)
5824         {
5825           size -= 5 + field_size;
5826           if (p != buff + field_size + 4)
5827             {
5828               if (size < (2 + 1))
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           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5838                    (unsigned long) os_flags);
5839           p += 5 + field_size;
5840         }
5841       if (proc_flags)
5842         {
5843           size -= 7 + field_size;
5844           if (p != buff + field_size + 4)
5845             {
5846               if (size < (2 + 1))
5847                 {
5848                   warn (_("Internal error: not enough buffer room for section flag info"));
5849                   return _("<unknown>");
5850                 }
5851               size -= 2;
5852               *p++ = ',';
5853               *p++ = ' ';
5854             }
5855           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5856                    (unsigned long) proc_flags);
5857           p += 7 + field_size;
5858         }
5859       if (unknown_flags)
5860         {
5861           size -= 10 + field_size;
5862           if (p != buff + field_size + 4)
5863             {
5864               if (size < (2 + 1))
5865                 {
5866                   warn (_("Internal error: not enough buffer room for section flag info"));
5867                   return _("<unknown>");
5868                 }
5869               size -= 2;
5870               *p++ = ',';
5871               *p++ = ' ';
5872             }
5873           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5874                    (unsigned long) unknown_flags);
5875           p += 10 + field_size;
5876         }
5877     }
5878
5879   *p = '\0';
5880   return buff;
5881 }
5882
5883 static unsigned int
5884 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5885 {
5886   if (is_32bit_elf)
5887     {
5888       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5889
5890       if (size < sizeof (* echdr))
5891         {
5892           error (_("Compressed section is too small even for a compression header\n"));
5893           return 0;
5894         }
5895
5896       chdr->ch_type = BYTE_GET (echdr->ch_type);
5897       chdr->ch_size = BYTE_GET (echdr->ch_size);
5898       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5899       return sizeof (*echdr);
5900     }
5901   else
5902     {
5903       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5904
5905       if (size < sizeof (* echdr))
5906         {
5907           error (_("Compressed section is too small even for a compression header\n"));
5908           return 0;
5909         }
5910
5911       chdr->ch_type = BYTE_GET (echdr->ch_type);
5912       chdr->ch_size = BYTE_GET (echdr->ch_size);
5913       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5914       return sizeof (*echdr);
5915     }
5916 }
5917
5918 static bfd_boolean
5919 process_section_headers (Filedata * filedata)
5920 {
5921   Elf_Internal_Shdr * section;
5922   unsigned int i;
5923
5924   filedata->section_headers = NULL;
5925
5926   if (filedata->file_header.e_shnum == 0)
5927     {
5928       /* PR binutils/12467.  */
5929       if (filedata->file_header.e_shoff != 0)
5930         {
5931           warn (_("possibly corrupt ELF file header - it has a non-zero"
5932                   " section header offset, but no section headers\n"));
5933           return FALSE;
5934         }
5935       else if (do_sections)
5936         printf (_("\nThere are no sections in this file.\n"));
5937
5938       return TRUE;
5939     }
5940
5941   if (do_sections && !do_header)
5942     printf (ngettext ("There is %d section header, "
5943                       "starting at offset 0x%lx:\n",
5944                       "There are %d section headers, "
5945                       "starting at offset 0x%lx:\n",
5946                       filedata->file_header.e_shnum),
5947             filedata->file_header.e_shnum,
5948             (unsigned long) filedata->file_header.e_shoff);
5949
5950   if (is_32bit_elf)
5951     {
5952       if (! get_32bit_section_headers (filedata, FALSE))
5953         return FALSE;
5954     }
5955   else
5956     {
5957       if (! get_64bit_section_headers (filedata, FALSE))
5958         return FALSE;
5959     }
5960
5961   /* Read in the string table, so that we have names to display.  */
5962   if (filedata->file_header.e_shstrndx != SHN_UNDEF
5963        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
5964     {
5965       section = filedata->section_headers + filedata->file_header.e_shstrndx;
5966
5967       if (section->sh_size != 0)
5968         {
5969           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
5970                                                       1, section->sh_size,
5971                                                       _("string table"));
5972
5973           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
5974         }
5975     }
5976
5977   /* Scan the sections for the dynamic symbol table
5978      and dynamic string table and debug sections.  */
5979   dynamic_symbols = NULL;
5980   dynamic_strings = NULL;
5981   dynamic_syminfo = NULL;
5982   symtab_shndx_list = NULL;
5983
5984   eh_addr_size = is_32bit_elf ? 4 : 8;
5985   switch (filedata->file_header.e_machine)
5986     {
5987     case EM_MIPS:
5988     case EM_MIPS_RS3_LE:
5989       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5990          FDE addresses.  However, the ABI also has a semi-official ILP32
5991          variant for which the normal FDE address size rules apply.
5992
5993          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5994          section, where XX is the size of longs in bits.  Unfortunately,
5995          earlier compilers provided no way of distinguishing ILP32 objects
5996          from LP64 objects, so if there's any doubt, we should assume that
5997          the official LP64 form is being used.  */
5998       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5999           && find_section (filedata, ".gcc_compiled_long32") == NULL)
6000         eh_addr_size = 8;
6001       break;
6002
6003     case EM_H8_300:
6004     case EM_H8_300H:
6005       switch (filedata->file_header.e_flags & EF_H8_MACH)
6006         {
6007         case E_H8_MACH_H8300:
6008         case E_H8_MACH_H8300HN:
6009         case E_H8_MACH_H8300SN:
6010         case E_H8_MACH_H8300SXN:
6011           eh_addr_size = 2;
6012           break;
6013         case E_H8_MACH_H8300H:
6014         case E_H8_MACH_H8300S:
6015         case E_H8_MACH_H8300SX:
6016           eh_addr_size = 4;
6017           break;
6018         }
6019       break;
6020
6021     case EM_M32C_OLD:
6022     case EM_M32C:
6023       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6024         {
6025         case EF_M32C_CPU_M16C:
6026           eh_addr_size = 2;
6027           break;
6028         }
6029       break;
6030     }
6031
6032 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6033   do                                                                    \
6034     {                                                                   \
6035       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6036       if (section->sh_entsize != expected_entsize)                      \
6037         {                                                               \
6038           char buf[40];                                                 \
6039           sprintf_vma (buf, section->sh_entsize);                       \
6040           /* Note: coded this way so that there is a single string for  \
6041              translation.  */ \
6042           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6043           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6044                    (unsigned) expected_entsize);                        \
6045           section->sh_entsize = expected_entsize;                       \
6046         }                                                               \
6047     }                                                                   \
6048   while (0)
6049
6050 #define CHECK_ENTSIZE(section, i, type)                                 \
6051   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6052                         sizeof (Elf64_External_##type))
6053
6054   for (i = 0, section = filedata->section_headers;
6055        i < filedata->file_header.e_shnum;
6056        i++, section++)
6057     {
6058       char * name = SECTION_NAME (section);
6059
6060       if (section->sh_type == SHT_DYNSYM)
6061         {
6062           if (dynamic_symbols != NULL)
6063             {
6064               error (_("File contains multiple dynamic symbol tables\n"));
6065               continue;
6066             }
6067
6068           CHECK_ENTSIZE (section, i, Sym);
6069           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6070         }
6071       else if (section->sh_type == SHT_STRTAB
6072                && streq (name, ".dynstr"))
6073         {
6074           if (dynamic_strings != NULL)
6075             {
6076               error (_("File contains multiple dynamic string tables\n"));
6077               continue;
6078             }
6079
6080           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6081                                                1, section->sh_size,
6082                                                _("dynamic strings"));
6083           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6084         }
6085       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6086         {
6087           elf_section_list * entry = xmalloc (sizeof * entry);
6088
6089           entry->hdr = section;
6090           entry->next = symtab_shndx_list;
6091           symtab_shndx_list = entry;
6092         }
6093       else if (section->sh_type == SHT_SYMTAB)
6094         CHECK_ENTSIZE (section, i, Sym);
6095       else if (section->sh_type == SHT_GROUP)
6096         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6097       else if (section->sh_type == SHT_REL)
6098         CHECK_ENTSIZE (section, i, Rel);
6099       else if (section->sh_type == SHT_RELA)
6100         CHECK_ENTSIZE (section, i, Rela);
6101       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6102                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6103                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6104                 || do_debug_str || do_debug_loc || do_debug_ranges
6105                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6106                && (const_strneq (name, ".debug_")
6107                    || const_strneq (name, ".zdebug_")))
6108         {
6109           if (name[1] == 'z')
6110             name += sizeof (".zdebug_") - 1;
6111           else
6112             name += sizeof (".debug_") - 1;
6113
6114           if (do_debugging
6115               || (do_debug_info     && const_strneq (name, "info"))
6116               || (do_debug_info     && const_strneq (name, "types"))
6117               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6118               || (do_debug_lines    && strcmp (name, "line") == 0)
6119               || (do_debug_lines    && const_strneq (name, "line."))
6120               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6121               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6122               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6123               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6124               || (do_debug_aranges  && const_strneq (name, "aranges"))
6125               || (do_debug_ranges   && const_strneq (name, "ranges"))
6126               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6127               || (do_debug_frames   && const_strneq (name, "frame"))
6128               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6129               || (do_debug_macinfo  && const_strneq (name, "macro"))
6130               || (do_debug_str      && const_strneq (name, "str"))
6131               || (do_debug_loc      && const_strneq (name, "loc"))
6132               || (do_debug_loc      && const_strneq (name, "loclists"))
6133               || (do_debug_addr     && const_strneq (name, "addr"))
6134               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6135               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6136               )
6137             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6138         }
6139       /* Linkonce section to be combined with .debug_info at link time.  */
6140       else if ((do_debugging || do_debug_info)
6141                && const_strneq (name, ".gnu.linkonce.wi."))
6142         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6143       else if (do_debug_frames && streq (name, ".eh_frame"))
6144         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6145       else if (do_gdb_index && (streq (name, ".gdb_index")
6146                                 || streq (name, ".debug_names")))
6147         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6148       /* Trace sections for Itanium VMS.  */
6149       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6150                 || do_trace_aranges)
6151                && const_strneq (name, ".trace_"))
6152         {
6153           name += sizeof (".trace_") - 1;
6154
6155           if (do_debugging
6156               || (do_trace_info     && streq (name, "info"))
6157               || (do_trace_abbrevs  && streq (name, "abbrev"))
6158               || (do_trace_aranges  && streq (name, "aranges"))
6159               )
6160             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6161         }
6162       else if ((do_debugging || do_debug_links)
6163                && (const_strneq (name, ".gnu_debuglink")
6164                    || const_strneq (name, ".gnu_debugaltlink")))
6165         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6166     }
6167
6168   if (! do_sections)
6169     return TRUE;
6170
6171   if (filedata->file_header.e_shnum > 1)
6172     printf (_("\nSection Headers:\n"));
6173   else
6174     printf (_("\nSection Header:\n"));
6175
6176   if (is_32bit_elf)
6177     {
6178       if (do_section_details)
6179         {
6180           printf (_("  [Nr] Name\n"));
6181           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6182         }
6183       else
6184         printf
6185           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6186     }
6187   else if (do_wide)
6188     {
6189       if (do_section_details)
6190         {
6191           printf (_("  [Nr] Name\n"));
6192           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6193         }
6194       else
6195         printf
6196           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6197     }
6198   else
6199     {
6200       if (do_section_details)
6201         {
6202           printf (_("  [Nr] Name\n"));
6203           printf (_("       Type              Address          Offset            Link\n"));
6204           printf (_("       Size              EntSize          Info              Align\n"));
6205         }
6206       else
6207         {
6208           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6209           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6210         }
6211     }
6212
6213   if (do_section_details)
6214     printf (_("       Flags\n"));
6215
6216   for (i = 0, section = filedata->section_headers;
6217        i < filedata->file_header.e_shnum;
6218        i++, section++)
6219     {
6220       /* Run some sanity checks on the section header.  */
6221
6222       /* Check the sh_link field.  */
6223       switch (section->sh_type)
6224         {
6225         case SHT_SYMTAB_SHNDX:
6226         case SHT_GROUP:
6227         case SHT_HASH:
6228         case SHT_GNU_HASH:
6229         case SHT_GNU_versym:
6230         case SHT_REL:
6231         case SHT_RELA:
6232           if (section->sh_link < 1
6233               || section->sh_link >= filedata->file_header.e_shnum
6234               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6235                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6236             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6237                   i, section->sh_link);
6238           break;
6239
6240         case SHT_DYNAMIC:
6241         case SHT_SYMTAB:
6242         case SHT_DYNSYM:
6243         case SHT_GNU_verneed:
6244         case SHT_GNU_verdef:
6245         case SHT_GNU_LIBLIST:
6246           if (section->sh_link < 1
6247               || section->sh_link >= filedata->file_header.e_shnum
6248               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6249             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6250                   i, section->sh_link);
6251           break;
6252
6253         case SHT_INIT_ARRAY:
6254         case SHT_FINI_ARRAY:
6255         case SHT_PREINIT_ARRAY:
6256           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6257             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6258                   i, section->sh_link);
6259           break;
6260
6261         default:
6262           /* FIXME: Add support for target specific section types.  */
6263 #if 0     /* Currently we do not check other section types as there are too
6264              many special cases.  Stab sections for example have a type
6265              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6266              section.  */
6267           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6268             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6269                   i, section->sh_link);
6270 #endif
6271           break;
6272         }
6273
6274       /* Check the sh_info field.  */
6275       switch (section->sh_type)
6276         {
6277         case SHT_REL:
6278         case SHT_RELA:
6279           if (section->sh_info < 1
6280               || section->sh_info >= filedata->file_header.e_shnum
6281               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6282                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6283                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6284                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6285                   /* FIXME: Are other section types valid ?  */
6286                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6287             {
6288               if (section->sh_info == 0
6289                   && (filedata->file_header.e_type == ET_EXEC
6290                       || filedata->file_header.e_type == ET_DYN
6291                       /* These next two tests may be redundant, but
6292                          they have been left in for paranoia's sake.  */
6293                       || streq (SECTION_NAME (section), ".rel.dyn")
6294                       || streq (SECTION_NAME (section), ".rela.dyn")))
6295                 /* Dynamic relocations apply to segments, not sections, so
6296                    they do not need an sh_info value.  */
6297                 ;
6298               else
6299                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6300                       i, section->sh_info);
6301             }
6302           break;
6303
6304         case SHT_DYNAMIC:
6305         case SHT_HASH:
6306         case SHT_SYMTAB_SHNDX:
6307         case SHT_INIT_ARRAY:
6308         case SHT_FINI_ARRAY:
6309         case SHT_PREINIT_ARRAY:
6310           if (section->sh_info != 0)
6311             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6312                   i, section->sh_info);
6313           break;
6314
6315         case SHT_GROUP:
6316         case SHT_SYMTAB:
6317         case SHT_DYNSYM:
6318           /* A symbol index - we assume that it is valid.  */
6319           break;
6320
6321         default:
6322           /* FIXME: Add support for target specific section types.  */
6323           if (section->sh_type == SHT_NOBITS)
6324             /* NOBITS section headers with non-zero sh_info fields can be
6325                created when a binary is stripped of everything but its debug
6326                information.  The stripped sections have their headers
6327                preserved but their types set to SHT_NOBITS.  So do not check
6328                this type of section.  */
6329             ;
6330           else if (section->sh_flags & SHF_INFO_LINK)
6331             {
6332               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6333                 warn (_("[%2u]: Expected link to another section in info field"), i);
6334             }
6335           else if (section->sh_type < SHT_LOOS
6336                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6337                    && section->sh_info != 0)
6338             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6339                   i, section->sh_info);
6340           break;
6341         }
6342
6343       /* Check the sh_size field.  */
6344       if (section->sh_size > filedata->file_size
6345           && section->sh_type != SHT_NOBITS
6346           && section->sh_type != SHT_NULL
6347           && section->sh_type < SHT_LOOS)
6348         warn (_("Size of section %u is larger than the entire file!\n"), i);
6349
6350       printf ("  [%2u] ", i);
6351       if (do_section_details)
6352         printf ("%s\n      ", printable_section_name (filedata, section));
6353       else
6354         print_symbol (-17, SECTION_NAME (section));
6355
6356       printf (do_wide ? " %-15s " : " %-15.15s ",
6357               get_section_type_name (filedata, section->sh_type));
6358
6359       if (is_32bit_elf)
6360         {
6361           const char * link_too_big = NULL;
6362
6363           print_vma (section->sh_addr, LONG_HEX);
6364
6365           printf ( " %6.6lx %6.6lx %2.2lx",
6366                    (unsigned long) section->sh_offset,
6367                    (unsigned long) section->sh_size,
6368                    (unsigned long) section->sh_entsize);
6369
6370           if (do_section_details)
6371             fputs ("  ", stdout);
6372           else
6373             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6374
6375           if (section->sh_link >= filedata->file_header.e_shnum)
6376             {
6377               link_too_big = "";
6378               /* The sh_link value is out of range.  Normally this indicates
6379                  an error but it can have special values in Solaris binaries.  */
6380               switch (filedata->file_header.e_machine)
6381                 {
6382                 case EM_386:
6383                 case EM_IAMCU:
6384                 case EM_X86_64:
6385                 case EM_L1OM:
6386                 case EM_K1OM:
6387                 case EM_OLD_SPARCV9:
6388                 case EM_SPARC32PLUS:
6389                 case EM_SPARCV9:
6390                 case EM_SPARC:
6391                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6392                     link_too_big = "BEFORE";
6393                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6394                     link_too_big = "AFTER";
6395                   break;
6396                 default:
6397                   break;
6398                 }
6399             }
6400
6401           if (do_section_details)
6402             {
6403               if (link_too_big != NULL && * link_too_big)
6404                 printf ("<%s> ", link_too_big);
6405               else
6406                 printf ("%2u ", section->sh_link);
6407               printf ("%3u %2lu\n", section->sh_info,
6408                       (unsigned long) section->sh_addralign);
6409             }
6410           else
6411             printf ("%2u %3u %2lu\n",
6412                     section->sh_link,
6413                     section->sh_info,
6414                     (unsigned long) section->sh_addralign);
6415
6416           if (link_too_big && ! * link_too_big)
6417             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6418                   i, section->sh_link);
6419         }
6420       else if (do_wide)
6421         {
6422           print_vma (section->sh_addr, LONG_HEX);
6423
6424           if ((long) section->sh_offset == section->sh_offset)
6425             printf (" %6.6lx", (unsigned long) section->sh_offset);
6426           else
6427             {
6428               putchar (' ');
6429               print_vma (section->sh_offset, LONG_HEX);
6430             }
6431
6432           if ((unsigned long) section->sh_size == section->sh_size)
6433             printf (" %6.6lx", (unsigned long) section->sh_size);
6434           else
6435             {
6436               putchar (' ');
6437               print_vma (section->sh_size, LONG_HEX);
6438             }
6439
6440           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6441             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6442           else
6443             {
6444               putchar (' ');
6445               print_vma (section->sh_entsize, LONG_HEX);
6446             }
6447
6448           if (do_section_details)
6449             fputs ("  ", stdout);
6450           else
6451             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6452
6453           printf ("%2u %3u ", section->sh_link, section->sh_info);
6454
6455           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6456             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6457           else
6458             {
6459               print_vma (section->sh_addralign, DEC);
6460               putchar ('\n');
6461             }
6462         }
6463       else if (do_section_details)
6464         {
6465           printf ("       %-15.15s  ",
6466                   get_section_type_name (filedata, section->sh_type));
6467           print_vma (section->sh_addr, LONG_HEX);
6468           if ((long) section->sh_offset == section->sh_offset)
6469             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6470           else
6471             {
6472               printf ("  ");
6473               print_vma (section->sh_offset, LONG_HEX);
6474             }
6475           printf ("  %u\n       ", section->sh_link);
6476           print_vma (section->sh_size, LONG_HEX);
6477           putchar (' ');
6478           print_vma (section->sh_entsize, LONG_HEX);
6479
6480           printf ("  %-16u  %lu\n",
6481                   section->sh_info,
6482                   (unsigned long) section->sh_addralign);
6483         }
6484       else
6485         {
6486           putchar (' ');
6487           print_vma (section->sh_addr, LONG_HEX);
6488           if ((long) section->sh_offset == section->sh_offset)
6489             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6490           else
6491             {
6492               printf ("  ");
6493               print_vma (section->sh_offset, LONG_HEX);
6494             }
6495           printf ("\n       ");
6496           print_vma (section->sh_size, LONG_HEX);
6497           printf ("  ");
6498           print_vma (section->sh_entsize, LONG_HEX);
6499
6500           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6501
6502           printf ("     %2u   %3u     %lu\n",
6503                   section->sh_link,
6504                   section->sh_info,
6505                   (unsigned long) section->sh_addralign);
6506         }
6507
6508       if (do_section_details)
6509         {
6510           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6511           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6512             {
6513               /* Minimum section size is 12 bytes for 32-bit compression
6514                  header + 12 bytes for compressed data header.  */
6515               unsigned char buf[24];
6516
6517               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6518               if (get_data (&buf, filedata, section->sh_offset, 1,
6519                             sizeof (buf), _("compression header")))
6520                 {
6521                   Elf_Internal_Chdr chdr;
6522
6523                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6524
6525                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6526                     printf ("       ZLIB, ");
6527                   else
6528                     printf (_("       [<unknown>: 0x%x], "),
6529                             chdr.ch_type);
6530                   print_vma (chdr.ch_size, LONG_HEX);
6531                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6532                 }
6533             }
6534         }
6535     }
6536
6537   if (!do_section_details)
6538     {
6539       /* The ordering of the letters shown here matches the ordering of the
6540          corresponding SHF_xxx values, and hence the order in which these
6541          letters will be displayed to the user.  */
6542       printf (_("Key to Flags:\n\
6543   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6544   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6545   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6546       if (filedata->file_header.e_machine == EM_X86_64
6547           || filedata->file_header.e_machine == EM_L1OM
6548           || filedata->file_header.e_machine == EM_K1OM)
6549         printf (_("l (large), "));
6550       else if (filedata->file_header.e_machine == EM_ARM)
6551         printf (_("y (purecode), "));
6552       else if (filedata->file_header.e_machine == EM_PPC)
6553         printf (_("v (VLE), "));
6554       printf ("p (processor specific)\n");
6555     }
6556
6557   return TRUE;
6558 }
6559
6560 static const char *
6561 get_group_flags (unsigned int flags)
6562 {
6563   static char buff[128];
6564
6565   if (flags == 0)
6566     return "";
6567   else if (flags == GRP_COMDAT)
6568     return "COMDAT ";
6569
6570   snprintf (buff, 14, _("[0x%x: "), flags);
6571
6572   flags &= ~ GRP_COMDAT;
6573   if (flags & GRP_MASKOS)
6574     {
6575       strcat (buff, "<OS specific>");
6576       flags &= ~ GRP_MASKOS;
6577     }
6578
6579   if (flags & GRP_MASKPROC)
6580     {
6581       strcat (buff, "<PROC specific>");
6582       flags &= ~ GRP_MASKPROC;
6583     }
6584
6585   if (flags)
6586     strcat (buff, "<unknown>");
6587
6588   strcat (buff, "]");
6589   return buff;
6590 }
6591
6592 static bfd_boolean
6593 process_section_groups (Filedata * filedata)
6594 {
6595   Elf_Internal_Shdr * section;
6596   unsigned int i;
6597   struct group * group;
6598   Elf_Internal_Shdr * symtab_sec;
6599   Elf_Internal_Shdr * strtab_sec;
6600   Elf_Internal_Sym * symtab;
6601   unsigned long num_syms;
6602   char * strtab;
6603   size_t strtab_size;
6604
6605   /* Don't process section groups unless needed.  */
6606   if (!do_unwind && !do_section_groups)
6607     return TRUE;
6608
6609   if (filedata->file_header.e_shnum == 0)
6610     {
6611       if (do_section_groups)
6612         printf (_("\nThere are no sections to group in this file.\n"));
6613
6614       return TRUE;
6615     }
6616
6617   if (filedata->section_headers == NULL)
6618     {
6619       error (_("Section headers are not available!\n"));
6620       /* PR 13622: This can happen with a corrupt ELF header.  */
6621       return FALSE;
6622     }
6623
6624   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6625                                                      sizeof (struct group *));
6626
6627   if (section_headers_groups == NULL)
6628     {
6629       error (_("Out of memory reading %u section group headers\n"),
6630              filedata->file_header.e_shnum);
6631       return FALSE;
6632     }
6633
6634   /* Scan the sections for the group section.  */
6635   group_count = 0;
6636   for (i = 0, section = filedata->section_headers;
6637        i < filedata->file_header.e_shnum;
6638        i++, section++)
6639     if (section->sh_type == SHT_GROUP)
6640       group_count++;
6641
6642   if (group_count == 0)
6643     {
6644       if (do_section_groups)
6645         printf (_("\nThere are no section groups in this file.\n"));
6646
6647       return TRUE;
6648     }
6649
6650   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6651
6652   if (section_groups == NULL)
6653     {
6654       error (_("Out of memory reading %lu groups\n"),
6655              (unsigned long) group_count);
6656       return FALSE;
6657     }
6658
6659   symtab_sec = NULL;
6660   strtab_sec = NULL;
6661   symtab = NULL;
6662   num_syms = 0;
6663   strtab = NULL;
6664   strtab_size = 0;
6665   for (i = 0, section = filedata->section_headers, group = section_groups;
6666        i < filedata->file_header.e_shnum;
6667        i++, section++)
6668     {
6669       if (section->sh_type == SHT_GROUP)
6670         {
6671           const char * name = printable_section_name (filedata, section);
6672           const char * group_name;
6673           unsigned char * start;
6674           unsigned char * indices;
6675           unsigned int entry, j, size;
6676           Elf_Internal_Shdr * sec;
6677           Elf_Internal_Sym * sym;
6678
6679           /* Get the symbol table.  */
6680           if (section->sh_link >= filedata->file_header.e_shnum
6681               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6682                   != SHT_SYMTAB))
6683             {
6684               error (_("Bad sh_link in group section `%s'\n"), name);
6685               continue;
6686             }
6687
6688           if (symtab_sec != sec)
6689             {
6690               symtab_sec = sec;
6691               if (symtab)
6692                 free (symtab);
6693               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6694             }
6695
6696           if (symtab == NULL)
6697             {
6698               error (_("Corrupt header in group section `%s'\n"), name);
6699               continue;
6700             }
6701
6702           if (section->sh_info >= num_syms)
6703             {
6704               error (_("Bad sh_info in group section `%s'\n"), name);
6705               continue;
6706             }
6707
6708           sym = symtab + section->sh_info;
6709
6710           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6711             {
6712               if (sym->st_shndx == 0
6713                   || sym->st_shndx >= filedata->file_header.e_shnum)
6714                 {
6715                   error (_("Bad sh_info in group section `%s'\n"), name);
6716                   continue;
6717                 }
6718
6719               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6720               strtab_sec = NULL;
6721               if (strtab)
6722                 free (strtab);
6723               strtab = NULL;
6724               strtab_size = 0;
6725             }
6726           else
6727             {
6728               /* Get the string table.  */
6729               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6730                 {
6731                   strtab_sec = NULL;
6732                   if (strtab)
6733                     free (strtab);
6734                   strtab = NULL;
6735                   strtab_size = 0;
6736                 }
6737               else if (strtab_sec
6738                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6739                 {
6740                   strtab_sec = sec;
6741                   if (strtab)
6742                     free (strtab);
6743
6744                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6745                                               1, strtab_sec->sh_size,
6746                                               _("string table"));
6747                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6748                 }
6749               group_name = sym->st_name < strtab_size
6750                 ? strtab + sym->st_name : _("<corrupt>");
6751             }
6752
6753           /* PR 17531: file: loop.  */
6754           if (section->sh_entsize > section->sh_size)
6755             {
6756               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6757                      printable_section_name (filedata, section),
6758                      (unsigned long) section->sh_entsize,
6759                      (unsigned long) section->sh_size);
6760               break;
6761             }
6762
6763           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6764                                               1, section->sh_size,
6765                                               _("section data"));
6766           if (start == NULL)
6767             continue;
6768
6769           indices = start;
6770           size = (section->sh_size / section->sh_entsize) - 1;
6771           entry = byte_get (indices, 4);
6772           indices += 4;
6773
6774           if (do_section_groups)
6775             {
6776               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6777                       get_group_flags (entry), i, name, group_name, size);
6778
6779               printf (_("   [Index]    Name\n"));
6780             }
6781
6782           group->group_index = i;
6783
6784           for (j = 0; j < size; j++)
6785             {
6786               struct group_list * g;
6787
6788               entry = byte_get (indices, 4);
6789               indices += 4;
6790
6791               if (entry >= filedata->file_header.e_shnum)
6792                 {
6793                   static unsigned num_group_errors = 0;
6794
6795                   if (num_group_errors ++ < 10)
6796                     {
6797                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6798                              entry, i, filedata->file_header.e_shnum - 1);
6799                       if (num_group_errors == 10)
6800                         warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6801                     }
6802                   continue;
6803                 }
6804
6805               if (section_headers_groups [entry] != NULL)
6806                 {
6807                   if (entry)
6808                     {
6809                       static unsigned num_errs = 0;
6810
6811                       if (num_errs ++ < 10)
6812                         {
6813                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6814                                  entry, i,
6815                                  section_headers_groups [entry]->group_index);
6816                           if (num_errs == 10)
6817                             warn (_("Further error messages about already contained group sections suppressed\n"));
6818                         }
6819                       continue;
6820                     }
6821                   else
6822                     {
6823                       /* Intel C/C++ compiler may put section 0 in a
6824                          section group.  We just warn it the first time
6825                          and ignore it afterwards.  */
6826                       static bfd_boolean warned = FALSE;
6827                       if (!warned)
6828                         {
6829                           error (_("section 0 in group section [%5u]\n"),
6830                                  section_headers_groups [entry]->group_index);
6831                           warned = TRUE;
6832                         }
6833                     }
6834                 }
6835
6836               section_headers_groups [entry] = group;
6837
6838               if (do_section_groups)
6839                 {
6840                   sec = filedata->section_headers + entry;
6841                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6842                 }
6843
6844               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6845               g->section_index = entry;
6846               g->next = group->root;
6847               group->root = g;
6848             }
6849
6850           if (start)
6851             free (start);
6852
6853           group++;
6854         }
6855     }
6856
6857   if (symtab)
6858     free (symtab);
6859   if (strtab)
6860     free (strtab);
6861   return TRUE;
6862 }
6863
6864 /* Data used to display dynamic fixups.  */
6865
6866 struct ia64_vms_dynfixup
6867 {
6868   bfd_vma needed_ident;         /* Library ident number.  */
6869   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6870   bfd_vma fixup_needed;         /* Index of the library.  */
6871   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6872   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6873 };
6874
6875 /* Data used to display dynamic relocations.  */
6876
6877 struct ia64_vms_dynimgrela
6878 {
6879   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6880   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6881 };
6882
6883 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6884    library).  */
6885
6886 static bfd_boolean
6887 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6888                               struct ia64_vms_dynfixup *  fixup,
6889                               const char *                strtab,
6890                               unsigned int                strtab_sz)
6891 {
6892   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6893   long i;
6894   const char * lib_name;
6895
6896   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6897                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6898                    _("dynamic section image fixups"));
6899   if (!imfs)
6900     return FALSE;
6901
6902   if (fixup->needed < strtab_sz)
6903     lib_name = strtab + fixup->needed;
6904   else
6905     {
6906       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6907             (unsigned long) fixup->needed);
6908       lib_name = "???";
6909     }
6910   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6911           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6912   printf
6913     (_("Seg Offset           Type                             SymVec DataType\n"));
6914
6915   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6916     {
6917       unsigned int type;
6918       const char *rtype;
6919
6920       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6921       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6922       type = BYTE_GET (imfs [i].type);
6923       rtype = elf_ia64_reloc_type (type);
6924       if (rtype == NULL)
6925         printf (" 0x%08x                       ", type);
6926       else
6927         printf (" %-32s ", rtype);
6928       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6929       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6930     }
6931
6932   free (imfs);
6933   return TRUE;
6934 }
6935
6936 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6937
6938 static bfd_boolean
6939 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
6940 {
6941   Elf64_External_VMS_IMAGE_RELA *imrs;
6942   long i;
6943
6944   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
6945                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6946                    _("dynamic section image relocations"));
6947   if (!imrs)
6948     return FALSE;
6949
6950   printf (_("\nImage relocs\n"));
6951   printf
6952     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6953
6954   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6955     {
6956       unsigned int type;
6957       const char *rtype;
6958
6959       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6960       printf ("%08" BFD_VMA_FMT "x ",
6961               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6962       type = BYTE_GET (imrs [i].type);
6963       rtype = elf_ia64_reloc_type (type);
6964       if (rtype == NULL)
6965         printf ("0x%08x                      ", type);
6966       else
6967         printf ("%-31s ", rtype);
6968       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6969       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6970       printf ("%08" BFD_VMA_FMT "x\n",
6971               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6972     }
6973
6974   free (imrs);
6975   return TRUE;
6976 }
6977
6978 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6979
6980 static bfd_boolean
6981 process_ia64_vms_dynamic_relocs (Filedata * filedata)
6982 {
6983   struct ia64_vms_dynfixup fixup;
6984   struct ia64_vms_dynimgrela imgrela;
6985   Elf_Internal_Dyn *entry;
6986   bfd_vma strtab_off = 0;
6987   bfd_vma strtab_sz = 0;
6988   char *strtab = NULL;
6989   bfd_boolean res = TRUE;
6990
6991   memset (&fixup, 0, sizeof (fixup));
6992   memset (&imgrela, 0, sizeof (imgrela));
6993
6994   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6995   for (entry = dynamic_section;
6996        entry < dynamic_section + dynamic_nent;
6997        entry++)
6998     {
6999       switch (entry->d_tag)
7000         {
7001         case DT_IA_64_VMS_STRTAB_OFFSET:
7002           strtab_off = entry->d_un.d_val;
7003           break;
7004         case DT_STRSZ:
7005           strtab_sz = entry->d_un.d_val;
7006           if (strtab == NULL)
7007             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7008                                1, strtab_sz, _("dynamic string section"));
7009           break;
7010
7011         case DT_IA_64_VMS_NEEDED_IDENT:
7012           fixup.needed_ident = entry->d_un.d_val;
7013           break;
7014         case DT_NEEDED:
7015           fixup.needed = entry->d_un.d_val;
7016           break;
7017         case DT_IA_64_VMS_FIXUP_NEEDED:
7018           fixup.fixup_needed = entry->d_un.d_val;
7019           break;
7020         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7021           fixup.fixup_rela_cnt = entry->d_un.d_val;
7022           break;
7023         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7024           fixup.fixup_rela_off = entry->d_un.d_val;
7025           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7026             res = FALSE;
7027           break;
7028         case DT_IA_64_VMS_IMG_RELA_CNT:
7029           imgrela.img_rela_cnt = entry->d_un.d_val;
7030           break;
7031         case DT_IA_64_VMS_IMG_RELA_OFF:
7032           imgrela.img_rela_off = entry->d_un.d_val;
7033           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7034             res = FALSE;
7035           break;
7036
7037         default:
7038           break;
7039         }
7040     }
7041
7042   if (strtab != NULL)
7043     free (strtab);
7044
7045   return res;
7046 }
7047
7048 static struct
7049 {
7050   const char * name;
7051   int reloc;
7052   int size;
7053   int rela;
7054 }
7055   dynamic_relocations [] =
7056 {
7057   { "REL", DT_REL, DT_RELSZ, FALSE },
7058   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7059   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7060 };
7061
7062 /* Process the reloc section.  */
7063
7064 static bfd_boolean
7065 process_relocs (Filedata * filedata)
7066 {
7067   unsigned long rel_size;
7068   unsigned long rel_offset;
7069
7070   if (!do_reloc)
7071     return TRUE;
7072
7073   if (do_using_dynamic)
7074     {
7075       int          is_rela;
7076       const char * name;
7077       bfd_boolean  has_dynamic_reloc;
7078       unsigned int i;
7079
7080       has_dynamic_reloc = FALSE;
7081
7082       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7083         {
7084           is_rela = dynamic_relocations [i].rela;
7085           name = dynamic_relocations [i].name;
7086           rel_size = dynamic_info [dynamic_relocations [i].size];
7087           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7088
7089           if (rel_size)
7090             has_dynamic_reloc = TRUE;
7091
7092           if (is_rela == UNKNOWN)
7093             {
7094               if (dynamic_relocations [i].reloc == DT_JMPREL)
7095                 switch (dynamic_info[DT_PLTREL])
7096                   {
7097                   case DT_REL:
7098                     is_rela = FALSE;
7099                     break;
7100                   case DT_RELA:
7101                     is_rela = TRUE;
7102                     break;
7103                   }
7104             }
7105
7106           if (rel_size)
7107             {
7108               printf
7109                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7110                  name, rel_offset, rel_size);
7111
7112               dump_relocations (filedata,
7113                                 offset_from_vma (filedata, rel_offset, rel_size),
7114                                 rel_size,
7115                                 dynamic_symbols, num_dynamic_syms,
7116                                 dynamic_strings, dynamic_strings_length,
7117                                 is_rela, TRUE /* is_dynamic */);
7118             }
7119         }
7120
7121       if (is_ia64_vms (filedata))
7122         if (process_ia64_vms_dynamic_relocs (filedata))
7123           has_dynamic_reloc = TRUE;
7124
7125       if (! has_dynamic_reloc)
7126         printf (_("\nThere are no dynamic relocations in this file.\n"));
7127     }
7128   else
7129     {
7130       Elf_Internal_Shdr * section;
7131       unsigned long i;
7132       bfd_boolean found = FALSE;
7133
7134       for (i = 0, section = filedata->section_headers;
7135            i < filedata->file_header.e_shnum;
7136            i++, section++)
7137         {
7138           if (   section->sh_type != SHT_RELA
7139               && section->sh_type != SHT_REL)
7140             continue;
7141
7142           rel_offset = section->sh_offset;
7143           rel_size   = section->sh_size;
7144
7145           if (rel_size)
7146             {
7147               Elf_Internal_Shdr * strsec;
7148               int is_rela;
7149               unsigned long num_rela;
7150
7151               printf (_("\nRelocation section "));
7152
7153               if (filedata->string_table == NULL)
7154                 printf ("%d", section->sh_name);
7155               else
7156                 printf ("'%s'", printable_section_name (filedata, section));
7157
7158               num_rela = rel_size / section->sh_entsize;
7159               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7160                                 " at offset 0x%lx contains %lu entries:\n",
7161                                 num_rela),
7162                       rel_offset, num_rela);
7163
7164               is_rela = section->sh_type == SHT_RELA;
7165
7166               if (section->sh_link != 0
7167                   && section->sh_link < filedata->file_header.e_shnum)
7168                 {
7169                   Elf_Internal_Shdr * symsec;
7170                   Elf_Internal_Sym *  symtab;
7171                   unsigned long nsyms;
7172                   unsigned long strtablen = 0;
7173                   char * strtab = NULL;
7174
7175                   symsec = filedata->section_headers + section->sh_link;
7176                   if (symsec->sh_type != SHT_SYMTAB
7177                       && symsec->sh_type != SHT_DYNSYM)
7178                     continue;
7179
7180                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7181
7182                   if (symtab == NULL)
7183                     continue;
7184
7185                   if (symsec->sh_link != 0
7186                       && symsec->sh_link < filedata->file_header.e_shnum)
7187                     {
7188                       strsec = filedata->section_headers + symsec->sh_link;
7189
7190                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7191                                                   1, strsec->sh_size,
7192                                                   _("string table"));
7193                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7194                     }
7195
7196                   dump_relocations (filedata, rel_offset, rel_size,
7197                                     symtab, nsyms, strtab, strtablen,
7198                                     is_rela,
7199                                     symsec->sh_type == SHT_DYNSYM);
7200                   if (strtab)
7201                     free (strtab);
7202                   free (symtab);
7203                 }
7204               else
7205                 dump_relocations (filedata, rel_offset, rel_size,
7206                                   NULL, 0, NULL, 0, is_rela,
7207                                   FALSE /* is_dynamic */);
7208
7209               found = TRUE;
7210             }
7211         }
7212
7213       if (! found)
7214         {
7215           /* Users sometimes forget the -D option, so try to be helpful.  */
7216           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7217             {
7218               if (dynamic_info [dynamic_relocations [i].size])
7219                 {
7220                   printf (_("\nThere are no static relocations in this file."));
7221                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7222
7223                   break;
7224                 }
7225             }
7226           if (i == ARRAY_SIZE (dynamic_relocations))
7227             printf (_("\nThere are no relocations in this file.\n"));
7228         }
7229     }
7230
7231   return TRUE;
7232 }
7233
7234 /* An absolute address consists of a section and an offset.  If the
7235    section is NULL, the offset itself is the address, otherwise, the
7236    address equals to LOAD_ADDRESS(section) + offset.  */
7237
7238 struct absaddr
7239 {
7240   unsigned short section;
7241   bfd_vma offset;
7242 };
7243
7244 #define ABSADDR(a) \
7245   ((a).section \
7246    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7247    : (a).offset)
7248
7249 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7250    name, if found, and the offset from the symbol to ADDR.  */
7251
7252 static void
7253 find_symbol_for_address (Filedata *          filedata,
7254                          Elf_Internal_Sym *  symtab,
7255                          unsigned long       nsyms,
7256                          const char *        strtab,
7257                          unsigned long       strtab_size,
7258                          struct absaddr      addr,
7259                          const char **       symname,
7260                          bfd_vma *           offset)
7261 {
7262   bfd_vma dist = 0x100000;
7263   Elf_Internal_Sym * sym;
7264   Elf_Internal_Sym * beg;
7265   Elf_Internal_Sym * end;
7266   Elf_Internal_Sym * best = NULL;
7267
7268   REMOVE_ARCH_BITS (addr.offset);
7269   beg = symtab;
7270   end = symtab + nsyms;
7271
7272   while (beg < end)
7273     {
7274       bfd_vma value;
7275
7276       sym = beg + (end - beg) / 2;
7277
7278       value = sym->st_value;
7279       REMOVE_ARCH_BITS (value);
7280
7281       if (sym->st_name != 0
7282           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7283           && addr.offset >= value
7284           && addr.offset - value < dist)
7285         {
7286           best = sym;
7287           dist = addr.offset - value;
7288           if (!dist)
7289             break;
7290         }
7291
7292       if (addr.offset < value)
7293         end = sym;
7294       else
7295         beg = sym + 1;
7296     }
7297
7298   if (best)
7299     {
7300       *symname = (best->st_name >= strtab_size
7301                   ? _("<corrupt>") : strtab + best->st_name);
7302       *offset = dist;
7303       return;
7304     }
7305
7306   *symname = NULL;
7307   *offset = addr.offset;
7308 }
7309
7310 static /* signed */ int
7311 symcmp (const void *p, const void *q)
7312 {
7313   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7314   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7315
7316   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7317 }
7318
7319 /* Process the unwind section.  */
7320
7321 #include "unwind-ia64.h"
7322
7323 struct ia64_unw_table_entry
7324 {
7325   struct absaddr start;
7326   struct absaddr end;
7327   struct absaddr info;
7328 };
7329
7330 struct ia64_unw_aux_info
7331 {
7332   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7333   unsigned long                 table_len;      /* Length of unwind table.  */
7334   unsigned char *               info;           /* Unwind info.  */
7335   unsigned long                 info_size;      /* Size of unwind info.  */
7336   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7337   bfd_vma                       seg_base;       /* Starting address of segment.  */
7338   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7339   unsigned long                 nsyms;          /* Number of symbols.  */
7340   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7341   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7342   char *                        strtab;         /* The string table.  */
7343   unsigned long                 strtab_size;    /* Size of string table.  */
7344 };
7345
7346 static bfd_boolean
7347 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7348 {
7349   struct ia64_unw_table_entry * tp;
7350   unsigned long j, nfuns;
7351   int in_body;
7352   bfd_boolean res = TRUE;
7353
7354   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7355   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7356     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7357       aux->funtab[nfuns++] = aux->symtab[j];
7358   aux->nfuns = nfuns;
7359   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7360
7361   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7362     {
7363       bfd_vma stamp;
7364       bfd_vma offset;
7365       const unsigned char * dp;
7366       const unsigned char * head;
7367       const unsigned char * end;
7368       const char * procname;
7369
7370       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7371                                aux->strtab_size, tp->start, &procname, &offset);
7372
7373       fputs ("\n<", stdout);
7374
7375       if (procname)
7376         {
7377           fputs (procname, stdout);
7378
7379           if (offset)
7380             printf ("+%lx", (unsigned long) offset);
7381         }
7382
7383       fputs (">: [", stdout);
7384       print_vma (tp->start.offset, PREFIX_HEX);
7385       fputc ('-', stdout);
7386       print_vma (tp->end.offset, PREFIX_HEX);
7387       printf ("], info at +0x%lx\n",
7388               (unsigned long) (tp->info.offset - aux->seg_base));
7389
7390       /* PR 17531: file: 86232b32.  */
7391       if (aux->info == NULL)
7392         continue;
7393
7394       /* PR 17531: file: 0997b4d1.  */
7395       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7396         {
7397           warn (_("Invalid offset %lx in table entry %ld\n"),
7398                 (long) tp->info.offset, (long) (tp - aux->table));
7399           res = FALSE;
7400           continue;
7401         }
7402
7403       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7404       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7405
7406       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7407               (unsigned) UNW_VER (stamp),
7408               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7409               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7410               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7411               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7412
7413       if (UNW_VER (stamp) != 1)
7414         {
7415           printf (_("\tUnknown version.\n"));
7416           continue;
7417         }
7418
7419       in_body = 0;
7420       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7421       /* PR 17531: file: 16ceda89.  */
7422       if (end > aux->info + aux->info_size)
7423         end = aux->info + aux->info_size;
7424       for (dp = head + 8; dp < end;)
7425         dp = unw_decode (dp, in_body, & in_body, end);
7426     }
7427
7428   free (aux->funtab);
7429
7430   return res;
7431 }
7432
7433 static bfd_boolean
7434 slurp_ia64_unwind_table (Filedata *                  filedata,
7435                          struct ia64_unw_aux_info *  aux,
7436                          Elf_Internal_Shdr *         sec)
7437 {
7438   unsigned long size, nrelas, i;
7439   Elf_Internal_Phdr * seg;
7440   struct ia64_unw_table_entry * tep;
7441   Elf_Internal_Shdr * relsec;
7442   Elf_Internal_Rela * rela;
7443   Elf_Internal_Rela * rp;
7444   unsigned char * table;
7445   unsigned char * tp;
7446   Elf_Internal_Sym * sym;
7447   const char * relname;
7448
7449   aux->table_len = 0;
7450
7451   /* First, find the starting address of the segment that includes
7452      this section: */
7453
7454   if (filedata->file_header.e_phnum)
7455     {
7456       if (! get_program_headers (filedata))
7457           return FALSE;
7458
7459       for (seg = filedata->program_headers;
7460            seg < filedata->program_headers + filedata->file_header.e_phnum;
7461            ++seg)
7462         {
7463           if (seg->p_type != PT_LOAD)
7464             continue;
7465
7466           if (sec->sh_addr >= seg->p_vaddr
7467               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7468             {
7469               aux->seg_base = seg->p_vaddr;
7470               break;
7471             }
7472         }
7473     }
7474
7475   /* Second, build the unwind table from the contents of the unwind section:  */
7476   size = sec->sh_size;
7477   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7478                                       _("unwind table"));
7479   if (!table)
7480     return FALSE;
7481
7482   aux->table_len = size / (3 * eh_addr_size);
7483   aux->table = (struct ia64_unw_table_entry *)
7484     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7485   tep = aux->table;
7486
7487   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7488     {
7489       tep->start.section = SHN_UNDEF;
7490       tep->end.section   = SHN_UNDEF;
7491       tep->info.section  = SHN_UNDEF;
7492       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7493       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7494       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7495       tep->start.offset += aux->seg_base;
7496       tep->end.offset   += aux->seg_base;
7497       tep->info.offset  += aux->seg_base;
7498     }
7499   free (table);
7500
7501   /* Third, apply any relocations to the unwind table:  */
7502   for (relsec = filedata->section_headers;
7503        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7504        ++relsec)
7505     {
7506       if (relsec->sh_type != SHT_RELA
7507           || relsec->sh_info >= filedata->file_header.e_shnum
7508           || filedata->section_headers + relsec->sh_info != sec)
7509         continue;
7510
7511       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7512                               & rela, & nrelas))
7513         {
7514           free (aux->table);
7515           aux->table = NULL;
7516           aux->table_len = 0;
7517           return FALSE;
7518         }
7519
7520       for (rp = rela; rp < rela + nrelas; ++rp)
7521         {
7522           relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7523           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7524
7525           /* PR 17531: file: 9fa67536.  */
7526           if (relname == NULL)
7527             {
7528               warn (_("Skipping unknown relocation type: %u\n"),
7529                     get_reloc_type (filedata, rp->r_info));
7530               continue;
7531             }
7532
7533           if (! const_strneq (relname, "R_IA64_SEGREL"))
7534             {
7535               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7536               continue;
7537             }
7538
7539           i = rp->r_offset / (3 * eh_addr_size);
7540
7541           /* PR 17531: file: 5bc8d9bf.  */
7542           if (i >= aux->table_len)
7543             {
7544               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7545               continue;
7546             }
7547
7548           switch (rp->r_offset / eh_addr_size % 3)
7549             {
7550             case 0:
7551               aux->table[i].start.section = sym->st_shndx;
7552               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7553               break;
7554             case 1:
7555               aux->table[i].end.section   = sym->st_shndx;
7556               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7557               break;
7558             case 2:
7559               aux->table[i].info.section  = sym->st_shndx;
7560               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7561               break;
7562             default:
7563               break;
7564             }
7565         }
7566
7567       free (rela);
7568     }
7569
7570   return TRUE;
7571 }
7572
7573 static bfd_boolean
7574 ia64_process_unwind (Filedata * filedata)
7575 {
7576   Elf_Internal_Shdr * sec;
7577   Elf_Internal_Shdr * unwsec = NULL;
7578   Elf_Internal_Shdr * strsec;
7579   unsigned long i, unwcount = 0, unwstart = 0;
7580   struct ia64_unw_aux_info aux;
7581   bfd_boolean res = TRUE;
7582
7583   memset (& aux, 0, sizeof (aux));
7584
7585   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7586     {
7587       if (sec->sh_type == SHT_SYMTAB
7588           && sec->sh_link < filedata->file_header.e_shnum)
7589         {
7590           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7591
7592           strsec = filedata->section_headers + sec->sh_link;
7593           if (aux.strtab != NULL)
7594             {
7595               error (_("Multiple auxillary string tables encountered\n"));
7596               free (aux.strtab);
7597               res = FALSE;
7598             }
7599           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7600                                           1, strsec->sh_size,
7601                                           _("string table"));
7602           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7603         }
7604       else if (sec->sh_type == SHT_IA_64_UNWIND)
7605         unwcount++;
7606     }
7607
7608   if (!unwcount)
7609     printf (_("\nThere are no unwind sections in this file.\n"));
7610
7611   while (unwcount-- > 0)
7612     {
7613       char * suffix;
7614       size_t len, len2;
7615
7616       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7617            i < filedata->file_header.e_shnum; ++i, ++sec)
7618         if (sec->sh_type == SHT_IA_64_UNWIND)
7619           {
7620             unwsec = sec;
7621             break;
7622           }
7623       /* We have already counted the number of SHT_IA64_UNWIND
7624          sections so the loop above should never fail.  */
7625       assert (unwsec != NULL);
7626
7627       unwstart = i + 1;
7628       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7629
7630       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7631         {
7632           /* We need to find which section group it is in.  */
7633           struct group_list * g;
7634
7635           if (section_headers_groups == NULL
7636               || section_headers_groups [i] == NULL)
7637             i = filedata->file_header.e_shnum;
7638           else
7639             {
7640               g = section_headers_groups [i]->root;
7641
7642               for (; g != NULL; g = g->next)
7643                 {
7644                   sec = filedata->section_headers + g->section_index;
7645
7646                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7647                     break;
7648                 }
7649
7650               if (g == NULL)
7651                 i = filedata->file_header.e_shnum;
7652             }
7653         }
7654       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7655         {
7656           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7657           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7658           suffix = SECTION_NAME (unwsec) + len;
7659           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7660                ++i, ++sec)
7661             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7662                 && streq (SECTION_NAME (sec) + len2, suffix))
7663               break;
7664         }
7665       else
7666         {
7667           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7668              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7669           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7670           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7671           suffix = "";
7672           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7673             suffix = SECTION_NAME (unwsec) + len;
7674           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7675                ++i, ++sec)
7676             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7677                 && streq (SECTION_NAME (sec) + len2, suffix))
7678               break;
7679         }
7680
7681       if (i == filedata->file_header.e_shnum)
7682         {
7683           printf (_("\nCould not find unwind info section for "));
7684
7685           if (filedata->string_table == NULL)
7686             printf ("%d", unwsec->sh_name);
7687           else
7688             printf ("'%s'", printable_section_name (filedata, unwsec));
7689         }
7690       else
7691         {
7692           aux.info_addr = sec->sh_addr;
7693           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7694                                                  sec->sh_size,
7695                                                  _("unwind info"));
7696           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7697
7698           printf (_("\nUnwind section "));
7699
7700           if (filedata->string_table == NULL)
7701             printf ("%d", unwsec->sh_name);
7702           else
7703             printf ("'%s'", printable_section_name (filedata, unwsec));
7704
7705           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7706                   (unsigned long) unwsec->sh_offset,
7707                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7708
7709           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7710               && aux.table_len > 0)
7711             dump_ia64_unwind (filedata, & aux);
7712
7713           if (aux.table)
7714             free ((char *) aux.table);
7715           if (aux.info)
7716             free ((char *) aux.info);
7717           aux.table = NULL;
7718           aux.info = NULL;
7719         }
7720     }
7721
7722   if (aux.symtab)
7723     free (aux.symtab);
7724   if (aux.strtab)
7725     free ((char *) aux.strtab);
7726
7727   return res;
7728 }
7729
7730 struct hppa_unw_table_entry
7731 {
7732   struct absaddr start;
7733   struct absaddr end;
7734   unsigned int Cannot_unwind:1;                 /* 0 */
7735   unsigned int Millicode:1;                     /* 1 */
7736   unsigned int Millicode_save_sr0:1;            /* 2 */
7737   unsigned int Region_description:2;            /* 3..4 */
7738   unsigned int reserved1:1;                     /* 5 */
7739   unsigned int Entry_SR:1;                      /* 6 */
7740   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7741   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7742   unsigned int Args_stored:1;                   /* 16 */
7743   unsigned int Variable_Frame:1;                /* 17 */
7744   unsigned int Separate_Package_Body:1;         /* 18 */
7745   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7746   unsigned int Stack_Overflow_Check:1;          /* 20 */
7747   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7748   unsigned int Ada_Region:1;                    /* 22 */
7749   unsigned int cxx_info:1;                      /* 23 */
7750   unsigned int cxx_try_catch:1;                 /* 24 */
7751   unsigned int sched_entry_seq:1;               /* 25 */
7752   unsigned int reserved2:1;                     /* 26 */
7753   unsigned int Save_SP:1;                       /* 27 */
7754   unsigned int Save_RP:1;                       /* 28 */
7755   unsigned int Save_MRP_in_frame:1;             /* 29 */
7756   unsigned int extn_ptr_defined:1;              /* 30 */
7757   unsigned int Cleanup_defined:1;               /* 31 */
7758
7759   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7760   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7761   unsigned int Large_frame:1;                   /* 2 */
7762   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7763   unsigned int reserved4:1;                     /* 4 */
7764   unsigned int Total_frame_size:27;             /* 5..31 */
7765 };
7766
7767 struct hppa_unw_aux_info
7768 {
7769   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7770   unsigned long                  table_len;     /* Length of unwind table.  */
7771   bfd_vma                        seg_base;      /* Starting address of segment.  */
7772   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7773   unsigned long                  nsyms;         /* Number of symbols.  */
7774   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7775   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7776   char *                         strtab;        /* The string table.  */
7777   unsigned long                  strtab_size;   /* Size of string table.  */
7778 };
7779
7780 static bfd_boolean
7781 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7782 {
7783   struct hppa_unw_table_entry * tp;
7784   unsigned long j, nfuns;
7785   bfd_boolean res = TRUE;
7786
7787   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7788   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7789     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7790       aux->funtab[nfuns++] = aux->symtab[j];
7791   aux->nfuns = nfuns;
7792   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7793
7794   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7795     {
7796       bfd_vma offset;
7797       const char * procname;
7798
7799       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7800                                aux->strtab_size, tp->start, &procname,
7801                                &offset);
7802
7803       fputs ("\n<", stdout);
7804
7805       if (procname)
7806         {
7807           fputs (procname, stdout);
7808
7809           if (offset)
7810             printf ("+%lx", (unsigned long) offset);
7811         }
7812
7813       fputs (">: [", stdout);
7814       print_vma (tp->start.offset, PREFIX_HEX);
7815       fputc ('-', stdout);
7816       print_vma (tp->end.offset, PREFIX_HEX);
7817       printf ("]\n\t");
7818
7819 #define PF(_m) if (tp->_m) printf (#_m " ");
7820 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7821       PF(Cannot_unwind);
7822       PF(Millicode);
7823       PF(Millicode_save_sr0);
7824       /* PV(Region_description);  */
7825       PF(Entry_SR);
7826       PV(Entry_FR);
7827       PV(Entry_GR);
7828       PF(Args_stored);
7829       PF(Variable_Frame);
7830       PF(Separate_Package_Body);
7831       PF(Frame_Extension_Millicode);
7832       PF(Stack_Overflow_Check);
7833       PF(Two_Instruction_SP_Increment);
7834       PF(Ada_Region);
7835       PF(cxx_info);
7836       PF(cxx_try_catch);
7837       PF(sched_entry_seq);
7838       PF(Save_SP);
7839       PF(Save_RP);
7840       PF(Save_MRP_in_frame);
7841       PF(extn_ptr_defined);
7842       PF(Cleanup_defined);
7843       PF(MPE_XL_interrupt_marker);
7844       PF(HP_UX_interrupt_marker);
7845       PF(Large_frame);
7846       PF(Pseudo_SP_Set);
7847       PV(Total_frame_size);
7848 #undef PF
7849 #undef PV
7850     }
7851
7852   printf ("\n");
7853
7854   free (aux->funtab);
7855
7856   return res;
7857 }
7858
7859 static bfd_boolean
7860 slurp_hppa_unwind_table (Filedata *                  filedata,
7861                          struct hppa_unw_aux_info *  aux,
7862                          Elf_Internal_Shdr *         sec)
7863 {
7864   unsigned long size, unw_ent_size, nentries, nrelas, i;
7865   Elf_Internal_Phdr * seg;
7866   struct hppa_unw_table_entry * tep;
7867   Elf_Internal_Shdr * relsec;
7868   Elf_Internal_Rela * rela;
7869   Elf_Internal_Rela * rp;
7870   unsigned char * table;
7871   unsigned char * tp;
7872   Elf_Internal_Sym * sym;
7873   const char * relname;
7874
7875   /* First, find the starting address of the segment that includes
7876      this section.  */
7877   if (filedata->file_header.e_phnum)
7878     {
7879       if (! get_program_headers (filedata))
7880         return FALSE;
7881
7882       for (seg = filedata->program_headers;
7883            seg < filedata->program_headers + filedata->file_header.e_phnum;
7884            ++seg)
7885         {
7886           if (seg->p_type != PT_LOAD)
7887             continue;
7888
7889           if (sec->sh_addr >= seg->p_vaddr
7890               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7891             {
7892               aux->seg_base = seg->p_vaddr;
7893               break;
7894             }
7895         }
7896     }
7897
7898   /* Second, build the unwind table from the contents of the unwind
7899      section.  */
7900   size = sec->sh_size;
7901   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7902                                       _("unwind table"));
7903   if (!table)
7904     return FALSE;
7905
7906   unw_ent_size = 16;
7907   nentries = size / unw_ent_size;
7908   size = unw_ent_size * nentries;
7909
7910   tep = aux->table = (struct hppa_unw_table_entry *)
7911       xcmalloc (nentries, sizeof (aux->table[0]));
7912
7913   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7914     {
7915       unsigned int tmp1, tmp2;
7916
7917       tep->start.section = SHN_UNDEF;
7918       tep->end.section   = SHN_UNDEF;
7919
7920       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7921       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7922       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7923       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7924
7925       tep->start.offset += aux->seg_base;
7926       tep->end.offset   += aux->seg_base;
7927
7928       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7929       tep->Millicode = (tmp1 >> 30) & 0x1;
7930       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7931       tep->Region_description = (tmp1 >> 27) & 0x3;
7932       tep->reserved1 = (tmp1 >> 26) & 0x1;
7933       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7934       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7935       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7936       tep->Args_stored = (tmp1 >> 15) & 0x1;
7937       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7938       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7939       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7940       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7941       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7942       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7943       tep->cxx_info = (tmp1 >> 8) & 0x1;
7944       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7945       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7946       tep->reserved2 = (tmp1 >> 5) & 0x1;
7947       tep->Save_SP = (tmp1 >> 4) & 0x1;
7948       tep->Save_RP = (tmp1 >> 3) & 0x1;
7949       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7950       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7951       tep->Cleanup_defined = tmp1 & 0x1;
7952
7953       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7954       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7955       tep->Large_frame = (tmp2 >> 29) & 0x1;
7956       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7957       tep->reserved4 = (tmp2 >> 27) & 0x1;
7958       tep->Total_frame_size = tmp2 & 0x7ffffff;
7959     }
7960   free (table);
7961
7962   /* Third, apply any relocations to the unwind table.  */
7963   for (relsec = filedata->section_headers;
7964        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7965        ++relsec)
7966     {
7967       if (relsec->sh_type != SHT_RELA
7968           || relsec->sh_info >= filedata->file_header.e_shnum
7969           || filedata->section_headers + relsec->sh_info != sec)
7970         continue;
7971
7972       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7973                               & rela, & nrelas))
7974         return FALSE;
7975
7976       for (rp = rela; rp < rela + nrelas; ++rp)
7977         {
7978           relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
7979           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7980
7981           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7982           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7983             {
7984               warn (_("Skipping unexpected relocation type %s\n"), relname);
7985               continue;
7986             }
7987
7988           i = rp->r_offset / unw_ent_size;
7989
7990           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7991             {
7992             case 0:
7993               aux->table[i].start.section = sym->st_shndx;
7994               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7995               break;
7996             case 1:
7997               aux->table[i].end.section   = sym->st_shndx;
7998               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7999               break;
8000             default:
8001               break;
8002             }
8003         }
8004
8005       free (rela);
8006     }
8007
8008   aux->table_len = nentries;
8009
8010   return TRUE;
8011 }
8012
8013 static bfd_boolean
8014 hppa_process_unwind (Filedata * filedata)
8015 {
8016   struct hppa_unw_aux_info aux;
8017   Elf_Internal_Shdr * unwsec = NULL;
8018   Elf_Internal_Shdr * strsec;
8019   Elf_Internal_Shdr * sec;
8020   unsigned long i;
8021   bfd_boolean res = TRUE;
8022
8023   if (filedata->string_table == NULL)
8024     return FALSE;
8025
8026   memset (& aux, 0, sizeof (aux));
8027
8028   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8029     {
8030       if (sec->sh_type == SHT_SYMTAB
8031           && sec->sh_link < filedata->file_header.e_shnum)
8032         {
8033           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8034
8035           strsec = filedata->section_headers + sec->sh_link;
8036           if (aux.strtab != NULL)
8037             {
8038               error (_("Multiple auxillary string tables encountered\n"));
8039               free (aux.strtab);
8040               res = FALSE;
8041             }
8042           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8043                                           1, strsec->sh_size,
8044                                           _("string table"));
8045           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8046         }
8047       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8048         unwsec = sec;
8049     }
8050
8051   if (!unwsec)
8052     printf (_("\nThere are no unwind sections in this file.\n"));
8053
8054   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8055     {
8056       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8057         {
8058           unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8059
8060           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8061                             "contains %lu entry:\n",
8062                             "\nUnwind section '%s' at offset 0x%lx "
8063                             "contains %lu entries:\n",
8064                             num_unwind),
8065                   printable_section_name (filedata, sec),
8066                   (unsigned long) sec->sh_offset,
8067                   num_unwind);
8068
8069           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8070             res = FALSE;
8071
8072           if (aux.table_len > 0)
8073             {
8074               if (! dump_hppa_unwind (filedata, &aux))
8075                 res = FALSE;
8076             }
8077
8078           if (aux.table)
8079             free ((char *) aux.table);
8080           aux.table = NULL;
8081         }
8082     }
8083
8084   if (aux.symtab)
8085     free (aux.symtab);
8086   if (aux.strtab)
8087     free ((char *) aux.strtab);
8088
8089   return res;
8090 }
8091
8092 struct arm_section
8093 {
8094   unsigned char *      data;            /* The unwind data.  */
8095   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8096   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8097   unsigned long        nrelas;          /* The number of relocations.  */
8098   unsigned int         rel_type;        /* REL or RELA ?  */
8099   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8100 };
8101
8102 struct arm_unw_aux_info
8103 {
8104   Filedata *          filedata;         /* The file containing the unwind sections.  */
8105   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8106   unsigned long       nsyms;            /* Number of symbols.  */
8107   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8108   unsigned long       nfuns;            /* Number of these symbols.  */
8109   char *              strtab;           /* The file's string table.  */
8110   unsigned long       strtab_size;      /* Size of string table.  */
8111 };
8112
8113 static const char *
8114 arm_print_vma_and_name (Filedata *                 filedata,
8115                         struct arm_unw_aux_info *  aux,
8116                         bfd_vma                    fn,
8117                         struct absaddr             addr)
8118 {
8119   const char *procname;
8120   bfd_vma sym_offset;
8121
8122   if (addr.section == SHN_UNDEF)
8123     addr.offset = fn;
8124
8125   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8126                            aux->strtab_size, addr, &procname,
8127                            &sym_offset);
8128
8129   print_vma (fn, PREFIX_HEX);
8130
8131   if (procname)
8132     {
8133       fputs (" <", stdout);
8134       fputs (procname, stdout);
8135
8136       if (sym_offset)
8137         printf ("+0x%lx", (unsigned long) sym_offset);
8138       fputc ('>', stdout);
8139     }
8140
8141   return procname;
8142 }
8143
8144 static void
8145 arm_free_section (struct arm_section *arm_sec)
8146 {
8147   if (arm_sec->data != NULL)
8148     free (arm_sec->data);
8149
8150   if (arm_sec->rela != NULL)
8151     free (arm_sec->rela);
8152 }
8153
8154 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8155       cached section and install SEC instead.
8156    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8157       and return its valued in * WORDP, relocating if necessary.
8158    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8159       relocation's offset in ADDR.
8160    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8161       into the string table of the symbol associated with the reloc.  If no
8162       reloc was applied store -1 there.
8163    5) Return TRUE upon success, FALSE otherwise.  */
8164
8165 static bfd_boolean
8166 get_unwind_section_word (Filedata *                 filedata,
8167                          struct arm_unw_aux_info *  aux,
8168                          struct arm_section *       arm_sec,
8169                          Elf_Internal_Shdr *        sec,
8170                          bfd_vma                    word_offset,
8171                          unsigned int *             wordp,
8172                          struct absaddr *           addr,
8173                          bfd_vma *                  sym_name)
8174 {
8175   Elf_Internal_Rela *rp;
8176   Elf_Internal_Sym *sym;
8177   const char * relname;
8178   unsigned int word;
8179   bfd_boolean wrapped;
8180
8181   if (sec == NULL || arm_sec == NULL)
8182     return FALSE;
8183
8184   addr->section = SHN_UNDEF;
8185   addr->offset = 0;
8186
8187   if (sym_name != NULL)
8188     *sym_name = (bfd_vma) -1;
8189
8190   /* If necessary, update the section cache.  */
8191   if (sec != arm_sec->sec)
8192     {
8193       Elf_Internal_Shdr *relsec;
8194
8195       arm_free_section (arm_sec);
8196
8197       arm_sec->sec = sec;
8198       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8199                                 sec->sh_size, _("unwind data"));
8200       arm_sec->rela = NULL;
8201       arm_sec->nrelas = 0;
8202
8203       for (relsec = filedata->section_headers;
8204            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8205            ++relsec)
8206         {
8207           if (relsec->sh_info >= filedata->file_header.e_shnum
8208               || filedata->section_headers + relsec->sh_info != sec
8209               /* PR 15745: Check the section type as well.  */
8210               || (relsec->sh_type != SHT_REL
8211                   && relsec->sh_type != SHT_RELA))
8212             continue;
8213
8214           arm_sec->rel_type = relsec->sh_type;
8215           if (relsec->sh_type == SHT_REL)
8216             {
8217               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8218                                      relsec->sh_size,
8219                                      & arm_sec->rela, & arm_sec->nrelas))
8220                 return FALSE;
8221             }
8222           else /* relsec->sh_type == SHT_RELA */
8223             {
8224               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8225                                       relsec->sh_size,
8226                                       & arm_sec->rela, & arm_sec->nrelas))
8227                 return FALSE;
8228             }
8229           break;
8230         }
8231
8232       arm_sec->next_rela = arm_sec->rela;
8233     }
8234
8235   /* If there is no unwind data we can do nothing.  */
8236   if (arm_sec->data == NULL)
8237     return FALSE;
8238
8239   /* If the offset is invalid then fail.  */
8240   if (/* PR 21343 *//* PR 18879 */
8241       sec->sh_size < 4
8242       || word_offset > (sec->sh_size - 4)
8243       || ((bfd_signed_vma) word_offset) < 0)
8244     return FALSE;
8245
8246   /* Get the word at the required offset.  */
8247   word = byte_get (arm_sec->data + word_offset, 4);
8248
8249   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8250   if (arm_sec->rela == NULL)
8251     {
8252       * wordp = word;
8253       return TRUE;
8254     }
8255
8256   /* Look through the relocs to find the one that applies to the provided offset.  */
8257   wrapped = FALSE;
8258   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8259     {
8260       bfd_vma prelval, offset;
8261
8262       if (rp->r_offset > word_offset && !wrapped)
8263         {
8264           rp = arm_sec->rela;
8265           wrapped = TRUE;
8266         }
8267       if (rp->r_offset > word_offset)
8268         break;
8269
8270       if (rp->r_offset & 3)
8271         {
8272           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8273                 (unsigned long) rp->r_offset);
8274           continue;
8275         }
8276
8277       if (rp->r_offset < word_offset)
8278         continue;
8279
8280       /* PR 17531: file: 027-161405-0.004  */
8281       if (aux->symtab == NULL)
8282         continue;
8283
8284       if (arm_sec->rel_type == SHT_REL)
8285         {
8286           offset = word & 0x7fffffff;
8287           if (offset & 0x40000000)
8288             offset |= ~ (bfd_vma) 0x7fffffff;
8289         }
8290       else if (arm_sec->rel_type == SHT_RELA)
8291         offset = rp->r_addend;
8292       else
8293         {
8294           error (_("Unknown section relocation type %d encountered\n"),
8295                  arm_sec->rel_type);
8296           break;
8297         }
8298
8299       /* PR 17531 file: 027-1241568-0.004.  */
8300       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8301         {
8302           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8303                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8304           break;
8305         }
8306
8307       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8308       offset += sym->st_value;
8309       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8310
8311       /* Check that we are processing the expected reloc type.  */
8312       if (filedata->file_header.e_machine == EM_ARM)
8313         {
8314           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8315           if (relname == NULL)
8316             {
8317               warn (_("Skipping unknown ARM relocation type: %d\n"),
8318                     (int) ELF32_R_TYPE (rp->r_info));
8319               continue;
8320             }
8321
8322           if (streq (relname, "R_ARM_NONE"))
8323               continue;
8324
8325           if (! streq (relname, "R_ARM_PREL31"))
8326             {
8327               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8328               continue;
8329             }
8330         }
8331       else if (filedata->file_header.e_machine == EM_TI_C6000)
8332         {
8333           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8334           if (relname == NULL)
8335             {
8336               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8337                     (int) ELF32_R_TYPE (rp->r_info));
8338               continue;
8339             }
8340
8341           if (streq (relname, "R_C6000_NONE"))
8342             continue;
8343
8344           if (! streq (relname, "R_C6000_PREL31"))
8345             {
8346               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8347               continue;
8348             }
8349
8350           prelval >>= 1;
8351         }
8352       else
8353         {
8354           /* This function currently only supports ARM and TI unwinders.  */
8355           warn (_("Only TI and ARM unwinders are currently supported\n"));
8356           break;
8357         }
8358
8359       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8360       addr->section = sym->st_shndx;
8361       addr->offset = offset;
8362
8363       if (sym_name)
8364         * sym_name = sym->st_name;
8365       break;
8366     }
8367
8368   *wordp = word;
8369   arm_sec->next_rela = rp;
8370
8371   return TRUE;
8372 }
8373
8374 static const char *tic6x_unwind_regnames[16] =
8375 {
8376   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8377   "A14", "A13", "A12", "A11", "A10",
8378   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8379 };
8380
8381 static void
8382 decode_tic6x_unwind_regmask (unsigned int mask)
8383 {
8384   int i;
8385
8386   for (i = 12; mask; mask >>= 1, i--)
8387     {
8388       if (mask & 1)
8389         {
8390           fputs (tic6x_unwind_regnames[i], stdout);
8391           if (mask > 1)
8392             fputs (", ", stdout);
8393         }
8394     }
8395 }
8396
8397 #define ADVANCE                                                 \
8398   if (remaining == 0 && more_words)                             \
8399     {                                                           \
8400       data_offset += 4;                                         \
8401       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8402                                      data_offset, & word, & addr, NULL))        \
8403         return FALSE;                                           \
8404       remaining = 4;                                            \
8405       more_words--;                                             \
8406     }                                                           \
8407
8408 #define GET_OP(OP)                      \
8409   ADVANCE;                              \
8410   if (remaining)                        \
8411     {                                   \
8412       remaining--;                      \
8413       (OP) = word >> 24;                \
8414       word <<= 8;                       \
8415     }                                   \
8416   else                                  \
8417     {                                   \
8418       printf (_("[Truncated opcode]\n"));       \
8419       return FALSE;                     \
8420     }                                   \
8421   printf ("0x%02x ", OP)
8422
8423 static bfd_boolean
8424 decode_arm_unwind_bytecode (Filedata *                 filedata,
8425                             struct arm_unw_aux_info *  aux,
8426                             unsigned int               word,
8427                             unsigned int               remaining,
8428                             unsigned int               more_words,
8429                             bfd_vma                    data_offset,
8430                             Elf_Internal_Shdr *        data_sec,
8431                             struct arm_section *       data_arm_sec)
8432 {
8433   struct absaddr addr;
8434   bfd_boolean res = TRUE;
8435
8436   /* Decode the unwinding instructions.  */
8437   while (1)
8438     {
8439       unsigned int op, op2;
8440
8441       ADVANCE;
8442       if (remaining == 0)
8443         break;
8444       remaining--;
8445       op = word >> 24;
8446       word <<= 8;
8447
8448       printf ("  0x%02x ", op);
8449
8450       if ((op & 0xc0) == 0x00)
8451         {
8452           int offset = ((op & 0x3f) << 2) + 4;
8453
8454           printf ("     vsp = vsp + %d", offset);
8455         }
8456       else if ((op & 0xc0) == 0x40)
8457         {
8458           int offset = ((op & 0x3f) << 2) + 4;
8459
8460           printf ("     vsp = vsp - %d", offset);
8461         }
8462       else if ((op & 0xf0) == 0x80)
8463         {
8464           GET_OP (op2);
8465           if (op == 0x80 && op2 == 0)
8466             printf (_("Refuse to unwind"));
8467           else
8468             {
8469               unsigned int mask = ((op & 0x0f) << 8) | op2;
8470               bfd_boolean first = TRUE;
8471               int i;
8472
8473               printf ("pop {");
8474               for (i = 0; i < 12; i++)
8475                 if (mask & (1 << i))
8476                   {
8477                     if (first)
8478                       first = FALSE;
8479                     else
8480                       printf (", ");
8481                     printf ("r%d", 4 + i);
8482                   }
8483               printf ("}");
8484             }
8485         }
8486       else if ((op & 0xf0) == 0x90)
8487         {
8488           if (op == 0x9d || op == 0x9f)
8489             printf (_("     [Reserved]"));
8490           else
8491             printf ("     vsp = r%d", op & 0x0f);
8492         }
8493       else if ((op & 0xf0) == 0xa0)
8494         {
8495           int end = 4 + (op & 0x07);
8496           bfd_boolean first = TRUE;
8497           int i;
8498
8499           printf ("     pop {");
8500           for (i = 4; i <= end; i++)
8501             {
8502               if (first)
8503                 first = FALSE;
8504               else
8505                 printf (", ");
8506               printf ("r%d", i);
8507             }
8508           if (op & 0x08)
8509             {
8510               if (!first)
8511                 printf (", ");
8512               printf ("r14");
8513             }
8514           printf ("}");
8515         }
8516       else if (op == 0xb0)
8517         printf (_("     finish"));
8518       else if (op == 0xb1)
8519         {
8520           GET_OP (op2);
8521           if (op2 == 0 || (op2 & 0xf0) != 0)
8522             printf (_("[Spare]"));
8523           else
8524             {
8525               unsigned int mask = op2 & 0x0f;
8526               bfd_boolean first = TRUE;
8527               int i;
8528
8529               printf ("pop {");
8530               for (i = 0; i < 12; i++)
8531                 if (mask & (1 << i))
8532                   {
8533                     if (first)
8534                       first = FALSE;
8535                     else
8536                       printf (", ");
8537                     printf ("r%d", i);
8538                   }
8539               printf ("}");
8540             }
8541         }
8542       else if (op == 0xb2)
8543         {
8544           unsigned char buf[9];
8545           unsigned int i, len;
8546           unsigned long offset;
8547
8548           for (i = 0; i < sizeof (buf); i++)
8549             {
8550               GET_OP (buf[i]);
8551               if ((buf[i] & 0x80) == 0)
8552                 break;
8553             }
8554           if (i == sizeof (buf))
8555             {
8556               error (_("corrupt change to vsp"));
8557               res = FALSE;
8558             }
8559           else
8560             {
8561               offset = read_uleb128 (buf, &len, buf + i + 1);
8562               assert (len == i + 1);
8563               offset = offset * 4 + 0x204;
8564               printf ("vsp = vsp + %ld", offset);
8565             }
8566         }
8567       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8568         {
8569           unsigned int first, last;
8570
8571           GET_OP (op2);
8572           first = op2 >> 4;
8573           last = op2 & 0x0f;
8574           if (op == 0xc8)
8575             first = first + 16;
8576           printf ("pop {D%d", first);
8577           if (last)
8578             printf ("-D%d", first + last);
8579           printf ("}");
8580         }
8581       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8582         {
8583           unsigned int count = op & 0x07;
8584
8585           printf ("pop {D8");
8586           if (count)
8587             printf ("-D%d", 8 + count);
8588           printf ("}");
8589         }
8590       else if (op >= 0xc0 && op <= 0xc5)
8591         {
8592           unsigned int count = op & 0x07;
8593
8594           printf ("     pop {wR10");
8595           if (count)
8596             printf ("-wR%d", 10 + count);
8597           printf ("}");
8598         }
8599       else if (op == 0xc6)
8600         {
8601           unsigned int first, last;
8602
8603           GET_OP (op2);
8604           first = op2 >> 4;
8605           last = op2 & 0x0f;
8606           printf ("pop {wR%d", first);
8607           if (last)
8608             printf ("-wR%d", first + last);
8609           printf ("}");
8610         }
8611       else if (op == 0xc7)
8612         {
8613           GET_OP (op2);
8614           if (op2 == 0 || (op2 & 0xf0) != 0)
8615             printf (_("[Spare]"));
8616           else
8617             {
8618               unsigned int mask = op2 & 0x0f;
8619               bfd_boolean first = TRUE;
8620               int i;
8621
8622               printf ("pop {");
8623               for (i = 0; i < 4; i++)
8624                 if (mask & (1 << i))
8625                   {
8626                     if (first)
8627                       first = FALSE;
8628                     else
8629                       printf (", ");
8630                     printf ("wCGR%d", i);
8631                   }
8632               printf ("}");
8633             }
8634         }
8635       else
8636         {
8637           printf (_("     [unsupported opcode]"));
8638           res = FALSE;
8639         }
8640
8641       printf ("\n");
8642     }
8643
8644   return res;
8645 }
8646
8647 static bfd_boolean
8648 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8649                               struct arm_unw_aux_info *  aux,
8650                               unsigned int               word,
8651                               unsigned int               remaining,
8652                               unsigned int               more_words,
8653                               bfd_vma                    data_offset,
8654                               Elf_Internal_Shdr *        data_sec,
8655                               struct arm_section *       data_arm_sec)
8656 {
8657   struct absaddr addr;
8658
8659   /* Decode the unwinding instructions.  */
8660   while (1)
8661     {
8662       unsigned int op, op2;
8663
8664       ADVANCE;
8665       if (remaining == 0)
8666         break;
8667       remaining--;
8668       op = word >> 24;
8669       word <<= 8;
8670
8671       printf ("  0x%02x ", op);
8672
8673       if ((op & 0xc0) == 0x00)
8674         {
8675           int offset = ((op & 0x3f) << 3) + 8;
8676           printf ("     sp = sp + %d", offset);
8677         }
8678       else if ((op & 0xc0) == 0x80)
8679         {
8680           GET_OP (op2);
8681           if (op == 0x80 && op2 == 0)
8682             printf (_("Refuse to unwind"));
8683           else
8684             {
8685               unsigned int mask = ((op & 0x1f) << 8) | op2;
8686               if (op & 0x20)
8687                 printf ("pop compact {");
8688               else
8689                 printf ("pop {");
8690
8691               decode_tic6x_unwind_regmask (mask);
8692               printf("}");
8693             }
8694         }
8695       else if ((op & 0xf0) == 0xc0)
8696         {
8697           unsigned int reg;
8698           unsigned int nregs;
8699           unsigned int i;
8700           const char *name;
8701           struct
8702           {
8703             unsigned int offset;
8704             unsigned int reg;
8705           } regpos[16];
8706
8707           /* Scan entire instruction first so that GET_OP output is not
8708              interleaved with disassembly.  */
8709           nregs = 0;
8710           for (i = 0; nregs < (op & 0xf); i++)
8711             {
8712               GET_OP (op2);
8713               reg = op2 >> 4;
8714               if (reg != 0xf)
8715                 {
8716                   regpos[nregs].offset = i * 2;
8717                   regpos[nregs].reg = reg;
8718                   nregs++;
8719                 }
8720
8721               reg = op2 & 0xf;
8722               if (reg != 0xf)
8723                 {
8724                   regpos[nregs].offset = i * 2 + 1;
8725                   regpos[nregs].reg = reg;
8726                   nregs++;
8727                 }
8728             }
8729
8730           printf (_("pop frame {"));
8731           reg = nregs - 1;
8732           for (i = i * 2; i > 0; i--)
8733             {
8734               if (regpos[reg].offset == i - 1)
8735                 {
8736                   name = tic6x_unwind_regnames[regpos[reg].reg];
8737                   if (reg > 0)
8738                     reg--;
8739                 }
8740               else
8741                 name = _("[pad]");
8742
8743               fputs (name, stdout);
8744               if (i > 1)
8745                 printf (", ");
8746             }
8747
8748           printf ("}");
8749         }
8750       else if (op == 0xd0)
8751         printf ("     MOV FP, SP");
8752       else if (op == 0xd1)
8753         printf ("     __c6xabi_pop_rts");
8754       else if (op == 0xd2)
8755         {
8756           unsigned char buf[9];
8757           unsigned int i, len;
8758           unsigned long offset;
8759
8760           for (i = 0; i < sizeof (buf); i++)
8761             {
8762               GET_OP (buf[i]);
8763               if ((buf[i] & 0x80) == 0)
8764                 break;
8765             }
8766           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8767           if (i == sizeof (buf))
8768             {
8769               warn (_("Corrupt stack pointer adjustment detected\n"));
8770               return FALSE;
8771             }
8772
8773           offset = read_uleb128 (buf, &len, buf + i + 1);
8774           assert (len == i + 1);
8775           offset = offset * 8 + 0x408;
8776           printf (_("sp = sp + %ld"), offset);
8777         }
8778       else if ((op & 0xf0) == 0xe0)
8779         {
8780           if ((op & 0x0f) == 7)
8781             printf ("     RETURN");
8782           else
8783             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8784         }
8785       else
8786         {
8787           printf (_("     [unsupported opcode]"));
8788         }
8789       putchar ('\n');
8790     }
8791
8792   return TRUE;
8793 }
8794
8795 static bfd_vma
8796 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8797 {
8798   bfd_vma offset;
8799
8800   offset = word & 0x7fffffff;
8801   if (offset & 0x40000000)
8802     offset |= ~ (bfd_vma) 0x7fffffff;
8803
8804   if (filedata->file_header.e_machine == EM_TI_C6000)
8805     offset <<= 1;
8806
8807   return offset + where;
8808 }
8809
8810 static bfd_boolean
8811 decode_arm_unwind (Filedata *                 filedata,
8812                    struct arm_unw_aux_info *  aux,
8813                    unsigned int               word,
8814                    unsigned int               remaining,
8815                    bfd_vma                    data_offset,
8816                    Elf_Internal_Shdr *        data_sec,
8817                    struct arm_section *       data_arm_sec)
8818 {
8819   int per_index;
8820   unsigned int more_words = 0;
8821   struct absaddr addr;
8822   bfd_vma sym_name = (bfd_vma) -1;
8823   bfd_boolean res = TRUE;
8824
8825   if (remaining == 0)
8826     {
8827       /* Fetch the first word.
8828          Note - when decoding an object file the address extracted
8829          here will always be 0.  So we also pass in the sym_name
8830          parameter so that we can find the symbol associated with
8831          the personality routine.  */
8832       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8833                                      & word, & addr, & sym_name))
8834         return FALSE;
8835
8836       remaining = 4;
8837     }
8838
8839   if ((word & 0x80000000) == 0)
8840     {
8841       /* Expand prel31 for personality routine.  */
8842       bfd_vma fn;
8843       const char *procname;
8844
8845       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8846       printf (_("  Personality routine: "));
8847       if (fn == 0
8848           && addr.section == SHN_UNDEF && addr.offset == 0
8849           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8850         {
8851           procname = aux->strtab + sym_name;
8852           print_vma (fn, PREFIX_HEX);
8853           if (procname)
8854             {
8855               fputs (" <", stdout);
8856               fputs (procname, stdout);
8857               fputc ('>', stdout);
8858             }
8859         }
8860       else
8861         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8862       fputc ('\n', stdout);
8863
8864       /* The GCC personality routines use the standard compact
8865          encoding, starting with one byte giving the number of
8866          words.  */
8867       if (procname != NULL
8868           && (const_strneq (procname, "__gcc_personality_v0")
8869               || const_strneq (procname, "__gxx_personality_v0")
8870               || const_strneq (procname, "__gcj_personality_v0")
8871               || const_strneq (procname, "__gnu_objc_personality_v0")))
8872         {
8873           remaining = 0;
8874           more_words = 1;
8875           ADVANCE;
8876           if (!remaining)
8877             {
8878               printf (_("  [Truncated data]\n"));
8879               return FALSE;
8880             }
8881           more_words = word >> 24;
8882           word <<= 8;
8883           remaining--;
8884           per_index = -1;
8885         }
8886       else
8887         return TRUE;
8888     }
8889   else
8890     {
8891       /* ARM EHABI Section 6.3:
8892
8893          An exception-handling table entry for the compact model looks like:
8894
8895            31 30-28 27-24 23-0
8896            -- ----- ----- ----
8897             1   0   index Data for personalityRoutine[index]    */
8898
8899       if (filedata->file_header.e_machine == EM_ARM
8900           && (word & 0x70000000))
8901         {
8902           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8903           res = FALSE;
8904         }
8905
8906       per_index = (word >> 24) & 0x7f;
8907       printf (_("  Compact model index: %d\n"), per_index);
8908       if (per_index == 0)
8909         {
8910           more_words = 0;
8911           word <<= 8;
8912           remaining--;
8913         }
8914       else if (per_index < 3)
8915         {
8916           more_words = (word >> 16) & 0xff;
8917           word <<= 16;
8918           remaining -= 2;
8919         }
8920     }
8921
8922   switch (filedata->file_header.e_machine)
8923     {
8924     case EM_ARM:
8925       if (per_index < 3)
8926         {
8927           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
8928                                             data_offset, data_sec, data_arm_sec))
8929             res = FALSE;
8930         }
8931       else
8932         {
8933           warn (_("Unknown ARM compact model index encountered\n"));
8934           printf (_("  [reserved]\n"));
8935           res = FALSE;
8936         }
8937       break;
8938
8939     case EM_TI_C6000:
8940       if (per_index < 3)
8941         {
8942           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
8943                                               data_offset, data_sec, data_arm_sec))
8944             res = FALSE;
8945         }
8946       else if (per_index < 5)
8947         {
8948           if (((word >> 17) & 0x7f) == 0x7f)
8949             printf (_("  Restore stack from frame pointer\n"));
8950           else
8951             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8952           printf (_("  Registers restored: "));
8953           if (per_index == 4)
8954             printf (" (compact) ");
8955           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8956           putchar ('\n');
8957           printf (_("  Return register: %s\n"),
8958                   tic6x_unwind_regnames[word & 0xf]);
8959         }
8960       else
8961         printf (_("  [reserved (%d)]\n"), per_index);
8962       break;
8963
8964     default:
8965       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8966              filedata->file_header.e_machine);
8967       res = FALSE;
8968     }
8969
8970   /* Decode the descriptors.  Not implemented.  */
8971
8972   return res;
8973 }
8974
8975 static bfd_boolean
8976 dump_arm_unwind (Filedata *                 filedata,
8977                  struct arm_unw_aux_info *  aux,
8978                  Elf_Internal_Shdr *        exidx_sec)
8979 {
8980   struct arm_section exidx_arm_sec, extab_arm_sec;
8981   unsigned int i, exidx_len;
8982   unsigned long j, nfuns;
8983   bfd_boolean res = TRUE;
8984
8985   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8986   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8987   exidx_len = exidx_sec->sh_size / 8;
8988
8989   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8990   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8991     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8992       aux->funtab[nfuns++] = aux->symtab[j];
8993   aux->nfuns = nfuns;
8994   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8995
8996   for (i = 0; i < exidx_len; i++)
8997     {
8998       unsigned int exidx_fn, exidx_entry;
8999       struct absaddr fn_addr, entry_addr;
9000       bfd_vma fn;
9001
9002       fputc ('\n', stdout);
9003
9004       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9005                                      8 * i, & exidx_fn, & fn_addr, NULL)
9006           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9007                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9008         {
9009           free (aux->funtab);
9010           arm_free_section (& exidx_arm_sec);
9011           arm_free_section (& extab_arm_sec);
9012           return FALSE;
9013         }
9014
9015       /* ARM EHABI, Section 5:
9016          An index table entry consists of 2 words.
9017          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9018       if (exidx_fn & 0x80000000)
9019         {
9020           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9021           res = FALSE;
9022         }
9023
9024       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9025
9026       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9027       fputs (": ", stdout);
9028
9029       if (exidx_entry == 1)
9030         {
9031           print_vma (exidx_entry, PREFIX_HEX);
9032           fputs (" [cantunwind]\n", stdout);
9033         }
9034       else if (exidx_entry & 0x80000000)
9035         {
9036           print_vma (exidx_entry, PREFIX_HEX);
9037           fputc ('\n', stdout);
9038           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9039         }
9040       else
9041         {
9042           bfd_vma table, table_offset = 0;
9043           Elf_Internal_Shdr *table_sec;
9044
9045           fputs ("@", stdout);
9046           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9047           print_vma (table, PREFIX_HEX);
9048           printf ("\n");
9049
9050           /* Locate the matching .ARM.extab.  */
9051           if (entry_addr.section != SHN_UNDEF
9052               && entry_addr.section < filedata->file_header.e_shnum)
9053             {
9054               table_sec = filedata->section_headers + entry_addr.section;
9055               table_offset = entry_addr.offset;
9056               /* PR 18879 */
9057               if (table_offset > table_sec->sh_size
9058                   || ((bfd_signed_vma) table_offset) < 0)
9059                 {
9060                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9061                         (unsigned long) table_offset,
9062                         printable_section_name (filedata, table_sec));
9063                   res = FALSE;
9064                   continue;
9065                 }
9066             }
9067           else
9068             {
9069               table_sec = find_section_by_address (filedata, table);
9070               if (table_sec != NULL)
9071                 table_offset = table - table_sec->sh_addr;
9072             }
9073
9074           if (table_sec == NULL)
9075             {
9076               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9077                     (unsigned long) table);
9078               res = FALSE;
9079               continue;
9080             }
9081
9082           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9083                                    &extab_arm_sec))
9084             res = FALSE;
9085         }
9086     }
9087
9088   printf ("\n");
9089
9090   free (aux->funtab);
9091   arm_free_section (&exidx_arm_sec);
9092   arm_free_section (&extab_arm_sec);
9093
9094   return res;
9095 }
9096
9097 /* Used for both ARM and C6X unwinding tables.  */
9098
9099 static bfd_boolean
9100 arm_process_unwind (Filedata * filedata)
9101 {
9102   struct arm_unw_aux_info aux;
9103   Elf_Internal_Shdr *unwsec = NULL;
9104   Elf_Internal_Shdr *strsec;
9105   Elf_Internal_Shdr *sec;
9106   unsigned long i;
9107   unsigned int sec_type;
9108   bfd_boolean res = TRUE;
9109
9110   switch (filedata->file_header.e_machine)
9111     {
9112     case EM_ARM:
9113       sec_type = SHT_ARM_EXIDX;
9114       break;
9115
9116     case EM_TI_C6000:
9117       sec_type = SHT_C6000_UNWIND;
9118       break;
9119
9120     default:
9121       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9122              filedata->file_header.e_machine);
9123       return FALSE;
9124     }
9125
9126   if (filedata->string_table == NULL)
9127     return FALSE;
9128
9129   memset (& aux, 0, sizeof (aux));
9130   aux.filedata = filedata;
9131
9132   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9133     {
9134       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9135         {
9136           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9137
9138           strsec = filedata->section_headers + sec->sh_link;
9139
9140           /* PR binutils/17531 file: 011-12666-0.004.  */
9141           if (aux.strtab != NULL)
9142             {
9143               error (_("Multiple string tables found in file.\n"));
9144               free (aux.strtab);
9145               res = FALSE;
9146             }
9147           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9148                                  1, strsec->sh_size, _("string table"));
9149           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9150         }
9151       else if (sec->sh_type == sec_type)
9152         unwsec = sec;
9153     }
9154
9155   if (unwsec == NULL)
9156     printf (_("\nThere are no unwind sections in this file.\n"));
9157   else
9158     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9159       {
9160         if (sec->sh_type == sec_type)
9161           {
9162             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9163             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9164                               "contains %lu entry:\n",
9165                               "\nUnwind section '%s' at offset 0x%lx "
9166                               "contains %lu entries:\n",
9167                               num_unwind),
9168                     printable_section_name (filedata, sec),
9169                     (unsigned long) sec->sh_offset,
9170                     num_unwind);
9171
9172             if (! dump_arm_unwind (filedata, &aux, sec))
9173               res = FALSE;
9174           }
9175       }
9176
9177   if (aux.symtab)
9178     free (aux.symtab);
9179   if (aux.strtab)
9180     free ((char *) aux.strtab);
9181
9182   return res;
9183 }
9184
9185 static bfd_boolean
9186 process_unwind (Filedata * filedata)
9187 {
9188   struct unwind_handler
9189   {
9190     unsigned int machtype;
9191     bfd_boolean (* handler)(Filedata *);
9192   } handlers[] =
9193   {
9194     { EM_ARM, arm_process_unwind },
9195     { EM_IA_64, ia64_process_unwind },
9196     { EM_PARISC, hppa_process_unwind },
9197     { EM_TI_C6000, arm_process_unwind },
9198     { 0, NULL }
9199   };
9200   int i;
9201
9202   if (!do_unwind)
9203     return TRUE;
9204
9205   for (i = 0; handlers[i].handler != NULL; i++)
9206     if (filedata->file_header.e_machine == handlers[i].machtype)
9207       return handlers[i].handler (filedata);
9208
9209   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9210           get_machine_name (filedata->file_header.e_machine));
9211   return TRUE;
9212 }
9213
9214 static void
9215 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9216 {
9217   switch (entry->d_tag)
9218     {
9219     case DT_MIPS_FLAGS:
9220       if (entry->d_un.d_val == 0)
9221         printf (_("NONE"));
9222       else
9223         {
9224           static const char * opts[] =
9225           {
9226             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9227             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9228             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9229             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9230             "RLD_ORDER_SAFE"
9231           };
9232           unsigned int cnt;
9233           bfd_boolean first = TRUE;
9234
9235           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9236             if (entry->d_un.d_val & (1 << cnt))
9237               {
9238                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9239                 first = FALSE;
9240               }
9241         }
9242       break;
9243
9244     case DT_MIPS_IVERSION:
9245       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9246         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9247       else
9248         {
9249           char buf[40];
9250           sprintf_vma (buf, entry->d_un.d_ptr);
9251           /* Note: coded this way so that there is a single string for translation.  */
9252           printf (_("<corrupt: %s>"), buf);
9253         }
9254       break;
9255
9256     case DT_MIPS_TIME_STAMP:
9257       {
9258         char timebuf[128];
9259         struct tm * tmp;
9260         time_t atime = entry->d_un.d_val;
9261
9262         tmp = gmtime (&atime);
9263         /* PR 17531: file: 6accc532.  */
9264         if (tmp == NULL)
9265           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9266         else
9267           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9268                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9269                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9270         printf (_("Time Stamp: %s"), timebuf);
9271       }
9272       break;
9273
9274     case DT_MIPS_RLD_VERSION:
9275     case DT_MIPS_LOCAL_GOTNO:
9276     case DT_MIPS_CONFLICTNO:
9277     case DT_MIPS_LIBLISTNO:
9278     case DT_MIPS_SYMTABNO:
9279     case DT_MIPS_UNREFEXTNO:
9280     case DT_MIPS_HIPAGENO:
9281     case DT_MIPS_DELTA_CLASS_NO:
9282     case DT_MIPS_DELTA_INSTANCE_NO:
9283     case DT_MIPS_DELTA_RELOC_NO:
9284     case DT_MIPS_DELTA_SYM_NO:
9285     case DT_MIPS_DELTA_CLASSSYM_NO:
9286     case DT_MIPS_COMPACT_SIZE:
9287       print_vma (entry->d_un.d_val, DEC);
9288       break;
9289
9290     default:
9291       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9292     }
9293     putchar ('\n');
9294 }
9295
9296 static void
9297 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9298 {
9299   switch (entry->d_tag)
9300     {
9301     case DT_HP_DLD_FLAGS:
9302       {
9303         static struct
9304         {
9305           long int bit;
9306           const char * str;
9307         }
9308         flags[] =
9309         {
9310           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9311           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9312           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9313           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9314           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9315           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9316           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9317           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9318           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9319           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9320           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9321           { DT_HP_GST, "HP_GST" },
9322           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9323           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9324           { DT_HP_NODELETE, "HP_NODELETE" },
9325           { DT_HP_GROUP, "HP_GROUP" },
9326           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9327         };
9328         bfd_boolean first = TRUE;
9329         size_t cnt;
9330         bfd_vma val = entry->d_un.d_val;
9331
9332         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9333           if (val & flags[cnt].bit)
9334             {
9335               if (! first)
9336                 putchar (' ');
9337               fputs (flags[cnt].str, stdout);
9338               first = FALSE;
9339               val ^= flags[cnt].bit;
9340             }
9341
9342         if (val != 0 || first)
9343           {
9344             if (! first)
9345               putchar (' ');
9346             print_vma (val, HEX);
9347           }
9348       }
9349       break;
9350
9351     default:
9352       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9353       break;
9354     }
9355   putchar ('\n');
9356 }
9357
9358 #ifdef BFD64
9359
9360 /* VMS vs Unix time offset and factor.  */
9361
9362 #define VMS_EPOCH_OFFSET 35067168000000000LL
9363 #define VMS_GRANULARITY_FACTOR 10000000
9364
9365 /* Display a VMS time in a human readable format.  */
9366
9367 static void
9368 print_vms_time (bfd_int64_t vmstime)
9369 {
9370   struct tm *tm;
9371   time_t unxtime;
9372
9373   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9374   tm = gmtime (&unxtime);
9375   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9376           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9377           tm->tm_hour, tm->tm_min, tm->tm_sec);
9378 }
9379 #endif /* BFD64 */
9380
9381 static void
9382 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9383 {
9384   switch (entry->d_tag)
9385     {
9386     case DT_IA_64_PLT_RESERVE:
9387       /* First 3 slots reserved.  */
9388       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9389       printf (" -- ");
9390       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9391       break;
9392
9393     case DT_IA_64_VMS_LINKTIME:
9394 #ifdef BFD64
9395       print_vms_time (entry->d_un.d_val);
9396 #endif
9397       break;
9398
9399     case DT_IA_64_VMS_LNKFLAGS:
9400       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9401       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9402         printf (" CALL_DEBUG");
9403       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9404         printf (" NOP0BUFS");
9405       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9406         printf (" P0IMAGE");
9407       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9408         printf (" MKTHREADS");
9409       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9410         printf (" UPCALLS");
9411       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9412         printf (" IMGSTA");
9413       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9414         printf (" INITIALIZE");
9415       if (entry->d_un.d_val & VMS_LF_MAIN)
9416         printf (" MAIN");
9417       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9418         printf (" EXE_INIT");
9419       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9420         printf (" TBK_IN_IMG");
9421       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9422         printf (" DBG_IN_IMG");
9423       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9424         printf (" TBK_IN_DSF");
9425       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9426         printf (" DBG_IN_DSF");
9427       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9428         printf (" SIGNATURES");
9429       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9430         printf (" REL_SEG_OFF");
9431       break;
9432
9433     default:
9434       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9435       break;
9436     }
9437   putchar ('\n');
9438 }
9439
9440 static bfd_boolean
9441 get_32bit_dynamic_section (Filedata * filedata)
9442 {
9443   Elf32_External_Dyn * edyn;
9444   Elf32_External_Dyn * ext;
9445   Elf_Internal_Dyn * entry;
9446
9447   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9448                                           dynamic_size, _("dynamic section"));
9449   if (!edyn)
9450     return FALSE;
9451
9452   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9453      might not have the luxury of section headers.  Look for the DT_NULL
9454      terminator to determine the number of entries.  */
9455   for (ext = edyn, dynamic_nent = 0;
9456        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9457        ext++)
9458     {
9459       dynamic_nent++;
9460       if (BYTE_GET (ext->d_tag) == DT_NULL)
9461         break;
9462     }
9463
9464   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9465                                                   sizeof (* entry));
9466   if (dynamic_section == NULL)
9467     {
9468       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9469              (unsigned long) dynamic_nent);
9470       free (edyn);
9471       return FALSE;
9472     }
9473
9474   for (ext = edyn, entry = dynamic_section;
9475        entry < dynamic_section + dynamic_nent;
9476        ext++, entry++)
9477     {
9478       entry->d_tag      = BYTE_GET (ext->d_tag);
9479       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9480     }
9481
9482   free (edyn);
9483
9484   return TRUE;
9485 }
9486
9487 static bfd_boolean
9488 get_64bit_dynamic_section (Filedata * filedata)
9489 {
9490   Elf64_External_Dyn * edyn;
9491   Elf64_External_Dyn * ext;
9492   Elf_Internal_Dyn * entry;
9493
9494   /* Read in the data.  */
9495   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9496                                           dynamic_size, _("dynamic section"));
9497   if (!edyn)
9498     return FALSE;
9499
9500   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9501      might not have the luxury of section headers.  Look for the DT_NULL
9502      terminator to determine the number of entries.  */
9503   for (ext = edyn, dynamic_nent = 0;
9504        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9505        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9506        ext++)
9507     {
9508       dynamic_nent++;
9509       if (BYTE_GET (ext->d_tag) == DT_NULL)
9510         break;
9511     }
9512
9513   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9514                                                   sizeof (* entry));
9515   if (dynamic_section == NULL)
9516     {
9517       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9518              (unsigned long) dynamic_nent);
9519       free (edyn);
9520       return FALSE;
9521     }
9522
9523   /* Convert from external to internal formats.  */
9524   for (ext = edyn, entry = dynamic_section;
9525        entry < dynamic_section + dynamic_nent;
9526        ext++, entry++)
9527     {
9528       entry->d_tag      = BYTE_GET (ext->d_tag);
9529       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9530     }
9531
9532   free (edyn);
9533
9534   return TRUE;
9535 }
9536
9537 static void
9538 print_dynamic_flags (bfd_vma flags)
9539 {
9540   bfd_boolean first = TRUE;
9541
9542   while (flags)
9543     {
9544       bfd_vma flag;
9545
9546       flag = flags & - flags;
9547       flags &= ~ flag;
9548
9549       if (first)
9550         first = FALSE;
9551       else
9552         putc (' ', stdout);
9553
9554       switch (flag)
9555         {
9556         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9557         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9558         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9559         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9560         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9561         default:                fputs (_("unknown"), stdout); break;
9562         }
9563     }
9564   puts ("");
9565 }
9566
9567 /* Parse and display the contents of the dynamic section.  */
9568
9569 static bfd_boolean
9570 process_dynamic_section (Filedata * filedata)
9571 {
9572   Elf_Internal_Dyn * entry;
9573
9574   if (dynamic_size == 0)
9575     {
9576       if (do_dynamic)
9577         printf (_("\nThere is no dynamic section in this file.\n"));
9578
9579       return TRUE;
9580     }
9581
9582   if (is_32bit_elf)
9583     {
9584       if (! get_32bit_dynamic_section (filedata))
9585         return FALSE;
9586     }
9587   else
9588     {
9589       if (! get_64bit_dynamic_section (filedata))
9590         return FALSE;
9591     }
9592
9593   /* Find the appropriate symbol table.  */
9594   if (dynamic_symbols == NULL)
9595     {
9596       for (entry = dynamic_section;
9597            entry < dynamic_section + dynamic_nent;
9598            ++entry)
9599         {
9600           Elf_Internal_Shdr section;
9601
9602           if (entry->d_tag != DT_SYMTAB)
9603             continue;
9604
9605           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9606
9607           /* Since we do not know how big the symbol table is,
9608              we default to reading in the entire file (!) and
9609              processing that.  This is overkill, I know, but it
9610              should work.  */
9611           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9612           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9613             {
9614               /* See PR 21379 for a reproducer.  */
9615               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9616               return FALSE;
9617             }
9618
9619           if (archive_file_offset != 0)
9620             section.sh_size = archive_file_size - section.sh_offset;
9621           else
9622             section.sh_size = filedata->file_size - section.sh_offset;
9623
9624           if (is_32bit_elf)
9625             section.sh_entsize = sizeof (Elf32_External_Sym);
9626           else
9627             section.sh_entsize = sizeof (Elf64_External_Sym);
9628           section.sh_name = filedata->string_table_length;
9629
9630           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9631           if (num_dynamic_syms < 1)
9632             {
9633               error (_("Unable to determine the number of symbols to load\n"));
9634               continue;
9635             }
9636         }
9637     }
9638
9639   /* Similarly find a string table.  */
9640   if (dynamic_strings == NULL)
9641     {
9642       for (entry = dynamic_section;
9643            entry < dynamic_section + dynamic_nent;
9644            ++entry)
9645         {
9646           unsigned long offset;
9647           long str_tab_len;
9648
9649           if (entry->d_tag != DT_STRTAB)
9650             continue;
9651
9652           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9653
9654           /* Since we do not know how big the string table is,
9655              we default to reading in the entire file (!) and
9656              processing that.  This is overkill, I know, but it
9657              should work.  */
9658
9659           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9660
9661           if (archive_file_offset != 0)
9662             str_tab_len = archive_file_size - offset;
9663           else
9664             str_tab_len = filedata->file_size - offset;
9665
9666           if (str_tab_len < 1)
9667             {
9668               error
9669                 (_("Unable to determine the length of the dynamic string table\n"));
9670               continue;
9671             }
9672
9673           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9674                                                str_tab_len,
9675                                                _("dynamic string table"));
9676           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9677           break;
9678         }
9679     }
9680
9681   /* And find the syminfo section if available.  */
9682   if (dynamic_syminfo == NULL)
9683     {
9684       unsigned long syminsz = 0;
9685
9686       for (entry = dynamic_section;
9687            entry < dynamic_section + dynamic_nent;
9688            ++entry)
9689         {
9690           if (entry->d_tag == DT_SYMINENT)
9691             {
9692               /* Note: these braces are necessary to avoid a syntax
9693                  error from the SunOS4 C compiler.  */
9694               /* PR binutils/17531: A corrupt file can trigger this test.
9695                  So do not use an assert, instead generate an error message.  */
9696               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9697                 error (_("Bad value (%d) for SYMINENT entry\n"),
9698                        (int) entry->d_un.d_val);
9699             }
9700           else if (entry->d_tag == DT_SYMINSZ)
9701             syminsz = entry->d_un.d_val;
9702           else if (entry->d_tag == DT_SYMINFO)
9703             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9704                                                       syminsz);
9705         }
9706
9707       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9708         {
9709           Elf_External_Syminfo * extsyminfo;
9710           Elf_External_Syminfo * extsym;
9711           Elf_Internal_Syminfo * syminfo;
9712
9713           /* There is a syminfo section.  Read the data.  */
9714           extsyminfo = (Elf_External_Syminfo *)
9715               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9716                         _("symbol information"));
9717           if (!extsyminfo)
9718             return FALSE;
9719
9720           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9721           if (dynamic_syminfo == NULL)
9722             {
9723               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9724                      (unsigned long) syminsz);
9725               return FALSE;
9726             }
9727
9728           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9729           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9730                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9731                ++syminfo, ++extsym)
9732             {
9733               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9734               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9735             }
9736
9737           free (extsyminfo);
9738         }
9739     }
9740
9741   if (do_dynamic && dynamic_addr)
9742     printf (ngettext ("\nDynamic section at offset 0x%lx "
9743                       "contains %lu entry:\n",
9744                       "\nDynamic section at offset 0x%lx "
9745                       "contains %lu entries:\n",
9746                       dynamic_nent),
9747             dynamic_addr, (unsigned long) dynamic_nent);
9748   if (do_dynamic)
9749     printf (_("  Tag        Type                         Name/Value\n"));
9750
9751   for (entry = dynamic_section;
9752        entry < dynamic_section + dynamic_nent;
9753        entry++)
9754     {
9755       if (do_dynamic)
9756         {
9757           const char * dtype;
9758
9759           putchar (' ');
9760           print_vma (entry->d_tag, FULL_HEX);
9761           dtype = get_dynamic_type (filedata, entry->d_tag);
9762           printf (" (%s)%*s", dtype,
9763                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9764         }
9765
9766       switch (entry->d_tag)
9767         {
9768         case DT_FLAGS:
9769           if (do_dynamic)
9770             print_dynamic_flags (entry->d_un.d_val);
9771           break;
9772
9773         case DT_AUXILIARY:
9774         case DT_FILTER:
9775         case DT_CONFIG:
9776         case DT_DEPAUDIT:
9777         case DT_AUDIT:
9778           if (do_dynamic)
9779             {
9780               switch (entry->d_tag)
9781                 {
9782                 case DT_AUXILIARY:
9783                   printf (_("Auxiliary library"));
9784                   break;
9785
9786                 case DT_FILTER:
9787                   printf (_("Filter library"));
9788                   break;
9789
9790                 case DT_CONFIG:
9791                   printf (_("Configuration file"));
9792                   break;
9793
9794                 case DT_DEPAUDIT:
9795                   printf (_("Dependency audit library"));
9796                   break;
9797
9798                 case DT_AUDIT:
9799                   printf (_("Audit library"));
9800                   break;
9801                 }
9802
9803               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9804                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9805               else
9806                 {
9807                   printf (": ");
9808                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9809                   putchar ('\n');
9810                 }
9811             }
9812           break;
9813
9814         case DT_FEATURE:
9815           if (do_dynamic)
9816             {
9817               printf (_("Flags:"));
9818
9819               if (entry->d_un.d_val == 0)
9820                 printf (_(" None\n"));
9821               else
9822                 {
9823                   unsigned long int val = entry->d_un.d_val;
9824
9825                   if (val & DTF_1_PARINIT)
9826                     {
9827                       printf (" PARINIT");
9828                       val ^= DTF_1_PARINIT;
9829                     }
9830                   if (val & DTF_1_CONFEXP)
9831                     {
9832                       printf (" CONFEXP");
9833                       val ^= DTF_1_CONFEXP;
9834                     }
9835                   if (val != 0)
9836                     printf (" %lx", val);
9837                   puts ("");
9838                 }
9839             }
9840           break;
9841
9842         case DT_POSFLAG_1:
9843           if (do_dynamic)
9844             {
9845               printf (_("Flags:"));
9846
9847               if (entry->d_un.d_val == 0)
9848                 printf (_(" None\n"));
9849               else
9850                 {
9851                   unsigned long int val = entry->d_un.d_val;
9852
9853                   if (val & DF_P1_LAZYLOAD)
9854                     {
9855                       printf (" LAZYLOAD");
9856                       val ^= DF_P1_LAZYLOAD;
9857                     }
9858                   if (val & DF_P1_GROUPPERM)
9859                     {
9860                       printf (" GROUPPERM");
9861                       val ^= DF_P1_GROUPPERM;
9862                     }
9863                   if (val != 0)
9864                     printf (" %lx", val);
9865                   puts ("");
9866                 }
9867             }
9868           break;
9869
9870         case DT_FLAGS_1:
9871           if (do_dynamic)
9872             {
9873               printf (_("Flags:"));
9874               if (entry->d_un.d_val == 0)
9875                 printf (_(" None\n"));
9876               else
9877                 {
9878                   unsigned long int val = entry->d_un.d_val;
9879
9880                   if (val & DF_1_NOW)
9881                     {
9882                       printf (" NOW");
9883                       val ^= DF_1_NOW;
9884                     }
9885                   if (val & DF_1_GLOBAL)
9886                     {
9887                       printf (" GLOBAL");
9888                       val ^= DF_1_GLOBAL;
9889                     }
9890                   if (val & DF_1_GROUP)
9891                     {
9892                       printf (" GROUP");
9893                       val ^= DF_1_GROUP;
9894                     }
9895                   if (val & DF_1_NODELETE)
9896                     {
9897                       printf (" NODELETE");
9898                       val ^= DF_1_NODELETE;
9899                     }
9900                   if (val & DF_1_LOADFLTR)
9901                     {
9902                       printf (" LOADFLTR");
9903                       val ^= DF_1_LOADFLTR;
9904                     }
9905                   if (val & DF_1_INITFIRST)
9906                     {
9907                       printf (" INITFIRST");
9908                       val ^= DF_1_INITFIRST;
9909                     }
9910                   if (val & DF_1_NOOPEN)
9911                     {
9912                       printf (" NOOPEN");
9913                       val ^= DF_1_NOOPEN;
9914                     }
9915                   if (val & DF_1_ORIGIN)
9916                     {
9917                       printf (" ORIGIN");
9918                       val ^= DF_1_ORIGIN;
9919                     }
9920                   if (val & DF_1_DIRECT)
9921                     {
9922                       printf (" DIRECT");
9923                       val ^= DF_1_DIRECT;
9924                     }
9925                   if (val & DF_1_TRANS)
9926                     {
9927                       printf (" TRANS");
9928                       val ^= DF_1_TRANS;
9929                     }
9930                   if (val & DF_1_INTERPOSE)
9931                     {
9932                       printf (" INTERPOSE");
9933                       val ^= DF_1_INTERPOSE;
9934                     }
9935                   if (val & DF_1_NODEFLIB)
9936                     {
9937                       printf (" NODEFLIB");
9938                       val ^= DF_1_NODEFLIB;
9939                     }
9940                   if (val & DF_1_NODUMP)
9941                     {
9942                       printf (" NODUMP");
9943                       val ^= DF_1_NODUMP;
9944                     }
9945                   if (val & DF_1_CONFALT)
9946                     {
9947                       printf (" CONFALT");
9948                       val ^= DF_1_CONFALT;
9949                     }
9950                   if (val & DF_1_ENDFILTEE)
9951                     {
9952                       printf (" ENDFILTEE");
9953                       val ^= DF_1_ENDFILTEE;
9954                     }
9955                   if (val & DF_1_DISPRELDNE)
9956                     {
9957                       printf (" DISPRELDNE");
9958                       val ^= DF_1_DISPRELDNE;
9959                     }
9960                   if (val & DF_1_DISPRELPND)
9961                     {
9962                       printf (" DISPRELPND");
9963                       val ^= DF_1_DISPRELPND;
9964                     }
9965                   if (val & DF_1_NODIRECT)
9966                     {
9967                       printf (" NODIRECT");
9968                       val ^= DF_1_NODIRECT;
9969                     }
9970                   if (val & DF_1_IGNMULDEF)
9971                     {
9972                       printf (" IGNMULDEF");
9973                       val ^= DF_1_IGNMULDEF;
9974                     }
9975                   if (val & DF_1_NOKSYMS)
9976                     {
9977                       printf (" NOKSYMS");
9978                       val ^= DF_1_NOKSYMS;
9979                     }
9980                   if (val & DF_1_NOHDR)
9981                     {
9982                       printf (" NOHDR");
9983                       val ^= DF_1_NOHDR;
9984                     }
9985                   if (val & DF_1_EDITED)
9986                     {
9987                       printf (" EDITED");
9988                       val ^= DF_1_EDITED;
9989                     }
9990                   if (val & DF_1_NORELOC)
9991                     {
9992                       printf (" NORELOC");
9993                       val ^= DF_1_NORELOC;
9994                     }
9995                   if (val & DF_1_SYMINTPOSE)
9996                     {
9997                       printf (" SYMINTPOSE");
9998                       val ^= DF_1_SYMINTPOSE;
9999                     }
10000                   if (val & DF_1_GLOBAUDIT)
10001                     {
10002                       printf (" GLOBAUDIT");
10003                       val ^= DF_1_GLOBAUDIT;
10004                     }
10005                   if (val & DF_1_SINGLETON)
10006                     {
10007                       printf (" SINGLETON");
10008                       val ^= DF_1_SINGLETON;
10009                     }
10010                   if (val & DF_1_STUB)
10011                     {
10012                       printf (" STUB");
10013                       val ^= DF_1_STUB;
10014                     }
10015                   if (val & DF_1_PIE)
10016                     {
10017                       printf (" PIE");
10018                       val ^= DF_1_PIE;
10019                     }
10020                   if (val & DF_1_KMOD)
10021                     {
10022                       printf (" KMOD");
10023                       val ^= DF_1_KMOD;
10024                     }
10025                   if (val & DF_1_WEAKFILTER)
10026                     {
10027                       printf (" WEAKFILTER");
10028                       val ^= DF_1_WEAKFILTER;
10029                     }
10030                   if (val & DF_1_NOCOMMON)
10031                     {
10032                       printf (" NOCOMMON");
10033                       val ^= DF_1_NOCOMMON;
10034                     }
10035                   if (val != 0)
10036                     printf (" %lx", val);
10037                   puts ("");
10038                 }
10039             }
10040           break;
10041
10042         case DT_PLTREL:
10043           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10044           if (do_dynamic)
10045             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10046           break;
10047
10048         case DT_NULL    :
10049         case DT_NEEDED  :
10050         case DT_PLTGOT  :
10051         case DT_HASH    :
10052         case DT_STRTAB  :
10053         case DT_SYMTAB  :
10054         case DT_RELA    :
10055         case DT_INIT    :
10056         case DT_FINI    :
10057         case DT_SONAME  :
10058         case DT_RPATH   :
10059         case DT_SYMBOLIC:
10060         case DT_REL     :
10061         case DT_DEBUG   :
10062         case DT_TEXTREL :
10063         case DT_JMPREL  :
10064         case DT_RUNPATH :
10065           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10066
10067           if (do_dynamic)
10068             {
10069               char * name;
10070
10071               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10072                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10073               else
10074                 name = NULL;
10075
10076               if (name)
10077                 {
10078                   switch (entry->d_tag)
10079                     {
10080                     case DT_NEEDED:
10081                       printf (_("Shared library: [%s]"), name);
10082
10083                       if (streq (name, program_interpreter))
10084                         printf (_(" program interpreter"));
10085                       break;
10086
10087                     case DT_SONAME:
10088                       printf (_("Library soname: [%s]"), name);
10089                       break;
10090
10091                     case DT_RPATH:
10092                       printf (_("Library rpath: [%s]"), name);
10093                       break;
10094
10095                     case DT_RUNPATH:
10096                       printf (_("Library runpath: [%s]"), name);
10097                       break;
10098
10099                     default:
10100                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10101                       break;
10102                     }
10103                 }
10104               else
10105                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10106
10107               putchar ('\n');
10108             }
10109           break;
10110
10111         case DT_PLTRELSZ:
10112         case DT_RELASZ  :
10113         case DT_STRSZ   :
10114         case DT_RELSZ   :
10115         case DT_RELAENT :
10116         case DT_SYMENT  :
10117         case DT_RELENT  :
10118           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10119           /* Fall through.  */
10120         case DT_PLTPADSZ:
10121         case DT_MOVEENT :
10122         case DT_MOVESZ  :
10123         case DT_INIT_ARRAYSZ:
10124         case DT_FINI_ARRAYSZ:
10125         case DT_GNU_CONFLICTSZ:
10126         case DT_GNU_LIBLISTSZ:
10127           if (do_dynamic)
10128             {
10129               print_vma (entry->d_un.d_val, UNSIGNED);
10130               printf (_(" (bytes)\n"));
10131             }
10132           break;
10133
10134         case DT_VERDEFNUM:
10135         case DT_VERNEEDNUM:
10136         case DT_RELACOUNT:
10137         case DT_RELCOUNT:
10138           if (do_dynamic)
10139             {
10140               print_vma (entry->d_un.d_val, UNSIGNED);
10141               putchar ('\n');
10142             }
10143           break;
10144
10145         case DT_SYMINSZ:
10146         case DT_SYMINENT:
10147         case DT_SYMINFO:
10148         case DT_USED:
10149         case DT_INIT_ARRAY:
10150         case DT_FINI_ARRAY:
10151           if (do_dynamic)
10152             {
10153               if (entry->d_tag == DT_USED
10154                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10155                 {
10156                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10157
10158                   if (*name)
10159                     {
10160                       printf (_("Not needed object: [%s]\n"), name);
10161                       break;
10162                     }
10163                 }
10164
10165               print_vma (entry->d_un.d_val, PREFIX_HEX);
10166               putchar ('\n');
10167             }
10168           break;
10169
10170         case DT_BIND_NOW:
10171           /* The value of this entry is ignored.  */
10172           if (do_dynamic)
10173             putchar ('\n');
10174           break;
10175
10176         case DT_GNU_PRELINKED:
10177           if (do_dynamic)
10178             {
10179               struct tm * tmp;
10180               time_t atime = entry->d_un.d_val;
10181
10182               tmp = gmtime (&atime);
10183               /* PR 17533 file: 041-1244816-0.004.  */
10184               if (tmp == NULL)
10185                 printf (_("<corrupt time val: %lx"),
10186                         (unsigned long) atime);
10187               else
10188                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10189                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10190                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10191
10192             }
10193           break;
10194
10195         case DT_GNU_HASH:
10196           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10197           if (do_dynamic)
10198             {
10199               print_vma (entry->d_un.d_val, PREFIX_HEX);
10200               putchar ('\n');
10201             }
10202           break;
10203
10204         default:
10205           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10206             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10207               entry->d_un.d_val;
10208
10209           if (do_dynamic)
10210             {
10211               switch (filedata->file_header.e_machine)
10212                 {
10213                 case EM_MIPS:
10214                 case EM_MIPS_RS3_LE:
10215                   dynamic_section_mips_val (entry);
10216                   break;
10217                 case EM_PARISC:
10218                   dynamic_section_parisc_val (entry);
10219                   break;
10220                 case EM_IA_64:
10221                   dynamic_section_ia64_val (entry);
10222                   break;
10223                 default:
10224                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10225                   putchar ('\n');
10226                 }
10227             }
10228           break;
10229         }
10230     }
10231
10232   return TRUE;
10233 }
10234
10235 static char *
10236 get_ver_flags (unsigned int flags)
10237 {
10238   static char buff[128];
10239
10240   buff[0] = 0;
10241
10242   if (flags == 0)
10243     return _("none");
10244
10245   if (flags & VER_FLG_BASE)
10246     strcat (buff, "BASE");
10247
10248   if (flags & VER_FLG_WEAK)
10249     {
10250       if (flags & VER_FLG_BASE)
10251         strcat (buff, " | ");
10252
10253       strcat (buff, "WEAK");
10254     }
10255
10256   if (flags & VER_FLG_INFO)
10257     {
10258       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10259         strcat (buff, " | ");
10260
10261       strcat (buff, "INFO");
10262     }
10263
10264   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10265     {
10266       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10267         strcat (buff, " | ");
10268
10269       strcat (buff, _("<unknown>"));
10270     }
10271
10272   return buff;
10273 }
10274
10275 /* Display the contents of the version sections.  */
10276
10277 static bfd_boolean
10278 process_version_sections (Filedata * filedata)
10279 {
10280   Elf_Internal_Shdr * section;
10281   unsigned i;
10282   bfd_boolean found = FALSE;
10283
10284   if (! do_version)
10285     return TRUE;
10286
10287   for (i = 0, section = filedata->section_headers;
10288        i < filedata->file_header.e_shnum;
10289        i++, section++)
10290     {
10291       switch (section->sh_type)
10292         {
10293         case SHT_GNU_verdef:
10294           {
10295             Elf_External_Verdef * edefs;
10296             unsigned long idx;
10297             unsigned long cnt;
10298             char * endbuf;
10299
10300             found = TRUE;
10301
10302             printf (ngettext ("\nVersion definition section '%s' "
10303                               "contains %u entry:\n",
10304                               "\nVersion definition section '%s' "
10305                               "contains %u entries:\n",
10306                               section->sh_info),
10307                     printable_section_name (filedata, section),
10308                     section->sh_info);
10309
10310             printf (_("  Addr: 0x"));
10311             printf_vma (section->sh_addr);
10312             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10313                     (unsigned long) section->sh_offset, section->sh_link,
10314                     printable_section_name_from_index (filedata, section->sh_link));
10315
10316             edefs = (Elf_External_Verdef *)
10317                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10318                           _("version definition section"));
10319             if (!edefs)
10320               break;
10321             endbuf = (char *) edefs + section->sh_size;
10322
10323             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10324               {
10325                 char * vstart;
10326                 Elf_External_Verdef * edef;
10327                 Elf_Internal_Verdef ent;
10328                 Elf_External_Verdaux * eaux;
10329                 Elf_Internal_Verdaux aux;
10330                 unsigned long isum;
10331                 int j;
10332
10333                 vstart = ((char *) edefs) + idx;
10334                 if (vstart + sizeof (*edef) > endbuf)
10335                   break;
10336
10337                 edef = (Elf_External_Verdef *) vstart;
10338
10339                 ent.vd_version = BYTE_GET (edef->vd_version);
10340                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10341                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10342                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10343                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10344                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10345                 ent.vd_next    = BYTE_GET (edef->vd_next);
10346
10347                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10348                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10349
10350                 printf (_("  Index: %d  Cnt: %d  "),
10351                         ent.vd_ndx, ent.vd_cnt);
10352
10353                 /* Check for overflow.  */
10354                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10355                   break;
10356
10357                 vstart += ent.vd_aux;
10358
10359                 if (vstart + sizeof (*eaux) > endbuf)
10360                   break;
10361                 eaux = (Elf_External_Verdaux *) vstart;
10362
10363                 aux.vda_name = BYTE_GET (eaux->vda_name);
10364                 aux.vda_next = BYTE_GET (eaux->vda_next);
10365
10366                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10367                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10368                 else
10369                   printf (_("Name index: %ld\n"), aux.vda_name);
10370
10371                 isum = idx + ent.vd_aux;
10372
10373                 for (j = 1; j < ent.vd_cnt; j++)
10374                   {
10375                     if (aux.vda_next < sizeof (*eaux)
10376                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10377                       {
10378                         warn (_("Invalid vda_next field of %lx\n"),
10379                               aux.vda_next);
10380                         j = ent.vd_cnt;
10381                         break;
10382                       }
10383                     /* Check for overflow.  */
10384                     if (aux.vda_next > (size_t) (endbuf - vstart))
10385                       break;
10386
10387                     isum   += aux.vda_next;
10388                     vstart += aux.vda_next;
10389
10390                     if (vstart + sizeof (*eaux) > endbuf)
10391                       break;
10392                     eaux = (Elf_External_Verdaux *) vstart;
10393
10394                     aux.vda_name = BYTE_GET (eaux->vda_name);
10395                     aux.vda_next = BYTE_GET (eaux->vda_next);
10396
10397                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10398                       printf (_("  %#06lx: Parent %d: %s\n"),
10399                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10400                     else
10401                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10402                               isum, j, aux.vda_name);
10403                   }
10404
10405                 if (j < ent.vd_cnt)
10406                   printf (_("  Version def aux past end of section\n"));
10407
10408                 /* PR 17531:
10409                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10410                 if (ent.vd_next < sizeof (*edef)
10411                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10412                   {
10413                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10414                     cnt = section->sh_info;
10415                     break;
10416                   }
10417                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10418                   break;
10419
10420                 idx += ent.vd_next;
10421               }
10422
10423             if (cnt < section->sh_info)
10424               printf (_("  Version definition past end of section\n"));
10425
10426             free (edefs);
10427           }
10428           break;
10429
10430         case SHT_GNU_verneed:
10431           {
10432             Elf_External_Verneed * eneed;
10433             unsigned long idx;
10434             unsigned long cnt;
10435             char * endbuf;
10436
10437             found = TRUE;
10438
10439             printf (ngettext ("\nVersion needs section '%s' "
10440                               "contains %u entry:\n",
10441                               "\nVersion needs section '%s' "
10442                               "contains %u entries:\n",
10443                               section->sh_info),
10444                     printable_section_name (filedata, section), section->sh_info);
10445
10446             printf (_(" Addr: 0x"));
10447             printf_vma (section->sh_addr);
10448             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10449                     (unsigned long) section->sh_offset, section->sh_link,
10450                     printable_section_name_from_index (filedata, section->sh_link));
10451
10452             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10453                                                        section->sh_offset, 1,
10454                                                        section->sh_size,
10455                                                        _("Version Needs section"));
10456             if (!eneed)
10457               break;
10458             endbuf = (char *) eneed + section->sh_size;
10459
10460             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10461               {
10462                 Elf_External_Verneed * entry;
10463                 Elf_Internal_Verneed ent;
10464                 unsigned long isum;
10465                 int j;
10466                 char * vstart;
10467
10468                 vstart = ((char *) eneed) + idx;
10469                 if (vstart + sizeof (*entry) > endbuf)
10470                   break;
10471
10472                 entry = (Elf_External_Verneed *) vstart;
10473
10474                 ent.vn_version = BYTE_GET (entry->vn_version);
10475                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10476                 ent.vn_file    = BYTE_GET (entry->vn_file);
10477                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10478                 ent.vn_next    = BYTE_GET (entry->vn_next);
10479
10480                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10481
10482                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10483                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10484                 else
10485                   printf (_("  File: %lx"), ent.vn_file);
10486
10487                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10488
10489                 /* Check for overflow.  */
10490                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10491                   break;
10492                 vstart += ent.vn_aux;
10493
10494                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10495                   {
10496                     Elf_External_Vernaux * eaux;
10497                     Elf_Internal_Vernaux aux;
10498
10499                     if (vstart + sizeof (*eaux) > endbuf)
10500                       break;
10501                     eaux = (Elf_External_Vernaux *) vstart;
10502
10503                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10504                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10505                     aux.vna_other = BYTE_GET (eaux->vna_other);
10506                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10507                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10508
10509                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10510                       printf (_("  %#06lx:   Name: %s"),
10511                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10512                     else
10513                       printf (_("  %#06lx:   Name index: %lx"),
10514                               isum, aux.vna_name);
10515
10516                     printf (_("  Flags: %s  Version: %d\n"),
10517                             get_ver_flags (aux.vna_flags), aux.vna_other);
10518
10519                     if (aux.vna_next < sizeof (*eaux)
10520                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10521                       {
10522                         warn (_("Invalid vna_next field of %lx\n"),
10523                               aux.vna_next);
10524                         j = ent.vn_cnt;
10525                         break;
10526                       }
10527                     /* Check for overflow.  */
10528                     if (aux.vna_next > (size_t) (endbuf - vstart))
10529                       break;
10530                     isum   += aux.vna_next;
10531                     vstart += aux.vna_next;
10532                   }
10533
10534                 if (j < ent.vn_cnt)
10535                   warn (_("Missing Version Needs auxillary information\n"));
10536
10537                 if (ent.vn_next < sizeof (*entry)
10538                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10539                   {
10540                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10541                     cnt = section->sh_info;
10542                     break;
10543                   }
10544                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10545                   break;
10546                 idx += ent.vn_next;
10547               }
10548
10549             if (cnt < section->sh_info)
10550               warn (_("Missing Version Needs information\n"));
10551
10552             free (eneed);
10553           }
10554           break;
10555
10556         case SHT_GNU_versym:
10557           {
10558             Elf_Internal_Shdr * link_section;
10559             size_t total;
10560             unsigned int cnt;
10561             unsigned char * edata;
10562             unsigned short * data;
10563             char * strtab;
10564             Elf_Internal_Sym * symbols;
10565             Elf_Internal_Shdr * string_sec;
10566             unsigned long num_syms;
10567             long off;
10568
10569             if (section->sh_link >= filedata->file_header.e_shnum)
10570               break;
10571
10572             link_section = filedata->section_headers + section->sh_link;
10573             total = section->sh_size / sizeof (Elf_External_Versym);
10574
10575             if (link_section->sh_link >= filedata->file_header.e_shnum)
10576               break;
10577
10578             found = TRUE;
10579
10580             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10581             if (symbols == NULL)
10582               break;
10583
10584             string_sec = filedata->section_headers + link_section->sh_link;
10585
10586             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10587                                         string_sec->sh_size,
10588                                         _("version string table"));
10589             if (!strtab)
10590               {
10591                 free (symbols);
10592                 break;
10593               }
10594
10595             printf (ngettext ("\nVersion symbols section '%s' "
10596                               "contains %lu entry:\n",
10597                               "\nVersion symbols section '%s' "
10598                               "contains %lu entries:\n",
10599                               total),
10600                     printable_section_name (filedata, section), (unsigned long) total);
10601
10602             printf (_(" Addr: "));
10603             printf_vma (section->sh_addr);
10604             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10605                     (unsigned long) section->sh_offset, section->sh_link,
10606                     printable_section_name (filedata, link_section));
10607
10608             off = offset_from_vma (filedata,
10609                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10610                                    total * sizeof (short));
10611             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10612                                                 sizeof (short),
10613                                                 _("version symbol data"));
10614             if (!edata)
10615               {
10616                 free (strtab);
10617                 free (symbols);
10618                 break;
10619               }
10620
10621             data = (short unsigned int *) cmalloc (total, sizeof (short));
10622
10623             for (cnt = total; cnt --;)
10624               data[cnt] = byte_get (edata + cnt * sizeof (short),
10625                                     sizeof (short));
10626
10627             free (edata);
10628
10629             for (cnt = 0; cnt < total; cnt += 4)
10630               {
10631                 int j, nn;
10632                 char *name;
10633                 char *invalid = _("*invalid*");
10634
10635                 printf ("  %03x:", cnt);
10636
10637                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10638                   switch (data[cnt + j])
10639                     {
10640                     case 0:
10641                       fputs (_("   0 (*local*)    "), stdout);
10642                       break;
10643
10644                     case 1:
10645                       fputs (_("   1 (*global*)   "), stdout);
10646                       break;
10647
10648                     default:
10649                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10650                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10651
10652                       /* If this index value is greater than the size of the symbols
10653                          array, break to avoid an out-of-bounds read.  */
10654                       if ((unsigned long)(cnt + j) >= num_syms)
10655                         {
10656                           warn (_("invalid index into symbol array\n"));
10657                           break;
10658                         }
10659
10660                       name = NULL;
10661                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10662                         {
10663                           Elf_Internal_Verneed ivn;
10664                           unsigned long offset;
10665
10666                           offset = offset_from_vma
10667                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10668                              sizeof (Elf_External_Verneed));
10669
10670                           do
10671                             {
10672                               Elf_Internal_Vernaux ivna;
10673                               Elf_External_Verneed evn;
10674                               Elf_External_Vernaux evna;
10675                               unsigned long a_off;
10676
10677                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10678                                             _("version need")) == NULL)
10679                                 break;
10680
10681                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10682                               ivn.vn_next = BYTE_GET (evn.vn_next);
10683
10684                               a_off = offset + ivn.vn_aux;
10685
10686                               do
10687                                 {
10688                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10689                                                 1, _("version need aux (2)")) == NULL)
10690                                     {
10691                                       ivna.vna_next  = 0;
10692                                       ivna.vna_other = 0;
10693                                     }
10694                                   else
10695                                     {
10696                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10697                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10698                                     }
10699
10700                                   a_off += ivna.vna_next;
10701                                 }
10702                               while (ivna.vna_other != data[cnt + j]
10703                                      && ivna.vna_next != 0);
10704
10705                               if (ivna.vna_other == data[cnt + j])
10706                                 {
10707                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10708
10709                                   if (ivna.vna_name >= string_sec->sh_size)
10710                                     name = invalid;
10711                                   else
10712                                     name = strtab + ivna.vna_name;
10713                                   break;
10714                                 }
10715
10716                               offset += ivn.vn_next;
10717                             }
10718                           while (ivn.vn_next);
10719                         }
10720
10721                       if (data[cnt + j] != 0x8001
10722                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10723                         {
10724                           Elf_Internal_Verdef ivd;
10725                           Elf_External_Verdef evd;
10726                           unsigned long offset;
10727
10728                           offset = offset_from_vma
10729                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10730                              sizeof evd);
10731
10732                           do
10733                             {
10734                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10735                                             _("version def")) == NULL)
10736                                 {
10737                                   ivd.vd_next = 0;
10738                                   /* PR 17531: file: 046-1082287-0.004.  */
10739                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10740                                   break;
10741                                 }
10742                               else
10743                                 {
10744                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10745                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10746                                 }
10747
10748                               offset += ivd.vd_next;
10749                             }
10750                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10751                                  && ivd.vd_next != 0);
10752
10753                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10754                             {
10755                               Elf_External_Verdaux evda;
10756                               Elf_Internal_Verdaux ivda;
10757
10758                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10759
10760                               if (get_data (&evda, filedata,
10761                                             offset - ivd.vd_next + ivd.vd_aux,
10762                                             sizeof (evda), 1,
10763                                             _("version def aux")) == NULL)
10764                                 break;
10765
10766                               ivda.vda_name = BYTE_GET (evda.vda_name);
10767
10768                               if (ivda.vda_name >= string_sec->sh_size)
10769                                 name = invalid;
10770                               else if (name != NULL && name != invalid)
10771                                 name = _("*both*");
10772                               else
10773                                 name = strtab + ivda.vda_name;
10774                             }
10775                         }
10776                       if (name != NULL)
10777                         nn += printf ("(%s%-*s",
10778                                       name,
10779                                       12 - (int) strlen (name),
10780                                       ")");
10781
10782                       if (nn < 18)
10783                         printf ("%*c", 18 - nn, ' ');
10784                     }
10785
10786                 putchar ('\n');
10787               }
10788
10789             free (data);
10790             free (strtab);
10791             free (symbols);
10792           }
10793           break;
10794
10795         default:
10796           break;
10797         }
10798     }
10799
10800   if (! found)
10801     printf (_("\nNo version information found in this file.\n"));
10802
10803   return TRUE;
10804 }
10805
10806 static const char *
10807 get_symbol_binding (Filedata * filedata, unsigned int binding)
10808 {
10809   static char buff[32];
10810
10811   switch (binding)
10812     {
10813     case STB_LOCAL:     return "LOCAL";
10814     case STB_GLOBAL:    return "GLOBAL";
10815     case STB_WEAK:      return "WEAK";
10816     default:
10817       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10818         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10819                   binding);
10820       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10821         {
10822           if (binding == STB_GNU_UNIQUE
10823               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10824                   /* GNU is still using the default value 0.  */
10825                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10826             return "UNIQUE";
10827           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10828         }
10829       else
10830         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10831       return buff;
10832     }
10833 }
10834
10835 static const char *
10836 get_symbol_type (Filedata * filedata, unsigned int type)
10837 {
10838   static char buff[32];
10839
10840   switch (type)
10841     {
10842     case STT_NOTYPE:    return "NOTYPE";
10843     case STT_OBJECT:    return "OBJECT";
10844     case STT_FUNC:      return "FUNC";
10845     case STT_SECTION:   return "SECTION";
10846     case STT_FILE:      return "FILE";
10847     case STT_COMMON:    return "COMMON";
10848     case STT_TLS:       return "TLS";
10849     case STT_RELC:      return "RELC";
10850     case STT_SRELC:     return "SRELC";
10851     default:
10852       if (type >= STT_LOPROC && type <= STT_HIPROC)
10853         {
10854           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10855             return "THUMB_FUNC";
10856
10857           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10858             return "REGISTER";
10859
10860           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10861             return "PARISC_MILLI";
10862
10863           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10864         }
10865       else if (type >= STT_LOOS && type <= STT_HIOS)
10866         {
10867           if (filedata->file_header.e_machine == EM_PARISC)
10868             {
10869               if (type == STT_HP_OPAQUE)
10870                 return "HP_OPAQUE";
10871               if (type == STT_HP_STUB)
10872                 return "HP_STUB";
10873             }
10874
10875           if (type == STT_GNU_IFUNC
10876               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10877                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10878                   /* GNU is still using the default value 0.  */
10879                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10880             return "IFUNC";
10881
10882           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10883         }
10884       else
10885         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10886       return buff;
10887     }
10888 }
10889
10890 static const char *
10891 get_symbol_visibility (unsigned int visibility)
10892 {
10893   switch (visibility)
10894     {
10895     case STV_DEFAULT:   return "DEFAULT";
10896     case STV_INTERNAL:  return "INTERNAL";
10897     case STV_HIDDEN:    return "HIDDEN";
10898     case STV_PROTECTED: return "PROTECTED";
10899     default:
10900       error (_("Unrecognized visibility value: %u"), visibility);
10901       return _("<unknown>");
10902     }
10903 }
10904
10905 static const char *
10906 get_solaris_symbol_visibility (unsigned int visibility)
10907 {
10908   switch (visibility)
10909     {
10910     case 4: return "EXPORTED";
10911     case 5: return "SINGLETON";
10912     case 6: return "ELIMINATE";
10913     default: return get_symbol_visibility (visibility);
10914     }
10915 }
10916
10917 static const char *
10918 get_mips_symbol_other (unsigned int other)
10919 {
10920   switch (other)
10921     {
10922     case STO_OPTIONAL:      return "OPTIONAL";
10923     case STO_MIPS_PLT:      return "MIPS PLT";
10924     case STO_MIPS_PIC:      return "MIPS PIC";
10925     case STO_MICROMIPS:     return "MICROMIPS";
10926     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10927     case STO_MIPS16:        return "MIPS16";
10928     default:                return NULL;
10929     }
10930 }
10931
10932 static const char *
10933 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
10934 {
10935   if (is_ia64_vms (filedata))
10936     {
10937       static char res[32];
10938
10939       res[0] = 0;
10940
10941       /* Function types is for images and .STB files only.  */
10942       switch (filedata->file_header.e_type)
10943         {
10944         case ET_DYN:
10945         case ET_EXEC:
10946           switch (VMS_ST_FUNC_TYPE (other))
10947             {
10948             case VMS_SFT_CODE_ADDR:
10949               strcat (res, " CA");
10950               break;
10951             case VMS_SFT_SYMV_IDX:
10952               strcat (res, " VEC");
10953               break;
10954             case VMS_SFT_FD:
10955               strcat (res, " FD");
10956               break;
10957             case VMS_SFT_RESERVE:
10958               strcat (res, " RSV");
10959               break;
10960             default:
10961               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10962                     VMS_ST_FUNC_TYPE (other));
10963               strcat (res, " <unknown>");
10964               break;
10965             }
10966           break;
10967         default:
10968           break;
10969         }
10970       switch (VMS_ST_LINKAGE (other))
10971         {
10972         case VMS_STL_IGNORE:
10973           strcat (res, " IGN");
10974           break;
10975         case VMS_STL_RESERVE:
10976           strcat (res, " RSV");
10977           break;
10978         case VMS_STL_STD:
10979           strcat (res, " STD");
10980           break;
10981         case VMS_STL_LNK:
10982           strcat (res, " LNK");
10983           break;
10984         default:
10985           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10986                 VMS_ST_LINKAGE (other));
10987           strcat (res, " <unknown>");
10988           break;
10989         }
10990
10991       if (res[0] != 0)
10992         return res + 1;
10993       else
10994         return res;
10995     }
10996   return NULL;
10997 }
10998
10999 static const char *
11000 get_ppc64_symbol_other (unsigned int other)
11001 {
11002   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
11003     {
11004       static char buf[32];
11005       snprintf (buf, sizeof buf, _("<localentry>: %d"),
11006                 PPC64_LOCAL_ENTRY_OFFSET (other));
11007       return buf;
11008     }
11009   return NULL;
11010 }
11011
11012 static const char *
11013 get_symbol_other (Filedata * filedata, unsigned int other)
11014 {
11015   const char * result = NULL;
11016   static char buff [32];
11017
11018   if (other == 0)
11019     return "";
11020
11021   switch (filedata->file_header.e_machine)
11022     {
11023     case EM_MIPS:
11024       result = get_mips_symbol_other (other);
11025       break;
11026     case EM_IA_64:
11027       result = get_ia64_symbol_other (filedata, other);
11028       break;
11029     case EM_PPC64:
11030       result = get_ppc64_symbol_other (other);
11031       break;
11032     default:
11033       result = NULL;
11034       break;
11035     }
11036
11037   if (result)
11038     return result;
11039
11040   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11041   return buff;
11042 }
11043
11044 static const char *
11045 get_symbol_index_type (Filedata * filedata, unsigned int type)
11046 {
11047   static char buff[32];
11048
11049   switch (type)
11050     {
11051     case SHN_UNDEF:     return "UND";
11052     case SHN_ABS:       return "ABS";
11053     case SHN_COMMON:    return "COM";
11054     default:
11055       if (type == SHN_IA_64_ANSI_COMMON
11056           && filedata->file_header.e_machine == EM_IA_64
11057           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11058         return "ANSI_COM";
11059       else if ((filedata->file_header.e_machine == EM_X86_64
11060                 || filedata->file_header.e_machine == EM_L1OM
11061                 || filedata->file_header.e_machine == EM_K1OM)
11062                && type == SHN_X86_64_LCOMMON)
11063         return "LARGE_COM";
11064       else if ((type == SHN_MIPS_SCOMMON
11065                 && filedata->file_header.e_machine == EM_MIPS)
11066                || (type == SHN_TIC6X_SCOMMON
11067                    && filedata->file_header.e_machine == EM_TI_C6000))
11068         return "SCOM";
11069       else if (type == SHN_MIPS_SUNDEFINED
11070                && filedata->file_header.e_machine == EM_MIPS)
11071         return "SUND";
11072       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11073         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11074       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11075         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11076       else if (type >= SHN_LORESERVE)
11077         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11078       else if (type >= filedata->file_header.e_shnum)
11079         sprintf (buff, _("bad section index[%3d]"), type);
11080       else
11081         sprintf (buff, "%3d", type);
11082       break;
11083     }
11084
11085   return buff;
11086 }
11087
11088 static bfd_vma *
11089 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11090 {
11091   unsigned char * e_data;
11092   bfd_vma * i_data;
11093
11094   /* If the size_t type is smaller than the bfd_size_type, eg because
11095      you are building a 32-bit tool on a 64-bit host, then make sure
11096      that when (number) is cast to (size_t) no information is lost.  */
11097   if (sizeof (size_t) < sizeof (bfd_size_type)
11098       && (bfd_size_type) ((size_t) number) != number)
11099     {
11100       error (_("Size truncation prevents reading %s elements of size %u\n"),
11101              bfd_vmatoa ("u", number), ent_size);
11102       return NULL;
11103     }
11104
11105   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11106      attempting to allocate memory when the read is bound to fail.  */
11107   if (ent_size * number > filedata->file_size)
11108     {
11109       error (_("Invalid number of dynamic entries: %s\n"),
11110              bfd_vmatoa ("u", number));
11111       return NULL;
11112     }
11113
11114   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11115   if (e_data == NULL)
11116     {
11117       error (_("Out of memory reading %s dynamic entries\n"),
11118              bfd_vmatoa ("u", number));
11119       return NULL;
11120     }
11121
11122   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11123     {
11124       error (_("Unable to read in %s bytes of dynamic data\n"),
11125              bfd_vmatoa ("u", number * ent_size));
11126       free (e_data);
11127       return NULL;
11128     }
11129
11130   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11131   if (i_data == NULL)
11132     {
11133       error (_("Out of memory allocating space for %s dynamic entries\n"),
11134              bfd_vmatoa ("u", number));
11135       free (e_data);
11136       return NULL;
11137     }
11138
11139   while (number--)
11140     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11141
11142   free (e_data);
11143
11144   return i_data;
11145 }
11146
11147 static void
11148 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11149 {
11150   Elf_Internal_Sym * psym;
11151   int n;
11152
11153   n = print_vma (si, DEC_5);
11154   if (n < 5)
11155     fputs (&"     "[n], stdout);
11156   printf (" %3lu: ", hn);
11157
11158   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11159     {
11160       printf (_("<No info available for dynamic symbol number %lu>\n"),
11161               (unsigned long) si);
11162       return;
11163     }
11164
11165   psym = dynamic_symbols + si;
11166   print_vma (psym->st_value, LONG_HEX);
11167   putchar (' ');
11168   print_vma (psym->st_size, DEC_5);
11169
11170   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11171   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11172
11173   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11174     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11175   else
11176     {
11177       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11178
11179       printf (" %-7s",  get_symbol_visibility (vis));
11180       /* Check to see if any other bits in the st_other field are set.
11181          Note - displaying this information disrupts the layout of the
11182          table being generated, but for the moment this case is very
11183          rare.  */
11184       if (psym->st_other ^ vis)
11185         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11186     }
11187
11188   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11189   if (VALID_DYNAMIC_NAME (psym->st_name))
11190     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11191   else
11192     printf (_(" <corrupt: %14ld>"), psym->st_name);
11193   putchar ('\n');
11194 }
11195
11196 static const char *
11197 get_symbol_version_string (Filedata *                   filedata,
11198                            bfd_boolean                  is_dynsym,
11199                            const char *                 strtab,
11200                            unsigned long int            strtab_size,
11201                            unsigned int                 si,
11202                            Elf_Internal_Sym *           psym,
11203                            enum versioned_symbol_info * sym_info,
11204                            unsigned short *             vna_other)
11205 {
11206   unsigned char data[2];
11207   unsigned short vers_data;
11208   unsigned long offset;
11209
11210   if (!is_dynsym
11211       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11212     return NULL;
11213
11214   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11215                             sizeof data + si * sizeof (vers_data));
11216
11217   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11218                 sizeof (data), 1, _("version data")) == NULL)
11219     return NULL;
11220
11221   vers_data = byte_get (data, 2);
11222
11223   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11224     return NULL;
11225
11226   /* Usually we'd only see verdef for defined symbols, and verneed for
11227      undefined symbols.  However, symbols defined by the linker in
11228      .dynbss for variables copied from a shared library in order to
11229      avoid text relocations are defined yet have verneed.  We could
11230      use a heuristic to detect the special case, for example, check
11231      for verneed first on symbols defined in SHT_NOBITS sections, but
11232      it is simpler and more reliable to just look for both verdef and
11233      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11234
11235   if (psym->st_shndx != SHN_UNDEF
11236       && vers_data != 0x8001
11237       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11238     {
11239       Elf_Internal_Verdef ivd;
11240       Elf_Internal_Verdaux ivda;
11241       Elf_External_Verdaux evda;
11242       unsigned long off;
11243
11244       off = offset_from_vma (filedata,
11245                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11246                              sizeof (Elf_External_Verdef));
11247
11248       do
11249         {
11250           Elf_External_Verdef evd;
11251
11252           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11253                         _("version def")) == NULL)
11254             {
11255               ivd.vd_ndx = 0;
11256               ivd.vd_aux = 0;
11257               ivd.vd_next = 0;
11258             }
11259           else
11260             {
11261               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11262               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11263               ivd.vd_next = BYTE_GET (evd.vd_next);
11264             }
11265
11266           off += ivd.vd_next;
11267         }
11268       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11269
11270       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11271         {
11272           off -= ivd.vd_next;
11273           off += ivd.vd_aux;
11274
11275           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11276                         _("version def aux")) != NULL)
11277             {
11278               ivda.vda_name = BYTE_GET (evda.vda_name);
11279
11280               if (psym->st_name != ivda.vda_name)
11281                 {
11282                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11283                                ? symbol_hidden : symbol_public);
11284                   return (ivda.vda_name < strtab_size
11285                           ? strtab + ivda.vda_name : _("<corrupt>"));
11286                 }
11287             }
11288         }
11289     }
11290
11291   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11292     {
11293       Elf_External_Verneed evn;
11294       Elf_Internal_Verneed ivn;
11295       Elf_Internal_Vernaux ivna;
11296
11297       offset = offset_from_vma (filedata,
11298                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11299                                 sizeof evn);
11300       do
11301         {
11302           unsigned long vna_off;
11303
11304           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11305                         _("version need")) == NULL)
11306             {
11307               ivna.vna_next = 0;
11308               ivna.vna_other = 0;
11309               ivna.vna_name = 0;
11310               break;
11311             }
11312
11313           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11314           ivn.vn_next = BYTE_GET (evn.vn_next);
11315
11316           vna_off = offset + ivn.vn_aux;
11317
11318           do
11319             {
11320               Elf_External_Vernaux evna;
11321
11322               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11323                             _("version need aux (3)")) == NULL)
11324                 {
11325                   ivna.vna_next = 0;
11326                   ivna.vna_other = 0;
11327                   ivna.vna_name = 0;
11328                 }
11329               else
11330                 {
11331                   ivna.vna_other = BYTE_GET (evna.vna_other);
11332                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11333                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11334                 }
11335
11336               vna_off += ivna.vna_next;
11337             }
11338           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11339
11340           if (ivna.vna_other == vers_data)
11341             break;
11342
11343           offset += ivn.vn_next;
11344         }
11345       while (ivn.vn_next != 0);
11346
11347       if (ivna.vna_other == vers_data)
11348         {
11349           *sym_info = symbol_undefined;
11350           *vna_other = ivna.vna_other;
11351           return (ivna.vna_name < strtab_size
11352                   ? strtab + ivna.vna_name : _("<corrupt>"));
11353         }
11354     }
11355   return NULL;
11356 }
11357
11358 /* Dump the symbol table.  */
11359 static bfd_boolean
11360 process_symbol_table (Filedata * filedata)
11361 {
11362   Elf_Internal_Shdr * section;
11363   bfd_size_type nbuckets = 0;
11364   bfd_size_type nchains = 0;
11365   bfd_vma * buckets = NULL;
11366   bfd_vma * chains = NULL;
11367   bfd_vma ngnubuckets = 0;
11368   bfd_vma * gnubuckets = NULL;
11369   bfd_vma * gnuchains = NULL;
11370   bfd_vma gnusymidx = 0;
11371   bfd_size_type ngnuchains = 0;
11372
11373   if (!do_syms && !do_dyn_syms && !do_histogram)
11374     return TRUE;
11375
11376   if (dynamic_info[DT_HASH]
11377       && (do_histogram
11378           || (do_using_dynamic
11379               && !do_dyn_syms
11380               && dynamic_strings != NULL)))
11381     {
11382       unsigned char nb[8];
11383       unsigned char nc[8];
11384       unsigned int hash_ent_size = 4;
11385
11386       if ((filedata->file_header.e_machine == EM_ALPHA
11387            || filedata->file_header.e_machine == EM_S390
11388            || filedata->file_header.e_machine == EM_S390_OLD)
11389           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11390         hash_ent_size = 8;
11391
11392       if (fseek (filedata->handle,
11393                  (archive_file_offset
11394                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11395                                      sizeof nb + sizeof nc)),
11396                  SEEK_SET))
11397         {
11398           error (_("Unable to seek to start of dynamic information\n"));
11399           goto no_hash;
11400         }
11401
11402       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11403         {
11404           error (_("Failed to read in number of buckets\n"));
11405           goto no_hash;
11406         }
11407
11408       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11409         {
11410           error (_("Failed to read in number of chains\n"));
11411           goto no_hash;
11412         }
11413
11414       nbuckets = byte_get (nb, hash_ent_size);
11415       nchains  = byte_get (nc, hash_ent_size);
11416
11417       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11418       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11419
11420     no_hash:
11421       if (buckets == NULL || chains == NULL)
11422         {
11423           if (do_using_dynamic)
11424             return FALSE;
11425           free (buckets);
11426           free (chains);
11427           buckets = NULL;
11428           chains = NULL;
11429           nbuckets = 0;
11430           nchains = 0;
11431         }
11432     }
11433
11434   if (dynamic_info_DT_GNU_HASH
11435       && (do_histogram
11436           || (do_using_dynamic
11437               && !do_dyn_syms
11438               && dynamic_strings != NULL)))
11439     {
11440       unsigned char nb[16];
11441       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11442       bfd_vma buckets_vma;
11443
11444       if (fseek (filedata->handle,
11445                  (archive_file_offset
11446                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11447                                      sizeof nb)),
11448                  SEEK_SET))
11449         {
11450           error (_("Unable to seek to start of dynamic information\n"));
11451           goto no_gnu_hash;
11452         }
11453
11454       if (fread (nb, 16, 1, filedata->handle) != 1)
11455         {
11456           error (_("Failed to read in number of buckets\n"));
11457           goto no_gnu_hash;
11458         }
11459
11460       ngnubuckets = byte_get (nb, 4);
11461       gnusymidx = byte_get (nb + 4, 4);
11462       bitmaskwords = byte_get (nb + 8, 4);
11463       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11464       if (is_32bit_elf)
11465         buckets_vma += bitmaskwords * 4;
11466       else
11467         buckets_vma += bitmaskwords * 8;
11468
11469       if (fseek (filedata->handle,
11470                  (archive_file_offset
11471                   + offset_from_vma (filedata, buckets_vma, 4)),
11472                  SEEK_SET))
11473         {
11474           error (_("Unable to seek to start of dynamic information\n"));
11475           goto no_gnu_hash;
11476         }
11477
11478       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11479
11480       if (gnubuckets == NULL)
11481         goto no_gnu_hash;
11482
11483       for (i = 0; i < ngnubuckets; i++)
11484         if (gnubuckets[i] != 0)
11485           {
11486             if (gnubuckets[i] < gnusymidx)
11487               return FALSE;
11488
11489             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11490               maxchain = gnubuckets[i];
11491           }
11492
11493       if (maxchain == 0xffffffff)
11494         goto no_gnu_hash;
11495
11496       maxchain -= gnusymidx;
11497
11498       if (fseek (filedata->handle,
11499                  (archive_file_offset
11500                   + offset_from_vma (filedata, buckets_vma
11501                                            + 4 * (ngnubuckets + maxchain), 4)),
11502                  SEEK_SET))
11503         {
11504           error (_("Unable to seek to start of dynamic information\n"));
11505           goto no_gnu_hash;
11506         }
11507
11508       do
11509         {
11510           if (fread (nb, 4, 1, filedata->handle) != 1)
11511             {
11512               error (_("Failed to determine last chain length\n"));
11513               goto no_gnu_hash;
11514             }
11515
11516           if (maxchain + 1 == 0)
11517             goto no_gnu_hash;
11518
11519           ++maxchain;
11520         }
11521       while ((byte_get (nb, 4) & 1) == 0);
11522
11523       if (fseek (filedata->handle,
11524                  (archive_file_offset
11525                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11526                  SEEK_SET))
11527         {
11528           error (_("Unable to seek to start of dynamic information\n"));
11529           goto no_gnu_hash;
11530         }
11531
11532       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11533       ngnuchains = maxchain;
11534
11535     no_gnu_hash:
11536       if (gnuchains == NULL)
11537         {
11538           free (gnubuckets);
11539           gnubuckets = NULL;
11540           ngnubuckets = 0;
11541           if (do_using_dynamic)
11542             return FALSE;
11543         }
11544     }
11545
11546   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11547       && do_syms
11548       && do_using_dynamic
11549       && dynamic_strings != NULL
11550       && dynamic_symbols != NULL)
11551     {
11552       unsigned long hn;
11553
11554       if (dynamic_info[DT_HASH])
11555         {
11556           bfd_vma si;
11557           char *visited;
11558
11559           printf (_("\nSymbol table for image:\n"));
11560           if (is_32bit_elf)
11561             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11562           else
11563             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11564
11565           visited = xcmalloc (nchains, 1);
11566           memset (visited, 0, nchains);
11567           for (hn = 0; hn < nbuckets; hn++)
11568             {
11569               for (si = buckets[hn]; si > 0; si = chains[si])
11570                 {
11571                   print_dynamic_symbol (filedata, si, hn);
11572                   if (si >= nchains || visited[si])
11573                     {
11574                       error (_("histogram chain is corrupt\n"));
11575                       break;
11576                     }
11577                   visited[si] = 1;
11578                 }
11579             }
11580           free (visited);
11581         }
11582
11583       if (dynamic_info_DT_GNU_HASH)
11584         {
11585           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11586           if (is_32bit_elf)
11587             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11588           else
11589             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11590
11591           for (hn = 0; hn < ngnubuckets; ++hn)
11592             if (gnubuckets[hn] != 0)
11593               {
11594                 bfd_vma si = gnubuckets[hn];
11595                 bfd_vma off = si - gnusymidx;
11596
11597                 do
11598                   {
11599                     print_dynamic_symbol (filedata, si, hn);
11600                     si++;
11601                   }
11602                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11603               }
11604         }
11605     }
11606   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11607            && filedata->section_headers != NULL)
11608     {
11609       unsigned int i;
11610
11611       for (i = 0, section = filedata->section_headers;
11612            i < filedata->file_header.e_shnum;
11613            i++, section++)
11614         {
11615           unsigned int si;
11616           char * strtab = NULL;
11617           unsigned long int strtab_size = 0;
11618           Elf_Internal_Sym * symtab;
11619           Elf_Internal_Sym * psym;
11620           unsigned long num_syms;
11621
11622           if ((section->sh_type != SHT_SYMTAB
11623                && section->sh_type != SHT_DYNSYM)
11624               || (!do_syms
11625                   && section->sh_type == SHT_SYMTAB))
11626             continue;
11627
11628           if (section->sh_entsize == 0)
11629             {
11630               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11631                       printable_section_name (filedata, section));
11632               continue;
11633             }
11634
11635           num_syms = section->sh_size / section->sh_entsize;
11636           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11637                             "\nSymbol table '%s' contains %lu entries:\n",
11638                             num_syms),
11639                   printable_section_name (filedata, section),
11640                   num_syms);
11641
11642           if (is_32bit_elf)
11643             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11644           else
11645             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11646
11647           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11648           if (symtab == NULL)
11649             continue;
11650
11651           if (section->sh_link == filedata->file_header.e_shstrndx)
11652             {
11653               strtab = filedata->string_table;
11654               strtab_size = filedata->string_table_length;
11655             }
11656           else if (section->sh_link < filedata->file_header.e_shnum)
11657             {
11658               Elf_Internal_Shdr * string_sec;
11659
11660               string_sec = filedata->section_headers + section->sh_link;
11661
11662               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11663                                           1, string_sec->sh_size,
11664                                           _("string table"));
11665               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11666             }
11667
11668           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11669             {
11670               const char *version_string;
11671               enum versioned_symbol_info sym_info;
11672               unsigned short vna_other;
11673
11674               printf ("%6d: ", si);
11675               print_vma (psym->st_value, LONG_HEX);
11676               putchar (' ');
11677               print_vma (psym->st_size, DEC_5);
11678               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11679               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11680               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11681                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11682               else
11683                 {
11684                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11685
11686                   printf (" %-7s", get_symbol_visibility (vis));
11687                   /* Check to see if any other bits in the st_other field are set.
11688                      Note - displaying this information disrupts the layout of the
11689                      table being generated, but for the moment this case is very rare.  */
11690                   if (psym->st_other ^ vis)
11691                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11692                 }
11693               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11694               print_symbol (25, psym->st_name < strtab_size
11695                             ? strtab + psym->st_name : _("<corrupt>"));
11696
11697               version_string
11698                 = get_symbol_version_string (filedata,
11699                                              section->sh_type == SHT_DYNSYM,
11700                                              strtab, strtab_size, si,
11701                                              psym, &sym_info, &vna_other);
11702               if (version_string)
11703                 {
11704                   if (sym_info == symbol_undefined)
11705                     printf ("@%s (%d)", version_string, vna_other);
11706                   else
11707                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11708                             version_string);
11709                 }
11710
11711               putchar ('\n');
11712
11713               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11714                   && si >= section->sh_info
11715                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11716                   && filedata->file_header.e_machine != EM_MIPS
11717                   /* Solaris binaries have been found to violate this requirement as
11718                      well.  Not sure if this is a bug or an ABI requirement.  */
11719                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11720                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11721                       si, printable_section_name (filedata, section), section->sh_info);
11722             }
11723
11724           free (symtab);
11725           if (strtab != filedata->string_table)
11726             free (strtab);
11727         }
11728     }
11729   else if (do_syms)
11730     printf
11731       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11732
11733   if (do_histogram && buckets != NULL)
11734     {
11735       unsigned long * lengths;
11736       unsigned long * counts;
11737       unsigned long hn;
11738       bfd_vma si;
11739       unsigned long maxlength = 0;
11740       unsigned long nzero_counts = 0;
11741       unsigned long nsyms = 0;
11742       char *visited;
11743
11744       printf (ngettext ("\nHistogram for bucket list length "
11745                         "(total of %lu bucket):\n",
11746                         "\nHistogram for bucket list length "
11747                         "(total of %lu buckets):\n",
11748                         (unsigned long) nbuckets),
11749               (unsigned long) nbuckets);
11750
11751       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11752       if (lengths == NULL)
11753         {
11754           error (_("Out of memory allocating space for histogram buckets\n"));
11755           return FALSE;
11756         }
11757       visited = xcmalloc (nchains, 1);
11758       memset (visited, 0, nchains);
11759
11760       printf (_(" Length  Number     %% of total  Coverage\n"));
11761       for (hn = 0; hn < nbuckets; ++hn)
11762         {
11763           for (si = buckets[hn]; si > 0; si = chains[si])
11764             {
11765               ++nsyms;
11766               if (maxlength < ++lengths[hn])
11767                 ++maxlength;
11768               if (si >= nchains || visited[si])
11769                 {
11770                   error (_("histogram chain is corrupt\n"));
11771                   break;
11772                 }
11773               visited[si] = 1;
11774             }
11775         }
11776       free (visited);
11777
11778       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11779       if (counts == NULL)
11780         {
11781           free (lengths);
11782           error (_("Out of memory allocating space for histogram counts\n"));
11783           return FALSE;
11784         }
11785
11786       for (hn = 0; hn < nbuckets; ++hn)
11787         ++counts[lengths[hn]];
11788
11789       if (nbuckets > 0)
11790         {
11791           unsigned long i;
11792           printf ("      0  %-10lu (%5.1f%%)\n",
11793                   counts[0], (counts[0] * 100.0) / nbuckets);
11794           for (i = 1; i <= maxlength; ++i)
11795             {
11796               nzero_counts += counts[i] * i;
11797               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11798                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11799                       (nzero_counts * 100.0) / nsyms);
11800             }
11801         }
11802
11803       free (counts);
11804       free (lengths);
11805     }
11806
11807   if (buckets != NULL)
11808     {
11809       free (buckets);
11810       free (chains);
11811     }
11812
11813   if (do_histogram && gnubuckets != NULL)
11814     {
11815       unsigned long * lengths;
11816       unsigned long * counts;
11817       unsigned long hn;
11818       unsigned long maxlength = 0;
11819       unsigned long nzero_counts = 0;
11820       unsigned long nsyms = 0;
11821
11822       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11823                         "(total of %lu bucket):\n",
11824                         "\nHistogram for `.gnu.hash' bucket list length "
11825                         "(total of %lu buckets):\n",
11826                         (unsigned long) ngnubuckets),
11827               (unsigned long) ngnubuckets);
11828
11829       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11830       if (lengths == NULL)
11831         {
11832           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11833           return FALSE;
11834         }
11835
11836       printf (_(" Length  Number     %% of total  Coverage\n"));
11837
11838       for (hn = 0; hn < ngnubuckets; ++hn)
11839         if (gnubuckets[hn] != 0)
11840           {
11841             bfd_vma off, length = 1;
11842
11843             for (off = gnubuckets[hn] - gnusymidx;
11844                  /* PR 17531 file: 010-77222-0.004.  */
11845                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11846                  ++off)
11847               ++length;
11848             lengths[hn] = length;
11849             if (length > maxlength)
11850               maxlength = length;
11851             nsyms += length;
11852           }
11853
11854       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11855       if (counts == NULL)
11856         {
11857           free (lengths);
11858           error (_("Out of memory allocating space for gnu histogram counts\n"));
11859           return FALSE;
11860         }
11861
11862       for (hn = 0; hn < ngnubuckets; ++hn)
11863         ++counts[lengths[hn]];
11864
11865       if (ngnubuckets > 0)
11866         {
11867           unsigned long j;
11868           printf ("      0  %-10lu (%5.1f%%)\n",
11869                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11870           for (j = 1; j <= maxlength; ++j)
11871             {
11872               nzero_counts += counts[j] * j;
11873               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11874                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11875                       (nzero_counts * 100.0) / nsyms);
11876             }
11877         }
11878
11879       free (counts);
11880       free (lengths);
11881       free (gnubuckets);
11882       free (gnuchains);
11883     }
11884
11885   return TRUE;
11886 }
11887
11888 static bfd_boolean
11889 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11890 {
11891   unsigned int i;
11892
11893   if (dynamic_syminfo == NULL
11894       || !do_dynamic)
11895     /* No syminfo, this is ok.  */
11896     return TRUE;
11897
11898   /* There better should be a dynamic symbol section.  */
11899   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11900     return FALSE;
11901
11902   if (dynamic_addr)
11903     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11904                       "contains %d entry:\n",
11905                       "\nDynamic info segment at offset 0x%lx "
11906                       "contains %d entries:\n",
11907                       dynamic_syminfo_nent),
11908             dynamic_syminfo_offset, dynamic_syminfo_nent);
11909
11910   printf (_(" Num: Name                           BoundTo     Flags\n"));
11911   for (i = 0; i < dynamic_syminfo_nent; ++i)
11912     {
11913       unsigned short int flags = dynamic_syminfo[i].si_flags;
11914
11915       printf ("%4d: ", i);
11916       if (i >= num_dynamic_syms)
11917         printf (_("<corrupt index>"));
11918       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11919         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11920       else
11921         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11922       putchar (' ');
11923
11924       switch (dynamic_syminfo[i].si_boundto)
11925         {
11926         case SYMINFO_BT_SELF:
11927           fputs ("SELF       ", stdout);
11928           break;
11929         case SYMINFO_BT_PARENT:
11930           fputs ("PARENT     ", stdout);
11931           break;
11932         default:
11933           if (dynamic_syminfo[i].si_boundto > 0
11934               && dynamic_syminfo[i].si_boundto < dynamic_nent
11935               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11936             {
11937               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11938               putchar (' ' );
11939             }
11940           else
11941             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11942           break;
11943         }
11944
11945       if (flags & SYMINFO_FLG_DIRECT)
11946         printf (" DIRECT");
11947       if (flags & SYMINFO_FLG_PASSTHRU)
11948         printf (" PASSTHRU");
11949       if (flags & SYMINFO_FLG_COPY)
11950         printf (" COPY");
11951       if (flags & SYMINFO_FLG_LAZYLOAD)
11952         printf (" LAZYLOAD");
11953
11954       puts ("");
11955     }
11956
11957   return TRUE;
11958 }
11959
11960 #define IN_RANGE(START,END,ADDR,OFF)            \
11961   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11962
11963 /* Check to see if the given reloc needs to be handled in a target specific
11964    manner.  If so then process the reloc and return TRUE otherwise return
11965    FALSE.
11966
11967    If called with reloc == NULL, then this is a signal that reloc processing
11968    for the current section has finished, and any saved state should be
11969    discarded.  */
11970
11971 static bfd_boolean
11972 target_specific_reloc_handling (Filedata *           filedata,
11973                                 Elf_Internal_Rela *  reloc,
11974                                 unsigned char *      start,
11975                                 unsigned char *      end,
11976                                 Elf_Internal_Sym *   symtab,
11977                                 unsigned long        num_syms)
11978 {
11979   unsigned int reloc_type = 0;
11980   unsigned long sym_index = 0;
11981
11982   if (reloc)
11983     {
11984       reloc_type = get_reloc_type (filedata, reloc->r_info);
11985       sym_index = get_reloc_symindex (reloc->r_info);
11986     }
11987
11988   switch (filedata->file_header.e_machine)
11989     {
11990     case EM_MSP430:
11991     case EM_MSP430_OLD:
11992       {
11993         static Elf_Internal_Sym * saved_sym = NULL;
11994
11995         if (reloc == NULL)
11996           {
11997             saved_sym = NULL;
11998             return TRUE;
11999           }
12000
12001         switch (reloc_type)
12002           {
12003           case 10: /* R_MSP430_SYM_DIFF */
12004             if (uses_msp430x_relocs (filedata))
12005               break;
12006             /* Fall through.  */
12007           case 21: /* R_MSP430X_SYM_DIFF */
12008             /* PR 21139.  */
12009             if (sym_index >= num_syms)
12010               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12011                      sym_index);
12012             else
12013               saved_sym = symtab + sym_index;
12014             return TRUE;
12015
12016           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12017           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12018             goto handle_sym_diff;
12019
12020           case 5: /* R_MSP430_16_BYTE */
12021           case 9: /* R_MSP430_8 */
12022             if (uses_msp430x_relocs (filedata))
12023               break;
12024             goto handle_sym_diff;
12025
12026           case 2: /* R_MSP430_ABS16 */
12027           case 15: /* R_MSP430X_ABS16 */
12028             if (! uses_msp430x_relocs (filedata))
12029               break;
12030             goto handle_sym_diff;
12031
12032           handle_sym_diff:
12033             if (saved_sym != NULL)
12034               {
12035                 int reloc_size = reloc_type == 1 ? 4 : 2;
12036                 bfd_vma value;
12037
12038                 if (sym_index >= num_syms)
12039                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12040                          sym_index);
12041                 else
12042                   {
12043                     value = reloc->r_addend + (symtab[sym_index].st_value
12044                                                - saved_sym->st_value);
12045
12046                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12047                       byte_put (start + reloc->r_offset, value, reloc_size);
12048                     else
12049                       /* PR 21137 */
12050                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12051                              (long) reloc->r_offset);
12052                   }
12053
12054                 saved_sym = NULL;
12055                 return TRUE;
12056               }
12057             break;
12058
12059           default:
12060             if (saved_sym != NULL)
12061               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12062             break;
12063           }
12064         break;
12065       }
12066
12067     case EM_MN10300:
12068     case EM_CYGNUS_MN10300:
12069       {
12070         static Elf_Internal_Sym * saved_sym = NULL;
12071
12072         if (reloc == NULL)
12073           {
12074             saved_sym = NULL;
12075             return TRUE;
12076           }
12077
12078         switch (reloc_type)
12079           {
12080           case 34: /* R_MN10300_ALIGN */
12081             return TRUE;
12082           case 33: /* R_MN10300_SYM_DIFF */
12083             if (sym_index >= num_syms)
12084               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12085                      sym_index);
12086             else
12087               saved_sym = symtab + sym_index;
12088             return TRUE;
12089
12090           case 1: /* R_MN10300_32 */
12091           case 2: /* R_MN10300_16 */
12092             if (saved_sym != NULL)
12093               {
12094                 int reloc_size = reloc_type == 1 ? 4 : 2;
12095                 bfd_vma value;
12096
12097                 if (sym_index >= num_syms)
12098                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12099                          sym_index);
12100                 else
12101                   {
12102                     value = reloc->r_addend + (symtab[sym_index].st_value
12103                                                - saved_sym->st_value);
12104
12105                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12106                       byte_put (start + reloc->r_offset, value, reloc_size);
12107                     else
12108                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12109                              (long) reloc->r_offset);
12110                   }
12111
12112                 saved_sym = NULL;
12113                 return TRUE;
12114               }
12115             break;
12116           default:
12117             if (saved_sym != NULL)
12118               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12119             break;
12120           }
12121         break;
12122       }
12123
12124     case EM_RL78:
12125       {
12126         static bfd_vma saved_sym1 = 0;
12127         static bfd_vma saved_sym2 = 0;
12128         static bfd_vma value;
12129
12130         if (reloc == NULL)
12131           {
12132             saved_sym1 = saved_sym2 = 0;
12133             return TRUE;
12134           }
12135
12136         switch (reloc_type)
12137           {
12138           case 0x80: /* R_RL78_SYM.  */
12139             saved_sym1 = saved_sym2;
12140             if (sym_index >= num_syms)
12141               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12142                      sym_index);
12143             else
12144               {
12145                 saved_sym2 = symtab[sym_index].st_value;
12146                 saved_sym2 += reloc->r_addend;
12147               }
12148             return TRUE;
12149
12150           case 0x83: /* R_RL78_OPsub.  */
12151             value = saved_sym1 - saved_sym2;
12152             saved_sym2 = saved_sym1 = 0;
12153             return TRUE;
12154             break;
12155
12156           case 0x41: /* R_RL78_ABS32.  */
12157             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12158               byte_put (start + reloc->r_offset, value, 4);
12159             else
12160               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12161                      (long) reloc->r_offset);
12162             value = 0;
12163             return TRUE;
12164
12165           case 0x43: /* R_RL78_ABS16.  */
12166             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12167               byte_put (start + reloc->r_offset, value, 2);
12168             else
12169               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12170                      (long) reloc->r_offset);
12171             value = 0;
12172             return TRUE;
12173
12174           default:
12175             break;
12176           }
12177         break;
12178       }
12179     }
12180
12181   return FALSE;
12182 }
12183
12184 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12185    DWARF debug sections.  This is a target specific test.  Note - we do not
12186    go through the whole including-target-headers-multiple-times route, (as
12187    we have already done with <elf/h8.h>) because this would become very
12188    messy and even then this function would have to contain target specific
12189    information (the names of the relocs instead of their numeric values).
12190    FIXME: This is not the correct way to solve this problem.  The proper way
12191    is to have target specific reloc sizing and typing functions created by
12192    the reloc-macros.h header, in the same way that it already creates the
12193    reloc naming functions.  */
12194
12195 static bfd_boolean
12196 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12197 {
12198   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12199   switch (filedata->file_header.e_machine)
12200     {
12201     case EM_386:
12202     case EM_IAMCU:
12203       return reloc_type == 1; /* R_386_32.  */
12204     case EM_68K:
12205       return reloc_type == 1; /* R_68K_32.  */
12206     case EM_860:
12207       return reloc_type == 1; /* R_860_32.  */
12208     case EM_960:
12209       return reloc_type == 2; /* R_960_32.  */
12210     case EM_AARCH64:
12211       return (reloc_type == 258
12212               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12213     case EM_ADAPTEVA_EPIPHANY:
12214       return reloc_type == 3;
12215     case EM_ALPHA:
12216       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12217     case EM_ARC:
12218       return reloc_type == 1; /* R_ARC_32.  */
12219     case EM_ARC_COMPACT:
12220     case EM_ARC_COMPACT2:
12221       return reloc_type == 4; /* R_ARC_32.  */
12222     case EM_ARM:
12223       return reloc_type == 2; /* R_ARM_ABS32 */
12224     case EM_AVR_OLD:
12225     case EM_AVR:
12226       return reloc_type == 1;
12227     case EM_BLACKFIN:
12228       return reloc_type == 0x12; /* R_byte4_data.  */
12229     case EM_CRIS:
12230       return reloc_type == 3; /* R_CRIS_32.  */
12231     case EM_CR16:
12232       return reloc_type == 3; /* R_CR16_NUM32.  */
12233     case EM_CRX:
12234       return reloc_type == 15; /* R_CRX_NUM32.  */
12235     case EM_CYGNUS_FRV:
12236       return reloc_type == 1;
12237     case EM_CYGNUS_D10V:
12238     case EM_D10V:
12239       return reloc_type == 6; /* R_D10V_32.  */
12240     case EM_CYGNUS_D30V:
12241     case EM_D30V:
12242       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12243     case EM_DLX:
12244       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12245     case EM_CYGNUS_FR30:
12246     case EM_FR30:
12247       return reloc_type == 3; /* R_FR30_32.  */
12248     case EM_FT32:
12249       return reloc_type == 1; /* R_FT32_32.  */
12250     case EM_H8S:
12251     case EM_H8_300:
12252     case EM_H8_300H:
12253       return reloc_type == 1; /* R_H8_DIR32.  */
12254     case EM_IA_64:
12255       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12256               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12257               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12258               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12259     case EM_IP2K_OLD:
12260     case EM_IP2K:
12261       return reloc_type == 2; /* R_IP2K_32.  */
12262     case EM_IQ2000:
12263       return reloc_type == 2; /* R_IQ2000_32.  */
12264     case EM_LATTICEMICO32:
12265       return reloc_type == 3; /* R_LM32_32.  */
12266     case EM_M32C_OLD:
12267     case EM_M32C:
12268       return reloc_type == 3; /* R_M32C_32.  */
12269     case EM_M32R:
12270       return reloc_type == 34; /* R_M32R_32_RELA.  */
12271     case EM_68HC11:
12272     case EM_68HC12:
12273       return reloc_type == 6; /* R_M68HC11_32.  */
12274     case EM_MCORE:
12275       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12276     case EM_CYGNUS_MEP:
12277       return reloc_type == 4; /* R_MEP_32.  */
12278     case EM_METAG:
12279       return reloc_type == 2; /* R_METAG_ADDR32.  */
12280     case EM_MICROBLAZE:
12281       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12282     case EM_MIPS:
12283       return reloc_type == 2; /* R_MIPS_32.  */
12284     case EM_MMIX:
12285       return reloc_type == 4; /* R_MMIX_32.  */
12286     case EM_CYGNUS_MN10200:
12287     case EM_MN10200:
12288       return reloc_type == 1; /* R_MN10200_32.  */
12289     case EM_CYGNUS_MN10300:
12290     case EM_MN10300:
12291       return reloc_type == 1; /* R_MN10300_32.  */
12292     case EM_MOXIE:
12293       return reloc_type == 1; /* R_MOXIE_32.  */
12294     case EM_MSP430_OLD:
12295     case EM_MSP430:
12296       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12297     case EM_MT:
12298       return reloc_type == 2; /* R_MT_32.  */
12299     case EM_NDS32:
12300       return reloc_type == 20; /* R_NDS32_RELA.  */
12301     case EM_ALTERA_NIOS2:
12302       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12303     case EM_NIOS32:
12304       return reloc_type == 1; /* R_NIOS_32.  */
12305     case EM_OR1K:
12306       return reloc_type == 1; /* R_OR1K_32.  */
12307     case EM_PARISC:
12308       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12309               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12310               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12311     case EM_PJ:
12312     case EM_PJ_OLD:
12313       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12314     case EM_PPC64:
12315       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12316     case EM_PPC:
12317       return reloc_type == 1; /* R_PPC_ADDR32.  */
12318     case EM_TI_PRU:
12319       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12320     case EM_RISCV:
12321       return reloc_type == 1; /* R_RISCV_32.  */
12322     case EM_RL78:
12323       return reloc_type == 1; /* R_RL78_DIR32.  */
12324     case EM_RX:
12325       return reloc_type == 1; /* R_RX_DIR32.  */
12326     case EM_S370:
12327       return reloc_type == 1; /* R_I370_ADDR31.  */
12328     case EM_S390_OLD:
12329     case EM_S390:
12330       return reloc_type == 4; /* R_S390_32.  */
12331     case EM_SCORE:
12332       return reloc_type == 8; /* R_SCORE_ABS32.  */
12333     case EM_SH:
12334       return reloc_type == 1; /* R_SH_DIR32.  */
12335     case EM_SPARC32PLUS:
12336     case EM_SPARCV9:
12337     case EM_SPARC:
12338       return reloc_type == 3 /* R_SPARC_32.  */
12339         || reloc_type == 23; /* R_SPARC_UA32.  */
12340     case EM_SPU:
12341       return reloc_type == 6; /* R_SPU_ADDR32 */
12342     case EM_TI_C6000:
12343       return reloc_type == 1; /* R_C6000_ABS32.  */
12344     case EM_TILEGX:
12345       return reloc_type == 2; /* R_TILEGX_32.  */
12346     case EM_TILEPRO:
12347       return reloc_type == 1; /* R_TILEPRO_32.  */
12348     case EM_CYGNUS_V850:
12349     case EM_V850:
12350       return reloc_type == 6; /* R_V850_ABS32.  */
12351     case EM_V800:
12352       return reloc_type == 0x33; /* R_V810_WORD.  */
12353     case EM_VAX:
12354       return reloc_type == 1; /* R_VAX_32.  */
12355     case EM_VISIUM:
12356       return reloc_type == 3;  /* R_VISIUM_32. */
12357     case EM_WEBASSEMBLY:
12358       return reloc_type == 1;  /* R_WASM32_32.  */
12359     case EM_X86_64:
12360     case EM_L1OM:
12361     case EM_K1OM:
12362       return reloc_type == 10; /* R_X86_64_32.  */
12363     case EM_XC16X:
12364     case EM_C166:
12365       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12366     case EM_XGATE:
12367       return reloc_type == 4; /* R_XGATE_32.  */
12368     case EM_XSTORMY16:
12369       return reloc_type == 1; /* R_XSTROMY16_32.  */
12370     case EM_XTENSA_OLD:
12371     case EM_XTENSA:
12372       return reloc_type == 1; /* R_XTENSA_32.  */
12373     default:
12374       {
12375         static unsigned int prev_warn = 0;
12376
12377         /* Avoid repeating the same warning multiple times.  */
12378         if (prev_warn != filedata->file_header.e_machine)
12379           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12380                  filedata->file_header.e_machine);
12381         prev_warn = filedata->file_header.e_machine;
12382         return FALSE;
12383       }
12384     }
12385 }
12386
12387 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12388    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12389
12390 static bfd_boolean
12391 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12392 {
12393   switch (filedata->file_header.e_machine)
12394   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12395     {
12396     case EM_386:
12397     case EM_IAMCU:
12398       return reloc_type == 2;  /* R_386_PC32.  */
12399     case EM_68K:
12400       return reloc_type == 4;  /* R_68K_PC32.  */
12401     case EM_AARCH64:
12402       return reloc_type == 261; /* R_AARCH64_PREL32 */
12403     case EM_ADAPTEVA_EPIPHANY:
12404       return reloc_type == 6;
12405     case EM_ALPHA:
12406       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12407     case EM_ARC_COMPACT:
12408     case EM_ARC_COMPACT2:
12409       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12410     case EM_ARM:
12411       return reloc_type == 3;  /* R_ARM_REL32 */
12412     case EM_AVR_OLD:
12413     case EM_AVR:
12414       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12415     case EM_MICROBLAZE:
12416       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12417     case EM_OR1K:
12418       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12419     case EM_PARISC:
12420       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12421     case EM_PPC:
12422       return reloc_type == 26; /* R_PPC_REL32.  */
12423     case EM_PPC64:
12424       return reloc_type == 26; /* R_PPC64_REL32.  */
12425     case EM_S390_OLD:
12426     case EM_S390:
12427       return reloc_type == 5;  /* R_390_PC32.  */
12428     case EM_SH:
12429       return reloc_type == 2;  /* R_SH_REL32.  */
12430     case EM_SPARC32PLUS:
12431     case EM_SPARCV9:
12432     case EM_SPARC:
12433       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12434     case EM_SPU:
12435       return reloc_type == 13; /* R_SPU_REL32.  */
12436     case EM_TILEGX:
12437       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12438     case EM_TILEPRO:
12439       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12440     case EM_VISIUM:
12441       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12442     case EM_X86_64:
12443     case EM_L1OM:
12444     case EM_K1OM:
12445       return reloc_type == 2;  /* R_X86_64_PC32.  */
12446     case EM_XTENSA_OLD:
12447     case EM_XTENSA:
12448       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12449     default:
12450       /* Do not abort or issue an error message here.  Not all targets use
12451          pc-relative 32-bit relocs in their DWARF debug information and we
12452          have already tested for target coverage in is_32bit_abs_reloc.  A
12453          more helpful warning message will be generated by apply_relocations
12454          anyway, so just return.  */
12455       return FALSE;
12456     }
12457 }
12458
12459 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12460    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12461
12462 static bfd_boolean
12463 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12464 {
12465   switch (filedata->file_header.e_machine)
12466     {
12467     case EM_AARCH64:
12468       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12469     case EM_ALPHA:
12470       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12471     case EM_IA_64:
12472       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12473               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12474     case EM_PARISC:
12475       return reloc_type == 80; /* R_PARISC_DIR64.  */
12476     case EM_PPC64:
12477       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12478     case EM_RISCV:
12479       return reloc_type == 2; /* R_RISCV_64.  */
12480     case EM_SPARC32PLUS:
12481     case EM_SPARCV9:
12482     case EM_SPARC:
12483       return reloc_type == 32 /* R_SPARC_64.  */
12484         || reloc_type == 54; /* R_SPARC_UA64.  */
12485     case EM_X86_64:
12486     case EM_L1OM:
12487     case EM_K1OM:
12488       return reloc_type == 1; /* R_X86_64_64.  */
12489     case EM_S390_OLD:
12490     case EM_S390:
12491       return reloc_type == 22;  /* R_S390_64.  */
12492     case EM_TILEGX:
12493       return reloc_type == 1; /* R_TILEGX_64.  */
12494     case EM_MIPS:
12495       return reloc_type == 18;  /* R_MIPS_64.  */
12496     default:
12497       return FALSE;
12498     }
12499 }
12500
12501 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12502    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12503
12504 static bfd_boolean
12505 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12506 {
12507   switch (filedata->file_header.e_machine)
12508     {
12509     case EM_AARCH64:
12510       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12511     case EM_ALPHA:
12512       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12513     case EM_IA_64:
12514       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12515               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12516     case EM_PARISC:
12517       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12518     case EM_PPC64:
12519       return reloc_type == 44; /* R_PPC64_REL64.  */
12520     case EM_SPARC32PLUS:
12521     case EM_SPARCV9:
12522     case EM_SPARC:
12523       return reloc_type == 46; /* R_SPARC_DISP64.  */
12524     case EM_X86_64:
12525     case EM_L1OM:
12526     case EM_K1OM:
12527       return reloc_type == 24; /* R_X86_64_PC64.  */
12528     case EM_S390_OLD:
12529     case EM_S390:
12530       return reloc_type == 23;  /* R_S390_PC64.  */
12531     case EM_TILEGX:
12532       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12533     default:
12534       return FALSE;
12535     }
12536 }
12537
12538 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12539    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12540
12541 static bfd_boolean
12542 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12543 {
12544   switch (filedata->file_header.e_machine)
12545     {
12546     case EM_CYGNUS_MN10200:
12547     case EM_MN10200:
12548       return reloc_type == 4; /* R_MN10200_24.  */
12549     case EM_FT32:
12550       return reloc_type == 5; /* R_FT32_20.  */
12551     default:
12552       return FALSE;
12553     }
12554 }
12555
12556 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12557    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12558
12559 static bfd_boolean
12560 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12561 {
12562   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12563   switch (filedata->file_header.e_machine)
12564     {
12565     case EM_ARC:
12566     case EM_ARC_COMPACT:
12567     case EM_ARC_COMPACT2:
12568       return reloc_type == 2; /* R_ARC_16.  */
12569     case EM_ADAPTEVA_EPIPHANY:
12570       return reloc_type == 5;
12571     case EM_AVR_OLD:
12572     case EM_AVR:
12573       return reloc_type == 4; /* R_AVR_16.  */
12574     case EM_CYGNUS_D10V:
12575     case EM_D10V:
12576       return reloc_type == 3; /* R_D10V_16.  */
12577     case EM_FT32:
12578       return reloc_type == 2; /* R_FT32_16.  */
12579     case EM_H8S:
12580     case EM_H8_300:
12581     case EM_H8_300H:
12582       return reloc_type == R_H8_DIR16;
12583     case EM_IP2K_OLD:
12584     case EM_IP2K:
12585       return reloc_type == 1; /* R_IP2K_16.  */
12586     case EM_M32C_OLD:
12587     case EM_M32C:
12588       return reloc_type == 1; /* R_M32C_16 */
12589     case EM_CYGNUS_MN10200:
12590     case EM_MN10200:
12591       return reloc_type == 2; /* R_MN10200_16.  */
12592     case EM_CYGNUS_MN10300:
12593     case EM_MN10300:
12594       return reloc_type == 2; /* R_MN10300_16.  */
12595     case EM_MSP430:
12596       if (uses_msp430x_relocs (filedata))
12597         return reloc_type == 2; /* R_MSP430_ABS16.  */
12598       /* Fall through.  */
12599     case EM_MSP430_OLD:
12600       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12601     case EM_NDS32:
12602       return reloc_type == 19; /* R_NDS32_RELA.  */
12603     case EM_ALTERA_NIOS2:
12604       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12605     case EM_NIOS32:
12606       return reloc_type == 9; /* R_NIOS_16.  */
12607     case EM_OR1K:
12608       return reloc_type == 2; /* R_OR1K_16.  */
12609     case EM_TI_PRU:
12610       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12611     case EM_TI_C6000:
12612       return reloc_type == 2; /* R_C6000_ABS16.  */
12613     case EM_VISIUM:
12614       return reloc_type == 2; /* R_VISIUM_16. */
12615     case EM_XC16X:
12616     case EM_C166:
12617       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12618     case EM_XGATE:
12619       return reloc_type == 3; /* R_XGATE_16.  */
12620     default:
12621       return FALSE;
12622     }
12623 }
12624
12625 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12626    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12627
12628 static bfd_boolean
12629 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12630 {
12631   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12632   switch (filedata->file_header.e_machine)
12633     {
12634     case EM_RISCV:
12635       return reloc_type == 35; /* R_RISCV_ADD32.  */
12636     default:
12637       return FALSE;
12638     }
12639 }
12640
12641 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12642    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12643
12644 static bfd_boolean
12645 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12646 {
12647   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12648   switch (filedata->file_header.e_machine)
12649     {
12650     case EM_RISCV:
12651       return reloc_type == 39; /* R_RISCV_SUB32.  */
12652     default:
12653       return FALSE;
12654     }
12655 }
12656
12657 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12658    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12659
12660 static bfd_boolean
12661 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12662 {
12663   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12664   switch (filedata->file_header.e_machine)
12665     {
12666     case EM_RISCV:
12667       return reloc_type == 36; /* R_RISCV_ADD64.  */
12668     default:
12669       return FALSE;
12670     }
12671 }
12672
12673 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12674    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12675
12676 static bfd_boolean
12677 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12678 {
12679   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12680   switch (filedata->file_header.e_machine)
12681     {
12682     case EM_RISCV:
12683       return reloc_type == 40; /* R_RISCV_SUB64.  */
12684     default:
12685       return FALSE;
12686     }
12687 }
12688
12689 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12690    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12691
12692 static bfd_boolean
12693 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12694 {
12695   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12696   switch (filedata->file_header.e_machine)
12697     {
12698     case EM_RISCV:
12699       return reloc_type == 34; /* R_RISCV_ADD16.  */
12700     default:
12701       return FALSE;
12702     }
12703 }
12704
12705 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12706    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12707
12708 static bfd_boolean
12709 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12710 {
12711   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12712   switch (filedata->file_header.e_machine)
12713     {
12714     case EM_RISCV:
12715       return reloc_type == 38; /* R_RISCV_SUB16.  */
12716     default:
12717       return FALSE;
12718     }
12719 }
12720
12721 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12722    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12723
12724 static bfd_boolean
12725 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12726 {
12727   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12728   switch (filedata->file_header.e_machine)
12729     {
12730     case EM_RISCV:
12731       return reloc_type == 33; /* R_RISCV_ADD8.  */
12732     default:
12733       return FALSE;
12734     }
12735 }
12736
12737 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12738    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12739
12740 static bfd_boolean
12741 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12742 {
12743   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12744   switch (filedata->file_header.e_machine)
12745     {
12746     case EM_RISCV:
12747       return reloc_type == 37; /* R_RISCV_SUB8.  */
12748     default:
12749       return FALSE;
12750     }
12751 }
12752
12753 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12754    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12755
12756 static bfd_boolean
12757 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12758 {
12759   switch (filedata->file_header.e_machine)
12760     {
12761     case EM_386:     /* R_386_NONE.  */
12762     case EM_68K:     /* R_68K_NONE.  */
12763     case EM_ADAPTEVA_EPIPHANY:
12764     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12765     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12766     case EM_ARC:     /* R_ARC_NONE.  */
12767     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12768     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12769     case EM_ARM:     /* R_ARM_NONE.  */
12770     case EM_C166:    /* R_XC16X_NONE.  */
12771     case EM_CRIS:    /* R_CRIS_NONE.  */
12772     case EM_FT32:    /* R_FT32_NONE.  */
12773     case EM_IA_64:   /* R_IA64_NONE.  */
12774     case EM_K1OM:    /* R_X86_64_NONE.  */
12775     case EM_L1OM:    /* R_X86_64_NONE.  */
12776     case EM_M32R:    /* R_M32R_NONE.  */
12777     case EM_MIPS:    /* R_MIPS_NONE.  */
12778     case EM_MN10300: /* R_MN10300_NONE.  */
12779     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12780     case EM_NIOS32:  /* R_NIOS_NONE.  */
12781     case EM_OR1K:    /* R_OR1K_NONE. */
12782     case EM_PARISC:  /* R_PARISC_NONE.  */
12783     case EM_PPC64:   /* R_PPC64_NONE.  */
12784     case EM_PPC:     /* R_PPC_NONE.  */
12785     case EM_RISCV:   /* R_RISCV_NONE.  */
12786     case EM_S390:    /* R_390_NONE.  */
12787     case EM_S390_OLD:
12788     case EM_SH:      /* R_SH_NONE.  */
12789     case EM_SPARC32PLUS:
12790     case EM_SPARC:   /* R_SPARC_NONE.  */
12791     case EM_SPARCV9:
12792     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12793     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12794     case EM_TI_C6000:/* R_C6000_NONE.  */
12795     case EM_X86_64:  /* R_X86_64_NONE.  */
12796     case EM_XC16X:
12797     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12798       return reloc_type == 0;
12799
12800     case EM_AARCH64:
12801       return reloc_type == 0 || reloc_type == 256;
12802     case EM_AVR_OLD:
12803     case EM_AVR:
12804       return (reloc_type == 0 /* R_AVR_NONE.  */
12805               || reloc_type == 30 /* R_AVR_DIFF8.  */
12806               || reloc_type == 31 /* R_AVR_DIFF16.  */
12807               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12808     case EM_METAG:
12809       return reloc_type == 3; /* R_METAG_NONE.  */
12810     case EM_NDS32:
12811       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12812               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12813               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12814               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12815               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12816     case EM_TI_PRU:
12817       return (reloc_type == 0       /* R_PRU_NONE.  */
12818               || reloc_type == 65   /* R_PRU_DIFF8.  */
12819               || reloc_type == 66   /* R_PRU_DIFF16.  */
12820               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12821     case EM_XTENSA_OLD:
12822     case EM_XTENSA:
12823       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12824               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12825               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12826               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12827     }
12828   return FALSE;
12829 }
12830
12831 /* Returns TRUE if there is a relocation against
12832    section NAME at OFFSET bytes.  */
12833
12834 bfd_boolean
12835 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12836 {
12837   Elf_Internal_Rela * relocs;
12838   Elf_Internal_Rela * rp;
12839
12840   if (dsec == NULL || dsec->reloc_info == NULL)
12841     return FALSE;
12842
12843   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12844
12845   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12846     if (rp->r_offset == offset)
12847       return TRUE;
12848
12849    return FALSE;
12850 }
12851
12852 /* Apply relocations to a section.
12853    Returns TRUE upon success, FALSE otherwise.
12854    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12855    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12856    will be set to the number of relocs loaded.
12857
12858    Note: So far support has been added only for those relocations
12859    which can be found in debug sections. FIXME: Add support for
12860    more relocations ?  */
12861
12862 static bfd_boolean
12863 apply_relocations (Filedata *                 filedata,
12864                    const Elf_Internal_Shdr *  section,
12865                    unsigned char *            start,
12866                    bfd_size_type              size,
12867                    void **                    relocs_return,
12868                    unsigned long *            num_relocs_return)
12869 {
12870   Elf_Internal_Shdr * relsec;
12871   unsigned char * end = start + size;
12872   bfd_boolean res = TRUE;
12873
12874   if (relocs_return != NULL)
12875     {
12876       * (Elf_Internal_Rela **) relocs_return = NULL;
12877       * num_relocs_return = 0;
12878     }
12879
12880   if (filedata->file_header.e_type != ET_REL)
12881     /* No relocs to apply.  */
12882     return TRUE;
12883
12884   /* Find the reloc section associated with the section.  */
12885   for (relsec = filedata->section_headers;
12886        relsec < filedata->section_headers + filedata->file_header.e_shnum;
12887        ++relsec)
12888     {
12889       bfd_boolean is_rela;
12890       unsigned long num_relocs;
12891       Elf_Internal_Rela * relocs;
12892       Elf_Internal_Rela * rp;
12893       Elf_Internal_Shdr * symsec;
12894       Elf_Internal_Sym * symtab;
12895       unsigned long num_syms;
12896       Elf_Internal_Sym * sym;
12897
12898       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12899           || relsec->sh_info >= filedata->file_header.e_shnum
12900           || filedata->section_headers + relsec->sh_info != section
12901           || relsec->sh_size == 0
12902           || relsec->sh_link >= filedata->file_header.e_shnum)
12903         continue;
12904
12905       is_rela = relsec->sh_type == SHT_RELA;
12906
12907       if (is_rela)
12908         {
12909           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
12910                                   relsec->sh_size, & relocs, & num_relocs))
12911             return FALSE;
12912         }
12913       else
12914         {
12915           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
12916                                  relsec->sh_size, & relocs, & num_relocs))
12917             return FALSE;
12918         }
12919
12920       /* SH uses RELA but uses in place value instead of the addend field.  */
12921       if (filedata->file_header.e_machine == EM_SH)
12922         is_rela = FALSE;
12923
12924       symsec = filedata->section_headers + relsec->sh_link;
12925       if (symsec->sh_type != SHT_SYMTAB
12926           && symsec->sh_type != SHT_DYNSYM)
12927         return FALSE;
12928       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
12929
12930       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12931         {
12932           bfd_vma         addend;
12933           unsigned int    reloc_type;
12934           unsigned int    reloc_size;
12935           bfd_boolean     reloc_inplace = FALSE;
12936           bfd_boolean     reloc_subtract = FALSE;
12937           unsigned char * rloc;
12938           unsigned long   sym_index;
12939
12940           reloc_type = get_reloc_type (filedata, rp->r_info);
12941
12942           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
12943             continue;
12944           else if (is_none_reloc (filedata, reloc_type))
12945             continue;
12946           else if (is_32bit_abs_reloc (filedata, reloc_type)
12947                    || is_32bit_pcrel_reloc (filedata, reloc_type))
12948             reloc_size = 4;
12949           else if (is_64bit_abs_reloc (filedata, reloc_type)
12950                    || is_64bit_pcrel_reloc (filedata, reloc_type))
12951             reloc_size = 8;
12952           else if (is_24bit_abs_reloc (filedata, reloc_type))
12953             reloc_size = 3;
12954           else if (is_16bit_abs_reloc (filedata, reloc_type))
12955             reloc_size = 2;
12956           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
12957                                                                  reloc_type))
12958                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
12959             {
12960               reloc_size = 4;
12961               reloc_inplace = TRUE;
12962             }
12963           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
12964                                                                  reloc_type))
12965                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
12966             {
12967               reloc_size = 8;
12968               reloc_inplace = TRUE;
12969             }
12970           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
12971                                                                  reloc_type))
12972                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
12973             {
12974               reloc_size = 2;
12975               reloc_inplace = TRUE;
12976             }
12977           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
12978                                                                 reloc_type))
12979                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
12980             {
12981               reloc_size = 1;
12982               reloc_inplace = TRUE;
12983             }
12984           else
12985             {
12986               static unsigned int prev_reloc = 0;
12987
12988               if (reloc_type != prev_reloc)
12989                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12990                       reloc_type, printable_section_name (filedata, section));
12991               prev_reloc = reloc_type;
12992               res = FALSE;
12993               continue;
12994             }
12995
12996           rloc = start + rp->r_offset;
12997           if ((rloc + reloc_size) > end || (rloc < start))
12998             {
12999               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13000                     (unsigned long) rp->r_offset,
13001                     printable_section_name (filedata, section));
13002               res = FALSE;
13003               continue;
13004             }
13005
13006           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13007           if (sym_index >= num_syms)
13008             {
13009               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13010                     sym_index, printable_section_name (filedata, section));
13011               res = FALSE;
13012               continue;
13013             }
13014           sym = symtab + sym_index;
13015
13016           /* If the reloc has a symbol associated with it,
13017              make sure that it is of an appropriate type.
13018
13019              Relocations against symbols without type can happen.
13020              Gcc -feliminate-dwarf2-dups may generate symbols
13021              without type for debug info.
13022
13023              Icc generates relocations against function symbols
13024              instead of local labels.
13025
13026              Relocations against object symbols can happen, eg when
13027              referencing a global array.  For an example of this see
13028              the _clz.o binary in libgcc.a.  */
13029           if (sym != symtab
13030               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13031               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13032             {
13033               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13034                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13035                     printable_section_name (filedata, relsec),
13036                     (long int)(rp - relocs));
13037               res = FALSE;
13038               continue;
13039             }
13040
13041           addend = 0;
13042           if (is_rela)
13043             addend += rp->r_addend;
13044           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13045              partial_inplace.  */
13046           if (!is_rela
13047               || (filedata->file_header.e_machine == EM_XTENSA
13048                   && reloc_type == 1)
13049               || ((filedata->file_header.e_machine == EM_PJ
13050                    || filedata->file_header.e_machine == EM_PJ_OLD)
13051                   && reloc_type == 1)
13052               || ((filedata->file_header.e_machine == EM_D30V
13053                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13054                   && reloc_type == 12)
13055               || reloc_inplace)
13056             addend += byte_get (rloc, reloc_size);
13057
13058           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13059               || is_64bit_pcrel_reloc (filedata, reloc_type))
13060             {
13061               /* On HPPA, all pc-relative relocations are biased by 8.  */
13062               if (filedata->file_header.e_machine == EM_PARISC)
13063                 addend -= 8;
13064               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13065                         reloc_size);
13066             }
13067           else if (reloc_subtract)
13068             byte_put (rloc, addend - sym->st_value, reloc_size);
13069           else
13070             byte_put (rloc, addend + sym->st_value, reloc_size);
13071         }
13072
13073       free (symtab);
13074       /* Let the target specific reloc processing code know that
13075          we have finished with these relocs.  */
13076       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13077
13078       if (relocs_return)
13079         {
13080           * (Elf_Internal_Rela **) relocs_return = relocs;
13081           * num_relocs_return = num_relocs;
13082         }
13083       else
13084         free (relocs);
13085
13086       break;
13087     }
13088
13089   return res;
13090 }
13091
13092 #ifdef SUPPORT_DISASSEMBLY
13093 static bfd_boolean
13094 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13095 {
13096   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13097
13098   /* FIXME: XXX -- to be done --- XXX */
13099
13100   return TRUE;
13101 }
13102 #endif
13103
13104 /* Reads in the contents of SECTION from FILE, returning a pointer
13105    to a malloc'ed buffer or NULL if something went wrong.  */
13106
13107 static char *
13108 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13109 {
13110   bfd_size_type num_bytes = section->sh_size;
13111
13112   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13113     {
13114       printf (_("Section '%s' has no data to dump.\n"),
13115               printable_section_name (filedata, section));
13116       return NULL;
13117     }
13118
13119   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13120                              _("section contents"));
13121 }
13122
13123 /* Uncompresses a section that was compressed using zlib, in place.  */
13124
13125 static bfd_boolean
13126 uncompress_section_contents (unsigned char **   buffer,
13127                              dwarf_size_type    uncompressed_size,
13128                              dwarf_size_type *  size)
13129 {
13130   dwarf_size_type compressed_size = *size;
13131   unsigned char * compressed_buffer = *buffer;
13132   unsigned char * uncompressed_buffer;
13133   z_stream strm;
13134   int rc;
13135
13136   /* It is possible the section consists of several compressed
13137      buffers concatenated together, so we uncompress in a loop.  */
13138   /* PR 18313: The state field in the z_stream structure is supposed
13139      to be invisible to the user (ie us), but some compilers will
13140      still complain about it being used without initialisation.  So
13141      we first zero the entire z_stream structure and then set the fields
13142      that we need.  */
13143   memset (& strm, 0, sizeof strm);
13144   strm.avail_in = compressed_size;
13145   strm.next_in = (Bytef *) compressed_buffer;
13146   strm.avail_out = uncompressed_size;
13147   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13148
13149   rc = inflateInit (& strm);
13150   while (strm.avail_in > 0)
13151     {
13152       if (rc != Z_OK)
13153         goto fail;
13154       strm.next_out = ((Bytef *) uncompressed_buffer
13155                        + (uncompressed_size - strm.avail_out));
13156       rc = inflate (&strm, Z_FINISH);
13157       if (rc != Z_STREAM_END)
13158         goto fail;
13159       rc = inflateReset (& strm);
13160     }
13161   rc = inflateEnd (& strm);
13162   if (rc != Z_OK
13163       || strm.avail_out != 0)
13164     goto fail;
13165
13166   *buffer = uncompressed_buffer;
13167   *size = uncompressed_size;
13168   return TRUE;
13169
13170  fail:
13171   free (uncompressed_buffer);
13172   /* Indicate decompression failure.  */
13173   *buffer = NULL;
13174   return FALSE;
13175 }
13176
13177 static bfd_boolean
13178 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13179 {
13180   Elf_Internal_Shdr *  relsec;
13181   bfd_size_type        num_bytes;
13182   unsigned char *      data;
13183   unsigned char *      end;
13184   unsigned char *      real_start;
13185   unsigned char *      start;
13186   bfd_boolean          some_strings_shown;
13187
13188   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13189   if (start == NULL)
13190     /* PR 21820: Do not fail if the section was empty.  */
13191     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13192
13193   num_bytes = section->sh_size;
13194
13195   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13196
13197   if (decompress_dumps)
13198     {
13199       dwarf_size_type new_size = num_bytes;
13200       dwarf_size_type uncompressed_size = 0;
13201
13202       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13203         {
13204           Elf_Internal_Chdr chdr;
13205           unsigned int compression_header_size
13206             = get_compression_header (& chdr, (unsigned char *) start,
13207                                       num_bytes);
13208
13209           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13210             {
13211               warn (_("section '%s' has unsupported compress type: %d\n"),
13212                     printable_section_name (filedata, section), chdr.ch_type);
13213               return FALSE;
13214             }
13215           else if (chdr.ch_addralign != section->sh_addralign)
13216             {
13217               warn (_("compressed section '%s' is corrupted\n"),
13218                     printable_section_name (filedata, section));
13219               return FALSE;
13220             }
13221           uncompressed_size = chdr.ch_size;
13222           start += compression_header_size;
13223           new_size -= compression_header_size;
13224         }
13225       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13226         {
13227           /* Read the zlib header.  In this case, it should be "ZLIB"
13228              followed by the uncompressed section size, 8 bytes in
13229              big-endian order.  */
13230           uncompressed_size = start[4]; uncompressed_size <<= 8;
13231           uncompressed_size += start[5]; uncompressed_size <<= 8;
13232           uncompressed_size += start[6]; uncompressed_size <<= 8;
13233           uncompressed_size += start[7]; uncompressed_size <<= 8;
13234           uncompressed_size += start[8]; uncompressed_size <<= 8;
13235           uncompressed_size += start[9]; uncompressed_size <<= 8;
13236           uncompressed_size += start[10]; uncompressed_size <<= 8;
13237           uncompressed_size += start[11];
13238           start += 12;
13239           new_size -= 12;
13240         }
13241
13242       if (uncompressed_size)
13243         {
13244           if (uncompress_section_contents (& start,
13245                                            uncompressed_size, & new_size))
13246             num_bytes = new_size;
13247           else
13248             {
13249               error (_("Unable to decompress section %s\n"),
13250                      printable_section_name (filedata, section));
13251               return FALSE;
13252             }
13253         }
13254       else
13255         start = real_start;
13256     }
13257
13258   /* If the section being dumped has relocations against it the user might
13259      be expecting these relocations to have been applied.  Check for this
13260      case and issue a warning message in order to avoid confusion.
13261      FIXME: Maybe we ought to have an option that dumps a section with
13262      relocs applied ?  */
13263   for (relsec = filedata->section_headers;
13264        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13265        ++relsec)
13266     {
13267       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13268           || relsec->sh_info >= filedata->file_header.e_shnum
13269           || filedata->section_headers + relsec->sh_info != section
13270           || relsec->sh_size == 0
13271           || relsec->sh_link >= filedata->file_header.e_shnum)
13272         continue;
13273
13274       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13275       break;
13276     }
13277
13278   data = start;
13279   end  = start + num_bytes;
13280   some_strings_shown = FALSE;
13281
13282   while (data < end)
13283     {
13284       while (!ISPRINT (* data))
13285         if (++ data >= end)
13286           break;
13287
13288       if (data < end)
13289         {
13290           size_t maxlen = end - data;
13291
13292 #ifndef __MSVCRT__
13293           /* PR 11128: Use two separate invocations in order to work
13294              around bugs in the Solaris 8 implementation of printf.  */
13295           printf ("  [%6tx]  ", data - start);
13296 #else
13297           printf ("  [%6Ix]  ", (size_t) (data - start));
13298 #endif
13299           if (maxlen > 0)
13300             {
13301               print_symbol ((int) maxlen, (const char *) data);
13302               putchar ('\n');
13303               data += strnlen ((const char *) data, maxlen);
13304             }
13305           else
13306             {
13307               printf (_("<corrupt>\n"));
13308               data = end;
13309             }
13310           some_strings_shown = TRUE;
13311         }
13312     }
13313
13314   if (! some_strings_shown)
13315     printf (_("  No strings found in this section."));
13316
13317   free (real_start);
13318
13319   putchar ('\n');
13320   return TRUE;
13321 }
13322
13323 static bfd_boolean
13324 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13325                        Filedata *           filedata,
13326                        bfd_boolean          relocate)
13327 {
13328   Elf_Internal_Shdr * relsec;
13329   bfd_size_type       bytes;
13330   bfd_size_type       section_size;
13331   bfd_vma             addr;
13332   unsigned char *     data;
13333   unsigned char *     real_start;
13334   unsigned char *     start;
13335
13336   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13337   if (start == NULL)
13338     /* PR 21820: Do not fail if the section was empty.  */
13339     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13340
13341   section_size = section->sh_size;
13342
13343   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13344
13345   if (decompress_dumps)
13346     {
13347       dwarf_size_type new_size = section_size;
13348       dwarf_size_type uncompressed_size = 0;
13349
13350       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13351         {
13352           Elf_Internal_Chdr chdr;
13353           unsigned int compression_header_size
13354             = get_compression_header (& chdr, start, section_size);
13355
13356           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13357             {
13358               warn (_("section '%s' has unsupported compress type: %d\n"),
13359                     printable_section_name (filedata, section), chdr.ch_type);
13360               return FALSE;
13361             }
13362           else if (chdr.ch_addralign != section->sh_addralign)
13363             {
13364               warn (_("compressed section '%s' is corrupted\n"),
13365                     printable_section_name (filedata, section));
13366               return FALSE;
13367             }
13368           uncompressed_size = chdr.ch_size;
13369           start += compression_header_size;
13370           new_size -= compression_header_size;
13371         }
13372       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13373         {
13374           /* Read the zlib header.  In this case, it should be "ZLIB"
13375              followed by the uncompressed section size, 8 bytes in
13376              big-endian order.  */
13377           uncompressed_size = start[4]; uncompressed_size <<= 8;
13378           uncompressed_size += start[5]; uncompressed_size <<= 8;
13379           uncompressed_size += start[6]; uncompressed_size <<= 8;
13380           uncompressed_size += start[7]; uncompressed_size <<= 8;
13381           uncompressed_size += start[8]; uncompressed_size <<= 8;
13382           uncompressed_size += start[9]; uncompressed_size <<= 8;
13383           uncompressed_size += start[10]; uncompressed_size <<= 8;
13384           uncompressed_size += start[11];
13385           start += 12;
13386           new_size -= 12;
13387         }
13388
13389       if (uncompressed_size)
13390         {
13391           if (uncompress_section_contents (& start, uncompressed_size,
13392                                            & new_size))
13393             {
13394               section_size = new_size;
13395             }
13396           else
13397             {
13398               error (_("Unable to decompress section %s\n"),
13399                      printable_section_name (filedata, section));
13400               /* FIXME: Print the section anyway ?  */
13401               return FALSE;
13402             }
13403         }
13404       else
13405         start = real_start;
13406     }
13407
13408   if (relocate)
13409     {
13410       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13411         return FALSE;
13412     }
13413   else
13414     {
13415       /* If the section being dumped has relocations against it the user might
13416          be expecting these relocations to have been applied.  Check for this
13417          case and issue a warning message in order to avoid confusion.
13418          FIXME: Maybe we ought to have an option that dumps a section with
13419          relocs applied ?  */
13420       for (relsec = filedata->section_headers;
13421            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13422            ++relsec)
13423         {
13424           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13425               || relsec->sh_info >= filedata->file_header.e_shnum
13426               || filedata->section_headers + relsec->sh_info != section
13427               || relsec->sh_size == 0
13428               || relsec->sh_link >= filedata->file_header.e_shnum)
13429             continue;
13430
13431           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13432           break;
13433         }
13434     }
13435
13436   addr = section->sh_addr;
13437   bytes = section_size;
13438   data = start;
13439
13440   while (bytes)
13441     {
13442       int j;
13443       int k;
13444       int lbytes;
13445
13446       lbytes = (bytes > 16 ? 16 : bytes);
13447
13448       printf ("  0x%8.8lx ", (unsigned long) addr);
13449
13450       for (j = 0; j < 16; j++)
13451         {
13452           if (j < lbytes)
13453             printf ("%2.2x", data[j]);
13454           else
13455             printf ("  ");
13456
13457           if ((j & 3) == 3)
13458             printf (" ");
13459         }
13460
13461       for (j = 0; j < lbytes; j++)
13462         {
13463           k = data[j];
13464           if (k >= ' ' && k < 0x7f)
13465             printf ("%c", k);
13466           else
13467             printf (".");
13468         }
13469
13470       putchar ('\n');
13471
13472       data  += lbytes;
13473       addr  += lbytes;
13474       bytes -= lbytes;
13475     }
13476
13477   free (real_start);
13478
13479   putchar ('\n');
13480   return TRUE;
13481 }
13482
13483 static bfd_boolean
13484 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13485                              const Elf_Internal_Shdr *        sec,
13486                              void *                           data)
13487 {
13488   struct dwarf_section * section = &debug_displays [debug].section;
13489   char buf [64];
13490   Filedata * filedata = (Filedata *) data;
13491
13492   if (section->start != NULL)
13493     {
13494       /* If it is already loaded, do nothing.  */
13495       if (streq (section->filename, filedata->file_name))
13496         return TRUE;
13497       free (section->start);
13498     }
13499
13500   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13501   section->address = sec->sh_addr;
13502   section->user_data = NULL;
13503   section->filename = filedata->file_name;
13504   section->start = (unsigned char *) get_data (NULL, filedata,
13505                                                sec->sh_offset, 1,
13506                                                sec->sh_size, buf);
13507   if (section->start == NULL)
13508     section->size = 0;
13509   else
13510     {
13511       unsigned char *start = section->start;
13512       dwarf_size_type size = sec->sh_size;
13513       dwarf_size_type uncompressed_size = 0;
13514
13515       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13516         {
13517           Elf_Internal_Chdr chdr;
13518           unsigned int compression_header_size;
13519
13520           if (size < (is_32bit_elf
13521                       ? sizeof (Elf32_External_Chdr)
13522                       : sizeof (Elf64_External_Chdr)))
13523             {
13524               warn (_("compressed section %s is too small to contain a compression header"),
13525                     section->name);
13526               return FALSE;
13527             }
13528
13529           compression_header_size = get_compression_header (&chdr, start, size);
13530
13531           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13532             {
13533               warn (_("section '%s' has unsupported compress type: %d\n"),
13534                     section->name, chdr.ch_type);
13535               return FALSE;
13536             }
13537           else if (chdr.ch_addralign != sec->sh_addralign)
13538             {
13539               warn (_("compressed section '%s' is corrupted\n"),
13540                     section->name);
13541               return FALSE;
13542             }
13543           uncompressed_size = chdr.ch_size;
13544           start += compression_header_size;
13545           size -= compression_header_size;
13546         }
13547       else if (size > 12 && streq ((char *) start, "ZLIB"))
13548         {
13549           /* Read the zlib header.  In this case, it should be "ZLIB"
13550              followed by the uncompressed section size, 8 bytes in
13551              big-endian order.  */
13552           uncompressed_size = start[4]; uncompressed_size <<= 8;
13553           uncompressed_size += start[5]; uncompressed_size <<= 8;
13554           uncompressed_size += start[6]; uncompressed_size <<= 8;
13555           uncompressed_size += start[7]; uncompressed_size <<= 8;
13556           uncompressed_size += start[8]; uncompressed_size <<= 8;
13557           uncompressed_size += start[9]; uncompressed_size <<= 8;
13558           uncompressed_size += start[10]; uncompressed_size <<= 8;
13559           uncompressed_size += start[11];
13560           start += 12;
13561           size -= 12;
13562         }
13563
13564       if (uncompressed_size)
13565         {
13566           if (uncompress_section_contents (&start, uncompressed_size,
13567                                            &size))
13568             {
13569               /* Free the compressed buffer, update the section buffer
13570                  and the section size if uncompress is successful.  */
13571               free (section->start);
13572               section->start = start;
13573             }
13574           else
13575             {
13576               error (_("Unable to decompress section %s\n"),
13577                      printable_section_name (filedata, sec));
13578               return FALSE;
13579             }
13580         }
13581
13582       section->size = size;
13583     }
13584
13585   if (section->start == NULL)
13586     return FALSE;
13587
13588   if (debug_displays [debug].relocate)
13589     {
13590       if (! apply_relocations (filedata, sec, section->start, section->size,
13591                                & section->reloc_info, & section->num_relocs))
13592         return FALSE;
13593     }
13594   else
13595     {
13596       section->reloc_info = NULL;
13597       section->num_relocs = 0;
13598     }
13599
13600   return TRUE;
13601 }
13602
13603 /* If this is not NULL, load_debug_section will only look for sections
13604    within the list of sections given here.  */
13605 static unsigned int * section_subset = NULL;
13606
13607 bfd_boolean
13608 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13609 {
13610   struct dwarf_section * section = &debug_displays [debug].section;
13611   Elf_Internal_Shdr * sec;
13612   Filedata * filedata = (Filedata *) data;
13613
13614   /* Without section headers we cannot find any sections.  */
13615   if (filedata->section_headers == NULL)
13616     return FALSE;
13617
13618   if (filedata->string_table == NULL
13619       && filedata->file_header.e_shstrndx != SHN_UNDEF
13620       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13621     {
13622       Elf_Internal_Shdr * strs;
13623
13624       /* Read in the string table, so that we have section names to scan.  */
13625       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13626
13627       if (strs != NULL && strs->sh_size != 0)
13628         {
13629           filedata->string_table
13630             = (char *) get_data (NULL, filedata, strs->sh_offset,
13631                                  1, strs->sh_size, _("string table"));
13632
13633           filedata->string_table_length
13634             = filedata->string_table != NULL ? strs->sh_size : 0;
13635         }
13636     }
13637
13638   /* Locate the debug section.  */
13639   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13640   if (sec != NULL)
13641     section->name = section->uncompressed_name;
13642   else
13643     {
13644       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13645       if (sec != NULL)
13646         section->name = section->compressed_name;
13647     }
13648   if (sec == NULL)
13649     return FALSE;
13650
13651   /* If we're loading from a subset of sections, and we've loaded
13652      a section matching this name before, it's likely that it's a
13653      different one.  */
13654   if (section_subset != NULL)
13655     free_debug_section (debug);
13656
13657   return load_specific_debug_section (debug, sec, data);
13658 }
13659
13660 void
13661 free_debug_section (enum dwarf_section_display_enum debug)
13662 {
13663   struct dwarf_section * section = &debug_displays [debug].section;
13664
13665   if (section->start == NULL)
13666     return;
13667
13668   free ((char *) section->start);
13669   section->start = NULL;
13670   section->address = 0;
13671   section->size = 0;
13672 }
13673
13674 static bfd_boolean
13675 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13676 {
13677   char * name = SECTION_NAME (section);
13678   const char * print_name = printable_section_name (filedata, section);
13679   bfd_size_type length;
13680   bfd_boolean result = TRUE;
13681   int i;
13682
13683   length = section->sh_size;
13684   if (length == 0)
13685     {
13686       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13687       return TRUE;
13688     }
13689   if (section->sh_type == SHT_NOBITS)
13690     {
13691       /* There is no point in dumping the contents of a debugging section
13692          which has the NOBITS type - the bits in the file will be random.
13693          This can happen when a file containing a .eh_frame section is
13694          stripped with the --only-keep-debug command line option.  */
13695       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13696               print_name);
13697       return FALSE;
13698     }
13699
13700   if (const_strneq (name, ".gnu.linkonce.wi."))
13701     name = ".debug_info";
13702
13703   /* See if we know how to display the contents of this section.  */
13704   for (i = 0; i < max; i++)
13705     {
13706       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13707       struct dwarf_section_display *   display = debug_displays + i;
13708       struct dwarf_section *           sec = & display->section;
13709
13710       if (streq (sec->uncompressed_name, name)
13711           || (id == line && const_strneq (name, ".debug_line."))
13712           || streq (sec->compressed_name, name))
13713         {
13714           bfd_boolean secondary = (section != find_section (filedata, name));
13715
13716           if (secondary)
13717             free_debug_section (id);
13718
13719           if (i == line && const_strneq (name, ".debug_line."))
13720             sec->name = name;
13721           else if (streq (sec->uncompressed_name, name))
13722             sec->name = sec->uncompressed_name;
13723           else
13724             sec->name = sec->compressed_name;
13725
13726           if (load_specific_debug_section (id, section, filedata))
13727             {
13728               /* If this debug section is part of a CU/TU set in a .dwp file,
13729                  restrict load_debug_section to the sections in that set.  */
13730               section_subset = find_cu_tu_set (filedata, shndx);
13731
13732               result &= display->display (sec, filedata);
13733
13734               section_subset = NULL;
13735
13736               if (secondary || (id != info && id != abbrev))
13737                 free_debug_section (id);
13738             }
13739           break;
13740         }
13741     }
13742
13743   if (i == max)
13744     {
13745       printf (_("Unrecognized debug section: %s\n"), print_name);
13746       result = FALSE;
13747     }
13748
13749   return result;
13750 }
13751
13752 /* Set DUMP_SECTS for all sections where dumps were requested
13753    based on section name.  */
13754
13755 static void
13756 initialise_dumps_byname (Filedata * filedata)
13757 {
13758   struct dump_list_entry * cur;
13759
13760   for (cur = dump_sects_byname; cur; cur = cur->next)
13761     {
13762       unsigned int i;
13763       bfd_boolean any = FALSE;
13764
13765       for (i = 0; i < filedata->file_header.e_shnum; i++)
13766         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13767           {
13768             request_dump_bynumber (filedata, i, cur->type);
13769             any = TRUE;
13770           }
13771
13772       if (!any)
13773         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13774               cur->name);
13775     }
13776 }
13777
13778 static bfd_boolean
13779 process_section_contents (Filedata * filedata)
13780 {
13781   Elf_Internal_Shdr * section;
13782   unsigned int i;
13783   bfd_boolean res = TRUE;
13784
13785   if (! do_dump)
13786     return TRUE;
13787
13788   initialise_dumps_byname (filedata);
13789
13790   for (i = 0, section = filedata->section_headers;
13791        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13792        i++, section++)
13793     {
13794       dump_type dump = filedata->dump_sects[i];
13795
13796 #ifdef SUPPORT_DISASSEMBLY
13797       if (dump & DISASS_DUMP)
13798         {
13799           if (! disassemble_section (section, filedata))
13800             res = FALSE;
13801         }
13802 #endif
13803       if (dump & HEX_DUMP)
13804         {
13805           if (! dump_section_as_bytes (section, filedata, FALSE))
13806             res = FALSE;
13807         }
13808
13809       if (dump & RELOC_DUMP)
13810         {
13811           if (! dump_section_as_bytes (section, filedata, TRUE))
13812             res = FALSE;
13813         }
13814
13815       if (dump & STRING_DUMP)
13816         {
13817           if (! dump_section_as_strings (section, filedata))
13818             res = FALSE;
13819         }
13820
13821       if (dump & DEBUG_DUMP)
13822         {
13823           if (! display_debug_section (i, section, filedata))
13824             res = FALSE;
13825         }
13826     }
13827
13828   /* Check to see if the user requested a
13829      dump of a section that does not exist.  */
13830   while (i < filedata->num_dump_sects)
13831     {
13832       if (filedata->dump_sects[i])
13833         {
13834           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13835           res = FALSE;
13836         }
13837       i++;
13838     }
13839
13840   return res;
13841 }
13842
13843 static void
13844 process_mips_fpe_exception (int mask)
13845 {
13846   if (mask)
13847     {
13848       bfd_boolean first = TRUE;
13849
13850       if (mask & OEX_FPU_INEX)
13851         fputs ("INEX", stdout), first = FALSE;
13852       if (mask & OEX_FPU_UFLO)
13853         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13854       if (mask & OEX_FPU_OFLO)
13855         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13856       if (mask & OEX_FPU_DIV0)
13857         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13858       if (mask & OEX_FPU_INVAL)
13859         printf ("%sINVAL", first ? "" : "|");
13860     }
13861   else
13862     fputs ("0", stdout);
13863 }
13864
13865 /* Display's the value of TAG at location P.  If TAG is
13866    greater than 0 it is assumed to be an unknown tag, and
13867    a message is printed to this effect.  Otherwise it is
13868    assumed that a message has already been printed.
13869
13870    If the bottom bit of TAG is set it assumed to have a
13871    string value, otherwise it is assumed to have an integer
13872    value.
13873
13874    Returns an updated P pointing to the first unread byte
13875    beyond the end of TAG's value.
13876
13877    Reads at or beyond END will not be made.  */
13878
13879 static unsigned char *
13880 display_tag_value (signed int tag,
13881                    unsigned char * p,
13882                    const unsigned char * const end)
13883 {
13884   unsigned long val;
13885
13886   if (tag > 0)
13887     printf ("  Tag_unknown_%d: ", tag);
13888
13889   if (p >= end)
13890     {
13891       warn (_("<corrupt tag>\n"));
13892     }
13893   else if (tag & 1)
13894     {
13895       /* PR 17531 file: 027-19978-0.004.  */
13896       size_t maxlen = (end - p) - 1;
13897
13898       putchar ('"');
13899       if (maxlen > 0)
13900         {
13901           print_symbol ((int) maxlen, (const char *) p);
13902           p += strnlen ((char *) p, maxlen) + 1;
13903         }
13904       else
13905         {
13906           printf (_("<corrupt string tag>"));
13907           p = (unsigned char *) end;
13908         }
13909       printf ("\"\n");
13910     }
13911   else
13912     {
13913       unsigned int len;
13914
13915       val = read_uleb128 (p, &len, end);
13916       p += len;
13917       printf ("%ld (0x%lx)\n", val, val);
13918     }
13919
13920   assert (p <= end);
13921   return p;
13922 }
13923
13924 /* ARC ABI attributes section.  */
13925
13926 static unsigned char *
13927 display_arc_attribute (unsigned char * p,
13928                        const unsigned char * const end)
13929 {
13930   unsigned int tag;
13931   unsigned int len;
13932   unsigned int val;
13933
13934   tag = read_uleb128 (p, &len, end);
13935   p += len;
13936
13937   switch (tag)
13938     {
13939     case Tag_ARC_PCS_config:
13940       val = read_uleb128 (p, &len, end);
13941       p += len;
13942       printf ("  Tag_ARC_PCS_config: ");
13943       switch (val)
13944         {
13945         case 0:
13946           printf (_("Absent/Non standard\n"));
13947           break;
13948         case 1:
13949           printf (_("Bare metal/mwdt\n"));
13950           break;
13951         case 2:
13952           printf (_("Bare metal/newlib\n"));
13953           break;
13954         case 3:
13955           printf (_("Linux/uclibc\n"));
13956           break;
13957         case 4:
13958           printf (_("Linux/glibc\n"));
13959           break;
13960         default:
13961           printf (_("Unknown\n"));
13962           break;
13963         }
13964       break;
13965
13966     case Tag_ARC_CPU_base:
13967       val = read_uleb128 (p, &len, end);
13968       p += len;
13969       printf ("  Tag_ARC_CPU_base: ");
13970       switch (val)
13971         {
13972         default:
13973         case TAG_CPU_NONE:
13974           printf (_("Absent\n"));
13975           break;
13976         case TAG_CPU_ARC6xx:
13977           printf ("ARC6xx\n");
13978           break;
13979         case TAG_CPU_ARC7xx:
13980           printf ("ARC7xx\n");
13981           break;
13982         case TAG_CPU_ARCEM:
13983           printf ("ARCEM\n");
13984           break;
13985         case TAG_CPU_ARCHS:
13986           printf ("ARCHS\n");
13987           break;
13988         }
13989       break;
13990
13991     case Tag_ARC_CPU_variation:
13992       val = read_uleb128 (p, &len, end);
13993       p += len;
13994       printf ("  Tag_ARC_CPU_variation: ");
13995       switch (val)
13996         {
13997         default:
13998           if (val > 0 && val < 16)
13999               printf ("Core%d\n", val);
14000           else
14001               printf ("Unknown\n");
14002           break;
14003
14004         case 0:
14005           printf (_("Absent\n"));
14006           break;
14007         }
14008       break;
14009
14010     case Tag_ARC_CPU_name:
14011       printf ("  Tag_ARC_CPU_name: ");
14012       p = display_tag_value (-1, p, end);
14013       break;
14014
14015     case Tag_ARC_ABI_rf16:
14016       val = read_uleb128 (p, &len, end);
14017       p += len;
14018       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14019       break;
14020
14021     case Tag_ARC_ABI_osver:
14022       val = read_uleb128 (p, &len, end);
14023       p += len;
14024       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14025       break;
14026
14027     case Tag_ARC_ABI_pic:
14028     case Tag_ARC_ABI_sda:
14029       val = read_uleb128 (p, &len, end);
14030       p += len;
14031       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14032               : "  Tag_ARC_ABI_pic: ");
14033       switch (val)
14034         {
14035         case 0:
14036           printf (_("Absent\n"));
14037           break;
14038         case 1:
14039           printf ("MWDT\n");
14040           break;
14041         case 2:
14042           printf ("GNU\n");
14043           break;
14044         default:
14045           printf (_("Unknown\n"));
14046           break;
14047         }
14048       break;
14049
14050     case Tag_ARC_ABI_tls:
14051       val = read_uleb128 (p, &len, end);
14052       p += len;
14053       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14054       break;
14055
14056     case Tag_ARC_ABI_enumsize:
14057       val = read_uleb128 (p, &len, end);
14058       p += len;
14059       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14060               _("smallest"));
14061       break;
14062
14063     case Tag_ARC_ABI_exceptions:
14064       val = read_uleb128 (p, &len, end);
14065       p += len;
14066       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14067               : _("default"));
14068       break;
14069
14070     case Tag_ARC_ABI_double_size:
14071       val = read_uleb128 (p, &len, end);
14072       p += len;
14073       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14074       break;
14075
14076     case Tag_ARC_ISA_config:
14077       printf ("  Tag_ARC_ISA_config: ");
14078       p = display_tag_value (-1, p, end);
14079       break;
14080
14081     case Tag_ARC_ISA_apex:
14082       printf ("  Tag_ARC_ISA_apex: ");
14083       p = display_tag_value (-1, p, end);
14084       break;
14085
14086     case Tag_ARC_ISA_mpy_option:
14087       val = read_uleb128 (p, &len, end);
14088       p += len;
14089       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14090       break;
14091
14092     default:
14093       return display_tag_value (tag & 1, p, end);
14094     }
14095
14096   return p;
14097 }
14098
14099 /* ARM EABI attributes section.  */
14100 typedef struct
14101 {
14102   unsigned int tag;
14103   const char * name;
14104   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14105   unsigned int type;
14106   const char ** table;
14107 } arm_attr_public_tag;
14108
14109 static const char * arm_attr_tag_CPU_arch[] =
14110   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14111    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14112    "v8-M.mainline"};
14113 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14114 static const char * arm_attr_tag_THUMB_ISA_use[] =
14115   {"No", "Thumb-1", "Thumb-2", "Yes"};
14116 static const char * arm_attr_tag_FP_arch[] =
14117   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14118    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14119 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14120 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14121   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14122    "NEON for ARMv8.1"};
14123 static const char * arm_attr_tag_PCS_config[] =
14124   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14125    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14126 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14127   {"V6", "SB", "TLS", "Unused"};
14128 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14129   {"Absolute", "PC-relative", "SB-relative", "None"};
14130 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14131   {"Absolute", "PC-relative", "None"};
14132 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14133   {"None", "direct", "GOT-indirect"};
14134 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14135   {"None", "??? 1", "2", "??? 3", "4"};
14136 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14137 static const char * arm_attr_tag_ABI_FP_denormal[] =
14138   {"Unused", "Needed", "Sign only"};
14139 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14140 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14141 static const char * arm_attr_tag_ABI_FP_number_model[] =
14142   {"Unused", "Finite", "RTABI", "IEEE 754"};
14143 static const char * arm_attr_tag_ABI_enum_size[] =
14144   {"Unused", "small", "int", "forced to int"};
14145 static const char * arm_attr_tag_ABI_HardFP_use[] =
14146   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14147 static const char * arm_attr_tag_ABI_VFP_args[] =
14148   {"AAPCS", "VFP registers", "custom", "compatible"};
14149 static const char * arm_attr_tag_ABI_WMMX_args[] =
14150   {"AAPCS", "WMMX registers", "custom"};
14151 static const char * arm_attr_tag_ABI_optimization_goals[] =
14152   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14153     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14154 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14155   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14156     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14157 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14158 static const char * arm_attr_tag_FP_HP_extension[] =
14159   {"Not Allowed", "Allowed"};
14160 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14161   {"None", "IEEE 754", "Alternative Format"};
14162 static const char * arm_attr_tag_DSP_extension[] =
14163   {"Follow architecture", "Allowed"};
14164 static const char * arm_attr_tag_MPextension_use[] =
14165   {"Not Allowed", "Allowed"};
14166 static const char * arm_attr_tag_DIV_use[] =
14167   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14168     "Allowed in v7-A with integer division extension"};
14169 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14170 static const char * arm_attr_tag_Virtualization_use[] =
14171   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14172     "TrustZone and Virtualization Extensions"};
14173 static const char * arm_attr_tag_MPextension_use_legacy[] =
14174   {"Not Allowed", "Allowed"};
14175
14176 #define LOOKUP(id, name) \
14177   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14178 static arm_attr_public_tag arm_attr_public_tags[] =
14179 {
14180   {4, "CPU_raw_name", 1, NULL},
14181   {5, "CPU_name", 1, NULL},
14182   LOOKUP(6, CPU_arch),
14183   {7, "CPU_arch_profile", 0, NULL},
14184   LOOKUP(8, ARM_ISA_use),
14185   LOOKUP(9, THUMB_ISA_use),
14186   LOOKUP(10, FP_arch),
14187   LOOKUP(11, WMMX_arch),
14188   LOOKUP(12, Advanced_SIMD_arch),
14189   LOOKUP(13, PCS_config),
14190   LOOKUP(14, ABI_PCS_R9_use),
14191   LOOKUP(15, ABI_PCS_RW_data),
14192   LOOKUP(16, ABI_PCS_RO_data),
14193   LOOKUP(17, ABI_PCS_GOT_use),
14194   LOOKUP(18, ABI_PCS_wchar_t),
14195   LOOKUP(19, ABI_FP_rounding),
14196   LOOKUP(20, ABI_FP_denormal),
14197   LOOKUP(21, ABI_FP_exceptions),
14198   LOOKUP(22, ABI_FP_user_exceptions),
14199   LOOKUP(23, ABI_FP_number_model),
14200   {24, "ABI_align_needed", 0, NULL},
14201   {25, "ABI_align_preserved", 0, NULL},
14202   LOOKUP(26, ABI_enum_size),
14203   LOOKUP(27, ABI_HardFP_use),
14204   LOOKUP(28, ABI_VFP_args),
14205   LOOKUP(29, ABI_WMMX_args),
14206   LOOKUP(30, ABI_optimization_goals),
14207   LOOKUP(31, ABI_FP_optimization_goals),
14208   {32, "compatibility", 0, NULL},
14209   LOOKUP(34, CPU_unaligned_access),
14210   LOOKUP(36, FP_HP_extension),
14211   LOOKUP(38, ABI_FP_16bit_format),
14212   LOOKUP(42, MPextension_use),
14213   LOOKUP(44, DIV_use),
14214   LOOKUP(46, DSP_extension),
14215   {64, "nodefaults", 0, NULL},
14216   {65, "also_compatible_with", 0, NULL},
14217   LOOKUP(66, T2EE_use),
14218   {67, "conformance", 1, NULL},
14219   LOOKUP(68, Virtualization_use),
14220   LOOKUP(70, MPextension_use_legacy)
14221 };
14222 #undef LOOKUP
14223
14224 static unsigned char *
14225 display_arm_attribute (unsigned char * p,
14226                        const unsigned char * const end)
14227 {
14228   unsigned int tag;
14229   unsigned int len;
14230   unsigned int val;
14231   arm_attr_public_tag * attr;
14232   unsigned i;
14233   unsigned int type;
14234
14235   tag = read_uleb128 (p, &len, end);
14236   p += len;
14237   attr = NULL;
14238   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14239     {
14240       if (arm_attr_public_tags[i].tag == tag)
14241         {
14242           attr = &arm_attr_public_tags[i];
14243           break;
14244         }
14245     }
14246
14247   if (attr)
14248     {
14249       printf ("  Tag_%s: ", attr->name);
14250       switch (attr->type)
14251         {
14252         case 0:
14253           switch (tag)
14254             {
14255             case 7: /* Tag_CPU_arch_profile.  */
14256               val = read_uleb128 (p, &len, end);
14257               p += len;
14258               switch (val)
14259                 {
14260                 case 0: printf (_("None\n")); break;
14261                 case 'A': printf (_("Application\n")); break;
14262                 case 'R': printf (_("Realtime\n")); break;
14263                 case 'M': printf (_("Microcontroller\n")); break;
14264                 case 'S': printf (_("Application or Realtime\n")); break;
14265                 default: printf ("??? (%d)\n", val); break;
14266                 }
14267               break;
14268
14269             case 24: /* Tag_align_needed.  */
14270               val = read_uleb128 (p, &len, end);
14271               p += len;
14272               switch (val)
14273                 {
14274                 case 0: printf (_("None\n")); break;
14275                 case 1: printf (_("8-byte\n")); break;
14276                 case 2: printf (_("4-byte\n")); break;
14277                 case 3: printf ("??? 3\n"); break;
14278                 default:
14279                   if (val <= 12)
14280                     printf (_("8-byte and up to %d-byte extended\n"),
14281                             1 << val);
14282                   else
14283                     printf ("??? (%d)\n", val);
14284                   break;
14285                 }
14286               break;
14287
14288             case 25: /* Tag_align_preserved.  */
14289               val = read_uleb128 (p, &len, end);
14290               p += len;
14291               switch (val)
14292                 {
14293                 case 0: printf (_("None\n")); break;
14294                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14295                 case 2: printf (_("8-byte\n")); break;
14296                 case 3: printf ("??? 3\n"); break;
14297                 default:
14298                   if (val <= 12)
14299                     printf (_("8-byte and up to %d-byte extended\n"),
14300                             1 << val);
14301                   else
14302                     printf ("??? (%d)\n", val);
14303                   break;
14304                 }
14305               break;
14306
14307             case 32: /* Tag_compatibility.  */
14308               {
14309                 val = read_uleb128 (p, &len, end);
14310                 p += len;
14311                 printf (_("flag = %d, vendor = "), val);
14312                 if (p < end - 1)
14313                   {
14314                     size_t maxlen = (end - p) - 1;
14315
14316                     print_symbol ((int) maxlen, (const char *) p);
14317                     p += strnlen ((char *) p, maxlen) + 1;
14318                   }
14319                 else
14320                   {
14321                     printf (_("<corrupt>"));
14322                     p = (unsigned char *) end;
14323                   }
14324                 putchar ('\n');
14325               }
14326               break;
14327
14328             case 64: /* Tag_nodefaults.  */
14329               /* PR 17531: file: 001-505008-0.01.  */
14330               if (p < end)
14331                 p++;
14332               printf (_("True\n"));
14333               break;
14334
14335             case 65: /* Tag_also_compatible_with.  */
14336               val = read_uleb128 (p, &len, end);
14337               p += len;
14338               if (val == 6 /* Tag_CPU_arch.  */)
14339                 {
14340                   val = read_uleb128 (p, &len, end);
14341                   p += len;
14342                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14343                     printf ("??? (%d)\n", val);
14344                   else
14345                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14346                 }
14347               else
14348                 printf ("???\n");
14349               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14350                 ;
14351               break;
14352
14353             default:
14354               printf (_("<unknown: %d>\n"), tag);
14355               break;
14356             }
14357           return p;
14358
14359         case 1:
14360           return display_tag_value (-1, p, end);
14361         case 2:
14362           return display_tag_value (0, p, end);
14363
14364         default:
14365           assert (attr->type & 0x80);
14366           val = read_uleb128 (p, &len, end);
14367           p += len;
14368           type = attr->type & 0x7f;
14369           if (val >= type)
14370             printf ("??? (%d)\n", val);
14371           else
14372             printf ("%s\n", attr->table[val]);
14373           return p;
14374         }
14375     }
14376
14377   return display_tag_value (tag, p, end);
14378 }
14379
14380 static unsigned char *
14381 display_gnu_attribute (unsigned char * p,
14382                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14383                        const unsigned char * const end)
14384 {
14385   int tag;
14386   unsigned int len;
14387   unsigned int val;
14388
14389   tag = read_uleb128 (p, &len, end);
14390   p += len;
14391
14392   /* Tag_compatibility is the only generic GNU attribute defined at
14393      present.  */
14394   if (tag == 32)
14395     {
14396       val = read_uleb128 (p, &len, end);
14397       p += len;
14398
14399       printf (_("flag = %d, vendor = "), val);
14400       if (p == end)
14401         {
14402           printf (_("<corrupt>\n"));
14403           warn (_("corrupt vendor attribute\n"));
14404         }
14405       else
14406         {
14407           if (p < end - 1)
14408             {
14409               size_t maxlen = (end - p) - 1;
14410
14411               print_symbol ((int) maxlen, (const char *) p);
14412               p += strnlen ((char *) p, maxlen) + 1;
14413             }
14414           else
14415             {
14416               printf (_("<corrupt>"));
14417               p = (unsigned char *) end;
14418             }
14419           putchar ('\n');
14420         }
14421       return p;
14422     }
14423
14424   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14425     return display_proc_gnu_attribute (p, tag, end);
14426
14427   return display_tag_value (tag, p, end);
14428 }
14429
14430 static unsigned char *
14431 display_power_gnu_attribute (unsigned char * p,
14432                              unsigned int tag,
14433                              const unsigned char * const end)
14434 {
14435   unsigned int len;
14436   unsigned int val;
14437
14438   if (tag == Tag_GNU_Power_ABI_FP)
14439     {
14440       val = read_uleb128 (p, &len, end);
14441       p += len;
14442       printf ("  Tag_GNU_Power_ABI_FP: ");
14443       if (len == 0)
14444         {
14445           printf (_("<corrupt>\n"));
14446           return p;
14447         }
14448
14449       if (val > 15)
14450         printf ("(%#x), ", val);
14451
14452       switch (val & 3)
14453         {
14454         case 0:
14455           printf (_("unspecified hard/soft float, "));
14456           break;
14457         case 1:
14458           printf (_("hard float, "));
14459           break;
14460         case 2:
14461           printf (_("soft float, "));
14462           break;
14463         case 3:
14464           printf (_("single-precision hard float, "));
14465           break;
14466         }
14467
14468       switch (val & 0xC)
14469         {
14470         case 0:
14471           printf (_("unspecified long double\n"));
14472           break;
14473         case 4:
14474           printf (_("128-bit IBM long double\n"));
14475           break;
14476         case 8:
14477           printf (_("64-bit long double\n"));
14478           break;
14479         case 12:
14480           printf (_("128-bit IEEE long double\n"));
14481           break;
14482         }
14483       return p;
14484     }
14485
14486   if (tag == Tag_GNU_Power_ABI_Vector)
14487     {
14488       val = read_uleb128 (p, &len, end);
14489       p += len;
14490       printf ("  Tag_GNU_Power_ABI_Vector: ");
14491       if (len == 0)
14492         {
14493           printf (_("<corrupt>\n"));
14494           return p;
14495         }
14496
14497       if (val > 3)
14498         printf ("(%#x), ", val);
14499
14500       switch (val & 3)
14501         {
14502         case 0:
14503           printf (_("unspecified\n"));
14504           break;
14505         case 1:
14506           printf (_("generic\n"));
14507           break;
14508         case 2:
14509           printf ("AltiVec\n");
14510           break;
14511         case 3:
14512           printf ("SPE\n");
14513           break;
14514         }
14515       return p;
14516     }
14517
14518   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14519     {
14520       val = read_uleb128 (p, &len, end);
14521       p += len;
14522       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14523       if (len == 0)
14524         {
14525           printf (_("<corrupt>\n"));
14526           return p;
14527         }
14528
14529       if (val > 2)
14530         printf ("(%#x), ", val);
14531
14532       switch (val & 3)
14533         {
14534         case 0:
14535           printf (_("unspecified\n"));
14536           break;
14537         case 1:
14538           printf ("r3/r4\n");
14539           break;
14540         case 2:
14541           printf (_("memory\n"));
14542           break;
14543         case 3:
14544           printf ("???\n");
14545           break;
14546         }
14547       return p;
14548     }
14549
14550   return display_tag_value (tag & 1, p, end);
14551 }
14552
14553 static unsigned char *
14554 display_s390_gnu_attribute (unsigned char * p,
14555                             unsigned int tag,
14556                             const unsigned char * const end)
14557 {
14558   unsigned int len;
14559   int val;
14560
14561   if (tag == Tag_GNU_S390_ABI_Vector)
14562     {
14563       val = read_uleb128 (p, &len, end);
14564       p += len;
14565       printf ("  Tag_GNU_S390_ABI_Vector: ");
14566
14567       switch (val)
14568         {
14569         case 0:
14570           printf (_("any\n"));
14571           break;
14572         case 1:
14573           printf (_("software\n"));
14574           break;
14575         case 2:
14576           printf (_("hardware\n"));
14577           break;
14578         default:
14579           printf ("??? (%d)\n", val);
14580           break;
14581         }
14582       return p;
14583    }
14584
14585   return display_tag_value (tag & 1, p, end);
14586 }
14587
14588 static void
14589 display_sparc_hwcaps (unsigned int mask)
14590 {
14591   if (mask)
14592     {
14593       bfd_boolean first = TRUE;
14594
14595       if (mask & ELF_SPARC_HWCAP_MUL32)
14596         fputs ("mul32", stdout), first = FALSE;
14597       if (mask & ELF_SPARC_HWCAP_DIV32)
14598         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14599       if (mask & ELF_SPARC_HWCAP_FSMULD)
14600         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14601       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14602         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14603       if (mask & ELF_SPARC_HWCAP_POPC)
14604         printf ("%spopc", first ? "" : "|"), first = FALSE;
14605       if (mask & ELF_SPARC_HWCAP_VIS)
14606         printf ("%svis", first ? "" : "|"), first = FALSE;
14607       if (mask & ELF_SPARC_HWCAP_VIS2)
14608         printf ("%svis2", first ? "" : "|"), first = FALSE;
14609       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14610         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14611       if (mask & ELF_SPARC_HWCAP_FMAF)
14612         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14613       if (mask & ELF_SPARC_HWCAP_VIS3)
14614         printf ("%svis3", first ? "" : "|"), first = FALSE;
14615       if (mask & ELF_SPARC_HWCAP_HPC)
14616         printf ("%shpc", first ? "" : "|"), first = FALSE;
14617       if (mask & ELF_SPARC_HWCAP_RANDOM)
14618         printf ("%srandom", first ? "" : "|"), first = FALSE;
14619       if (mask & ELF_SPARC_HWCAP_TRANS)
14620         printf ("%strans", first ? "" : "|"), first = FALSE;
14621       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14622         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14623       if (mask & ELF_SPARC_HWCAP_IMA)
14624         printf ("%sima", first ? "" : "|"), first = FALSE;
14625       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14626         printf ("%scspare", first ? "" : "|"), first = FALSE;
14627     }
14628   else
14629     fputc ('0', stdout);
14630   fputc ('\n', stdout);
14631 }
14632
14633 static void
14634 display_sparc_hwcaps2 (unsigned int mask)
14635 {
14636   if (mask)
14637     {
14638       bfd_boolean first = TRUE;
14639
14640       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14641         fputs ("fjathplus", stdout), first = FALSE;
14642       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14643         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14644       if (mask & ELF_SPARC_HWCAP2_ADP)
14645         printf ("%sadp", first ? "" : "|"), first = FALSE;
14646       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14647         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14648       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14649         printf ("%smwait", first ? "" : "|"), first = FALSE;
14650       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14651         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14652       if (mask & ELF_SPARC_HWCAP2_XMONT)
14653         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14654       if (mask & ELF_SPARC_HWCAP2_NSEC)
14655         printf ("%snsec", first ? "" : "|"), first = FALSE;
14656       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14657         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14658       if (mask & ELF_SPARC_HWCAP2_FJDES)
14659         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14660       if (mask & ELF_SPARC_HWCAP2_FJAES)
14661         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14662     }
14663   else
14664     fputc ('0', stdout);
14665   fputc ('\n', stdout);
14666 }
14667
14668 static unsigned char *
14669 display_sparc_gnu_attribute (unsigned char * p,
14670                              unsigned int tag,
14671                              const unsigned char * const end)
14672 {
14673   unsigned int len;
14674   int val;
14675
14676   if (tag == Tag_GNU_Sparc_HWCAPS)
14677     {
14678       val = read_uleb128 (p, &len, end);
14679       p += len;
14680       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14681       display_sparc_hwcaps (val);
14682       return p;
14683     }
14684   if (tag == Tag_GNU_Sparc_HWCAPS2)
14685     {
14686       val = read_uleb128 (p, &len, end);
14687       p += len;
14688       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14689       display_sparc_hwcaps2 (val);
14690       return p;
14691     }
14692
14693   return display_tag_value (tag, p, end);
14694 }
14695
14696 static void
14697 print_mips_fp_abi_value (unsigned int val)
14698 {
14699   switch (val)
14700     {
14701     case Val_GNU_MIPS_ABI_FP_ANY:
14702       printf (_("Hard or soft float\n"));
14703       break;
14704     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14705       printf (_("Hard float (double precision)\n"));
14706       break;
14707     case Val_GNU_MIPS_ABI_FP_SINGLE:
14708       printf (_("Hard float (single precision)\n"));
14709       break;
14710     case Val_GNU_MIPS_ABI_FP_SOFT:
14711       printf (_("Soft float\n"));
14712       break;
14713     case Val_GNU_MIPS_ABI_FP_OLD_64:
14714       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14715       break;
14716     case Val_GNU_MIPS_ABI_FP_XX:
14717       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14718       break;
14719     case Val_GNU_MIPS_ABI_FP_64:
14720       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14721       break;
14722     case Val_GNU_MIPS_ABI_FP_64A:
14723       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14724       break;
14725     case Val_GNU_MIPS_ABI_FP_NAN2008:
14726       printf (_("NaN 2008 compatibility\n"));
14727       break;
14728     default:
14729       printf ("??? (%d)\n", val);
14730       break;
14731     }
14732 }
14733
14734 static unsigned char *
14735 display_mips_gnu_attribute (unsigned char * p,
14736                             unsigned int tag,
14737                             const unsigned char * const end)
14738 {
14739   if (tag == Tag_GNU_MIPS_ABI_FP)
14740     {
14741       unsigned int len;
14742       unsigned int val;
14743
14744       val = read_uleb128 (p, &len, end);
14745       p += len;
14746       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14747
14748       print_mips_fp_abi_value (val);
14749
14750       return p;
14751    }
14752
14753   if (tag == Tag_GNU_MIPS_ABI_MSA)
14754     {
14755       unsigned int len;
14756       unsigned int val;
14757
14758       val = read_uleb128 (p, &len, end);
14759       p += len;
14760       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14761
14762       switch (val)
14763         {
14764         case Val_GNU_MIPS_ABI_MSA_ANY:
14765           printf (_("Any MSA or not\n"));
14766           break;
14767         case Val_GNU_MIPS_ABI_MSA_128:
14768           printf (_("128-bit MSA\n"));
14769           break;
14770         default:
14771           printf ("??? (%d)\n", val);
14772           break;
14773         }
14774       return p;
14775     }
14776
14777   return display_tag_value (tag & 1, p, end);
14778 }
14779
14780 static unsigned char *
14781 display_tic6x_attribute (unsigned char * p,
14782                          const unsigned char * const end)
14783 {
14784   unsigned int tag;
14785   unsigned int len;
14786   int val;
14787
14788   tag = read_uleb128 (p, &len, end);
14789   p += len;
14790
14791   switch (tag)
14792     {
14793     case Tag_ISA:
14794       val = read_uleb128 (p, &len, end);
14795       p += len;
14796       printf ("  Tag_ISA: ");
14797
14798       switch (val)
14799         {
14800         case C6XABI_Tag_ISA_none:
14801           printf (_("None\n"));
14802           break;
14803         case C6XABI_Tag_ISA_C62X:
14804           printf ("C62x\n");
14805           break;
14806         case C6XABI_Tag_ISA_C67X:
14807           printf ("C67x\n");
14808           break;
14809         case C6XABI_Tag_ISA_C67XP:
14810           printf ("C67x+\n");
14811           break;
14812         case C6XABI_Tag_ISA_C64X:
14813           printf ("C64x\n");
14814           break;
14815         case C6XABI_Tag_ISA_C64XP:
14816           printf ("C64x+\n");
14817           break;
14818         case C6XABI_Tag_ISA_C674X:
14819           printf ("C674x\n");
14820           break;
14821         default:
14822           printf ("??? (%d)\n", val);
14823           break;
14824         }
14825       return p;
14826
14827     case Tag_ABI_wchar_t:
14828       val = read_uleb128 (p, &len, end);
14829       p += len;
14830       printf ("  Tag_ABI_wchar_t: ");
14831       switch (val)
14832         {
14833         case 0:
14834           printf (_("Not used\n"));
14835           break;
14836         case 1:
14837           printf (_("2 bytes\n"));
14838           break;
14839         case 2:
14840           printf (_("4 bytes\n"));
14841           break;
14842         default:
14843           printf ("??? (%d)\n", val);
14844           break;
14845         }
14846       return p;
14847
14848     case Tag_ABI_stack_align_needed:
14849       val = read_uleb128 (p, &len, end);
14850       p += len;
14851       printf ("  Tag_ABI_stack_align_needed: ");
14852       switch (val)
14853         {
14854         case 0:
14855           printf (_("8-byte\n"));
14856           break;
14857         case 1:
14858           printf (_("16-byte\n"));
14859           break;
14860         default:
14861           printf ("??? (%d)\n", val);
14862           break;
14863         }
14864       return p;
14865
14866     case Tag_ABI_stack_align_preserved:
14867       val = read_uleb128 (p, &len, end);
14868       p += len;
14869       printf ("  Tag_ABI_stack_align_preserved: ");
14870       switch (val)
14871         {
14872         case 0:
14873           printf (_("8-byte\n"));
14874           break;
14875         case 1:
14876           printf (_("16-byte\n"));
14877           break;
14878         default:
14879           printf ("??? (%d)\n", val);
14880           break;
14881         }
14882       return p;
14883
14884     case Tag_ABI_DSBT:
14885       val = read_uleb128 (p, &len, end);
14886       p += len;
14887       printf ("  Tag_ABI_DSBT: ");
14888       switch (val)
14889         {
14890         case 0:
14891           printf (_("DSBT addressing not used\n"));
14892           break;
14893         case 1:
14894           printf (_("DSBT addressing used\n"));
14895           break;
14896         default:
14897           printf ("??? (%d)\n", val);
14898           break;
14899         }
14900       return p;
14901
14902     case Tag_ABI_PID:
14903       val = read_uleb128 (p, &len, end);
14904       p += len;
14905       printf ("  Tag_ABI_PID: ");
14906       switch (val)
14907         {
14908         case 0:
14909           printf (_("Data addressing position-dependent\n"));
14910           break;
14911         case 1:
14912           printf (_("Data addressing position-independent, GOT near DP\n"));
14913           break;
14914         case 2:
14915           printf (_("Data addressing position-independent, GOT far from DP\n"));
14916           break;
14917         default:
14918           printf ("??? (%d)\n", val);
14919           break;
14920         }
14921       return p;
14922
14923     case Tag_ABI_PIC:
14924       val = read_uleb128 (p, &len, end);
14925       p += len;
14926       printf ("  Tag_ABI_PIC: ");
14927       switch (val)
14928         {
14929         case 0:
14930           printf (_("Code addressing position-dependent\n"));
14931           break;
14932         case 1:
14933           printf (_("Code addressing position-independent\n"));
14934           break;
14935         default:
14936           printf ("??? (%d)\n", val);
14937           break;
14938         }
14939       return p;
14940
14941     case Tag_ABI_array_object_alignment:
14942       val = read_uleb128 (p, &len, end);
14943       p += len;
14944       printf ("  Tag_ABI_array_object_alignment: ");
14945       switch (val)
14946         {
14947         case 0:
14948           printf (_("8-byte\n"));
14949           break;
14950         case 1:
14951           printf (_("4-byte\n"));
14952           break;
14953         case 2:
14954           printf (_("16-byte\n"));
14955           break;
14956         default:
14957           printf ("??? (%d)\n", val);
14958           break;
14959         }
14960       return p;
14961
14962     case Tag_ABI_array_object_align_expected:
14963       val = read_uleb128 (p, &len, end);
14964       p += len;
14965       printf ("  Tag_ABI_array_object_align_expected: ");
14966       switch (val)
14967         {
14968         case 0:
14969           printf (_("8-byte\n"));
14970           break;
14971         case 1:
14972           printf (_("4-byte\n"));
14973           break;
14974         case 2:
14975           printf (_("16-byte\n"));
14976           break;
14977         default:
14978           printf ("??? (%d)\n", val);
14979           break;
14980         }
14981       return p;
14982
14983     case Tag_ABI_compatibility:
14984       {
14985         val = read_uleb128 (p, &len, end);
14986         p += len;
14987         printf ("  Tag_ABI_compatibility: ");
14988         printf (_("flag = %d, vendor = "), val);
14989         if (p < end - 1)
14990           {
14991             size_t maxlen = (end - p) - 1;
14992
14993             print_symbol ((int) maxlen, (const char *) p);
14994             p += strnlen ((char *) p, maxlen) + 1;
14995           }
14996         else
14997           {
14998             printf (_("<corrupt>"));
14999             p = (unsigned char *) end;
15000           }
15001         putchar ('\n');
15002         return p;
15003       }
15004
15005     case Tag_ABI_conformance:
15006       {
15007         printf ("  Tag_ABI_conformance: \"");
15008         if (p < end - 1)
15009           {
15010             size_t maxlen = (end - p) - 1;
15011
15012             print_symbol ((int) maxlen, (const char *) p);
15013             p += strnlen ((char *) p, maxlen) + 1;
15014           }
15015         else
15016           {
15017             printf (_("<corrupt>"));
15018             p = (unsigned char *) end;
15019           }
15020         printf ("\"\n");
15021         return p;
15022       }
15023     }
15024
15025   return display_tag_value (tag, p, end);
15026 }
15027
15028 static void
15029 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15030 {
15031   unsigned long addr = 0;
15032   size_t bytes = end - p;
15033
15034   assert (end > p);
15035   while (bytes)
15036     {
15037       int j;
15038       int k;
15039       int lbytes = (bytes > 16 ? 16 : bytes);
15040
15041       printf ("  0x%8.8lx ", addr);
15042
15043       for (j = 0; j < 16; j++)
15044         {
15045           if (j < lbytes)
15046             printf ("%2.2x", p[j]);
15047           else
15048             printf ("  ");
15049
15050           if ((j & 3) == 3)
15051             printf (" ");
15052         }
15053
15054       for (j = 0; j < lbytes; j++)
15055         {
15056           k = p[j];
15057           if (k >= ' ' && k < 0x7f)
15058             printf ("%c", k);
15059           else
15060             printf (".");
15061         }
15062
15063       putchar ('\n');
15064
15065       p  += lbytes;
15066       bytes -= lbytes;
15067       addr += lbytes;
15068     }
15069
15070   putchar ('\n');
15071 }
15072
15073 static unsigned char *
15074 display_msp430x_attribute (unsigned char * p,
15075                            const unsigned char * const end)
15076 {
15077   unsigned int len;
15078   unsigned int val;
15079   unsigned int tag;
15080
15081   tag = read_uleb128 (p, & len, end);
15082   p += len;
15083
15084   switch (tag)
15085     {
15086     case OFBA_MSPABI_Tag_ISA:
15087       val = read_uleb128 (p, &len, end);
15088       p += len;
15089       printf ("  Tag_ISA: ");
15090       switch (val)
15091         {
15092         case 0: printf (_("None\n")); break;
15093         case 1: printf (_("MSP430\n")); break;
15094         case 2: printf (_("MSP430X\n")); break;
15095         default: printf ("??? (%d)\n", val); break;
15096         }
15097       break;
15098
15099     case OFBA_MSPABI_Tag_Code_Model:
15100       val = read_uleb128 (p, &len, end);
15101       p += len;
15102       printf ("  Tag_Code_Model: ");
15103       switch (val)
15104         {
15105         case 0: printf (_("None\n")); break;
15106         case 1: printf (_("Small\n")); break;
15107         case 2: printf (_("Large\n")); break;
15108         default: printf ("??? (%d)\n", val); break;
15109         }
15110       break;
15111
15112     case OFBA_MSPABI_Tag_Data_Model:
15113       val = read_uleb128 (p, &len, end);
15114       p += len;
15115       printf ("  Tag_Data_Model: ");
15116       switch (val)
15117         {
15118         case 0: printf (_("None\n")); break;
15119         case 1: printf (_("Small\n")); break;
15120         case 2: printf (_("Large\n")); break;
15121         case 3: printf (_("Restricted Large\n")); break;
15122         default: printf ("??? (%d)\n", val); break;
15123         }
15124       break;
15125
15126     default:
15127       printf (_("  <unknown tag %d>: "), tag);
15128
15129       if (tag & 1)
15130         {
15131           putchar ('"');
15132           if (p < end - 1)
15133             {
15134               size_t maxlen = (end - p) - 1;
15135
15136               print_symbol ((int) maxlen, (const char *) p);
15137               p += strnlen ((char *) p, maxlen) + 1;
15138             }
15139           else
15140             {
15141               printf (_("<corrupt>"));
15142               p = (unsigned char *) end;
15143             }
15144           printf ("\"\n");
15145         }
15146       else
15147         {
15148           val = read_uleb128 (p, &len, end);
15149           p += len;
15150           printf ("%d (0x%x)\n", val, val);
15151         }
15152       break;
15153    }
15154
15155   assert (p <= end);
15156   return p;
15157 }
15158
15159 static bfd_boolean
15160 process_attributes (Filedata * filedata,
15161                     const char * public_name,
15162                     unsigned int proc_type,
15163                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15164                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15165 {
15166   Elf_Internal_Shdr * sect;
15167   unsigned i;
15168   bfd_boolean res = TRUE;
15169
15170   /* Find the section header so that we get the size.  */
15171   for (i = 0, sect = filedata->section_headers;
15172        i < filedata->file_header.e_shnum;
15173        i++, sect++)
15174     {
15175       unsigned char * contents;
15176       unsigned char * p;
15177
15178       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15179         continue;
15180
15181       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15182                                              sect->sh_size, _("attributes"));
15183       if (contents == NULL)
15184         {
15185           res = FALSE;
15186           continue;
15187         }
15188
15189       p = contents;
15190       /* The first character is the version of the attributes.
15191          Currently only version 1, (aka 'A') is recognised here.  */
15192       if (*p != 'A')
15193         {
15194           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15195           res = FALSE;
15196         }
15197       else
15198         {
15199           bfd_vma section_len;
15200
15201           section_len = sect->sh_size - 1;
15202           p++;
15203
15204           while (section_len > 0)
15205             {
15206               bfd_vma attr_len;
15207               unsigned int namelen;
15208               bfd_boolean public_section;
15209               bfd_boolean gnu_section;
15210
15211               if (section_len <= 4)
15212                 {
15213                   error (_("Tag section ends prematurely\n"));
15214                   res = FALSE;
15215                   break;
15216                 }
15217               attr_len = byte_get (p, 4);
15218               p += 4;
15219
15220               if (attr_len > section_len)
15221                 {
15222                   error (_("Bad attribute length (%u > %u)\n"),
15223                           (unsigned) attr_len, (unsigned) section_len);
15224                   attr_len = section_len;
15225                   res = FALSE;
15226                 }
15227               /* PR 17531: file: 001-101425-0.004  */
15228               else if (attr_len < 5)
15229                 {
15230                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15231                   res = FALSE;
15232                   break;
15233                 }
15234
15235               section_len -= attr_len;
15236               attr_len -= 4;
15237
15238               namelen = strnlen ((char *) p, attr_len) + 1;
15239               if (namelen == 0 || namelen >= attr_len)
15240                 {
15241                   error (_("Corrupt attribute section name\n"));
15242                   res = FALSE;
15243                   break;
15244                 }
15245
15246               printf (_("Attribute Section: "));
15247               print_symbol (INT_MAX, (const char *) p);
15248               putchar ('\n');
15249
15250               if (public_name && streq ((char *) p, public_name))
15251                 public_section = TRUE;
15252               else
15253                 public_section = FALSE;
15254
15255               if (streq ((char *) p, "gnu"))
15256                 gnu_section = TRUE;
15257               else
15258                 gnu_section = FALSE;
15259
15260               p += namelen;
15261               attr_len -= namelen;
15262
15263               while (attr_len > 0 && p < contents + sect->sh_size)
15264                 {
15265                   int tag;
15266                   int val;
15267                   bfd_vma size;
15268                   unsigned char * end;
15269
15270                   /* PR binutils/17531: Safe handling of corrupt files.  */
15271                   if (attr_len < 6)
15272                     {
15273                       error (_("Unused bytes at end of section\n"));
15274                       res = FALSE;
15275                       section_len = 0;
15276                       break;
15277                     }
15278
15279                   tag = *(p++);
15280                   size = byte_get (p, 4);
15281                   if (size > attr_len)
15282                     {
15283                       error (_("Bad subsection length (%u > %u)\n"),
15284                               (unsigned) size, (unsigned) attr_len);
15285                       res = FALSE;
15286                       size = attr_len;
15287                     }
15288                   /* PR binutils/17531: Safe handling of corrupt files.  */
15289                   if (size < 6)
15290                     {
15291                       error (_("Bad subsection length (%u < 6)\n"),
15292                               (unsigned) size);
15293                       res = FALSE;
15294                       section_len = 0;
15295                       break;
15296                     }
15297
15298                   attr_len -= size;
15299                   end = p + size - 1;
15300                   assert (end <= contents + sect->sh_size);
15301                   p += 4;
15302
15303                   switch (tag)
15304                     {
15305                     case 1:
15306                       printf (_("File Attributes\n"));
15307                       break;
15308                     case 2:
15309                       printf (_("Section Attributes:"));
15310                       goto do_numlist;
15311                     case 3:
15312                       printf (_("Symbol Attributes:"));
15313                       /* Fall through.  */
15314                     do_numlist:
15315                       for (;;)
15316                         {
15317                           unsigned int j;
15318
15319                           val = read_uleb128 (p, &j, end);
15320                           p += j;
15321                           if (val == 0)
15322                             break;
15323                           printf (" %d", val);
15324                         }
15325                       printf ("\n");
15326                       break;
15327                     default:
15328                       printf (_("Unknown tag: %d\n"), tag);
15329                       public_section = FALSE;
15330                       break;
15331                     }
15332
15333                   if (public_section && display_pub_attribute != NULL)
15334                     {
15335                       while (p < end)
15336                         p = display_pub_attribute (p, end);
15337                       assert (p == end);
15338                     }
15339                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15340                     {
15341                       while (p < end)
15342                         p = display_gnu_attribute (p,
15343                                                    display_proc_gnu_attribute,
15344                                                    end);
15345                       assert (p == end);
15346                     }
15347                   else if (p < end)
15348                     {
15349                       printf (_("  Unknown attribute:\n"));
15350                       display_raw_attribute (p, end);
15351                       p = end;
15352                     }
15353                   else
15354                     attr_len = 0;
15355                 }
15356             }
15357         }
15358
15359       free (contents);
15360     }
15361
15362   return res;
15363 }
15364
15365 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15366    Print the Address, Access and Initial fields of an entry at VMA ADDR
15367    and return the VMA of the next entry, or -1 if there was a problem.
15368    Does not read from DATA_END or beyond.  */
15369
15370 static bfd_vma
15371 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15372                       unsigned char * data_end)
15373 {
15374   printf ("  ");
15375   print_vma (addr, LONG_HEX);
15376   printf (" ");
15377   if (addr < pltgot + 0xfff0)
15378     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15379   else
15380     printf ("%10s", "");
15381   printf (" ");
15382   if (data == NULL)
15383     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15384   else
15385     {
15386       bfd_vma entry;
15387       unsigned char * from = data + addr - pltgot;
15388
15389       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15390         {
15391           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15392           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15393           return (bfd_vma) -1;
15394         }
15395       else
15396         {
15397           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15398           print_vma (entry, LONG_HEX);
15399         }
15400     }
15401   return addr + (is_32bit_elf ? 4 : 8);
15402 }
15403
15404 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15405    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15406    ADDR and return the VMA of the next entry.  */
15407
15408 static bfd_vma
15409 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15410 {
15411   printf ("  ");
15412   print_vma (addr, LONG_HEX);
15413   printf (" ");
15414   if (data == NULL)
15415     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15416   else
15417     {
15418       bfd_vma entry;
15419
15420       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15421       print_vma (entry, LONG_HEX);
15422     }
15423   return addr + (is_32bit_elf ? 4 : 8);
15424 }
15425
15426 static void
15427 print_mips_ases (unsigned int mask)
15428 {
15429   if (mask & AFL_ASE_DSP)
15430     fputs ("\n\tDSP ASE", stdout);
15431   if (mask & AFL_ASE_DSPR2)
15432     fputs ("\n\tDSP R2 ASE", stdout);
15433   if (mask & AFL_ASE_DSPR3)
15434     fputs ("\n\tDSP R3 ASE", stdout);
15435   if (mask & AFL_ASE_EVA)
15436     fputs ("\n\tEnhanced VA Scheme", stdout);
15437   if (mask & AFL_ASE_MCU)
15438     fputs ("\n\tMCU (MicroController) ASE", stdout);
15439   if (mask & AFL_ASE_MDMX)
15440     fputs ("\n\tMDMX ASE", stdout);
15441   if (mask & AFL_ASE_MIPS3D)
15442     fputs ("\n\tMIPS-3D ASE", stdout);
15443   if (mask & AFL_ASE_MT)
15444     fputs ("\n\tMT ASE", stdout);
15445   if (mask & AFL_ASE_SMARTMIPS)
15446     fputs ("\n\tSmartMIPS ASE", stdout);
15447   if (mask & AFL_ASE_VIRT)
15448     fputs ("\n\tVZ ASE", stdout);
15449   if (mask & AFL_ASE_MSA)
15450     fputs ("\n\tMSA ASE", stdout);
15451   if (mask & AFL_ASE_MIPS16)
15452     fputs ("\n\tMIPS16 ASE", stdout);
15453   if (mask & AFL_ASE_MICROMIPS)
15454     fputs ("\n\tMICROMIPS ASE", stdout);
15455   if (mask & AFL_ASE_XPA)
15456     fputs ("\n\tXPA ASE", stdout);
15457   if (mask & AFL_ASE_MIPS16E2)
15458     fputs ("\n\tMIPS16e2 ASE", stdout);
15459   if (mask == 0)
15460     fprintf (stdout, "\n\t%s", _("None"));
15461   else if ((mask & ~AFL_ASE_MASK) != 0)
15462     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15463 }
15464
15465 static void
15466 print_mips_isa_ext (unsigned int isa_ext)
15467 {
15468   switch (isa_ext)
15469     {
15470     case 0:
15471       fputs (_("None"), stdout);
15472       break;
15473     case AFL_EXT_XLR:
15474       fputs ("RMI XLR", stdout);
15475       break;
15476     case AFL_EXT_OCTEON3:
15477       fputs ("Cavium Networks Octeon3", stdout);
15478       break;
15479     case AFL_EXT_OCTEON2:
15480       fputs ("Cavium Networks Octeon2", stdout);
15481       break;
15482     case AFL_EXT_OCTEONP:
15483       fputs ("Cavium Networks OcteonP", stdout);
15484       break;
15485     case AFL_EXT_LOONGSON_3A:
15486       fputs ("Loongson 3A", stdout);
15487       break;
15488     case AFL_EXT_OCTEON:
15489       fputs ("Cavium Networks Octeon", stdout);
15490       break;
15491     case AFL_EXT_5900:
15492       fputs ("Toshiba R5900", stdout);
15493       break;
15494     case AFL_EXT_4650:
15495       fputs ("MIPS R4650", stdout);
15496       break;
15497     case AFL_EXT_4010:
15498       fputs ("LSI R4010", stdout);
15499       break;
15500     case AFL_EXT_4100:
15501       fputs ("NEC VR4100", stdout);
15502       break;
15503     case AFL_EXT_3900:
15504       fputs ("Toshiba R3900", stdout);
15505       break;
15506     case AFL_EXT_10000:
15507       fputs ("MIPS R10000", stdout);
15508       break;
15509     case AFL_EXT_SB1:
15510       fputs ("Broadcom SB-1", stdout);
15511       break;
15512     case AFL_EXT_4111:
15513       fputs ("NEC VR4111/VR4181", stdout);
15514       break;
15515     case AFL_EXT_4120:
15516       fputs ("NEC VR4120", stdout);
15517       break;
15518     case AFL_EXT_5400:
15519       fputs ("NEC VR5400", stdout);
15520       break;
15521     case AFL_EXT_5500:
15522       fputs ("NEC VR5500", stdout);
15523       break;
15524     case AFL_EXT_LOONGSON_2E:
15525       fputs ("ST Microelectronics Loongson 2E", stdout);
15526       break;
15527     case AFL_EXT_LOONGSON_2F:
15528       fputs ("ST Microelectronics Loongson 2F", stdout);
15529       break;
15530     case AFL_EXT_INTERAPTIV_MR2:
15531       fputs ("Imagination interAptiv MR2", stdout);
15532       break;
15533     default:
15534       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15535     }
15536 }
15537
15538 static signed int
15539 get_mips_reg_size (int reg_size)
15540 {
15541   return (reg_size == AFL_REG_NONE) ? 0
15542          : (reg_size == AFL_REG_32) ? 32
15543          : (reg_size == AFL_REG_64) ? 64
15544          : (reg_size == AFL_REG_128) ? 128
15545          : -1;
15546 }
15547
15548 static bfd_boolean
15549 process_mips_specific (Filedata * filedata)
15550 {
15551   Elf_Internal_Dyn * entry;
15552   Elf_Internal_Shdr *sect = NULL;
15553   size_t liblist_offset = 0;
15554   size_t liblistno = 0;
15555   size_t conflictsno = 0;
15556   size_t options_offset = 0;
15557   size_t conflicts_offset = 0;
15558   size_t pltrelsz = 0;
15559   size_t pltrel = 0;
15560   bfd_vma pltgot = 0;
15561   bfd_vma mips_pltgot = 0;
15562   bfd_vma jmprel = 0;
15563   bfd_vma local_gotno = 0;
15564   bfd_vma gotsym = 0;
15565   bfd_vma symtabno = 0;
15566   bfd_boolean res = TRUE;
15567
15568   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15569                             display_mips_gnu_attribute))
15570     res = FALSE;
15571
15572   sect = find_section (filedata, ".MIPS.abiflags");
15573
15574   if (sect != NULL)
15575     {
15576       Elf_External_ABIFlags_v0 *abiflags_ext;
15577       Elf_Internal_ABIFlags_v0 abiflags_in;
15578
15579       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15580         {
15581           error (_("Corrupt MIPS ABI Flags section.\n"));
15582           res = FALSE;
15583         }
15584       else
15585         {
15586           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15587                                    sect->sh_size, _("MIPS ABI Flags section"));
15588           if (abiflags_ext)
15589             {
15590               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15591               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15592               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15593               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15594               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15595               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15596               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15597               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15598               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15599               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15600               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15601
15602               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15603               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15604               if (abiflags_in.isa_rev > 1)
15605                 printf ("r%d", abiflags_in.isa_rev);
15606               printf ("\nGPR size: %d",
15607                       get_mips_reg_size (abiflags_in.gpr_size));
15608               printf ("\nCPR1 size: %d",
15609                       get_mips_reg_size (abiflags_in.cpr1_size));
15610               printf ("\nCPR2 size: %d",
15611                       get_mips_reg_size (abiflags_in.cpr2_size));
15612               fputs ("\nFP ABI: ", stdout);
15613               print_mips_fp_abi_value (abiflags_in.fp_abi);
15614               fputs ("ISA Extension: ", stdout);
15615               print_mips_isa_ext (abiflags_in.isa_ext);
15616               fputs ("\nASEs:", stdout);
15617               print_mips_ases (abiflags_in.ases);
15618               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15619               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15620               fputc ('\n', stdout);
15621               free (abiflags_ext);
15622             }
15623         }
15624     }
15625
15626   /* We have a lot of special sections.  Thanks SGI!  */
15627   if (dynamic_section == NULL)
15628     {
15629       /* No dynamic information available.  See if there is static GOT.  */
15630       sect = find_section (filedata, ".got");
15631       if (sect != NULL)
15632         {
15633           unsigned char *data_end;
15634           unsigned char *data;
15635           bfd_vma ent, end;
15636           int addr_size;
15637
15638           pltgot = sect->sh_addr;
15639
15640           ent = pltgot;
15641           addr_size = (is_32bit_elf ? 4 : 8);
15642           end = pltgot + sect->sh_size;
15643
15644           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15645                                              end - pltgot, 1,
15646                                              _("Global Offset Table data"));
15647           /* PR 12855: Null data is handled gracefully throughout.  */
15648           data_end = data + (end - pltgot);
15649
15650           printf (_("\nStatic GOT:\n"));
15651           printf (_(" Canonical gp value: "));
15652           print_vma (ent + 0x7ff0, LONG_HEX);
15653           printf ("\n\n");
15654
15655           /* In a dynamic binary GOT[0] is reserved for the dynamic
15656              loader to store the lazy resolver pointer, however in
15657              a static binary it may well have been omitted and GOT
15658              reduced to a table of addresses.
15659              PR 21344: Check for the entry being fully available
15660              before fetching it.  */
15661           if (data
15662               && data + ent - pltgot + addr_size <= data_end
15663               && byte_get (data + ent - pltgot, addr_size) == 0)
15664             {
15665               printf (_(" Reserved entries:\n"));
15666               printf (_("  %*s %10s %*s\n"),
15667                       addr_size * 2, _("Address"), _("Access"),
15668                       addr_size * 2, _("Value"));
15669               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15670               printf ("\n");
15671               if (ent == (bfd_vma) -1)
15672                 goto sgot_print_fail;
15673
15674               /* Check for the MSB of GOT[1] being set, identifying a
15675                  GNU object.  This entry will be used by some runtime
15676                  loaders, to store the module pointer.  Otherwise this
15677                  is an ordinary local entry.
15678                  PR 21344: Check for the entry being fully available
15679                  before fetching it.  */
15680               if (data
15681                   && data + ent - pltgot + addr_size <= data_end
15682                   && (byte_get (data + ent - pltgot, addr_size)
15683                       >> (addr_size * 8 - 1)) != 0)
15684                 {
15685                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15686                   printf ("\n");
15687                   if (ent == (bfd_vma) -1)
15688                     goto sgot_print_fail;
15689                 }
15690               printf ("\n");
15691             }
15692
15693           if (data != NULL && ent < end)
15694             {
15695               printf (_(" Local entries:\n"));
15696               printf ("  %*s %10s %*s\n",
15697                       addr_size * 2, _("Address"), _("Access"),
15698                       addr_size * 2, _("Value"));
15699               while (ent < end)
15700                 {
15701                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15702                   printf ("\n");
15703                   if (ent == (bfd_vma) -1)
15704                     goto sgot_print_fail;
15705                 }
15706               printf ("\n");
15707             }
15708
15709         sgot_print_fail:
15710           if (data)
15711             free (data);
15712         }
15713       return res;
15714     }
15715
15716   for (entry = dynamic_section;
15717        /* PR 17531 file: 012-50589-0.004.  */
15718        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15719        ++entry)
15720     switch (entry->d_tag)
15721       {
15722       case DT_MIPS_LIBLIST:
15723         liblist_offset
15724           = offset_from_vma (filedata, entry->d_un.d_val,
15725                              liblistno * sizeof (Elf32_External_Lib));
15726         break;
15727       case DT_MIPS_LIBLISTNO:
15728         liblistno = entry->d_un.d_val;
15729         break;
15730       case DT_MIPS_OPTIONS:
15731         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15732         break;
15733       case DT_MIPS_CONFLICT:
15734         conflicts_offset
15735           = offset_from_vma (filedata, entry->d_un.d_val,
15736                              conflictsno * sizeof (Elf32_External_Conflict));
15737         break;
15738       case DT_MIPS_CONFLICTNO:
15739         conflictsno = entry->d_un.d_val;
15740         break;
15741       case DT_PLTGOT:
15742         pltgot = entry->d_un.d_ptr;
15743         break;
15744       case DT_MIPS_LOCAL_GOTNO:
15745         local_gotno = entry->d_un.d_val;
15746         break;
15747       case DT_MIPS_GOTSYM:
15748         gotsym = entry->d_un.d_val;
15749         break;
15750       case DT_MIPS_SYMTABNO:
15751         symtabno = entry->d_un.d_val;
15752         break;
15753       case DT_MIPS_PLTGOT:
15754         mips_pltgot = entry->d_un.d_ptr;
15755         break;
15756       case DT_PLTREL:
15757         pltrel = entry->d_un.d_val;
15758         break;
15759       case DT_PLTRELSZ:
15760         pltrelsz = entry->d_un.d_val;
15761         break;
15762       case DT_JMPREL:
15763         jmprel = entry->d_un.d_ptr;
15764         break;
15765       default:
15766         break;
15767       }
15768
15769   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15770     {
15771       Elf32_External_Lib * elib;
15772       size_t cnt;
15773
15774       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15775                                               liblistno,
15776                                               sizeof (Elf32_External_Lib),
15777                                               _("liblist section data"));
15778       if (elib)
15779         {
15780           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15781                             "\nSection '.liblist' contains %lu entries:\n",
15782                             (unsigned long) liblistno),
15783                   (unsigned long) liblistno);
15784           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15785                  stdout);
15786
15787           for (cnt = 0; cnt < liblistno; ++cnt)
15788             {
15789               Elf32_Lib liblist;
15790               time_t atime;
15791               char timebuf[128];
15792               struct tm * tmp;
15793
15794               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15795               atime = BYTE_GET (elib[cnt].l_time_stamp);
15796               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15797               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15798               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15799
15800               tmp = gmtime (&atime);
15801               snprintf (timebuf, sizeof (timebuf),
15802                         "%04u-%02u-%02uT%02u:%02u:%02u",
15803                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15804                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15805
15806               printf ("%3lu: ", (unsigned long) cnt);
15807               if (VALID_DYNAMIC_NAME (liblist.l_name))
15808                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15809               else
15810                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15811               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15812                       liblist.l_version);
15813
15814               if (liblist.l_flags == 0)
15815                 puts (_(" NONE"));
15816               else
15817                 {
15818                   static const struct
15819                   {
15820                     const char * name;
15821                     int bit;
15822                   }
15823                   l_flags_vals[] =
15824                   {
15825                     { " EXACT_MATCH", LL_EXACT_MATCH },
15826                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15827                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15828                     { " EXPORTS", LL_EXPORTS },
15829                     { " DELAY_LOAD", LL_DELAY_LOAD },
15830                     { " DELTA", LL_DELTA }
15831                   };
15832                   int flags = liblist.l_flags;
15833                   size_t fcnt;
15834
15835                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15836                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15837                       {
15838                         fputs (l_flags_vals[fcnt].name, stdout);
15839                         flags ^= l_flags_vals[fcnt].bit;
15840                       }
15841                   if (flags != 0)
15842                     printf (" %#x", (unsigned int) flags);
15843
15844                   puts ("");
15845                 }
15846             }
15847
15848           free (elib);
15849         }
15850       else
15851         res = FALSE;
15852     }
15853
15854   if (options_offset != 0)
15855     {
15856       Elf_External_Options * eopt;
15857       Elf_Internal_Options * iopt;
15858       Elf_Internal_Options * option;
15859       size_t offset;
15860       int cnt;
15861       sect = filedata->section_headers;
15862
15863       /* Find the section header so that we get the size.  */
15864       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
15865       /* PR 17533 file: 012-277276-0.004.  */
15866       if (sect == NULL)
15867         {
15868           error (_("No MIPS_OPTIONS header found\n"));
15869           return FALSE;
15870         }
15871
15872       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
15873                                                 sect->sh_size, _("options"));
15874       if (eopt)
15875         {
15876           iopt = (Elf_Internal_Options *)
15877               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15878           if (iopt == NULL)
15879             {
15880               error (_("Out of memory allocating space for MIPS options\n"));
15881               return FALSE;
15882             }
15883
15884           offset = cnt = 0;
15885           option = iopt;
15886
15887           while (offset <= sect->sh_size - sizeof (* eopt))
15888             {
15889               Elf_External_Options * eoption;
15890
15891               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15892
15893               option->kind = BYTE_GET (eoption->kind);
15894               option->size = BYTE_GET (eoption->size);
15895               option->section = BYTE_GET (eoption->section);
15896               option->info = BYTE_GET (eoption->info);
15897
15898               /* PR 17531: file: ffa0fa3b.  */
15899               if (option->size < sizeof (* eopt)
15900                   || offset + option->size > sect->sh_size)
15901                 {
15902                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15903                   return FALSE;
15904                 }
15905               offset += option->size;
15906
15907               ++option;
15908               ++cnt;
15909             }
15910
15911           printf (ngettext ("\nSection '%s' contains %d entry:\n",
15912                             "\nSection '%s' contains %d entries:\n",
15913                             cnt),
15914                   printable_section_name (filedata, sect), cnt);
15915
15916           option = iopt;
15917           offset = 0;
15918
15919           while (cnt-- > 0)
15920             {
15921               size_t len;
15922
15923               switch (option->kind)
15924                 {
15925                 case ODK_NULL:
15926                   /* This shouldn't happen.  */
15927                   printf (" NULL       %d %lx", option->section, option->info);
15928                   break;
15929                 case ODK_REGINFO:
15930                   printf (" REGINFO    ");
15931                   if (filedata->file_header.e_machine == EM_MIPS)
15932                     {
15933                       /* 32bit form.  */
15934                       Elf32_External_RegInfo * ereg;
15935                       Elf32_RegInfo reginfo;
15936
15937                       ereg = (Elf32_External_RegInfo *) (option + 1);
15938                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15939                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15940                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15941                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15942                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15943                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15944
15945                       printf ("GPR %08lx  GP 0x%lx\n",
15946                               reginfo.ri_gprmask,
15947                               (unsigned long) reginfo.ri_gp_value);
15948                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15949                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15950                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15951                     }
15952                   else
15953                     {
15954                       /* 64 bit form.  */
15955                       Elf64_External_RegInfo * ereg;
15956                       Elf64_Internal_RegInfo reginfo;
15957
15958                       ereg = (Elf64_External_RegInfo *) (option + 1);
15959                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15960                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15961                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15962                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15963                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15964                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15965
15966                       printf ("GPR %08lx  GP 0x",
15967                               reginfo.ri_gprmask);
15968                       printf_vma (reginfo.ri_gp_value);
15969                       printf ("\n");
15970
15971                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15972                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15973                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15974                     }
15975                   ++option;
15976                   continue;
15977                 case ODK_EXCEPTIONS:
15978                   fputs (" EXCEPTIONS fpe_min(", stdout);
15979                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15980                   fputs (") fpe_max(", stdout);
15981                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15982                   fputs (")", stdout);
15983
15984                   if (option->info & OEX_PAGE0)
15985                     fputs (" PAGE0", stdout);
15986                   if (option->info & OEX_SMM)
15987                     fputs (" SMM", stdout);
15988                   if (option->info & OEX_FPDBUG)
15989                     fputs (" FPDBUG", stdout);
15990                   if (option->info & OEX_DISMISS)
15991                     fputs (" DISMISS", stdout);
15992                   break;
15993                 case ODK_PAD:
15994                   fputs (" PAD       ", stdout);
15995                   if (option->info & OPAD_PREFIX)
15996                     fputs (" PREFIX", stdout);
15997                   if (option->info & OPAD_POSTFIX)
15998                     fputs (" POSTFIX", stdout);
15999                   if (option->info & OPAD_SYMBOL)
16000                     fputs (" SYMBOL", stdout);
16001                   break;
16002                 case ODK_HWPATCH:
16003                   fputs (" HWPATCH   ", stdout);
16004                   if (option->info & OHW_R4KEOP)
16005                     fputs (" R4KEOP", stdout);
16006                   if (option->info & OHW_R8KPFETCH)
16007                     fputs (" R8KPFETCH", stdout);
16008                   if (option->info & OHW_R5KEOP)
16009                     fputs (" R5KEOP", stdout);
16010                   if (option->info & OHW_R5KCVTL)
16011                     fputs (" R5KCVTL", stdout);
16012                   break;
16013                 case ODK_FILL:
16014                   fputs (" FILL       ", stdout);
16015                   /* XXX Print content of info word?  */
16016                   break;
16017                 case ODK_TAGS:
16018                   fputs (" TAGS       ", stdout);
16019                   /* XXX Print content of info word?  */
16020                   break;
16021                 case ODK_HWAND:
16022                   fputs (" HWAND     ", stdout);
16023                   if (option->info & OHWA0_R4KEOP_CHECKED)
16024                     fputs (" R4KEOP_CHECKED", stdout);
16025                   if (option->info & OHWA0_R4KEOP_CLEAN)
16026                     fputs (" R4KEOP_CLEAN", stdout);
16027                   break;
16028                 case ODK_HWOR:
16029                   fputs (" HWOR      ", stdout);
16030                   if (option->info & OHWA0_R4KEOP_CHECKED)
16031                     fputs (" R4KEOP_CHECKED", stdout);
16032                   if (option->info & OHWA0_R4KEOP_CLEAN)
16033                     fputs (" R4KEOP_CLEAN", stdout);
16034                   break;
16035                 case ODK_GP_GROUP:
16036                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16037                           option->info & OGP_GROUP,
16038                           (option->info & OGP_SELF) >> 16);
16039                   break;
16040                 case ODK_IDENT:
16041                   printf (" IDENT     %#06lx  self-contained %#06lx",
16042                           option->info & OGP_GROUP,
16043                           (option->info & OGP_SELF) >> 16);
16044                   break;
16045                 default:
16046                   /* This shouldn't happen.  */
16047                   printf (" %3d ???     %d %lx",
16048                           option->kind, option->section, option->info);
16049                   break;
16050                 }
16051
16052               len = sizeof (* eopt);
16053               while (len < option->size)
16054                 {
16055                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16056
16057                   if (ISPRINT (datum))
16058                     printf ("%c", datum);
16059                   else
16060                     printf ("\\%03o", datum);
16061                   len ++;
16062                 }
16063               fputs ("\n", stdout);
16064
16065               offset += option->size;
16066               ++option;
16067             }
16068
16069           free (eopt);
16070         }
16071       else
16072         res = FALSE;
16073     }
16074
16075   if (conflicts_offset != 0 && conflictsno != 0)
16076     {
16077       Elf32_Conflict * iconf;
16078       size_t cnt;
16079
16080       if (dynamic_symbols == NULL)
16081         {
16082           error (_("conflict list found without a dynamic symbol table\n"));
16083           return FALSE;
16084         }
16085
16086       /* PR 21345 - print a slightly more helpful error message
16087          if we are sure that the cmalloc will fail.  */
16088       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16089         {
16090           error (_("Overlarge number of conflicts detected: %lx\n"),
16091                  (long) conflictsno);
16092           return FALSE;
16093         }
16094
16095       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16096       if (iconf == NULL)
16097         {
16098           error (_("Out of memory allocating space for dynamic conflicts\n"));
16099           return FALSE;
16100         }
16101
16102       if (is_32bit_elf)
16103         {
16104           Elf32_External_Conflict * econf32;
16105
16106           econf32 = (Elf32_External_Conflict *)
16107               get_data (NULL, filedata, conflicts_offset, conflictsno,
16108                         sizeof (* econf32), _("conflict"));
16109           if (!econf32)
16110             return FALSE;
16111
16112           for (cnt = 0; cnt < conflictsno; ++cnt)
16113             iconf[cnt] = BYTE_GET (econf32[cnt]);
16114
16115           free (econf32);
16116         }
16117       else
16118         {
16119           Elf64_External_Conflict * econf64;
16120
16121           econf64 = (Elf64_External_Conflict *)
16122               get_data (NULL, filedata, conflicts_offset, conflictsno,
16123                         sizeof (* econf64), _("conflict"));
16124           if (!econf64)
16125             return FALSE;
16126
16127           for (cnt = 0; cnt < conflictsno; ++cnt)
16128             iconf[cnt] = BYTE_GET (econf64[cnt]);
16129
16130           free (econf64);
16131         }
16132
16133       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16134                         "\nSection '.conflict' contains %lu entries:\n",
16135                         (unsigned long) conflictsno),
16136               (unsigned long) conflictsno);
16137       puts (_("  Num:    Index       Value  Name"));
16138
16139       for (cnt = 0; cnt < conflictsno; ++cnt)
16140         {
16141           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16142
16143           if (iconf[cnt] >= num_dynamic_syms)
16144             printf (_("<corrupt symbol index>"));
16145           else
16146             {
16147               Elf_Internal_Sym * psym;
16148
16149               psym = & dynamic_symbols[iconf[cnt]];
16150               print_vma (psym->st_value, FULL_HEX);
16151               putchar (' ');
16152               if (VALID_DYNAMIC_NAME (psym->st_name))
16153                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16154               else
16155                 printf (_("<corrupt: %14ld>"), psym->st_name);
16156             }
16157           putchar ('\n');
16158         }
16159
16160       free (iconf);
16161     }
16162
16163   if (pltgot != 0 && local_gotno != 0)
16164     {
16165       bfd_vma ent, local_end, global_end;
16166       size_t i, offset;
16167       unsigned char * data;
16168       unsigned char * data_end;
16169       int addr_size;
16170
16171       ent = pltgot;
16172       addr_size = (is_32bit_elf ? 4 : 8);
16173       local_end = pltgot + local_gotno * addr_size;
16174
16175       /* PR binutils/17533 file: 012-111227-0.004  */
16176       if (symtabno < gotsym)
16177         {
16178           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16179                  (unsigned long) gotsym, (unsigned long) symtabno);
16180           return FALSE;
16181         }
16182
16183       global_end = local_end + (symtabno - gotsym) * addr_size;
16184       /* PR 17531: file: 54c91a34.  */
16185       if (global_end < local_end)
16186         {
16187           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16188           return FALSE;
16189         }
16190
16191       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16192       data = (unsigned char *) get_data (NULL, filedata, offset,
16193                                          global_end - pltgot, 1,
16194                                          _("Global Offset Table data"));
16195       /* PR 12855: Null data is handled gracefully throughout.  */
16196       data_end = data + (global_end - pltgot);
16197
16198       printf (_("\nPrimary GOT:\n"));
16199       printf (_(" Canonical gp value: "));
16200       print_vma (pltgot + 0x7ff0, LONG_HEX);
16201       printf ("\n\n");
16202
16203       printf (_(" Reserved entries:\n"));
16204       printf (_("  %*s %10s %*s Purpose\n"),
16205               addr_size * 2, _("Address"), _("Access"),
16206               addr_size * 2, _("Initial"));
16207       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16208       printf (_(" Lazy resolver\n"));
16209       if (ent == (bfd_vma) -1)
16210         goto got_print_fail;
16211
16212       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16213          This entry will be used by some runtime loaders, to store the
16214          module pointer.  Otherwise this is an ordinary local entry.
16215          PR 21344: Check for the entry being fully available before
16216          fetching it.  */
16217       if (data
16218           && data + ent - pltgot + addr_size <= data_end
16219           && (byte_get (data + ent - pltgot, addr_size)
16220               >> (addr_size * 8 - 1)) != 0)
16221         {
16222           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16223           printf (_(" Module pointer (GNU extension)\n"));
16224           if (ent == (bfd_vma) -1)
16225             goto got_print_fail;
16226         }
16227       printf ("\n");
16228
16229       if (data != NULL && ent < local_end)
16230         {
16231           printf (_(" Local entries:\n"));
16232           printf ("  %*s %10s %*s\n",
16233                   addr_size * 2, _("Address"), _("Access"),
16234                   addr_size * 2, _("Initial"));
16235           while (ent < local_end)
16236             {
16237               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16238               printf ("\n");
16239               if (ent == (bfd_vma) -1)
16240                 goto got_print_fail;
16241             }
16242           printf ("\n");
16243         }
16244
16245       if (data != NULL && gotsym < symtabno)
16246         {
16247           int sym_width;
16248
16249           printf (_(" Global entries:\n"));
16250           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16251                   addr_size * 2, _("Address"),
16252                   _("Access"),
16253                   addr_size * 2, _("Initial"),
16254                   addr_size * 2, _("Sym.Val."),
16255                   _("Type"),
16256                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16257                   _("Ndx"), _("Name"));
16258
16259           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16260
16261           for (i = gotsym; i < symtabno; i++)
16262             {
16263               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16264               printf (" ");
16265
16266               if (dynamic_symbols == NULL)
16267                 printf (_("<no dynamic symbols>"));
16268               else if (i < num_dynamic_syms)
16269                 {
16270                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16271
16272                   print_vma (psym->st_value, LONG_HEX);
16273                   printf (" %-7s %3s ",
16274                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16275                           get_symbol_index_type (filedata, psym->st_shndx));
16276
16277                   if (VALID_DYNAMIC_NAME (psym->st_name))
16278                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16279                   else
16280                     printf (_("<corrupt: %14ld>"), psym->st_name);
16281                 }
16282               else
16283                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16284                         (unsigned long) i);
16285
16286               printf ("\n");
16287               if (ent == (bfd_vma) -1)
16288                 break;
16289             }
16290           printf ("\n");
16291         }
16292
16293     got_print_fail:
16294       if (data)
16295         free (data);
16296     }
16297
16298   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16299     {
16300       bfd_vma ent, end;
16301       size_t offset, rel_offset;
16302       unsigned long count, i;
16303       unsigned char * data;
16304       int addr_size, sym_width;
16305       Elf_Internal_Rela * rels;
16306
16307       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16308       if (pltrel == DT_RELA)
16309         {
16310           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16311             return FALSE;
16312         }
16313       else
16314         {
16315           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16316             return FALSE;
16317         }
16318
16319       ent = mips_pltgot;
16320       addr_size = (is_32bit_elf ? 4 : 8);
16321       end = mips_pltgot + (2 + count) * addr_size;
16322
16323       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16324       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16325                                          1, _("Procedure Linkage Table data"));
16326       if (data == NULL)
16327         return FALSE;
16328
16329       printf ("\nPLT GOT:\n\n");
16330       printf (_(" Reserved entries:\n"));
16331       printf (_("  %*s %*s Purpose\n"),
16332               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16333       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16334       printf (_(" PLT lazy resolver\n"));
16335       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16336       printf (_(" Module pointer\n"));
16337       printf ("\n");
16338
16339       printf (_(" Entries:\n"));
16340       printf ("  %*s %*s %*s %-7s %3s %s\n",
16341               addr_size * 2, _("Address"),
16342               addr_size * 2, _("Initial"),
16343               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16344       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16345       for (i = 0; i < count; i++)
16346         {
16347           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16348
16349           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16350           printf (" ");
16351
16352           if (idx >= num_dynamic_syms)
16353             printf (_("<corrupt symbol index: %lu>"), idx);
16354           else
16355             {
16356               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16357
16358               print_vma (psym->st_value, LONG_HEX);
16359               printf (" %-7s %3s ",
16360                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16361                       get_symbol_index_type (filedata, psym->st_shndx));
16362               if (VALID_DYNAMIC_NAME (psym->st_name))
16363                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16364               else
16365                 printf (_("<corrupt: %14ld>"), psym->st_name);
16366             }
16367           printf ("\n");
16368         }
16369       printf ("\n");
16370
16371       if (data)
16372         free (data);
16373       free (rels);
16374     }
16375
16376   return res;
16377 }
16378
16379 static bfd_boolean
16380 process_nds32_specific (Filedata * filedata)
16381 {
16382   Elf_Internal_Shdr *sect = NULL;
16383
16384   sect = find_section (filedata, ".nds32_e_flags");
16385   if (sect != NULL)
16386     {
16387       unsigned int *flag;
16388
16389       printf ("\nNDS32 elf flags section:\n");
16390       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16391                        sect->sh_size, _("NDS32 elf flags section"));
16392
16393       if (! flag)
16394         return FALSE;
16395
16396       switch ((*flag) & 0x3)
16397         {
16398         case 0:
16399           printf ("(VEC_SIZE):\tNo entry.\n");
16400           break;
16401         case 1:
16402           printf ("(VEC_SIZE):\t4 bytes\n");
16403           break;
16404         case 2:
16405           printf ("(VEC_SIZE):\t16 bytes\n");
16406           break;
16407         case 3:
16408           printf ("(VEC_SIZE):\treserved\n");
16409           break;
16410         }
16411     }
16412
16413   return TRUE;
16414 }
16415
16416 static bfd_boolean
16417 process_gnu_liblist (Filedata * filedata)
16418 {
16419   Elf_Internal_Shdr * section;
16420   Elf_Internal_Shdr * string_sec;
16421   Elf32_External_Lib * elib;
16422   char * strtab;
16423   size_t strtab_size;
16424   size_t cnt;
16425   unsigned long num_liblist;
16426   unsigned i;
16427   bfd_boolean res = TRUE;
16428
16429   if (! do_arch)
16430     return TRUE;
16431
16432   for (i = 0, section = filedata->section_headers;
16433        i < filedata->file_header.e_shnum;
16434        i++, section++)
16435     {
16436       switch (section->sh_type)
16437         {
16438         case SHT_GNU_LIBLIST:
16439           if (section->sh_link >= filedata->file_header.e_shnum)
16440             break;
16441
16442           elib = (Elf32_External_Lib *)
16443               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16444                         _("liblist section data"));
16445
16446           if (elib == NULL)
16447             {
16448               res = FALSE;
16449               break;
16450             }
16451
16452           string_sec = filedata->section_headers + section->sh_link;
16453           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16454                                       string_sec->sh_size,
16455                                       _("liblist string table"));
16456           if (strtab == NULL
16457               || section->sh_entsize != sizeof (Elf32_External_Lib))
16458             {
16459               free (elib);
16460               free (strtab);
16461               res = FALSE;
16462               break;
16463             }
16464           strtab_size = string_sec->sh_size;
16465
16466           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16467           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16468                             "\nLibrary list section '%s' contains %lu entries:\n",
16469                             num_liblist),
16470                   printable_section_name (filedata, section),
16471                   num_liblist);
16472
16473           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16474
16475           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16476                ++cnt)
16477             {
16478               Elf32_Lib liblist;
16479               time_t atime;
16480               char timebuf[128];
16481               struct tm * tmp;
16482
16483               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16484               atime = BYTE_GET (elib[cnt].l_time_stamp);
16485               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16486               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16487               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16488
16489               tmp = gmtime (&atime);
16490               snprintf (timebuf, sizeof (timebuf),
16491                         "%04u-%02u-%02uT%02u:%02u:%02u",
16492                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16493                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16494
16495               printf ("%3lu: ", (unsigned long) cnt);
16496               if (do_wide)
16497                 printf ("%-20s", liblist.l_name < strtab_size
16498                         ? strtab + liblist.l_name : _("<corrupt>"));
16499               else
16500                 printf ("%-20.20s", liblist.l_name < strtab_size
16501                         ? strtab + liblist.l_name : _("<corrupt>"));
16502               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16503                       liblist.l_version, liblist.l_flags);
16504             }
16505
16506           free (elib);
16507           free (strtab);
16508         }
16509     }
16510
16511   return res;
16512 }
16513
16514 static const char *
16515 get_note_type (Filedata * filedata, unsigned e_type)
16516 {
16517   static char buff[64];
16518
16519   if (filedata->file_header.e_type == ET_CORE)
16520     switch (e_type)
16521       {
16522       case NT_AUXV:
16523         return _("NT_AUXV (auxiliary vector)");
16524       case NT_PRSTATUS:
16525         return _("NT_PRSTATUS (prstatus structure)");
16526       case NT_FPREGSET:
16527         return _("NT_FPREGSET (floating point registers)");
16528       case NT_PRPSINFO:
16529         return _("NT_PRPSINFO (prpsinfo structure)");
16530       case NT_TASKSTRUCT:
16531         return _("NT_TASKSTRUCT (task structure)");
16532       case NT_PRXFPREG:
16533         return _("NT_PRXFPREG (user_xfpregs structure)");
16534       case NT_PPC_VMX:
16535         return _("NT_PPC_VMX (ppc Altivec registers)");
16536       case NT_PPC_VSX:
16537         return _("NT_PPC_VSX (ppc VSX registers)");
16538       case NT_PPC_TAR:
16539         return _("NT_PPC_TAR (ppc TAR register)");
16540       case NT_PPC_PPR:
16541         return _("NT_PPC_PPR (ppc PPR register)");
16542       case NT_PPC_DSCR:
16543         return _("NT_PPC_DSCR (ppc DSCR register)");
16544       case NT_PPC_EBB:
16545         return _("NT_PPC_EBB (ppc EBB registers)");
16546       case NT_PPC_PMU:
16547         return _("NT_PPC_PMU (ppc PMU registers)");
16548       case NT_PPC_TM_CGPR:
16549         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16550       case NT_PPC_TM_CFPR:
16551         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16552       case NT_PPC_TM_CVMX:
16553         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16554       case NT_PPC_TM_CVSX:
16555         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16556       case NT_PPC_TM_SPR:
16557         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16558       case NT_PPC_TM_CTAR:
16559         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16560       case NT_PPC_TM_CPPR:
16561         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16562       case NT_PPC_TM_CDSCR:
16563         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16564       case NT_386_TLS:
16565         return _("NT_386_TLS (x86 TLS information)");
16566       case NT_386_IOPERM:
16567         return _("NT_386_IOPERM (x86 I/O permissions)");
16568       case NT_X86_XSTATE:
16569         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16570       case NT_S390_HIGH_GPRS:
16571         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16572       case NT_S390_TIMER:
16573         return _("NT_S390_TIMER (s390 timer register)");
16574       case NT_S390_TODCMP:
16575         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16576       case NT_S390_TODPREG:
16577         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16578       case NT_S390_CTRS:
16579         return _("NT_S390_CTRS (s390 control registers)");
16580       case NT_S390_PREFIX:
16581         return _("NT_S390_PREFIX (s390 prefix register)");
16582       case NT_S390_LAST_BREAK:
16583         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16584       case NT_S390_SYSTEM_CALL:
16585         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16586       case NT_S390_TDB:
16587         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16588       case NT_S390_VXRS_LOW:
16589         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16590       case NT_S390_VXRS_HIGH:
16591         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16592       case NT_S390_GS_CB:
16593         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16594       case NT_S390_GS_BC:
16595         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16596       case NT_ARM_VFP:
16597         return _("NT_ARM_VFP (arm VFP registers)");
16598       case NT_ARM_TLS:
16599         return _("NT_ARM_TLS (AArch TLS registers)");
16600       case NT_ARM_HW_BREAK:
16601         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16602       case NT_ARM_HW_WATCH:
16603         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16604       case NT_PSTATUS:
16605         return _("NT_PSTATUS (pstatus structure)");
16606       case NT_FPREGS:
16607         return _("NT_FPREGS (floating point registers)");
16608       case NT_PSINFO:
16609         return _("NT_PSINFO (psinfo structure)");
16610       case NT_LWPSTATUS:
16611         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16612       case NT_LWPSINFO:
16613         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16614       case NT_WIN32PSTATUS:
16615         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16616       case NT_SIGINFO:
16617         return _("NT_SIGINFO (siginfo_t data)");
16618       case NT_FILE:
16619         return _("NT_FILE (mapped files)");
16620       default:
16621         break;
16622       }
16623   else
16624     switch (e_type)
16625       {
16626       case NT_VERSION:
16627         return _("NT_VERSION (version)");
16628       case NT_ARCH:
16629         return _("NT_ARCH (architecture)");
16630       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16631         return _("OPEN");
16632       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16633         return _("func");
16634       default:
16635         break;
16636       }
16637
16638   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16639   return buff;
16640 }
16641
16642 static bfd_boolean
16643 print_core_note (Elf_Internal_Note *pnote)
16644 {
16645   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16646   bfd_vma count, page_size;
16647   unsigned char *descdata, *filenames, *descend;
16648
16649   if (pnote->type != NT_FILE)
16650     {
16651       if (do_wide)
16652         printf ("\n");
16653       return TRUE;
16654     }
16655
16656 #ifndef BFD64
16657   if (!is_32bit_elf)
16658     {
16659       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16660       /* Still "successful".  */
16661       return TRUE;
16662     }
16663 #endif
16664
16665   if (pnote->descsz < 2 * addr_size)
16666     {
16667       error (_("    Malformed note - too short for header\n"));
16668       return FALSE;
16669     }
16670
16671   descdata = (unsigned char *) pnote->descdata;
16672   descend = descdata + pnote->descsz;
16673
16674   if (descdata[pnote->descsz - 1] != '\0')
16675     {
16676       error (_("    Malformed note - does not end with \\0\n"));
16677       return FALSE;
16678     }
16679
16680   count = byte_get (descdata, addr_size);
16681   descdata += addr_size;
16682
16683   page_size = byte_get (descdata, addr_size);
16684   descdata += addr_size;
16685
16686   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16687       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16688     {
16689       error (_("    Malformed note - too short for supplied file count\n"));
16690       return FALSE;
16691     }
16692
16693   printf (_("    Page size: "));
16694   print_vma (page_size, DEC);
16695   printf ("\n");
16696
16697   printf (_("    %*s%*s%*s\n"),
16698           (int) (2 + 2 * addr_size), _("Start"),
16699           (int) (4 + 2 * addr_size), _("End"),
16700           (int) (4 + 2 * addr_size), _("Page Offset"));
16701   filenames = descdata + count * 3 * addr_size;
16702   while (count-- > 0)
16703     {
16704       bfd_vma start, end, file_ofs;
16705
16706       if (filenames == descend)
16707         {
16708           error (_("    Malformed note - filenames end too early\n"));
16709           return FALSE;
16710         }
16711
16712       start = byte_get (descdata, addr_size);
16713       descdata += addr_size;
16714       end = byte_get (descdata, addr_size);
16715       descdata += addr_size;
16716       file_ofs = byte_get (descdata, addr_size);
16717       descdata += addr_size;
16718
16719       printf ("    ");
16720       print_vma (start, FULL_HEX);
16721       printf ("  ");
16722       print_vma (end, FULL_HEX);
16723       printf ("  ");
16724       print_vma (file_ofs, FULL_HEX);
16725       printf ("\n        %s\n", filenames);
16726
16727       filenames += 1 + strlen ((char *) filenames);
16728     }
16729
16730   return TRUE;
16731 }
16732
16733 static const char *
16734 get_gnu_elf_note_type (unsigned e_type)
16735 {
16736   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16737   switch (e_type)
16738     {
16739     case NT_GNU_ABI_TAG:
16740       return _("NT_GNU_ABI_TAG (ABI version tag)");
16741     case NT_GNU_HWCAP:
16742       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16743     case NT_GNU_BUILD_ID:
16744       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16745     case NT_GNU_GOLD_VERSION:
16746       return _("NT_GNU_GOLD_VERSION (gold version)");
16747     case NT_GNU_PROPERTY_TYPE_0:
16748       return _("NT_GNU_PROPERTY_TYPE_0");
16749     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16750       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16751     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16752       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16753     default:
16754       {
16755         static char buff[64];
16756
16757         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16758         return buff;
16759       }
16760     }
16761 }
16762
16763 static void
16764 decode_x86_isa (unsigned int bitmask)
16765 {
16766   while (bitmask)
16767     {
16768       unsigned int bit = bitmask & (- bitmask);
16769
16770       bitmask &= ~ bit;
16771       switch (bit)
16772         {
16773         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16774         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16775         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16776         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16777         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16778         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16779         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16780         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16781         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16782         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16783         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16784         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16785         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16786         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16787         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16788         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16789         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16790         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16791         default: printf (_("<unknown: %x>"), bit); break;
16792         }
16793       if (bitmask)
16794         printf (", ");
16795     }
16796 }
16797
16798 static void
16799 decode_x86_feature (unsigned int type, unsigned int bitmask)
16800 {
16801   while (bitmask)
16802     {
16803       unsigned int bit = bitmask & (- bitmask);
16804
16805       bitmask &= ~ bit;
16806       switch (bit)
16807         {
16808         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16809           switch (type)
16810             {
16811             case GNU_PROPERTY_X86_FEATURE_1_AND:
16812               printf ("IBT");
16813               break;
16814             default:
16815               /* This should never happen.  */
16816               abort ();
16817             }
16818           break;
16819         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16820           switch (type)
16821             {
16822             case GNU_PROPERTY_X86_FEATURE_1_AND:
16823               printf ("SHSTK");
16824               break;
16825             default:
16826               /* This should never happen.  */
16827               abort ();
16828             }
16829           break;
16830         default:
16831           printf (_("<unknown: %x>"), bit);
16832           break;
16833         }
16834       if (bitmask)
16835         printf (", ");
16836     }
16837 }
16838
16839 static void
16840 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
16841 {
16842   unsigned char * ptr = (unsigned char *) pnote->descdata;
16843   unsigned char * ptr_end = ptr + pnote->descsz;
16844   unsigned int    size = is_32bit_elf ? 4 : 8;
16845
16846   printf (_("      Properties: "));
16847
16848   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16849     {
16850       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16851       return;
16852     }
16853
16854   while (ptr < ptr_end)
16855     {
16856       unsigned int j;
16857       unsigned int type;
16858       unsigned int datasz;
16859
16860       if ((size_t) (ptr_end - ptr) < 8)
16861         {
16862           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16863           break;
16864         }
16865
16866       type = byte_get (ptr, 4);
16867       datasz = byte_get (ptr + 4, 4);
16868
16869       ptr += 8;
16870
16871       if (datasz > (size_t) (ptr_end - ptr))
16872         {
16873           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16874                   type, datasz);
16875           break;
16876         }
16877
16878       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16879         {
16880           if (filedata->file_header.e_machine == EM_X86_64
16881               || filedata->file_header.e_machine == EM_IAMCU
16882               || filedata->file_header.e_machine == EM_386)
16883             {
16884               switch (type)
16885                 {
16886                 case GNU_PROPERTY_X86_ISA_1_USED:
16887                   printf ("x86 ISA used: ");
16888                   if (datasz != 4)
16889                     printf (_("<corrupt length: %#x> "), datasz);
16890                   else
16891                     decode_x86_isa (byte_get (ptr, 4));
16892                   goto next;
16893
16894                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16895                   printf ("x86 ISA needed: ");
16896                   if (datasz != 4)
16897                     printf (_("<corrupt length: %#x> "), datasz);
16898                   else
16899                     decode_x86_isa (byte_get (ptr, 4));
16900                   goto next;
16901
16902                 case GNU_PROPERTY_X86_FEATURE_1_AND:
16903                   printf ("x86 feature: ");
16904                   if (datasz != 4)
16905                     printf (_("<corrupt length: %#x> "), datasz);
16906                   else
16907                     decode_x86_feature (type, byte_get (ptr, 4));
16908                   goto next;
16909
16910                 default:
16911                   break;
16912                 }
16913             }
16914         }
16915       else
16916         {
16917           switch (type)
16918             {
16919             case GNU_PROPERTY_STACK_SIZE:
16920               printf (_("stack size: "));
16921               if (datasz != size)
16922                 printf (_("<corrupt length: %#x> "), datasz);
16923               else
16924                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16925               goto next;
16926
16927             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16928               printf ("no copy on protected ");
16929               if (datasz)
16930                 printf (_("<corrupt length: %#x> "), datasz);
16931               goto next;
16932
16933             default:
16934               break;
16935             }
16936         }
16937
16938       if (type < GNU_PROPERTY_LOPROC)
16939         printf (_("<unknown type %#x data: "), type);
16940       else if (type < GNU_PROPERTY_LOUSER)
16941         printf (_("<procesor-specific type %#x data: "), type);
16942       else
16943         printf (_("<application-specific type %#x data: "), type);
16944       for (j = 0; j < datasz; ++j)
16945         printf ("%02x ", ptr[j] & 0xff);
16946       printf (">");
16947
16948 next:
16949       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16950       if (ptr == ptr_end)
16951         break;
16952
16953       if (do_wide)
16954         printf (", ");
16955       else
16956         printf ("\n\t");
16957     }
16958
16959   printf ("\n");
16960 }
16961
16962 static bfd_boolean
16963 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
16964 {
16965   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16966   switch (pnote->type)
16967     {
16968     case NT_GNU_BUILD_ID:
16969       {
16970         unsigned long i;
16971
16972         printf (_("    Build ID: "));
16973         for (i = 0; i < pnote->descsz; ++i)
16974           printf ("%02x", pnote->descdata[i] & 0xff);
16975         printf ("\n");
16976       }
16977       break;
16978
16979     case NT_GNU_ABI_TAG:
16980       {
16981         unsigned long os, major, minor, subminor;
16982         const char *osname;
16983
16984         /* PR 17531: file: 030-599401-0.004.  */
16985         if (pnote->descsz < 16)
16986           {
16987             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16988             break;
16989           }
16990
16991         os = byte_get ((unsigned char *) pnote->descdata, 4);
16992         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16993         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16994         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16995
16996         switch (os)
16997           {
16998           case GNU_ABI_TAG_LINUX:
16999             osname = "Linux";
17000             break;
17001           case GNU_ABI_TAG_HURD:
17002             osname = "Hurd";
17003             break;
17004           case GNU_ABI_TAG_SOLARIS:
17005             osname = "Solaris";
17006             break;
17007           case GNU_ABI_TAG_FREEBSD:
17008             osname = "FreeBSD";
17009             break;
17010           case GNU_ABI_TAG_NETBSD:
17011             osname = "NetBSD";
17012             break;
17013           case GNU_ABI_TAG_SYLLABLE:
17014             osname = "Syllable";
17015             break;
17016           case GNU_ABI_TAG_NACL:
17017             osname = "NaCl";
17018             break;
17019           default:
17020             osname = "Unknown";
17021             break;
17022           }
17023
17024         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17025                 major, minor, subminor);
17026       }
17027       break;
17028
17029     case NT_GNU_GOLD_VERSION:
17030       {
17031         unsigned long i;
17032
17033         printf (_("    Version: "));
17034         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17035           printf ("%c", pnote->descdata[i]);
17036         printf ("\n");
17037       }
17038       break;
17039
17040     case NT_GNU_HWCAP:
17041       {
17042         unsigned long num_entries, mask;
17043
17044         /* Hardware capabilities information.  Word 0 is the number of entries.
17045            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17046            is a series of entries, where each entry is a single byte followed
17047            by a nul terminated string.  The byte gives the bit number to test
17048            if enabled in the bitmask.  */
17049         printf (_("      Hardware Capabilities: "));
17050         if (pnote->descsz < 8)
17051           {
17052             error (_("<corrupt GNU_HWCAP>\n"));
17053             return FALSE;
17054           }
17055         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17056         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17057         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17058         /* FIXME: Add code to display the entries... */
17059       }
17060       break;
17061
17062     case NT_GNU_PROPERTY_TYPE_0:
17063       print_gnu_property_note (filedata, pnote);
17064       break;
17065
17066     default:
17067       /* Handle unrecognised types.  An error message should have already been
17068          created by get_gnu_elf_note_type(), so all that we need to do is to
17069          display the data.  */
17070       {
17071         unsigned long i;
17072
17073         printf (_("    Description data: "));
17074         for (i = 0; i < pnote->descsz; ++i)
17075           printf ("%02x ", pnote->descdata[i] & 0xff);
17076         printf ("\n");
17077       }
17078       break;
17079     }
17080
17081   return TRUE;
17082 }
17083
17084 static const char *
17085 get_v850_elf_note_type (enum v850_notes n_type)
17086 {
17087   static char buff[64];
17088
17089   switch (n_type)
17090     {
17091     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17092     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17093     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17094     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17095     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17096     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17097     default:
17098       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17099       return buff;
17100     }
17101 }
17102
17103 static bfd_boolean
17104 print_v850_note (Elf_Internal_Note * pnote)
17105 {
17106   unsigned int val;
17107
17108   if (pnote->descsz != 4)
17109     return FALSE;
17110
17111   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17112
17113   if (val == 0)
17114     {
17115       printf (_("not set\n"));
17116       return TRUE;
17117     }
17118
17119   switch (pnote->type)
17120     {
17121     case V850_NOTE_ALIGNMENT:
17122       switch (val)
17123         {
17124         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17125         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17126         }
17127       break;
17128
17129     case V850_NOTE_DATA_SIZE:
17130       switch (val)
17131         {
17132         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17133         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17134         }
17135       break;
17136
17137     case V850_NOTE_FPU_INFO:
17138       switch (val)
17139         {
17140         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17141         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17142         }
17143       break;
17144
17145     case V850_NOTE_MMU_INFO:
17146     case V850_NOTE_CACHE_INFO:
17147     case V850_NOTE_SIMD_INFO:
17148       if (val == EF_RH850_SIMD)
17149         {
17150           printf (_("yes\n"));
17151           return TRUE;
17152         }
17153       break;
17154
17155     default:
17156       /* An 'unknown note type' message will already have been displayed.  */
17157       break;
17158     }
17159
17160   printf (_("unknown value: %x\n"), val);
17161   return FALSE;
17162 }
17163
17164 static bfd_boolean
17165 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17166 {
17167   unsigned int version;
17168
17169   switch (pnote->type)
17170     {
17171     case NT_NETBSD_IDENT:
17172       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17173       if ((version / 10000) % 100)
17174         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17175                 version, version / 100000000, (version / 1000000) % 100,
17176                 (version / 10000) % 100 > 26 ? "Z" : "",
17177                 'A' + (version / 10000) % 26);
17178       else
17179         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17180                 version, version / 100000000, (version / 1000000) % 100,
17181                 (version / 100) % 100);
17182       return TRUE;
17183
17184     case NT_NETBSD_MARCH:
17185       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17186               pnote->descdata);
17187       return TRUE;
17188
17189     default:
17190       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17191               pnote->type);
17192       return FALSE;
17193     }
17194 }
17195
17196 static const char *
17197 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17198 {
17199   switch (e_type)
17200     {
17201     case NT_FREEBSD_THRMISC:
17202       return _("NT_THRMISC (thrmisc structure)");
17203     case NT_FREEBSD_PROCSTAT_PROC:
17204       return _("NT_PROCSTAT_PROC (proc data)");
17205     case NT_FREEBSD_PROCSTAT_FILES:
17206       return _("NT_PROCSTAT_FILES (files data)");
17207     case NT_FREEBSD_PROCSTAT_VMMAP:
17208       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17209     case NT_FREEBSD_PROCSTAT_GROUPS:
17210       return _("NT_PROCSTAT_GROUPS (groups data)");
17211     case NT_FREEBSD_PROCSTAT_UMASK:
17212       return _("NT_PROCSTAT_UMASK (umask data)");
17213     case NT_FREEBSD_PROCSTAT_RLIMIT:
17214       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17215     case NT_FREEBSD_PROCSTAT_OSREL:
17216       return _("NT_PROCSTAT_OSREL (osreldate data)");
17217     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17218       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17219     case NT_FREEBSD_PROCSTAT_AUXV:
17220       return _("NT_PROCSTAT_AUXV (auxv data)");
17221     case NT_FREEBSD_PTLWPINFO:
17222       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17223     }
17224   return get_note_type (filedata, e_type);
17225 }
17226
17227 static const char *
17228 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17229 {
17230   static char buff[64];
17231
17232   if (e_type == NT_NETBSDCORE_PROCINFO)
17233     return _("NetBSD procinfo structure");
17234
17235   /* As of Jan 2002 there are no other machine-independent notes
17236      defined for NetBSD core files.  If the note type is less
17237      than the start of the machine-dependent note types, we don't
17238      understand it.  */
17239
17240   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17241     {
17242       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17243       return buff;
17244     }
17245
17246   switch (filedata->file_header.e_machine)
17247     {
17248     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17249        and PT_GETFPREGS == mach+2.  */
17250
17251     case EM_OLD_ALPHA:
17252     case EM_ALPHA:
17253     case EM_SPARC:
17254     case EM_SPARC32PLUS:
17255     case EM_SPARCV9:
17256       switch (e_type)
17257         {
17258         case NT_NETBSDCORE_FIRSTMACH + 0:
17259           return _("PT_GETREGS (reg structure)");
17260         case NT_NETBSDCORE_FIRSTMACH + 2:
17261           return _("PT_GETFPREGS (fpreg structure)");
17262         default:
17263           break;
17264         }
17265       break;
17266
17267     /* On all other arch's, PT_GETREGS == mach+1 and
17268        PT_GETFPREGS == mach+3.  */
17269     default:
17270       switch (e_type)
17271         {
17272         case NT_NETBSDCORE_FIRSTMACH + 1:
17273           return _("PT_GETREGS (reg structure)");
17274         case NT_NETBSDCORE_FIRSTMACH + 3:
17275           return _("PT_GETFPREGS (fpreg structure)");
17276         default:
17277           break;
17278         }
17279     }
17280
17281   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17282             e_type - NT_NETBSDCORE_FIRSTMACH);
17283   return buff;
17284 }
17285
17286 static const char *
17287 get_stapsdt_note_type (unsigned e_type)
17288 {
17289   static char buff[64];
17290
17291   switch (e_type)
17292     {
17293     case NT_STAPSDT:
17294       return _("NT_STAPSDT (SystemTap probe descriptors)");
17295
17296     default:
17297       break;
17298     }
17299
17300   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17301   return buff;
17302 }
17303
17304 static bfd_boolean
17305 print_stapsdt_note (Elf_Internal_Note *pnote)
17306 {
17307   int addr_size = is_32bit_elf ? 4 : 8;
17308   char *data = pnote->descdata;
17309   char *data_end = pnote->descdata + pnote->descsz;
17310   bfd_vma pc, base_addr, semaphore;
17311   char *provider, *probe, *arg_fmt;
17312
17313   pc = byte_get ((unsigned char *) data, addr_size);
17314   data += addr_size;
17315   base_addr = byte_get ((unsigned char *) data, addr_size);
17316   data += addr_size;
17317   semaphore = byte_get ((unsigned char *) data, addr_size);
17318   data += addr_size;
17319
17320   provider = data;
17321   data += strlen (data) + 1;
17322   probe = data;
17323   data += strlen (data) + 1;
17324   arg_fmt = data;
17325   data += strlen (data) + 1;
17326
17327   printf (_("    Provider: %s\n"), provider);
17328   printf (_("    Name: %s\n"), probe);
17329   printf (_("    Location: "));
17330   print_vma (pc, FULL_HEX);
17331   printf (_(", Base: "));
17332   print_vma (base_addr, FULL_HEX);
17333   printf (_(", Semaphore: "));
17334   print_vma (semaphore, FULL_HEX);
17335   printf ("\n");
17336   printf (_("    Arguments: %s\n"), arg_fmt);
17337
17338   return data == data_end;
17339 }
17340
17341 static const char *
17342 get_ia64_vms_note_type (unsigned e_type)
17343 {
17344   static char buff[64];
17345
17346   switch (e_type)
17347     {
17348     case NT_VMS_MHD:
17349       return _("NT_VMS_MHD (module header)");
17350     case NT_VMS_LNM:
17351       return _("NT_VMS_LNM (language name)");
17352     case NT_VMS_SRC:
17353       return _("NT_VMS_SRC (source files)");
17354     case NT_VMS_TITLE:
17355       return "NT_VMS_TITLE";
17356     case NT_VMS_EIDC:
17357       return _("NT_VMS_EIDC (consistency check)");
17358     case NT_VMS_FPMODE:
17359       return _("NT_VMS_FPMODE (FP mode)");
17360     case NT_VMS_LINKTIME:
17361       return "NT_VMS_LINKTIME";
17362     case NT_VMS_IMGNAM:
17363       return _("NT_VMS_IMGNAM (image name)");
17364     case NT_VMS_IMGID:
17365       return _("NT_VMS_IMGID (image id)");
17366     case NT_VMS_LINKID:
17367       return _("NT_VMS_LINKID (link id)");
17368     case NT_VMS_IMGBID:
17369       return _("NT_VMS_IMGBID (build id)");
17370     case NT_VMS_GSTNAM:
17371       return _("NT_VMS_GSTNAM (sym table name)");
17372     case NT_VMS_ORIG_DYN:
17373       return "NT_VMS_ORIG_DYN";
17374     case NT_VMS_PATCHTIME:
17375       return "NT_VMS_PATCHTIME";
17376     default:
17377       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17378       return buff;
17379     }
17380 }
17381
17382 static bfd_boolean
17383 print_ia64_vms_note (Elf_Internal_Note * pnote)
17384 {
17385   switch (pnote->type)
17386     {
17387     case NT_VMS_MHD:
17388       if (pnote->descsz > 36)
17389         {
17390           size_t l = strlen (pnote->descdata + 34);
17391           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17392           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17393           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17394           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17395         }
17396       else
17397         printf (_("    Invalid size\n"));
17398       break;
17399     case NT_VMS_LNM:
17400       printf (_("   Language: %s\n"), pnote->descdata);
17401       break;
17402 #ifdef BFD64
17403     case NT_VMS_FPMODE:
17404       printf (_("   Floating Point mode: "));
17405       printf ("0x%016" BFD_VMA_FMT "x\n",
17406               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17407       break;
17408     case NT_VMS_LINKTIME:
17409       printf (_("   Link time: "));
17410       print_vms_time
17411         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17412       printf ("\n");
17413       break;
17414     case NT_VMS_PATCHTIME:
17415       printf (_("   Patch time: "));
17416       print_vms_time
17417         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17418       printf ("\n");
17419       break;
17420     case NT_VMS_ORIG_DYN:
17421       printf (_("   Major id: %u,  minor id: %u\n"),
17422               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17423               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17424       printf (_("   Last modified  : "));
17425       print_vms_time
17426         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17427       printf (_("\n   Link flags  : "));
17428       printf ("0x%016" BFD_VMA_FMT "x\n",
17429               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17430       printf (_("   Header flags: 0x%08x\n"),
17431               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17432       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17433       break;
17434 #endif
17435     case NT_VMS_IMGNAM:
17436       printf (_("    Image name: %s\n"), pnote->descdata);
17437       break;
17438     case NT_VMS_GSTNAM:
17439       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17440       break;
17441     case NT_VMS_IMGID:
17442       printf (_("    Image id: %s\n"), pnote->descdata);
17443       break;
17444     case NT_VMS_LINKID:
17445       printf (_("    Linker id: %s\n"), pnote->descdata);
17446       break;
17447     default:
17448       return FALSE;
17449     }
17450   return TRUE;
17451 }
17452
17453 /* Find the symbol associated with a build attribute that is attached
17454    to address OFFSET.  If PNAME is non-NULL then store the name of
17455    the symbol (if found) in the provided pointer,  Returns NULL if a
17456    symbol could not be found.  */
17457
17458 static Elf_Internal_Sym *
17459 get_symbol_for_build_attribute (Filedata *       filedata,
17460                                 unsigned long    offset,
17461                                 bfd_boolean      is_open_attr,
17462                                 const char **    pname)
17463 {
17464   static Filedata *         saved_filedata = NULL;
17465   static char *             strtab;
17466   static unsigned long      strtablen;
17467   static Elf_Internal_Sym * symtab;
17468   static unsigned long      nsyms;
17469   Elf_Internal_Sym *        saved_sym = NULL;
17470   Elf_Internal_Sym *        sym;
17471
17472   if (filedata->section_headers != NULL
17473       && (saved_filedata == NULL || filedata != saved_filedata))
17474     {
17475       Elf_Internal_Shdr * symsec;
17476
17477       /* Load the symbol and string sections.  */
17478       for (symsec = filedata->section_headers;
17479            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17480            symsec ++)
17481         {
17482           if (symsec->sh_type == SHT_SYMTAB)
17483             {
17484               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17485
17486               if (symsec->sh_link < filedata->file_header.e_shnum)
17487                 {
17488                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17489
17490                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17491                                               1, strtab_sec->sh_size,
17492                                               _("string table"));
17493                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17494                 }
17495             }
17496         }
17497       saved_filedata = filedata;
17498     }
17499
17500   if (symtab == NULL || strtab == NULL)
17501     return NULL;
17502
17503   /* Find a symbol whose value matches offset.  */
17504   for (sym = symtab; sym < symtab + nsyms; sym ++)
17505     if (sym->st_value == offset)
17506       {
17507         if (sym->st_name >= strtablen)
17508           /* Huh ?  This should not happen.  */
17509           continue;
17510
17511         if (strtab[sym->st_name] == 0)
17512           continue;
17513
17514         /* The AArch64 and ARM architectures define mapping symbols
17515            (eg $d, $x, $t) which we want to ignore.  */
17516         if (strtab[sym->st_name] == '$'
17517             && strtab[sym->st_name + 1] != 0
17518             && strtab[sym->st_name + 2] == 0)
17519           continue;
17520
17521         if (is_open_attr)
17522           {
17523             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17524                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17525                FUNC symbols entirely.  */
17526             switch (ELF_ST_TYPE (sym->st_info))
17527               {
17528               case STT_OBJECT:
17529               case STT_FILE:
17530                 saved_sym = sym;
17531                 if (sym->st_size)
17532                   {
17533                     /* If the symbol has a size associated
17534                        with it then we can stop searching.  */
17535                     sym = symtab + nsyms;
17536                   }
17537                 continue;
17538
17539               case STT_FUNC:
17540                 /* Ignore function symbols.  */
17541                 continue;
17542
17543               default:
17544                 break;
17545               }
17546
17547             switch (ELF_ST_BIND (sym->st_info))
17548               {
17549               case STB_GLOBAL:
17550                 if (saved_sym == NULL
17551                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17552                   saved_sym = sym;
17553                 break;
17554
17555               case STB_LOCAL:
17556                 if (saved_sym == NULL)
17557                   saved_sym = sym;
17558                 break;
17559
17560               default:
17561                 break;
17562               }
17563           }
17564         else
17565           {
17566             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17567               continue;
17568
17569             saved_sym = sym;
17570             break;
17571           }
17572       }
17573
17574   if (saved_sym && pname)
17575     * pname = strtab + saved_sym->st_name;
17576
17577   return saved_sym;
17578 }
17579
17580 static bfd_boolean
17581 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
17582                                        Filedata *           filedata)
17583 {
17584   static unsigned long  global_offset = 0;
17585   static unsigned long  global_end = 0;
17586   static unsigned long  func_offset = 0;
17587   static unsigned long  func_end = 0;
17588
17589   Elf_Internal_Sym *    sym;
17590   const char *          name;
17591   unsigned long         start;
17592   unsigned long         end;
17593   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17594
17595   switch (pnote->descsz)
17596     {
17597     case 0:
17598       /* A zero-length description means that the range of
17599          the previous note of the same type should be used.  */
17600       if (is_open_attr)
17601         {
17602           if (global_end > global_offset)
17603             printf (_("    Applies to region from %#lx to %#lx\n"),
17604                     global_offset, global_end);
17605           else
17606             printf (_("    Applies to region from %#lx\n"), global_offset);
17607         }
17608       else
17609         {
17610           if (func_end > func_offset)
17611             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
17612           else
17613             printf (_("    Applies to region from %#lx\n"), func_offset);
17614         }
17615       return TRUE;
17616
17617     case 4:
17618       start = byte_get ((unsigned char *) pnote->descdata, 4);
17619       end = 0;
17620       break;
17621
17622     case 8:
17623       if (is_32bit_elf)
17624         {
17625           /* FIXME: We should check that version 3+ notes are being used here...  */
17626           start = byte_get ((unsigned char *) pnote->descdata, 4);
17627           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17628         }
17629       else
17630         {
17631           start = byte_get ((unsigned char *) pnote->descdata, 8);
17632           end = 0;
17633         }
17634       break;
17635
17636     case 16:
17637       start = byte_get ((unsigned char *) pnote->descdata, 8);
17638       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
17639       break;
17640
17641     default:
17642       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17643       printf (_("    <invalid descsz>"));
17644       return FALSE;
17645     }
17646
17647   name = NULL;
17648   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
17649   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17650      in order to avoid them being confused with the start address of the
17651      first function in the file...  */
17652   if (sym == NULL && is_open_attr)
17653     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
17654                                           & name);
17655
17656   if (end == 0 && sym != NULL && sym->st_size > 0)
17657     end = start + sym->st_size;
17658
17659   if (is_open_attr)
17660     {
17661       /* FIXME: Need to properly allow for section alignment.  16 is just the alignment used on x86_64.  */
17662       if (global_end > 0 && start > BFD_ALIGN (global_end, 16))
17663         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17664               global_end + 1, start - 1);
17665
17666       printf (_("    Applies to region from %#lx"), start);
17667       global_offset = start;
17668
17669       if (end)
17670         {
17671           printf (_(" to %#lx"), end);
17672           global_end = end;
17673         }
17674     }
17675   else
17676     {
17677       printf (_("    Applies to region from %#lx"), start);
17678       func_offset = start;
17679
17680       if (end)
17681         {
17682           printf (_(" to %#lx"), end);
17683           func_end = end;
17684         }
17685     }
17686
17687   if (sym && name)
17688     printf (_(" (%s)"), name);
17689
17690   printf ("\n");
17691   return TRUE;
17692 }
17693
17694 static bfd_boolean
17695 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17696 {
17697   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17698   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17699   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17700   char         name_type;
17701   char         name_attribute;
17702   const char * expected_types;
17703   const char * name = pnote->namedata;
17704   const char * text;
17705   signed int   left;
17706
17707   if (name == NULL || pnote->namesz < 2)
17708     {
17709       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17710       print_symbol (-20, _("  <corrupt name>"));
17711       return FALSE;
17712     }
17713
17714   if (do_wide)
17715     left = 28;
17716   else
17717     left = 20;
17718
17719   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17720   if (name[0] == 'G' && name[1] == 'A')
17721     {
17722       if (pnote->namesz < 4)
17723         {
17724           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17725           print_symbol (-20, _("  <corrupt name>"));
17726           return FALSE;
17727         }
17728
17729       printf ("GA");
17730       name += 2;
17731       left -= 2;
17732     }
17733
17734   switch ((name_type = * name))
17735     {
17736     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17737     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17738     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17739     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17740       printf ("%c", * name);
17741       left --;
17742       break;
17743     default:
17744       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17745       print_symbol (-20, _("<unknown name type>"));
17746       return FALSE;
17747     }
17748
17749   ++ name;
17750   text = NULL;
17751
17752   switch ((name_attribute = * name))
17753     {
17754     case GNU_BUILD_ATTRIBUTE_VERSION:
17755       text = _("<version>");
17756       expected_types = string_expected;
17757       ++ name;
17758       break;
17759     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17760       text = _("<stack prot>");
17761       expected_types = "!+*";
17762       ++ name;
17763       break;
17764     case GNU_BUILD_ATTRIBUTE_RELRO:
17765       text = _("<relro>");
17766       expected_types = bool_expected;
17767       ++ name;
17768       break;
17769     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17770       text = _("<stack size>");
17771       expected_types = number_expected;
17772       ++ name;
17773       break;
17774     case GNU_BUILD_ATTRIBUTE_TOOL:
17775       text = _("<tool>");
17776       expected_types = string_expected;
17777       ++ name;
17778       break;
17779     case GNU_BUILD_ATTRIBUTE_ABI:
17780       text = _("<ABI>");
17781       expected_types = "$*";
17782       ++ name;
17783       break;
17784     case GNU_BUILD_ATTRIBUTE_PIC:
17785       text = _("<PIC>");
17786       expected_types = number_expected;
17787       ++ name;
17788       break;
17789     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17790       text = _("<short enum>");
17791       expected_types = bool_expected;
17792       ++ name;
17793       break;
17794     default:
17795       if (ISPRINT (* name))
17796         {
17797           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17798
17799           if (len > left && ! do_wide)
17800             len = left;
17801           printf ("%.*s:", len, name);
17802           left -= len;
17803           name += len;
17804         }
17805       else
17806         {
17807           static char tmpbuf [128];
17808
17809           error (_("unrecognised byte in name field: %d\n"), * name);
17810           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17811           text = tmpbuf;
17812           name ++;
17813         }
17814       expected_types = "*$!+";
17815       break;
17816     }
17817
17818   if (text)
17819     left -= printf ("%s", text);
17820
17821   if (strchr (expected_types, name_type) == NULL)
17822     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17823
17824   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17825     {
17826       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17827              (unsigned long) pnote->namesz,
17828              (long) (name - pnote->namedata));
17829       return FALSE;
17830     }
17831
17832   if (left < 1 && ! do_wide)
17833     return TRUE;
17834
17835   switch (name_type)
17836     {
17837     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17838       {
17839         unsigned int        bytes;
17840         unsigned long long  val = 0;
17841         unsigned int        shift = 0;
17842         char *              decoded = NULL;
17843
17844         bytes = pnote->namesz - (name - pnote->namedata);
17845         if (bytes > 0)
17846           /* The -1 is because the name field is always 0 terminated, and we
17847              want to be able to ensure that the shift in the while loop below
17848              will not overflow.  */
17849           -- bytes;
17850
17851         if (bytes > sizeof (val))
17852           {
17853             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17854                    bytes);
17855             bytes = sizeof (val);
17856           }
17857         /* We do not bother to warn if bytes == 0 as this can
17858            happen with some early versions of the gcc plugin.  */
17859
17860         while (bytes --)
17861           {
17862             unsigned long byte = (* name ++) & 0xff;
17863
17864             val |= byte << shift;
17865             shift += 8;
17866           }
17867
17868         switch (name_attribute)
17869           {
17870           case GNU_BUILD_ATTRIBUTE_PIC:
17871             switch (val)
17872               {
17873               case 0: decoded = "static"; break;
17874               case 1: decoded = "pic"; break;
17875               case 2: decoded = "PIC"; break;
17876               case 3: decoded = "pie"; break;
17877               case 4: decoded = "PIE"; break;
17878               default: break;
17879               }
17880             break;
17881           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17882             switch (val)
17883               {
17884                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17885               case 0: decoded = "off"; break;
17886               case 1: decoded = "on"; break;
17887               case 2: decoded = "all"; break;
17888               case 3: decoded = "strong"; break;
17889               case 4: decoded = "explicit"; break;
17890               default: break;
17891               }
17892             break;
17893           default:
17894             break;
17895           }
17896
17897         if (decoded != NULL)
17898           {
17899             print_symbol (-left, decoded);
17900             left = 0;
17901           }
17902         else if (val == 0)
17903           {
17904             printf ("0x0");
17905             left -= 3;
17906           }
17907         else
17908           {
17909             if (do_wide)
17910               left -= printf ("0x%llx", val);
17911             else
17912               left -= printf ("0x%-.*llx", left, val);
17913           }
17914       }
17915       break;
17916     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17917       left -= print_symbol (- left, name);
17918       break;
17919     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17920       left -= print_symbol (- left, "true");
17921       break;
17922     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17923       left -= print_symbol (- left, "false");
17924       break;
17925     }
17926
17927   if (do_wide && left > 0)
17928     printf ("%-*s", left, " ");
17929
17930   return TRUE;
17931 }
17932
17933 /* Note that by the ELF standard, the name field is already null byte
17934    terminated, and namesz includes the terminating null byte.
17935    I.E. the value of namesz for the name "FSF" is 4.
17936
17937    If the value of namesz is zero, there is no name present.  */
17938
17939 static bfd_boolean
17940 process_note (Elf_Internal_Note *  pnote,
17941               Filedata *           filedata)
17942 {
17943   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17944   const char * nt;
17945
17946   if (pnote->namesz == 0)
17947     /* If there is no note name, then use the default set of
17948        note type strings.  */
17949     nt = get_note_type (filedata, pnote->type);
17950
17951   else if (const_strneq (pnote->namedata, "GNU"))
17952     /* GNU-specific object file notes.  */
17953     nt = get_gnu_elf_note_type (pnote->type);
17954
17955   else if (const_strneq (pnote->namedata, "FreeBSD"))
17956     /* FreeBSD-specific core file notes.  */
17957     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
17958
17959   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17960     /* NetBSD-specific core file notes.  */
17961     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
17962
17963   else if (const_strneq (pnote->namedata, "NetBSD"))
17964     /* NetBSD-specific core file notes.  */
17965     return process_netbsd_elf_note (pnote);
17966
17967   else if (strneq (pnote->namedata, "SPU/", 4))
17968     {
17969       /* SPU-specific core file notes.  */
17970       nt = pnote->namedata + 4;
17971       name = "SPU";
17972     }
17973
17974   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17975     /* VMS/ia64-specific file notes.  */
17976     nt = get_ia64_vms_note_type (pnote->type);
17977
17978   else if (const_strneq (pnote->namedata, "stapsdt"))
17979     nt = get_stapsdt_note_type (pnote->type);
17980
17981   else
17982     /* Don't recognize this note name; just use the default set of
17983        note type strings.  */
17984     nt = get_note_type (filedata, pnote->type);
17985
17986   printf ("  ");
17987
17988   if (((const_strneq (pnote->namedata, "GA")
17989         && strchr ("*$!+", pnote->namedata[2]) != NULL)
17990        || strchr ("*$!+", pnote->namedata[0]) != NULL)
17991       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17992           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17993     print_gnu_build_attribute_name (pnote);
17994   else
17995     print_symbol (-20, name);
17996
17997   if (do_wide)
17998     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17999   else
18000     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18001
18002   if (const_strneq (pnote->namedata, "IPF/VMS"))
18003     return print_ia64_vms_note (pnote);
18004   else if (const_strneq (pnote->namedata, "GNU"))
18005     return print_gnu_note (filedata, pnote);
18006   else if (const_strneq (pnote->namedata, "stapsdt"))
18007     return print_stapsdt_note (pnote);
18008   else if (const_strneq (pnote->namedata, "CORE"))
18009     return print_core_note (pnote);
18010   else if (((const_strneq (pnote->namedata, "GA")
18011              && strchr ("*$!+", pnote->namedata[2]) != NULL)
18012             || strchr ("*$!+", pnote->namedata[0]) != NULL)
18013            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18014                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18015     return print_gnu_build_attribute_description (pnote, filedata);
18016
18017   if (pnote->descsz)
18018     {
18019       unsigned long i;
18020
18021       printf (_("   description data: "));
18022       for (i = 0; i < pnote->descsz; i++)
18023         printf ("%02x ", pnote->descdata[i]);
18024       if (!do_wide)
18025         printf ("\n");
18026     }
18027
18028   if (do_wide)
18029     printf ("\n");
18030
18031   return TRUE;
18032 }
18033
18034 static bfd_boolean
18035 process_notes_at (Filedata *           filedata,
18036                   Elf_Internal_Shdr *  section,
18037                   bfd_vma              offset,
18038                   bfd_vma              length,
18039                   bfd_vma              align)
18040 {
18041   Elf_External_Note * pnotes;
18042   Elf_External_Note * external;
18043   char *              end;
18044   bfd_boolean         res = TRUE;
18045
18046   if (length <= 0)
18047     return FALSE;
18048
18049   if (section)
18050     {
18051       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18052       if (pnotes)
18053         {
18054           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18055             return FALSE;
18056         }
18057     }
18058   else
18059     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18060                                              _("notes"));
18061
18062   if (pnotes == NULL)
18063     return FALSE;
18064
18065   external = pnotes;
18066
18067   if (section)
18068     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18069   else
18070     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18071             (unsigned long) offset, (unsigned long) length);
18072
18073   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18074      specifies that notes should be aligned to 4 bytes in 32-bit
18075      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18076      we also support 4 byte alignment in 64-bit objects.  If section
18077      alignment is less than 4, we treate alignment as 4 bytes.   */
18078   if (align < 4)
18079     align = 4;
18080   else if (align != 4 && align != 8)
18081     {
18082       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18083             (long) align);
18084       return FALSE;
18085     }
18086
18087   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18088
18089   end = (char *) pnotes + length;
18090   while ((char *) external < end)
18091     {
18092       Elf_Internal_Note inote;
18093       size_t min_notesz;
18094       char * next;
18095       char * temp = NULL;
18096       size_t data_remaining = end - (char *) external;
18097
18098       if (!is_ia64_vms (filedata))
18099         {
18100           /* PR binutils/15191
18101              Make sure that there is enough data to read.  */
18102           min_notesz = offsetof (Elf_External_Note, name);
18103           if (data_remaining < min_notesz)
18104             {
18105               warn (ngettext ("Corrupt note: only %ld byte remains, "
18106                               "not enough for a full note\n",
18107                               "Corrupt note: only %ld bytes remain, "
18108                               "not enough for a full note\n",
18109                               data_remaining),
18110                     (long) data_remaining);
18111               break;
18112             }
18113           data_remaining -= min_notesz;
18114
18115           inote.type     = BYTE_GET (external->type);
18116           inote.namesz   = BYTE_GET (external->namesz);
18117           inote.namedata = external->name;
18118           inote.descsz   = BYTE_GET (external->descsz);
18119           inote.descdata = ((char *) external
18120                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18121           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18122           next = ((char *) external
18123                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18124         }
18125       else
18126         {
18127           Elf64_External_VMS_Note *vms_external;
18128
18129           /* PR binutils/15191
18130              Make sure that there is enough data to read.  */
18131           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18132           if (data_remaining < min_notesz)
18133             {
18134               warn (ngettext ("Corrupt note: only %ld byte remains, "
18135                               "not enough for a full note\n",
18136                               "Corrupt note: only %ld bytes remain, "
18137                               "not enough for a full note\n",
18138                               data_remaining),
18139                     (long) data_remaining);
18140               break;
18141             }
18142           data_remaining -= min_notesz;
18143
18144           vms_external = (Elf64_External_VMS_Note *) external;
18145           inote.type     = BYTE_GET (vms_external->type);
18146           inote.namesz   = BYTE_GET (vms_external->namesz);
18147           inote.namedata = vms_external->name;
18148           inote.descsz   = BYTE_GET (vms_external->descsz);
18149           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18150           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18151           next = inote.descdata + align_power (inote.descsz, 3);
18152         }
18153
18154       /* PR 17531: file: 3443835e.  */
18155       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18156       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18157           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18158           || (size_t) (next - inote.descdata) < inote.descsz
18159           || ((size_t) (next - inote.descdata)
18160               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18161         {
18162           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18163                 (unsigned long) ((char *) external - (char *) pnotes));
18164           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18165                 inote.type, inote.namesz, inote.descsz, (int) align);
18166           break;
18167         }
18168
18169       external = (Elf_External_Note *) next;
18170
18171       /* Verify that name is null terminated.  It appears that at least
18172          one version of Linux (RedHat 6.0) generates corefiles that don't
18173          comply with the ELF spec by failing to include the null byte in
18174          namesz.  */
18175       if (inote.namedata[inote.namesz - 1] != '\0')
18176         {
18177           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18178             {
18179               temp = (char *) malloc (inote.namesz + 1);
18180               if (temp == NULL)
18181                 {
18182                   error (_("Out of memory allocating space for inote name\n"));
18183                   res = FALSE;
18184                   break;
18185                 }
18186
18187               memcpy (temp, inote.namedata, inote.namesz);
18188               inote.namedata = temp;
18189             }
18190           inote.namedata[inote.namesz] = 0;
18191         }
18192
18193       if (! process_note (& inote, filedata))
18194         res = FALSE;
18195
18196       if (temp != NULL)
18197         {
18198           free (temp);
18199           temp = NULL;
18200         }
18201     }
18202
18203   free (pnotes);
18204
18205   return res;
18206 }
18207
18208 static bfd_boolean
18209 process_corefile_note_segments (Filedata * filedata)
18210 {
18211   Elf_Internal_Phdr * segment;
18212   unsigned int i;
18213   bfd_boolean res = TRUE;
18214
18215   if (! get_program_headers (filedata))
18216     return TRUE;
18217
18218   for (i = 0, segment = filedata->program_headers;
18219        i < filedata->file_header.e_phnum;
18220        i++, segment++)
18221     {
18222       if (segment->p_type == PT_NOTE)
18223         if (! process_notes_at (filedata, NULL,
18224                                 (bfd_vma) segment->p_offset,
18225                                 (bfd_vma) segment->p_filesz,
18226                                 (bfd_vma) segment->p_align))
18227           res = FALSE;
18228     }
18229
18230   return res;
18231 }
18232
18233 static bfd_boolean
18234 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18235 {
18236   Elf_External_Note * pnotes;
18237   Elf_External_Note * external;
18238   char * end;
18239   bfd_boolean res = TRUE;
18240
18241   if (length <= 0)
18242     return FALSE;
18243
18244   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18245                                            _("v850 notes"));
18246   if (pnotes == NULL)
18247     return FALSE;
18248
18249   external = pnotes;
18250   end = (char*) pnotes + length;
18251
18252   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18253           (unsigned long) offset, (unsigned long) length);
18254
18255   while ((char *) external + sizeof (Elf_External_Note) < end)
18256     {
18257       Elf_External_Note * next;
18258       Elf_Internal_Note inote;
18259
18260       inote.type     = BYTE_GET (external->type);
18261       inote.namesz   = BYTE_GET (external->namesz);
18262       inote.namedata = external->name;
18263       inote.descsz   = BYTE_GET (external->descsz);
18264       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18265       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18266
18267       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18268         {
18269           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18270           inote.descdata = inote.namedata;
18271           inote.namesz   = 0;
18272         }
18273
18274       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18275
18276       if (   ((char *) next > end)
18277           || ((char *) next <  (char *) pnotes))
18278         {
18279           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18280                 (unsigned long) ((char *) external - (char *) pnotes));
18281           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18282                 inote.type, inote.namesz, inote.descsz);
18283           break;
18284         }
18285
18286       external = next;
18287
18288       /* Prevent out-of-bounds indexing.  */
18289       if (   inote.namedata + inote.namesz > end
18290           || inote.namedata + inote.namesz < inote.namedata)
18291         {
18292           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18293                 (unsigned long) ((char *) external - (char *) pnotes));
18294           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18295                 inote.type, inote.namesz, inote.descsz);
18296           break;
18297         }
18298
18299       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18300
18301       if (! print_v850_note (& inote))
18302         {
18303           res = FALSE;
18304           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18305                   inote.namesz, inote.descsz);
18306         }
18307     }
18308
18309   free (pnotes);
18310
18311   return res;
18312 }
18313
18314 static bfd_boolean
18315 process_note_sections (Filedata * filedata)
18316 {
18317   Elf_Internal_Shdr * section;
18318   unsigned long i;
18319   unsigned int n = 0;
18320   bfd_boolean res = TRUE;
18321
18322   for (i = 0, section = filedata->section_headers;
18323        i < filedata->file_header.e_shnum && section != NULL;
18324        i++, section++)
18325     {
18326       if (section->sh_type == SHT_NOTE)
18327         {
18328           if (! process_notes_at (filedata, section,
18329                                   (bfd_vma) section->sh_offset,
18330                                   (bfd_vma) section->sh_size,
18331                                   (bfd_vma) section->sh_addralign))
18332             res = FALSE;
18333           n++;
18334         }
18335
18336       if ((   filedata->file_header.e_machine == EM_V800
18337            || filedata->file_header.e_machine == EM_V850
18338            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18339           && section->sh_type == SHT_RENESAS_INFO)
18340         {
18341           if (! process_v850_notes (filedata,
18342                                     (bfd_vma) section->sh_offset,
18343                                     (bfd_vma) section->sh_size))
18344             res = FALSE;
18345           n++;
18346         }
18347     }
18348
18349   if (n == 0)
18350     /* Try processing NOTE segments instead.  */
18351     return process_corefile_note_segments (filedata);
18352
18353   return res;
18354 }
18355
18356 static bfd_boolean
18357 process_notes (Filedata * filedata)
18358 {
18359   /* If we have not been asked to display the notes then do nothing.  */
18360   if (! do_notes)
18361     return TRUE;
18362
18363   if (filedata->file_header.e_type != ET_CORE)
18364     return process_note_sections (filedata);
18365
18366   /* No program headers means no NOTE segment.  */
18367   if (filedata->file_header.e_phnum > 0)
18368     return process_corefile_note_segments (filedata);
18369
18370   printf (_("No note segments present in the core file.\n"));
18371   return TRUE;
18372 }
18373
18374 static unsigned char *
18375 display_public_gnu_attributes (unsigned char * start,
18376                                const unsigned char * const end)
18377 {
18378   printf (_("  Unknown GNU attribute: %s\n"), start);
18379
18380   start += strnlen ((char *) start, end - start);
18381   display_raw_attribute (start, end);
18382
18383   return (unsigned char *) end;
18384 }
18385
18386 static unsigned char *
18387 display_generic_attribute (unsigned char * start,
18388                            unsigned int tag,
18389                            const unsigned char * const end)
18390 {
18391   if (tag == 0)
18392     return (unsigned char *) end;
18393
18394   return display_tag_value (tag, start, end);
18395 }
18396
18397 static bfd_boolean
18398 process_arch_specific (Filedata * filedata)
18399 {
18400   if (! do_arch)
18401     return TRUE;
18402
18403   switch (filedata->file_header.e_machine)
18404     {
18405     case EM_ARC:
18406     case EM_ARC_COMPACT:
18407     case EM_ARC_COMPACT2:
18408       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18409                                  display_arc_attribute,
18410                                  display_generic_attribute);
18411     case EM_ARM:
18412       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18413                                  display_arm_attribute,
18414                                  display_generic_attribute);
18415
18416     case EM_MIPS:
18417     case EM_MIPS_RS3_LE:
18418       return process_mips_specific (filedata);
18419
18420     case EM_MSP430:
18421      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18422                                 display_msp430x_attribute,
18423                                 display_generic_attribute);
18424
18425     case EM_NDS32:
18426       return process_nds32_specific (filedata);
18427
18428     case EM_PPC:
18429     case EM_PPC64:
18430       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18431                                  display_power_gnu_attribute);
18432
18433     case EM_S390:
18434     case EM_S390_OLD:
18435       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18436                                  display_s390_gnu_attribute);
18437
18438     case EM_SPARC:
18439     case EM_SPARC32PLUS:
18440     case EM_SPARCV9:
18441       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18442                                  display_sparc_gnu_attribute);
18443
18444     case EM_TI_C6000:
18445       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18446                                  display_tic6x_attribute,
18447                                  display_generic_attribute);
18448
18449     default:
18450       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18451                                  display_public_gnu_attributes,
18452                                  display_generic_attribute);
18453     }
18454 }
18455
18456 static bfd_boolean
18457 get_file_header (Filedata * filedata)
18458 {
18459   /* Read in the identity array.  */
18460   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18461     return FALSE;
18462
18463   /* Determine how to read the rest of the header.  */
18464   switch (filedata->file_header.e_ident[EI_DATA])
18465     {
18466     default:
18467     case ELFDATANONE:
18468     case ELFDATA2LSB:
18469       byte_get = byte_get_little_endian;
18470       byte_put = byte_put_little_endian;
18471       break;
18472     case ELFDATA2MSB:
18473       byte_get = byte_get_big_endian;
18474       byte_put = byte_put_big_endian;
18475       break;
18476     }
18477
18478   /* For now we only support 32 bit and 64 bit ELF files.  */
18479   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18480
18481   /* Read in the rest of the header.  */
18482   if (is_32bit_elf)
18483     {
18484       Elf32_External_Ehdr ehdr32;
18485
18486       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18487         return FALSE;
18488
18489       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18490       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18491       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18492       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18493       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18494       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18495       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18496       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18497       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18498       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18499       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18500       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18501       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18502     }
18503   else
18504     {
18505       Elf64_External_Ehdr ehdr64;
18506
18507       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18508          we will not be able to cope with the 64bit data found in
18509          64 ELF files.  Detect this now and abort before we start
18510          overwriting things.  */
18511       if (sizeof (bfd_vma) < 8)
18512         {
18513           error (_("This instance of readelf has been built without support for a\n\
18514 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18515           return FALSE;
18516         }
18517
18518       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18519         return FALSE;
18520
18521       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18522       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18523       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18524       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18525       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18526       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18527       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18528       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18529       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18530       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18531       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18532       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18533       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18534     }
18535
18536   if (filedata->file_header.e_shoff)
18537     {
18538       /* There may be some extensions in the first section header.  Don't
18539          bomb if we can't read it.  */
18540       if (is_32bit_elf)
18541         get_32bit_section_headers (filedata, TRUE);
18542       else
18543         get_64bit_section_headers (filedata, TRUE);
18544     }
18545
18546   return TRUE;
18547 }
18548
18549 static void
18550 close_file (Filedata * filedata)
18551 {
18552   if (filedata)
18553     {
18554       if (filedata->handle)
18555         fclose (filedata->handle);
18556       free (filedata);
18557     }
18558 }
18559
18560 void
18561 close_debug_file (void * data)
18562 {
18563   close_file ((Filedata *) data);
18564 }
18565
18566 static Filedata *
18567 open_file (const char * pathname)
18568 {
18569   struct stat  statbuf;
18570   Filedata *   filedata = NULL;
18571
18572   if (stat (pathname, & statbuf) < 0
18573       || ! S_ISREG (statbuf.st_mode))
18574     goto fail;
18575
18576   filedata = calloc (1, sizeof * filedata);
18577   if (filedata == NULL)
18578     goto fail;
18579
18580   filedata->handle = fopen (pathname, "rb");
18581   if (filedata->handle == NULL)
18582     goto fail;
18583
18584   filedata->file_size = (bfd_size_type) statbuf.st_size;
18585   filedata->file_name = pathname;
18586
18587   if (! get_file_header (filedata))
18588     goto fail;
18589
18590   if (filedata->file_header.e_shoff)
18591     {
18592       bfd_boolean res;
18593
18594       /* Read the section headers again, this time for real.  */
18595       if (is_32bit_elf)
18596         res = get_32bit_section_headers (filedata, FALSE);
18597       else
18598         res = get_64bit_section_headers (filedata, FALSE);
18599
18600       if (!res)
18601         goto fail;
18602     }
18603
18604   return filedata;
18605
18606  fail:
18607   if (filedata)
18608     {
18609       if (filedata->handle)
18610         fclose (filedata->handle);
18611       free (filedata);
18612     }
18613   return NULL;
18614 }
18615
18616 void *
18617 open_debug_file (const char * pathname)
18618 {
18619   return open_file (pathname);
18620 }
18621
18622 /* Process one ELF object file according to the command line options.
18623    This file may actually be stored in an archive.  The file is
18624    positioned at the start of the ELF object.  Returns TRUE if no
18625    problems were encountered, FALSE otherwise.  */
18626
18627 static bfd_boolean
18628 process_object (Filedata * filedata)
18629 {
18630   Filedata * separates;
18631   unsigned int i;
18632   bfd_boolean res = TRUE;
18633
18634   if (! get_file_header (filedata))
18635     {
18636       error (_("%s: Failed to read file header\n"), filedata->file_name);
18637       return FALSE;
18638     }
18639
18640   /* Initialise per file variables.  */
18641   for (i = ARRAY_SIZE (version_info); i--;)
18642     version_info[i] = 0;
18643
18644   for (i = ARRAY_SIZE (dynamic_info); i--;)
18645     dynamic_info[i] = 0;
18646   dynamic_info_DT_GNU_HASH = 0;
18647
18648   /* Process the file.  */
18649   if (show_name)
18650     printf (_("\nFile: %s\n"), filedata->file_name);
18651
18652   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18653      Note we do this even if cmdline_dump_sects is empty because we
18654      must make sure that the dump_sets array is zeroed out before each
18655      object file is processed.  */
18656   if (filedata->num_dump_sects > cmdline.num_dump_sects)
18657     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
18658
18659   if (cmdline.num_dump_sects > 0)
18660     {
18661       if (filedata->num_dump_sects == 0)
18662         /* A sneaky way of allocating the dump_sects array.  */
18663         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
18664
18665       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
18666       memcpy (filedata->dump_sects, cmdline.dump_sects,
18667               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
18668     }
18669
18670   if (! process_file_header (filedata))
18671     return FALSE;
18672
18673   if (! process_section_headers (filedata))
18674     {
18675       /* Without loaded section headers we cannot process lots of things.  */
18676       do_unwind = do_version = do_dump = do_arch = FALSE;
18677
18678       if (! do_using_dynamic)
18679         do_syms = do_dyn_syms = do_reloc = FALSE;
18680     }
18681
18682   if (! process_section_groups (filedata))
18683     /* Without loaded section groups we cannot process unwind.  */
18684     do_unwind = FALSE;
18685
18686   if (process_program_headers (filedata))
18687     process_dynamic_section (filedata);
18688   else
18689     res = FALSE;
18690
18691   if (! process_relocs (filedata))
18692     res = FALSE;
18693
18694   if (! process_unwind (filedata))
18695     res = FALSE;
18696
18697   if (! process_symbol_table (filedata))
18698     res = FALSE;
18699
18700   if (! process_syminfo (filedata))
18701     res = FALSE;
18702
18703   if (! process_version_sections (filedata))
18704     res = FALSE;
18705
18706   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
18707     separates = load_separate_debug_file (filedata, filedata->file_name);
18708   else
18709     separates = NULL;
18710
18711   if (! process_section_contents (filedata))
18712     res = FALSE;
18713
18714   if (separates)
18715     {
18716       if (! process_section_headers (separates))
18717         res = FALSE;
18718       else if (! process_section_contents (separates))
18719         res = FALSE;
18720     }
18721
18722   if (! process_notes (filedata))
18723     res = FALSE;
18724
18725   if (! process_gnu_liblist (filedata))
18726     res = FALSE;
18727
18728   if (! process_arch_specific (filedata))
18729     res = FALSE;
18730
18731   free (filedata->program_headers);
18732   filedata->program_headers = NULL;
18733
18734   free (filedata->section_headers);
18735   filedata->section_headers = NULL;
18736
18737   free (filedata->string_table);
18738   filedata->string_table = NULL;
18739   filedata->string_table_length = 0;
18740
18741   if (dynamic_strings)
18742     {
18743       free (dynamic_strings);
18744       dynamic_strings = NULL;
18745       dynamic_strings_length = 0;
18746     }
18747
18748   if (dynamic_symbols)
18749     {
18750       free (dynamic_symbols);
18751       dynamic_symbols = NULL;
18752       num_dynamic_syms = 0;
18753     }
18754
18755   if (dynamic_syminfo)
18756     {
18757       free (dynamic_syminfo);
18758       dynamic_syminfo = NULL;
18759     }
18760
18761   if (dynamic_section)
18762     {
18763       free (dynamic_section);
18764       dynamic_section = NULL;
18765     }
18766
18767   if (section_headers_groups)
18768     {
18769       free (section_headers_groups);
18770       section_headers_groups = NULL;
18771     }
18772
18773   if (section_groups)
18774     {
18775       struct group_list * g;
18776       struct group_list * next;
18777
18778       for (i = 0; i < group_count; i++)
18779         {
18780           for (g = section_groups [i].root; g != NULL; g = next)
18781             {
18782               next = g->next;
18783               free (g);
18784             }
18785         }
18786
18787       free (section_groups);
18788       section_groups = NULL;
18789     }
18790
18791   free_debug_memory ();
18792
18793   return res;
18794 }
18795
18796 /* Process an ELF archive.
18797    On entry the file is positioned just after the ARMAG string.
18798    Returns TRUE upon success, FALSE otherwise.  */
18799
18800 static bfd_boolean
18801 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
18802 {
18803   struct archive_info arch;
18804   struct archive_info nested_arch;
18805   size_t got;
18806   bfd_boolean ret = TRUE;
18807
18808   show_name = TRUE;
18809
18810   /* The ARCH structure is used to hold information about this archive.  */
18811   arch.file_name = NULL;
18812   arch.file = NULL;
18813   arch.index_array = NULL;
18814   arch.sym_table = NULL;
18815   arch.longnames = NULL;
18816
18817   /* The NESTED_ARCH structure is used as a single-item cache of information
18818      about a nested archive (when members of a thin archive reside within
18819      another regular archive file).  */
18820   nested_arch.file_name = NULL;
18821   nested_arch.file = NULL;
18822   nested_arch.index_array = NULL;
18823   nested_arch.sym_table = NULL;
18824   nested_arch.longnames = NULL;
18825
18826   if (setup_archive (&arch, filedata->file_name, filedata->handle,
18827                      is_thin_archive, do_archive_index) != 0)
18828     {
18829       ret = FALSE;
18830       goto out;
18831     }
18832
18833   if (do_archive_index)
18834     {
18835       if (arch.sym_table == NULL)
18836         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
18837       else
18838         {
18839           unsigned long i, l;
18840           unsigned long current_pos;
18841
18842           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18843                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
18844
18845           current_pos = ftell (filedata->handle);
18846
18847           for (i = l = 0; i < arch.index_num; i++)
18848             {
18849               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18850                 {
18851                   char * member_name;
18852
18853                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18854
18855                   if (member_name != NULL)
18856                     {
18857                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18858
18859                       if (qualified_name != NULL)
18860                         {
18861                           printf (_("Contents of binary %s at offset "), qualified_name);
18862                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18863                           putchar ('\n');
18864                           free (qualified_name);
18865                         }
18866                     }
18867                 }
18868
18869               if (l >= arch.sym_size)
18870                 {
18871                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18872                          filedata->file_name);
18873                   ret = FALSE;
18874                   break;
18875                 }
18876               /* PR 17531: file: 0b6630b2.  */
18877               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18878               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18879             }
18880
18881           if (arch.uses_64bit_indicies)
18882             l = (l + 7) & ~ 7;
18883           else
18884             l += l & 1;
18885
18886           if (l < arch.sym_size)
18887             {
18888               error (ngettext ("%s: %ld byte remains in the symbol table, "
18889                                "but without corresponding entries in "
18890                                "the index table\n",
18891                                "%s: %ld bytes remain in the symbol table, "
18892                                "but without corresponding entries in "
18893                                "the index table\n",
18894                                arch.sym_size - l),
18895                      filedata->file_name, arch.sym_size - l);
18896               ret = FALSE;
18897             }
18898
18899           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
18900             {
18901               error (_("%s: failed to seek back to start of object files in the archive\n"),
18902                      filedata->file_name);
18903               ret = FALSE;
18904               goto out;
18905             }
18906         }
18907
18908       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18909           && !do_segments && !do_header && !do_dump && !do_version
18910           && !do_histogram && !do_debugging && !do_arch && !do_notes
18911           && !do_section_groups && !do_dyn_syms)
18912         {
18913           ret = TRUE; /* Archive index only.  */
18914           goto out;
18915         }
18916     }
18917
18918   while (1)
18919     {
18920       char * name;
18921       size_t namelen;
18922       char * qualified_name;
18923
18924       /* Read the next archive header.  */
18925       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
18926         {
18927           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
18928           return FALSE;
18929         }
18930       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
18931       if (got != sizeof arch.arhdr)
18932         {
18933           if (got == 0)
18934             break;
18935           error (_("%s: failed to read archive header\n"), filedata->file_name);
18936           ret = FALSE;
18937           break;
18938         }
18939       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18940         {
18941           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18942           ret = FALSE;
18943           break;
18944         }
18945
18946       arch.next_arhdr_offset += sizeof arch.arhdr;
18947
18948       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18949       if (archive_file_size & 01)
18950         ++archive_file_size;
18951
18952       name = get_archive_member_name (&arch, &nested_arch);
18953       if (name == NULL)
18954         {
18955           error (_("%s: bad archive file name\n"), filedata->file_name);
18956           ret = FALSE;
18957           break;
18958         }
18959       namelen = strlen (name);
18960
18961       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18962       if (qualified_name == NULL)
18963         {
18964           error (_("%s: bad archive file name\n"), filedata->file_name);
18965           ret = FALSE;
18966           break;
18967         }
18968
18969       if (is_thin_archive && arch.nested_member_origin == 0)
18970         {
18971           /* This is a proxy for an external member of a thin archive.  */
18972           Filedata * member_filedata;
18973           char * member_file_name = adjust_relative_path
18974             (filedata->file_name, name, namelen);
18975
18976           if (member_file_name == NULL)
18977             {
18978               ret = FALSE;
18979               break;
18980             }
18981
18982           member_filedata = open_file (member_file_name);
18983           if (member_filedata == NULL)
18984             {
18985               error (_("Input file '%s' is not readable.\n"), member_file_name);
18986               free (member_file_name);
18987               ret = FALSE;
18988               break;
18989             }
18990
18991           archive_file_offset = arch.nested_member_origin;
18992           member_filedata->file_name = qualified_name;
18993
18994           if (! process_object (member_filedata))
18995             ret = FALSE;
18996
18997           close_file (member_filedata);
18998           free (member_file_name);
18999         }
19000       else if (is_thin_archive)
19001         {
19002           Filedata thin_filedata;
19003
19004           memset (&thin_filedata, 0, sizeof (thin_filedata));
19005
19006           /* PR 15140: Allow for corrupt thin archives.  */
19007           if (nested_arch.file == NULL)
19008             {
19009               error (_("%s: contains corrupt thin archive: %s\n"),
19010                      filedata->file_name, name);
19011               ret = FALSE;
19012               break;
19013             }
19014
19015           /* This is a proxy for a member of a nested archive.  */
19016           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19017
19018           /* The nested archive file will have been opened and setup by
19019              get_archive_member_name.  */
19020           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19021             {
19022               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19023               ret = FALSE;
19024               break;
19025             }
19026
19027           thin_filedata.handle = nested_arch.file;
19028           thin_filedata.file_name = qualified_name;
19029
19030           if (! process_object (& thin_filedata))
19031             ret = FALSE;
19032         }
19033       else
19034         {
19035           archive_file_offset = arch.next_arhdr_offset;
19036           arch.next_arhdr_offset += archive_file_size;
19037
19038           filedata->file_name = qualified_name;
19039           if (! process_object (filedata))
19040             ret = FALSE;
19041         }
19042
19043       if (filedata->dump_sects != NULL)
19044         {
19045           free (filedata->dump_sects);
19046           filedata->dump_sects = NULL;
19047           filedata->num_dump_sects = 0;
19048         }
19049
19050       free (qualified_name);
19051     }
19052
19053  out:
19054   if (nested_arch.file != NULL)
19055     fclose (nested_arch.file);
19056   release_archive (&nested_arch);
19057   release_archive (&arch);
19058
19059   return ret;
19060 }
19061
19062 static bfd_boolean
19063 process_file (char * file_name)
19064 {
19065   Filedata * filedata = NULL;
19066   struct stat statbuf;
19067   char armag[SARMAG];
19068   bfd_boolean ret = TRUE;
19069
19070   if (stat (file_name, &statbuf) < 0)
19071     {
19072       if (errno == ENOENT)
19073         error (_("'%s': No such file\n"), file_name);
19074       else
19075         error (_("Could not locate '%s'.  System error message: %s\n"),
19076                file_name, strerror (errno));
19077       return FALSE;
19078     }
19079
19080   if (! S_ISREG (statbuf.st_mode))
19081     {
19082       error (_("'%s' is not an ordinary file\n"), file_name);
19083       return FALSE;
19084     }
19085
19086   filedata = calloc (1, sizeof * filedata);
19087   if (filedata == NULL)
19088     {
19089       error (_("Out of memory allocating file data structure\n"));
19090       return FALSE;
19091     }
19092
19093   filedata->file_name = file_name;
19094   filedata->handle = fopen (file_name, "rb");
19095   if (filedata->handle == NULL)
19096     {
19097       error (_("Input file '%s' is not readable.\n"), file_name);
19098       free (filedata);
19099       return FALSE;
19100     }
19101
19102   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19103     {
19104       error (_("%s: Failed to read file's magic number\n"), file_name);
19105       fclose (filedata->handle);
19106       free (filedata);
19107       return FALSE;
19108     }
19109
19110   filedata->file_size = (bfd_size_type) statbuf.st_size;
19111
19112   if (memcmp (armag, ARMAG, SARMAG) == 0)
19113     {
19114       if (! process_archive (filedata, FALSE))
19115         ret = FALSE;
19116     }
19117   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19118     {
19119       if ( ! process_archive (filedata, TRUE))
19120         ret = FALSE;
19121     }
19122   else
19123     {
19124       if (do_archive_index)
19125         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19126                file_name);
19127
19128       rewind (filedata->handle);
19129       archive_file_size = archive_file_offset = 0;
19130
19131       if (! process_object (filedata))
19132         ret = FALSE;
19133     }
19134
19135   fclose (filedata->handle);
19136   free (filedata);
19137
19138   return ret;
19139 }
19140
19141 #ifdef SUPPORT_DISASSEMBLY
19142 /* Needed by the i386 disassembler.  For extra credit, someone could
19143    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19144    symbols.  */
19145
19146 void
19147 print_address (unsigned int addr, FILE * outfile)
19148 {
19149   fprintf (outfile,"0x%8.8x", addr);
19150 }
19151
19152 /* Needed by the i386 disassembler.  */
19153
19154 void
19155 db_task_printsym (unsigned int addr)
19156 {
19157   print_address (addr, stderr);
19158 }
19159 #endif
19160
19161 int
19162 main (int argc, char ** argv)
19163 {
19164   int err;
19165
19166 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19167   setlocale (LC_MESSAGES, "");
19168 #endif
19169 #if defined (HAVE_SETLOCALE)
19170   setlocale (LC_CTYPE, "");
19171 #endif
19172   bindtextdomain (PACKAGE, LOCALEDIR);
19173   textdomain (PACKAGE);
19174
19175   expandargv (&argc, &argv);
19176
19177   cmdline.file_name = "<cmdline>";
19178   parse_args (& cmdline, argc, argv);
19179
19180   if (optind < (argc - 1))
19181     show_name = TRUE;
19182   else if (optind >= argc)
19183     {
19184       warn (_("Nothing to do.\n"));
19185       usage (stderr);
19186     }
19187
19188   err = FALSE;
19189   while (optind < argc)
19190     if (! process_file (argv[optind++]))
19191       err = TRUE;
19192
19193   if (cmdline.dump_sects != NULL)
19194     free (cmdline.dump_sects);
19195
19196   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19197 }