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