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   assert (width != 0);
 519
 520   if (do_wide)
 521     /* Set the remaining width to a very large value.
 522        This simplifies the code below.  */
 523     width_remaining = INT_MAX;
 524   else
 525     width_remaining = width;
 526
 527 #ifdef HAVE_MBSTATE_T
 528   /* Initialise the multibyte conversion state.  */
 529   memset (& state, 0, sizeof (state));
 530 #endif
 531
 532   while (width_remaining)
 533     {
 534       size_t  n;
 535       const char c = *symbol++;
 536
 537       if (c == 0)
 538         break;
 539
 540       /* Do not print control characters directly as they can affect terminal
 541          settings.  Such characters usually appear in the names generated
 542          by the assembler for local labels.  */
 543       if (ISCNTRL (c))
 544         {
 545           if (width_remaining < 2)
 546             break;
 547
 548           printf ("^%c", c + 0x40);
 549           width_remaining -= 2;
 550           num_printed += 2;
 551         }
 552       else if (ISPRINT (c))
 553         {
 554           putchar (c);
 555           width_remaining --;
 556           num_printed ++;
 557         }
 558       else
 559         {
 560 #ifdef HAVE_MBSTATE_T
 561           wchar_t w;
 562 #endif
 563           /* Let printf do the hard work of displaying multibyte characters.  */
 564           printf ("%.1s", symbol - 1);
 565           width_remaining --;
 566           num_printed ++;
 567
 568 #ifdef HAVE_MBSTATE_T
 569           /* Try to find out how many bytes made up the character that was
 570              just printed.  Advance the symbol pointer past the bytes that
 571              were displayed.  */
 572           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 573 #else
 574           n = 1;
 575 #endif
 576           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 577             symbol += (n - 1);
 578         }
 579     }
 580
 581   if (extra_padding && num_printed < width)
 582     {
 583       /* Fill in the remaining spaces.  */
 584       printf ("%-*s", width - num_printed, " ");
 585       num_printed = width;
 586     }
 587
 588   return num_printed;
 589 }
 590
 591 /* Returns a pointer to a static buffer containing a printable version of
 592    the given section's name.  Like print_symbol, except that it does not try
 593    to print multibyte characters, it just interprets them as hex values.  */
 594
 595 static const char *
 596 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 597 {
 598 #define MAX_PRINT_SEC_NAME_LEN 128
 599   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 600   const char * name = SECTION_NAME (sec);
 601   char *       buf = sec_name_buf;
 602   char         c;
 603   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 604
 605   while ((c = * name ++) != 0)
 606     {
 607       if (ISCNTRL (c))
 608         {
 609           if (remaining < 2)
 610             break;
 611
 612           * buf ++ = '^';
 613           * buf ++ = c + 0x40;
 614           remaining -= 2;
 615         }
 616       else if (ISPRINT (c))
 617         {
 618           * buf ++ = c;
 619           remaining -= 1;
 620         }
 621       else
 622         {
 623           static char hex[17] = "0123456789ABCDEF";
 624
 625           if (remaining < 4)
 626             break;
 627           * buf ++ = '<';
 628           * buf ++ = hex[(c & 0xf0) >> 4];
 629           * buf ++ = hex[c & 0x0f];
 630           * buf ++ = '>';
 631           remaining -= 4;
 632         }
 633
 634       if (remaining == 0)
 635         break;
 636     }
 637
 638   * buf = 0;
 639   return sec_name_buf;
 640 }
 641
 642 static const char *
 643 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 644 {
 645   if (ndx >= filedata->file_header.e_shnum)
 646     return _("<corrupt>");
 647
 648   return printable_section_name (filedata, filedata->section_headers + ndx);
 649 }
 650
 651 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 652
 653 static Elf_Internal_Shdr *
 654 find_section (Filedata * filedata, const char * name)
 655 {
 656   unsigned int i;
 657
 658   if (filedata->section_headers == NULL)
 659     return NULL;
 660
 661   for (i = 0; i < filedata->file_header.e_shnum; i++)
 662     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 663       return filedata->section_headers + i;
 664
 665   return NULL;
 666 }
 667
 668 /* Return a pointer to a section containing ADDR, or NULL if no such
 669    section exists.  */
 670
 671 static Elf_Internal_Shdr *
 672 find_section_by_address (Filedata * filedata, bfd_vma addr)
 673 {
 674   unsigned int i;
 675
 676   if (filedata->section_headers == NULL)
 677     return NULL;
 678
 679   for (i = 0; i < filedata->file_header.e_shnum; i++)
 680     {
 681       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 682
 683       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 684         return sec;
 685     }
 686
 687   return NULL;
 688 }
 689
 690 static Elf_Internal_Shdr *
 691 find_section_by_type (Filedata * filedata, unsigned int type)
 692 {
 693   unsigned int i;
 694
 695   if (filedata->section_headers == NULL)
 696     return NULL;
 697
 698   for (i = 0; i < filedata->file_header.e_shnum; i++)
 699     {
 700       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 701
 702       if (sec->sh_type == type)
 703         return sec;
 704     }
 705
 706   return NULL;
 707 }
 708
 709 /* Return a pointer to section NAME, or NULL if no such section exists,
 710    restricted to the list of sections given in SET.  */
 711
 712 static Elf_Internal_Shdr *
 713 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 714 {
 715   unsigned int i;
 716
 717   if (filedata->section_headers == NULL)
 718     return NULL;
 719
 720   if (set != NULL)
 721     {
 722       while ((i = *set++) > 0)
 723         {
 724           /* See PR 21156 for a reproducer.  */
 725           if (i >= filedata->file_header.e_shnum)
 726             continue; /* FIXME: Should we issue an error message ?  */
 727
 728           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 729             return filedata->section_headers + i;
 730         }
 731     }
 732
 733   return find_section (filedata, name);
 734 }
 735
 736 /* Read an unsigned LEB128 encoded value from DATA.
 737    Set *LENGTH_RETURN to the number of bytes read.  */
 738
 739 static inline unsigned long
 740 read_uleb128 (unsigned char * data,
 741               unsigned int * length_return,
 742               const unsigned char * const end)
 743 {
 744   return read_leb128 (data, length_return, FALSE, end);
 745 }
 746
 747 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 748    This OS has so many departures from the ELF standard that we test it at
 749    many places.  */
 750
 751 static inline bfd_boolean
 752 is_ia64_vms (Filedata * filedata)
 753 {
 754   return filedata->file_header.e_machine == EM_IA_64
 755     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 756 }
 757
 758 /* Guess the relocation size commonly used by the specific machines.  */
 759
 760 static bfd_boolean
 761 guess_is_rela (unsigned int e_machine)
 762 {
 763   switch (e_machine)
 764     {
 765       /* Targets that use REL relocations.  */
 766     case EM_386:
 767     case EM_IAMCU:
 768     case EM_960:
 769     case EM_ARM:
 770     case EM_D10V:
 771     case EM_CYGNUS_D10V:
 772     case EM_DLX:
 773     case EM_MIPS:
 774     case EM_MIPS_RS3_LE:
 775     case EM_CYGNUS_M32R:
 776     case EM_SCORE:
 777     case EM_XGATE:
 778       return FALSE;
 779
 780       /* Targets that use RELA relocations.  */
 781     case EM_68K:
 782     case EM_860:
 783     case EM_AARCH64:
 784     case EM_ADAPTEVA_EPIPHANY:
 785     case EM_ALPHA:
 786     case EM_ALTERA_NIOS2:
 787     case EM_ARC:
 788     case EM_ARC_COMPACT:
 789     case EM_ARC_COMPACT2:
 790     case EM_AVR:
 791     case EM_AVR_OLD:
 792     case EM_BLACKFIN:
 793     case EM_CR16:
 794     case EM_CRIS:
 795     case EM_CRX:
 796     case EM_D30V:
 797     case EM_CYGNUS_D30V:
 798     case EM_FR30:
 799     case EM_FT32:
 800     case EM_CYGNUS_FR30:
 801     case EM_CYGNUS_FRV:
 802     case EM_H8S:
 803     case EM_H8_300:
 804     case EM_H8_300H:
 805     case EM_IA_64:
 806     case EM_IP2K:
 807     case EM_IP2K_OLD:
 808     case EM_IQ2000:
 809     case EM_LATTICEMICO32:
 810     case EM_M32C_OLD:
 811     case EM_M32C:
 812     case EM_M32R:
 813     case EM_MCORE:
 814     case EM_CYGNUS_MEP:
 815     case EM_METAG:
 816     case EM_MMIX:
 817     case EM_MN10200:
 818     case EM_CYGNUS_MN10200:
 819     case EM_MN10300:
 820     case EM_CYGNUS_MN10300:
 821     case EM_MOXIE:
 822     case EM_MSP430:
 823     case EM_MSP430_OLD:
 824     case EM_MT:
 825     case EM_NDS32:
 826     case EM_NIOS32:
 827     case EM_OR1K:
 828     case EM_PPC64:
 829     case EM_PPC:
 830     case EM_TI_PRU:
 831     case EM_RISCV:
 832     case EM_RL78:
 833     case EM_RX:
 834     case EM_S390:
 835     case EM_S390_OLD:
 836     case EM_SH:
 837     case EM_SPARC:
 838     case EM_SPARC32PLUS:
 839     case EM_SPARCV9:
 840     case EM_SPU:
 841     case EM_TI_C6000:
 842     case EM_TILEGX:
 843     case EM_TILEPRO:
 844     case EM_V800:
 845     case EM_V850:
 846     case EM_CYGNUS_V850:
 847     case EM_VAX:
 848     case EM_VISIUM:
 849     case EM_X86_64:
 850     case EM_L1OM:
 851     case EM_K1OM:
 852     case EM_XSTORMY16:
 853     case EM_XTENSA:
 854     case EM_XTENSA_OLD:
 855     case EM_MICROBLAZE:
 856     case EM_MICROBLAZE_OLD:
 857     case EM_WEBASSEMBLY:
 858       return TRUE;
 859
 860     case EM_68HC05:
 861     case EM_68HC08:
 862     case EM_68HC11:
 863     case EM_68HC16:
 864     case EM_FX66:
 865     case EM_ME16:
 866     case EM_MMA:
 867     case EM_NCPU:
 868     case EM_NDR1:
 869     case EM_PCP:
 870     case EM_ST100:
 871     case EM_ST19:
 872     case EM_ST7:
 873     case EM_ST9PLUS:
 874     case EM_STARCORE:
 875     case EM_SVX:
 876     case EM_TINYJ:
 877     default:
 878       warn (_("Don't know about relocations on this machine architecture\n"));
 879       return FALSE;
 880     }
 881 }
 882
 883 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 884    Returns TRUE upon success, FALSE otherwise.  If successful then a
 885    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 886    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 887    responsibility to free the allocated buffer.  */
 888
 889 static bfd_boolean
 890 slurp_rela_relocs (Filedata *            filedata,
 891                    unsigned long         rel_offset,
 892                    unsigned long         rel_size,
 893                    Elf_Internal_Rela **  relasp,
 894                    unsigned long *       nrelasp)
 895 {
 896   Elf_Internal_Rela * relas;
 897   size_t nrelas;
 898   unsigned int i;
 899
 900   if (is_32bit_elf)
 901     {
 902       Elf32_External_Rela * erelas;
 903
 904       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 905                                                  rel_size, _("32-bit relocation data"));
 906       if (!erelas)
 907         return FALSE;
 908
 909       nrelas = rel_size / sizeof (Elf32_External_Rela);
 910
 911       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 912                                              sizeof (Elf_Internal_Rela));
 913
 914       if (relas == NULL)
 915         {
 916           free (erelas);
 917           error (_("out of memory parsing relocs\n"));
 918           return FALSE;
 919         }
 920
 921       for (i = 0; i < nrelas; i++)
 922         {
 923           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 924           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 925           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 926         }
 927
 928       free (erelas);
 929     }
 930   else
 931     {
 932       Elf64_External_Rela * erelas;
 933
 934       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 935                                                  rel_size, _("64-bit relocation data"));
 936       if (!erelas)
 937         return FALSE;
 938
 939       nrelas = rel_size / sizeof (Elf64_External_Rela);
 940
 941       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 942                                              sizeof (Elf_Internal_Rela));
 943
 944       if (relas == NULL)
 945         {
 946           free (erelas);
 947           error (_("out of memory parsing relocs\n"));
 948           return FALSE;
 949         }
 950
 951       for (i = 0; i < nrelas; i++)
 952         {
 953           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 954           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 955           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 956
 957           /* The #ifdef BFD64 below is to prevent a compile time
 958              warning.  We know that if we do not have a 64 bit data
 959              type that we will never execute this code anyway.  */
 960 #ifdef BFD64
 961           if (filedata->file_header.e_machine == EM_MIPS
 962               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 963             {
 964               /* In little-endian objects, r_info isn't really a
 965                  64-bit little-endian value: it has a 32-bit
 966                  little-endian symbol index followed by four
 967                  individual byte fields.  Reorder INFO
 968                  accordingly.  */
 969               bfd_vma inf = relas[i].r_info;
 970               inf = (((inf & 0xffffffff) << 32)
 971                       | ((inf >> 56) & 0xff)
 972                       | ((inf >> 40) & 0xff00)
 973                       | ((inf >> 24) & 0xff0000)
 974                       | ((inf >> 8) & 0xff000000));
 975               relas[i].r_info = inf;
 976             }
 977 #endif /* BFD64 */
 978         }
 979
 980       free (erelas);
 981     }
 982
 983   *relasp = relas;
 984   *nrelasp = nrelas;
 985   return TRUE;
 986 }
 987
 988 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 989    Returns TRUE upon success, FALSE otherwise.  If successful then a
 990    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 991    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 992    responsibility to free the allocated buffer.  */
 993
 994 static bfd_boolean
 995 slurp_rel_relocs (Filedata *            filedata,
 996                   unsigned long         rel_offset,
 997                   unsigned long         rel_size,
 998                   Elf_Internal_Rela **  relsp,
 999                   unsigned long *       nrelsp)
1000 {
1001   Elf_Internal_Rela * rels;
1002   size_t nrels;
1003   unsigned int i;
1004
1005   if (is_32bit_elf)
1006     {
1007       Elf32_External_Rel * erels;
1008
1009       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1010                                                rel_size, _("32-bit relocation data"));
1011       if (!erels)
1012         return FALSE;
1013
1014       nrels = rel_size / sizeof (Elf32_External_Rel);
1015
1016       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1017
1018       if (rels == NULL)
1019         {
1020           free (erels);
1021           error (_("out of memory parsing relocs\n"));
1022           return FALSE;
1023         }
1024
1025       for (i = 0; i < nrels; i++)
1026         {
1027           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1028           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1029           rels[i].r_addend = 0;
1030         }
1031
1032       free (erels);
1033     }
1034   else
1035     {
1036       Elf64_External_Rel * erels;
1037
1038       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1039                                                rel_size, _("64-bit relocation data"));
1040       if (!erels)
1041         return FALSE;
1042
1043       nrels = rel_size / sizeof (Elf64_External_Rel);
1044
1045       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1046
1047       if (rels == NULL)
1048         {
1049           free (erels);
1050           error (_("out of memory parsing relocs\n"));
1051           return FALSE;
1052         }
1053
1054       for (i = 0; i < nrels; i++)
1055         {
1056           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1057           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1058           rels[i].r_addend = 0;
1059
1060           /* The #ifdef BFD64 below is to prevent a compile time
1061              warning.  We know that if we do not have a 64 bit data
1062              type that we will never execute this code anyway.  */
1063 #ifdef BFD64
1064           if (filedata->file_header.e_machine == EM_MIPS
1065               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1066             {
1067               /* In little-endian objects, r_info isn't really a
1068                  64-bit little-endian value: it has a 32-bit
1069                  little-endian symbol index followed by four
1070                  individual byte fields.  Reorder INFO
1071                  accordingly.  */
1072               bfd_vma inf = rels[i].r_info;
1073               inf = (((inf & 0xffffffff) << 32)
1074                      | ((inf >> 56) & 0xff)
1075                      | ((inf >> 40) & 0xff00)
1076                      | ((inf >> 24) & 0xff0000)
1077                      | ((inf >> 8) & 0xff000000));
1078               rels[i].r_info = inf;
1079             }
1080 #endif /* BFD64 */
1081         }
1082
1083       free (erels);
1084     }
1085
1086   *relsp = rels;
1087   *nrelsp = nrels;
1088   return TRUE;
1089 }
1090
1091 /* Returns the reloc type extracted from the reloc info field.  */
1092
1093 static unsigned int
1094 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1095 {
1096   if (is_32bit_elf)
1097     return ELF32_R_TYPE (reloc_info);
1098
1099   switch (filedata->file_header.e_machine)
1100     {
1101     case EM_MIPS:
1102       /* Note: We assume that reloc_info has already been adjusted for us.  */
1103       return ELF64_MIPS_R_TYPE (reloc_info);
1104
1105     case EM_SPARCV9:
1106       return ELF64_R_TYPE_ID (reloc_info);
1107
1108     default:
1109       return ELF64_R_TYPE (reloc_info);
1110     }
1111 }
1112
1113 /* Return the symbol index extracted from the reloc info field.  */
1114
1115 static bfd_vma
1116 get_reloc_symindex (bfd_vma reloc_info)
1117 {
1118   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1119 }
1120
1121 static inline bfd_boolean
1122 uses_msp430x_relocs (Filedata * filedata)
1123 {
1124   return
1125     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1126     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1127     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1128         /* TI compiler uses ELFOSABI_NONE.  */
1129         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1130 }
1131
1132 /* Display the contents of the relocation data found at the specified
1133    offset.  */
1134
1135 static bfd_boolean
1136 dump_relocations (Filedata *          filedata,
1137                   unsigned long       rel_offset,
1138                   unsigned long       rel_size,
1139                   Elf_Internal_Sym *  symtab,
1140                   unsigned long       nsyms,
1141                   char *              strtab,
1142                   unsigned long       strtablen,
1143                   int                 is_rela,
1144                   bfd_boolean         is_dynsym)
1145 {
1146   unsigned long i;
1147   Elf_Internal_Rela * rels;
1148   bfd_boolean res = TRUE;
1149
1150   if (is_rela == UNKNOWN)
1151     is_rela = guess_is_rela (filedata->file_header.e_machine);
1152
1153   if (is_rela)
1154     {
1155       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1156         return FALSE;
1157     }
1158   else
1159     {
1160       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1161         return FALSE;
1162     }
1163
1164   if (is_32bit_elf)
1165     {
1166       if (is_rela)
1167         {
1168           if (do_wide)
1169             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1170           else
1171             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1172         }
1173       else
1174         {
1175           if (do_wide)
1176             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1177           else
1178             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1179         }
1180     }
1181   else
1182     {
1183       if (is_rela)
1184         {
1185           if (do_wide)
1186             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1187           else
1188             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1189         }
1190       else
1191         {
1192           if (do_wide)
1193             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1194           else
1195             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1196         }
1197     }
1198
1199   for (i = 0; i < rel_size; i++)
1200     {
1201       const char * rtype;
1202       bfd_vma offset;
1203       bfd_vma inf;
1204       bfd_vma symtab_index;
1205       bfd_vma type;
1206
1207       offset = rels[i].r_offset;
1208       inf    = rels[i].r_info;
1209
1210       type = get_reloc_type (filedata, inf);
1211       symtab_index = get_reloc_symindex  (inf);
1212
1213       if (is_32bit_elf)
1214         {
1215           printf ("%8.8lx  %8.8lx ",
1216                   (unsigned long) offset & 0xffffffff,
1217                   (unsigned long) inf & 0xffffffff);
1218         }
1219       else
1220         {
1221 #if BFD_HOST_64BIT_LONG
1222           printf (do_wide
1223                   ? "%16.16lx  %16.16lx "
1224                   : "%12.12lx  %12.12lx ",
1225                   offset, inf);
1226 #elif BFD_HOST_64BIT_LONG_LONG
1227 #ifndef __MSVCRT__
1228           printf (do_wide
1229                   ? "%16.16llx  %16.16llx "
1230                   : "%12.12llx  %12.12llx ",
1231                   offset, inf);
1232 #else
1233           printf (do_wide
1234                   ? "%16.16I64x  %16.16I64x "
1235                   : "%12.12I64x  %12.12I64x ",
1236                   offset, inf);
1237 #endif
1238 #else
1239           printf (do_wide
1240                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1241                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1242                   _bfd_int64_high (offset),
1243                   _bfd_int64_low (offset),
1244                   _bfd_int64_high (inf),
1245                   _bfd_int64_low (inf));
1246 #endif
1247         }
1248
1249       switch (filedata->file_header.e_machine)
1250         {
1251         default:
1252           rtype = NULL;
1253           break;
1254
1255         case EM_AARCH64:
1256           rtype = elf_aarch64_reloc_type (type);
1257           break;
1258
1259         case EM_M32R:
1260         case EM_CYGNUS_M32R:
1261           rtype = elf_m32r_reloc_type (type);
1262           break;
1263
1264         case EM_386:
1265         case EM_IAMCU:
1266           rtype = elf_i386_reloc_type (type);
1267           break;
1268
1269         case EM_68HC11:
1270         case EM_68HC12:
1271           rtype = elf_m68hc11_reloc_type (type);
1272           break;
1273
1274         case EM_68K:
1275           rtype = elf_m68k_reloc_type (type);
1276           break;
1277
1278         case EM_960:
1279           rtype = elf_i960_reloc_type (type);
1280           break;
1281
1282         case EM_AVR:
1283         case EM_AVR_OLD:
1284           rtype = elf_avr_reloc_type (type);
1285           break;
1286
1287         case EM_OLD_SPARCV9:
1288         case EM_SPARC32PLUS:
1289         case EM_SPARCV9:
1290         case EM_SPARC:
1291           rtype = elf_sparc_reloc_type (type);
1292           break;
1293
1294         case EM_SPU:
1295           rtype = elf_spu_reloc_type (type);
1296           break;
1297
1298         case EM_V800:
1299           rtype = v800_reloc_type (type);
1300           break;
1301         case EM_V850:
1302         case EM_CYGNUS_V850:
1303           rtype = v850_reloc_type (type);
1304           break;
1305
1306         case EM_D10V:
1307         case EM_CYGNUS_D10V:
1308           rtype = elf_d10v_reloc_type (type);
1309           break;
1310
1311         case EM_D30V:
1312         case EM_CYGNUS_D30V:
1313           rtype = elf_d30v_reloc_type (type);
1314           break;
1315
1316         case EM_DLX:
1317           rtype = elf_dlx_reloc_type (type);
1318           break;
1319
1320         case EM_SH:
1321           rtype = elf_sh_reloc_type (type);
1322           break;
1323
1324         case EM_MN10300:
1325         case EM_CYGNUS_MN10300:
1326           rtype = elf_mn10300_reloc_type (type);
1327           break;
1328
1329         case EM_MN10200:
1330         case EM_CYGNUS_MN10200:
1331           rtype = elf_mn10200_reloc_type (type);
1332           break;
1333
1334         case EM_FR30:
1335         case EM_CYGNUS_FR30:
1336           rtype = elf_fr30_reloc_type (type);
1337           break;
1338
1339         case EM_CYGNUS_FRV:
1340           rtype = elf_frv_reloc_type (type);
1341           break;
1342
1343         case EM_FT32:
1344           rtype = elf_ft32_reloc_type (type);
1345           break;
1346
1347         case EM_MCORE:
1348           rtype = elf_mcore_reloc_type (type);
1349           break;
1350
1351         case EM_MMIX:
1352           rtype = elf_mmix_reloc_type (type);
1353           break;
1354
1355         case EM_MOXIE:
1356           rtype = elf_moxie_reloc_type (type);
1357           break;
1358
1359         case EM_MSP430:
1360           if (uses_msp430x_relocs (filedata))
1361             {
1362               rtype = elf_msp430x_reloc_type (type);
1363               break;
1364             }
1365           /* Fall through.  */
1366         case EM_MSP430_OLD:
1367           rtype = elf_msp430_reloc_type (type);
1368           break;
1369
1370         case EM_NDS32:
1371           rtype = elf_nds32_reloc_type (type);
1372           break;
1373
1374         case EM_PPC:
1375           rtype = elf_ppc_reloc_type (type);
1376           break;
1377
1378         case EM_PPC64:
1379           rtype = elf_ppc64_reloc_type (type);
1380           break;
1381
1382         case EM_MIPS:
1383         case EM_MIPS_RS3_LE:
1384           rtype = elf_mips_reloc_type (type);
1385           break;
1386
1387         case EM_RISCV:
1388           rtype = elf_riscv_reloc_type (type);
1389           break;
1390
1391         case EM_ALPHA:
1392           rtype = elf_alpha_reloc_type (type);
1393           break;
1394
1395         case EM_ARM:
1396           rtype = elf_arm_reloc_type (type);
1397           break;
1398
1399         case EM_ARC:
1400         case EM_ARC_COMPACT:
1401         case EM_ARC_COMPACT2:
1402           rtype = elf_arc_reloc_type (type);
1403           break;
1404
1405         case EM_PARISC:
1406           rtype = elf_hppa_reloc_type (type);
1407           break;
1408
1409         case EM_H8_300:
1410         case EM_H8_300H:
1411         case EM_H8S:
1412           rtype = elf_h8_reloc_type (type);
1413           break;
1414
1415         case EM_OR1K:
1416           rtype = elf_or1k_reloc_type (type);
1417           break;
1418
1419         case EM_PJ:
1420         case EM_PJ_OLD:
1421           rtype = elf_pj_reloc_type (type);
1422           break;
1423         case EM_IA_64:
1424           rtype = elf_ia64_reloc_type (type);
1425           break;
1426
1427         case EM_CRIS:
1428           rtype = elf_cris_reloc_type (type);
1429           break;
1430
1431         case EM_860:
1432           rtype = elf_i860_reloc_type (type);
1433           break;
1434
1435         case EM_X86_64:
1436         case EM_L1OM:
1437         case EM_K1OM:
1438           rtype = elf_x86_64_reloc_type (type);
1439           break;
1440
1441         case EM_S370:
1442           rtype = i370_reloc_type (type);
1443           break;
1444
1445         case EM_S390_OLD:
1446         case EM_S390:
1447           rtype = elf_s390_reloc_type (type);
1448           break;
1449
1450         case EM_SCORE:
1451           rtype = elf_score_reloc_type (type);
1452           break;
1453
1454         case EM_XSTORMY16:
1455           rtype = elf_xstormy16_reloc_type (type);
1456           break;
1457
1458         case EM_CRX:
1459           rtype = elf_crx_reloc_type (type);
1460           break;
1461
1462         case EM_VAX:
1463           rtype = elf_vax_reloc_type (type);
1464           break;
1465
1466         case EM_VISIUM:
1467           rtype = elf_visium_reloc_type (type);
1468           break;
1469
1470         case EM_ADAPTEVA_EPIPHANY:
1471           rtype = elf_epiphany_reloc_type (type);
1472           break;
1473
1474         case EM_IP2K:
1475         case EM_IP2K_OLD:
1476           rtype = elf_ip2k_reloc_type (type);
1477           break;
1478
1479         case EM_IQ2000:
1480           rtype = elf_iq2000_reloc_type (type);
1481           break;
1482
1483         case EM_XTENSA_OLD:
1484         case EM_XTENSA:
1485           rtype = elf_xtensa_reloc_type (type);
1486           break;
1487
1488         case EM_LATTICEMICO32:
1489           rtype = elf_lm32_reloc_type (type);
1490           break;
1491
1492         case EM_M32C_OLD:
1493         case EM_M32C:
1494           rtype = elf_m32c_reloc_type (type);
1495           break;
1496
1497         case EM_MT:
1498           rtype = elf_mt_reloc_type (type);
1499           break;
1500
1501         case EM_BLACKFIN:
1502           rtype = elf_bfin_reloc_type (type);
1503           break;
1504
1505         case EM_CYGNUS_MEP:
1506           rtype = elf_mep_reloc_type (type);
1507           break;
1508
1509         case EM_CR16:
1510           rtype = elf_cr16_reloc_type (type);
1511           break;
1512
1513         case EM_MICROBLAZE:
1514         case EM_MICROBLAZE_OLD:
1515           rtype = elf_microblaze_reloc_type (type);
1516           break;
1517
1518         case EM_RL78:
1519           rtype = elf_rl78_reloc_type (type);
1520           break;
1521
1522         case EM_RX:
1523           rtype = elf_rx_reloc_type (type);
1524           break;
1525
1526         case EM_METAG:
1527           rtype = elf_metag_reloc_type (type);
1528           break;
1529
1530         case EM_XC16X:
1531         case EM_C166:
1532           rtype = elf_xc16x_reloc_type (type);
1533           break;
1534
1535         case EM_TI_C6000:
1536           rtype = elf_tic6x_reloc_type (type);
1537           break;
1538
1539         case EM_TILEGX:
1540           rtype = elf_tilegx_reloc_type (type);
1541           break;
1542
1543         case EM_TILEPRO:
1544           rtype = elf_tilepro_reloc_type (type);
1545           break;
1546
1547         case EM_WEBASSEMBLY:
1548           rtype = elf_wasm32_reloc_type (type);
1549           break;
1550
1551         case EM_XGATE:
1552           rtype = elf_xgate_reloc_type (type);
1553           break;
1554
1555         case EM_ALTERA_NIOS2:
1556           rtype = elf_nios2_reloc_type (type);
1557           break;
1558
1559         case EM_TI_PRU:
1560           rtype = elf_pru_reloc_type (type);
1561           break;
1562         }
1563
1564       if (rtype == NULL)
1565         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1566       else
1567         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1568
1569       if (filedata->file_header.e_machine == EM_ALPHA
1570           && rtype != NULL
1571           && streq (rtype, "R_ALPHA_LITUSE")
1572           && is_rela)
1573         {
1574           switch (rels[i].r_addend)
1575             {
1576             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1577             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1578             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1579             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1580             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1581             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1582             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1583             default: rtype = NULL;
1584             }
1585
1586           if (rtype)
1587             printf (" (%s)", rtype);
1588           else
1589             {
1590               putchar (' ');
1591               printf (_("<unknown addend: %lx>"),
1592                       (unsigned long) rels[i].r_addend);
1593               res = FALSE;
1594             }
1595         }
1596       else if (symtab_index)
1597         {
1598           if (symtab == NULL || symtab_index >= nsyms)
1599             {
1600               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1601               res = FALSE;
1602             }
1603           else
1604             {
1605               Elf_Internal_Sym * psym;
1606               const char * version_string;
1607               enum versioned_symbol_info sym_info;
1608               unsigned short vna_other;
1609
1610               psym = symtab + symtab_index;
1611
1612               version_string
1613                 = get_symbol_version_string (filedata, is_dynsym,
1614                                              strtab, strtablen,
1615                                              symtab_index,
1616                                              psym,
1617                                              &sym_info,
1618                                              &vna_other);
1619
1620               printf (" ");
1621
1622               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1623                 {
1624                   const char * name;
1625                   unsigned int len;
1626                   unsigned int width = is_32bit_elf ? 8 : 14;
1627
1628                   /* Relocations against GNU_IFUNC symbols do not use the value
1629                      of the symbol as the address to relocate against.  Instead
1630                      they invoke the function named by the symbol and use its
1631                      result as the address for relocation.
1632
1633                      To indicate this to the user, do not display the value of
1634                      the symbol in the "Symbols's Value" field.  Instead show
1635                      its name followed by () as a hint that the symbol is
1636                      invoked.  */
1637
1638                   if (strtab == NULL
1639                       || psym->st_name == 0
1640                       || psym->st_name >= strtablen)
1641                     name = "??";
1642                   else
1643                     name = strtab + psym->st_name;
1644
1645                   len = print_symbol (width, name);
1646                   if (version_string)
1647                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1648                             version_string);
1649                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1650                 }
1651               else
1652                 {
1653                   print_vma (psym->st_value, LONG_HEX);
1654
1655                   printf (is_32bit_elf ? "   " : " ");
1656                 }
1657
1658               if (psym->st_name == 0)
1659                 {
1660                   const char * sec_name = "<null>";
1661                   char name_buf[40];
1662
1663                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1664                     {
1665                       if (psym->st_shndx < filedata->file_header.e_shnum)
1666                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1667                       else if (psym->st_shndx == SHN_ABS)
1668                         sec_name = "ABS";
1669                       else if (psym->st_shndx == SHN_COMMON)
1670                         sec_name = "COMMON";
1671                       else if ((filedata->file_header.e_machine == EM_MIPS
1672                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1673                                || (filedata->file_header.e_machine == EM_TI_C6000
1674                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1675                         sec_name = "SCOMMON";
1676                       else if (filedata->file_header.e_machine == EM_MIPS
1677                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1678                         sec_name = "SUNDEF";
1679                       else if ((filedata->file_header.e_machine == EM_X86_64
1680                                 || filedata->file_header.e_machine == EM_L1OM
1681                                 || filedata->file_header.e_machine == EM_K1OM)
1682                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1683                         sec_name = "LARGE_COMMON";
1684                       else if (filedata->file_header.e_machine == EM_IA_64
1685                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1686                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1687                         sec_name = "ANSI_COM";
1688                       else if (is_ia64_vms (filedata)
1689                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1690                         sec_name = "VMS_SYMVEC";
1691                       else
1692                         {
1693                           sprintf (name_buf, "<section 0x%x>",
1694                                    (unsigned int) psym->st_shndx);
1695                           sec_name = name_buf;
1696                         }
1697                     }
1698                   print_symbol (22, sec_name);
1699                 }
1700               else if (strtab == NULL)
1701                 printf (_("<string table index: %3ld>"), psym->st_name);
1702               else if (psym->st_name >= strtablen)
1703                 {
1704                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1705                   res = FALSE;
1706                 }
1707               else
1708                 {
1709                   print_symbol (22, strtab + psym->st_name);
1710                   if (version_string)
1711                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1712                             version_string);
1713                 }
1714
1715               if (is_rela)
1716                 {
1717                   bfd_vma off = rels[i].r_addend;
1718
1719                   if ((bfd_signed_vma) off < 0)
1720                     printf (" - %" BFD_VMA_FMT "x", - off);
1721                   else
1722                     printf (" + %" BFD_VMA_FMT "x", off);
1723                 }
1724             }
1725         }
1726       else if (is_rela)
1727         {
1728           bfd_vma off = rels[i].r_addend;
1729
1730           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1731           if ((bfd_signed_vma) off < 0)
1732             printf ("-%" BFD_VMA_FMT "x", - off);
1733           else
1734             printf ("%" BFD_VMA_FMT "x", off);
1735         }
1736
1737       if (filedata->file_header.e_machine == EM_SPARCV9
1738           && rtype != NULL
1739           && streq (rtype, "R_SPARC_OLO10"))
1740         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1741
1742       putchar ('\n');
1743
1744 #ifdef BFD64
1745       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1746         {
1747           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1748           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1749           const char * rtype2 = elf_mips_reloc_type (type2);
1750           const char * rtype3 = elf_mips_reloc_type (type3);
1751
1752           printf ("                    Type2: ");
1753
1754           if (rtype2 == NULL)
1755             printf (_("unrecognized: %-7lx"),
1756                     (unsigned long) type2 & 0xffffffff);
1757           else
1758             printf ("%-17.17s", rtype2);
1759
1760           printf ("\n                    Type3: ");
1761
1762           if (rtype3 == NULL)
1763             printf (_("unrecognized: %-7lx"),
1764                     (unsigned long) type3 & 0xffffffff);
1765           else
1766             printf ("%-17.17s", rtype3);
1767
1768           putchar ('\n');
1769         }
1770 #endif /* BFD64 */
1771     }
1772
1773   free (rels);
1774
1775   return res;
1776 }
1777
1778 static const char *
1779 get_mips_dynamic_type (unsigned long type)
1780 {
1781   switch (type)
1782     {
1783     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1784     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1785     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1786     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1787     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1788     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1789     case DT_MIPS_MSYM: return "MIPS_MSYM";
1790     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1791     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1792     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1793     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1794     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1795     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1796     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1797     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1798     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1799     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1800     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1801     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1802     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1803     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1804     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1805     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1806     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1807     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1808     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1809     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1810     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1811     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1812     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1813     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1814     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1815     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1816     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1817     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1818     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1819     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1820     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1821     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1822     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1823     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1824     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1825     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1826     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1827     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1828     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1829     default:
1830       return NULL;
1831     }
1832 }
1833
1834 static const char *
1835 get_sparc64_dynamic_type (unsigned long type)
1836 {
1837   switch (type)
1838     {
1839     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1840     default:
1841       return NULL;
1842     }
1843 }
1844
1845 static const char *
1846 get_ppc_dynamic_type (unsigned long type)
1847 {
1848   switch (type)
1849     {
1850     case DT_PPC_GOT:    return "PPC_GOT";
1851     case DT_PPC_OPT:    return "PPC_OPT";
1852     default:
1853       return NULL;
1854     }
1855 }
1856
1857 static const char *
1858 get_ppc64_dynamic_type (unsigned long type)
1859 {
1860   switch (type)
1861     {
1862     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1863     case DT_PPC64_OPD:    return "PPC64_OPD";
1864     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1865     case DT_PPC64_OPT:    return "PPC64_OPT";
1866     default:
1867       return NULL;
1868     }
1869 }
1870
1871 static const char *
1872 get_parisc_dynamic_type (unsigned long type)
1873 {
1874   switch (type)
1875     {
1876     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1877     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1878     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1879     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1880     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1881     case DT_HP_PREINIT:         return "HP_PREINIT";
1882     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1883     case DT_HP_NEEDED:          return "HP_NEEDED";
1884     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1885     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1886     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1887     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1888     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1889     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1890     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1891     case DT_HP_FILTERED:        return "HP_FILTERED";
1892     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1893     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1894     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1895     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1896     case DT_PLT:                return "PLT";
1897     case DT_PLT_SIZE:           return "PLT_SIZE";
1898     case DT_DLT:                return "DLT";
1899     case DT_DLT_SIZE:           return "DLT_SIZE";
1900     default:
1901       return NULL;
1902     }
1903 }
1904
1905 static const char *
1906 get_ia64_dynamic_type (unsigned long type)
1907 {
1908   switch (type)
1909     {
1910     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1911     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1912     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1913     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1914     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1915     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1916     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1917     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1918     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1919     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1920     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1921     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1922     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1923     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1924     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1925     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1926     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1927     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1928     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1929     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1930     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1931     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1932     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1933     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1934     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1935     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1936     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1937     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1938     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1939     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1940     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1941     default:
1942       return NULL;
1943     }
1944 }
1945
1946 static const char *
1947 get_solaris_section_type (unsigned long type)
1948 {
1949   switch (type)
1950     {
1951     case 0x6fffffee: return "SUNW_ancillary";
1952     case 0x6fffffef: return "SUNW_capchain";
1953     case 0x6ffffff0: return "SUNW_capinfo";
1954     case 0x6ffffff1: return "SUNW_symsort";
1955     case 0x6ffffff2: return "SUNW_tlssort";
1956     case 0x6ffffff3: return "SUNW_LDYNSYM";
1957     case 0x6ffffff4: return "SUNW_dof";
1958     case 0x6ffffff5: return "SUNW_cap";
1959     case 0x6ffffff6: return "SUNW_SIGNATURE";
1960     case 0x6ffffff7: return "SUNW_ANNOTATE";
1961     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1962     case 0x6ffffff9: return "SUNW_DEBUG";
1963     case 0x6ffffffa: return "SUNW_move";
1964     case 0x6ffffffb: return "SUNW_COMDAT";
1965     case 0x6ffffffc: return "SUNW_syminfo";
1966     case 0x6ffffffd: return "SUNW_verdef";
1967     case 0x6ffffffe: return "SUNW_verneed";
1968     case 0x6fffffff: return "SUNW_versym";
1969     case 0x70000000: return "SPARC_GOTDATA";
1970     default: return NULL;
1971     }
1972 }
1973
1974 static const char *
1975 get_alpha_dynamic_type (unsigned long type)
1976 {
1977   switch (type)
1978     {
1979     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1980     default: return NULL;
1981     }
1982 }
1983
1984 static const char *
1985 get_score_dynamic_type (unsigned long type)
1986 {
1987   switch (type)
1988     {
1989     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1990     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1991     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1992     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1993     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1994     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1995     default:                    return NULL;
1996     }
1997 }
1998
1999 static const char *
2000 get_tic6x_dynamic_type (unsigned long type)
2001 {
2002   switch (type)
2003     {
2004     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2005     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2006     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2007     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2008     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2009     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2010     default:                   return NULL;
2011     }
2012 }
2013
2014 static const char *
2015 get_nios2_dynamic_type (unsigned long type)
2016 {
2017   switch (type)
2018     {
2019     case DT_NIOS2_GP: return "NIOS2_GP";
2020     default:          return NULL;
2021     }
2022 }
2023
2024 static const char *
2025 get_solaris_dynamic_type (unsigned long type)
2026 {
2027   switch (type)
2028     {
2029     case 0x6000000d: return "SUNW_AUXILIARY";
2030     case 0x6000000e: return "SUNW_RTLDINF";
2031     case 0x6000000f: return "SUNW_FILTER";
2032     case 0x60000010: return "SUNW_CAP";
2033     case 0x60000011: return "SUNW_SYMTAB";
2034     case 0x60000012: return "SUNW_SYMSZ";
2035     case 0x60000013: return "SUNW_SORTENT";
2036     case 0x60000014: return "SUNW_SYMSORT";
2037     case 0x60000015: return "SUNW_SYMSORTSZ";
2038     case 0x60000016: return "SUNW_TLSSORT";
2039     case 0x60000017: return "SUNW_TLSSORTSZ";
2040     case 0x60000018: return "SUNW_CAPINFO";
2041     case 0x60000019: return "SUNW_STRPAD";
2042     case 0x6000001a: return "SUNW_CAPCHAIN";
2043     case 0x6000001b: return "SUNW_LDMACH";
2044     case 0x6000001d: return "SUNW_CAPCHAINENT";
2045     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2046     case 0x60000021: return "SUNW_PARENT";
2047     case 0x60000023: return "SUNW_ASLR";
2048     case 0x60000025: return "SUNW_RELAX";
2049     case 0x60000029: return "SUNW_NXHEAP";
2050     case 0x6000002b: return "SUNW_NXSTACK";
2051
2052     case 0x70000001: return "SPARC_REGISTER";
2053     case 0x7ffffffd: return "AUXILIARY";
2054     case 0x7ffffffe: return "USED";
2055     case 0x7fffffff: return "FILTER";
2056
2057     default: return NULL;
2058     }
2059 }
2060
2061 static const char *
2062 get_dynamic_type (Filedata * filedata, unsigned long type)
2063 {
2064   static char buff[64];
2065
2066   switch (type)
2067     {
2068     case DT_NULL:       return "NULL";
2069     case DT_NEEDED:     return "NEEDED";
2070     case DT_PLTRELSZ:   return "PLTRELSZ";
2071     case DT_PLTGOT:     return "PLTGOT";
2072     case DT_HASH:       return "HASH";
2073     case DT_STRTAB:     return "STRTAB";
2074     case DT_SYMTAB:     return "SYMTAB";
2075     case DT_RELA:       return "RELA";
2076     case DT_RELASZ:     return "RELASZ";
2077     case DT_RELAENT:    return "RELAENT";
2078     case DT_STRSZ:      return "STRSZ";
2079     case DT_SYMENT:     return "SYMENT";
2080     case DT_INIT:       return "INIT";
2081     case DT_FINI:       return "FINI";
2082     case DT_SONAME:     return "SONAME";
2083     case DT_RPATH:      return "RPATH";
2084     case DT_SYMBOLIC:   return "SYMBOLIC";
2085     case DT_REL:        return "REL";
2086     case DT_RELSZ:      return "RELSZ";
2087     case DT_RELENT:     return "RELENT";
2088     case DT_PLTREL:     return "PLTREL";
2089     case DT_DEBUG:      return "DEBUG";
2090     case DT_TEXTREL:    return "TEXTREL";
2091     case DT_JMPREL:     return "JMPREL";
2092     case DT_BIND_NOW:   return "BIND_NOW";
2093     case DT_INIT_ARRAY: return "INIT_ARRAY";
2094     case DT_FINI_ARRAY: return "FINI_ARRAY";
2095     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2096     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2097     case DT_RUNPATH:    return "RUNPATH";
2098     case DT_FLAGS:      return "FLAGS";
2099
2100     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2101     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2102     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2103
2104     case DT_CHECKSUM:   return "CHECKSUM";
2105     case DT_PLTPADSZ:   return "PLTPADSZ";
2106     case DT_MOVEENT:    return "MOVEENT";
2107     case DT_MOVESZ:     return "MOVESZ";
2108     case DT_FEATURE:    return "FEATURE";
2109     case DT_POSFLAG_1:  return "POSFLAG_1";
2110     case DT_SYMINSZ:    return "SYMINSZ";
2111     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2112
2113     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2114     case DT_CONFIG:     return "CONFIG";
2115     case DT_DEPAUDIT:   return "DEPAUDIT";
2116     case DT_AUDIT:      return "AUDIT";
2117     case DT_PLTPAD:     return "PLTPAD";
2118     case DT_MOVETAB:    return "MOVETAB";
2119     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2120
2121     case DT_VERSYM:     return "VERSYM";
2122
2123     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2124     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2125     case DT_RELACOUNT:  return "RELACOUNT";
2126     case DT_RELCOUNT:   return "RELCOUNT";
2127     case DT_FLAGS_1:    return "FLAGS_1";
2128     case DT_VERDEF:     return "VERDEF";
2129     case DT_VERDEFNUM:  return "VERDEFNUM";
2130     case DT_VERNEED:    return "VERNEED";
2131     case DT_VERNEEDNUM: return "VERNEEDNUM";
2132
2133     case DT_AUXILIARY:  return "AUXILIARY";
2134     case DT_USED:       return "USED";
2135     case DT_FILTER:     return "FILTER";
2136
2137     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2138     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2139     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2140     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2141     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2142     case DT_GNU_HASH:   return "GNU_HASH";
2143
2144     default:
2145       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2146         {
2147           const char * result;
2148
2149           switch (filedata->file_header.e_machine)
2150             {
2151             case EM_MIPS:
2152             case EM_MIPS_RS3_LE:
2153               result = get_mips_dynamic_type (type);
2154               break;
2155             case EM_SPARCV9:
2156               result = get_sparc64_dynamic_type (type);
2157               break;
2158             case EM_PPC:
2159               result = get_ppc_dynamic_type (type);
2160               break;
2161             case EM_PPC64:
2162               result = get_ppc64_dynamic_type (type);
2163               break;
2164             case EM_IA_64:
2165               result = get_ia64_dynamic_type (type);
2166               break;
2167             case EM_ALPHA:
2168               result = get_alpha_dynamic_type (type);
2169               break;
2170             case EM_SCORE:
2171               result = get_score_dynamic_type (type);
2172               break;
2173             case EM_TI_C6000:
2174               result = get_tic6x_dynamic_type (type);
2175               break;
2176             case EM_ALTERA_NIOS2:
2177               result = get_nios2_dynamic_type (type);
2178               break;
2179             default:
2180               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2181                 result = get_solaris_dynamic_type (type);
2182               else
2183                 result = NULL;
2184               break;
2185             }
2186
2187           if (result != NULL)
2188             return result;
2189
2190           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2191         }
2192       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2193                || (filedata->file_header.e_machine == EM_PARISC
2194                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2195         {
2196           const char * result;
2197
2198           switch (filedata->file_header.e_machine)
2199             {
2200             case EM_PARISC:
2201               result = get_parisc_dynamic_type (type);
2202               break;
2203             case EM_IA_64:
2204               result = get_ia64_dynamic_type (type);
2205               break;
2206             default:
2207               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2208                 result = get_solaris_dynamic_type (type);
2209               else
2210                 result = NULL;
2211               break;
2212             }
2213
2214           if (result != NULL)
2215             return result;
2216
2217           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2218                     type);
2219         }
2220       else
2221         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2222
2223       return buff;
2224     }
2225 }
2226
2227 static char *
2228 get_file_type (unsigned e_type)
2229 {
2230   static char buff[32];
2231
2232   switch (e_type)
2233     {
2234     case ET_NONE: return _("NONE (None)");
2235     case ET_REL:  return _("REL (Relocatable file)");
2236     case ET_EXEC: return _("EXEC (Executable file)");
2237     case ET_DYN:  return _("DYN (Shared object file)");
2238     case ET_CORE: return _("CORE (Core file)");
2239
2240     default:
2241       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2242         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2243       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2244         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2245       else
2246         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2247       return buff;
2248     }
2249 }
2250
2251 static char *
2252 get_machine_name (unsigned e_machine)
2253 {
2254   static char buff[64]; /* XXX */
2255
2256   switch (e_machine)
2257     {
2258       /* Please keep this switch table sorted by increasing EM_ value.  */
2259       /* 0 */
2260     case EM_NONE:               return _("None");
2261     case EM_M32:                return "WE32100";
2262     case EM_SPARC:              return "Sparc";
2263     case EM_386:                return "Intel 80386";
2264     case EM_68K:                return "MC68000";
2265     case EM_88K:                return "MC88000";
2266     case EM_IAMCU:              return "Intel MCU";
2267     case EM_860:                return "Intel 80860";
2268     case EM_MIPS:               return "MIPS R3000";
2269     case EM_S370:               return "IBM System/370";
2270       /* 10 */
2271     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2272     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2273     case EM_PARISC:             return "HPPA";
2274     case EM_VPP550:             return "Fujitsu VPP500";
2275     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2276     case EM_960:                return "Intel 90860";
2277     case EM_PPC:                return "PowerPC";
2278       /* 20 */
2279     case EM_PPC64:              return "PowerPC64";
2280     case EM_S390_OLD:
2281     case EM_S390:               return "IBM S/390";
2282     case EM_SPU:                return "SPU";
2283       /* 30 */
2284     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2285     case EM_FR20:               return "Fujitsu FR20";
2286     case EM_RH32:               return "TRW RH32";
2287     case EM_MCORE:              return "MCORE";
2288       /* 40 */
2289     case EM_ARM:                return "ARM";
2290     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2291     case EM_SH:                 return "Renesas / SuperH SH";
2292     case EM_SPARCV9:            return "Sparc v9";
2293     case EM_TRICORE:            return "Siemens Tricore";
2294     case EM_ARC:                return "ARC";
2295     case EM_H8_300:             return "Renesas H8/300";
2296     case EM_H8_300H:            return "Renesas H8/300H";
2297     case EM_H8S:                return "Renesas H8S";
2298     case EM_H8_500:             return "Renesas H8/500";
2299       /* 50 */
2300     case EM_IA_64:              return "Intel IA-64";
2301     case EM_MIPS_X:             return "Stanford MIPS-X";
2302     case EM_COLDFIRE:           return "Motorola Coldfire";
2303     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2304     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2305     case EM_PCP:                return "Siemens PCP";
2306     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2307     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2308     case EM_STARCORE:           return "Motorola Star*Core processor";
2309     case EM_ME16:               return "Toyota ME16 processor";
2310       /* 60 */
2311     case EM_ST100:              return "STMicroelectronics ST100 processor";
2312     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2313     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2314     case EM_PDSP:               return "Sony DSP processor";
2315     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2316     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2317     case EM_FX66:               return "Siemens FX66 microcontroller";
2318     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2319     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2320     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2321       /* 70 */
2322     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2323     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2324     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2325     case EM_SVX:                return "Silicon Graphics SVx";
2326     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2327     case EM_VAX:                return "Digital VAX";
2328     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2329     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2330     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2331     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2332       /* 80 */
2333     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2334     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2335     case EM_PRISM:              return "Vitesse Prism";
2336     case EM_AVR_OLD:
2337     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2338     case EM_CYGNUS_FR30:
2339     case EM_FR30:               return "Fujitsu FR30";
2340     case EM_CYGNUS_D10V:
2341     case EM_D10V:               return "d10v";
2342     case EM_CYGNUS_D30V:
2343     case EM_D30V:               return "d30v";
2344     case EM_CYGNUS_V850:
2345     case EM_V850:               return "Renesas V850";
2346     case EM_CYGNUS_M32R:
2347     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2348     case EM_CYGNUS_MN10300:
2349     case EM_MN10300:            return "mn10300";
2350       /* 90 */
2351     case EM_CYGNUS_MN10200:
2352     case EM_MN10200:            return "mn10200";
2353     case EM_PJ:                 return "picoJava";
2354     case EM_OR1K:               return "OpenRISC 1000";
2355     case EM_ARC_COMPACT:        return "ARCompact";
2356     case EM_XTENSA_OLD:
2357     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2358     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2359     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2360     case EM_NS32K:              return "National Semiconductor 32000 series";
2361     case EM_TPC:                return "Tenor Network TPC processor";
2362     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2363       /* 100 */
2364     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2365     case EM_IP2K_OLD:
2366     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2367     case EM_MAX:                return "MAX Processor";
2368     case EM_CR:                 return "National Semiconductor CompactRISC";
2369     case EM_F2MC16:             return "Fujitsu F2MC16";
2370     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2371     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2372     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2373     case EM_SEP:                return "Sharp embedded microprocessor";
2374     case EM_ARCA:               return "Arca RISC microprocessor";
2375       /* 110 */
2376     case EM_UNICORE:            return "Unicore";
2377     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2378     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2379     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2380     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2381     case EM_XGATE:              return "Motorola XGATE embedded processor";
2382     case EM_C166:
2383     case EM_XC16X:              return "Infineon Technologies xc16x";
2384     case EM_M16C:               return "Renesas M16C series microprocessors";
2385     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2386     case EM_CE:                 return "Freescale Communication Engine RISC core";
2387       /* 120 */
2388     case EM_M32C:               return "Renesas M32c";
2389       /* 130 */
2390     case EM_TSK3000:            return "Altium TSK3000 core";
2391     case EM_RS08:               return "Freescale RS08 embedded processor";
2392     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2393     case EM_SCORE:              return "SUNPLUS S+Core";
2394     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2395     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2396     case EM_LATTICEMICO32:      return "Lattice Mico32";
2397     case EM_SE_C17:             return "Seiko Epson C17 family";
2398       /* 140 */
2399     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2400     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2401     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2402     case EM_TI_PRU:             return "TI PRU I/O processor";
2403       /* 160 */
2404     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2405     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2406     case EM_R32C:               return "Renesas R32C series microprocessors";
2407     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2408     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2409     case EM_8051:               return "Intel 8051 and variants";
2410     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2411     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2412     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2413     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2414       /* 170 */
2415     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2416     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2417     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2418     case EM_RX:                 return "Renesas RX";
2419     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2420     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2421     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2422     case EM_CR16:
2423     case EM_MICROBLAZE:
2424     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2425     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2426     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2427       /* 180 */
2428     case EM_L1OM:               return "Intel L1OM";
2429     case EM_K1OM:               return "Intel K1OM";
2430     case EM_INTEL182:           return "Intel (reserved)";
2431     case EM_AARCH64:            return "AArch64";
2432     case EM_ARM184:             return "ARM (reserved)";
2433     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2434     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2435     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2436     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2437       /* 190 */
2438     case EM_CUDA:               return "NVIDIA CUDA architecture";
2439     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2440     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2441     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2442     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2443     case EM_ARC_COMPACT2:       return "ARCv2";
2444     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2445     case EM_RL78:               return "Renesas RL78";
2446     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2447     case EM_78K0R:              return "Renesas 78K0R";
2448       /* 200 */
2449     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2450     case EM_BA1:                return "Beyond BA1 CPU architecture";
2451     case EM_BA2:                return "Beyond BA2 CPU architecture";
2452     case EM_XCORE:              return "XMOS xCORE processor family";
2453     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2454       /* 210 */
2455     case EM_KM32:               return "KM211 KM32 32-bit processor";
2456     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2457     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2458     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2459     case EM_KVARC:              return "KM211 KVARC processor";
2460     case EM_CDP:                return "Paneve CDP architecture family";
2461     case EM_COGE:               return "Cognitive Smart Memory Processor";
2462     case EM_COOL:               return "Bluechip Systems CoolEngine";
2463     case EM_NORC:               return "Nanoradio Optimized RISC";
2464     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2465       /* 220 */
2466     case EM_Z80:                return "Zilog Z80";
2467     case EM_VISIUM:             return "CDS VISIUMcore processor";
2468     case EM_FT32:               return "FTDI Chip FT32";
2469     case EM_MOXIE:              return "Moxie";
2470     case EM_AMDGPU:             return "AMD GPU";
2471     case EM_RISCV:              return "RISC-V";
2472     case EM_LANAI:              return "Lanai 32-bit processor";
2473     case EM_BPF:                return "Linux BPF";
2474
2475       /* Large numbers...  */
2476     case EM_MT:                 return "Morpho Techologies MT processor";
2477     case EM_ALPHA:              return "Alpha";
2478     case EM_WEBASSEMBLY:        return "Web Assembly";
2479     case EM_DLX:                return "OpenDLX";
2480     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2481     case EM_IQ2000:             return "Vitesse IQ2000";
2482     case EM_M32C_OLD:
2483     case EM_NIOS32:             return "Altera Nios";
2484     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2485     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2486     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2487
2488     default:
2489       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2490       return buff;
2491     }
2492 }
2493
2494 static void
2495 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2496 {
2497   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2498      other compilers don't a specific architecture type in the e_flags, and
2499      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2500      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2501      architectures.
2502
2503      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2504      but also sets a specific architecture type in the e_flags field.
2505
2506      However, when decoding the flags we don't worry if we see an
2507      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2508      ARCEM architecture type.  */
2509
2510   switch (e_flags & EF_ARC_MACH_MSK)
2511     {
2512       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2513     case EF_ARC_CPU_ARCV2EM:
2514       strcat (buf, ", ARC EM");
2515       break;
2516     case EF_ARC_CPU_ARCV2HS:
2517       strcat (buf, ", ARC HS");
2518       break;
2519
2520       /* We only expect these to occur for EM_ARC_COMPACT.  */
2521     case E_ARC_MACH_ARC600:
2522       strcat (buf, ", ARC600");
2523       break;
2524     case E_ARC_MACH_ARC601:
2525       strcat (buf, ", ARC601");
2526       break;
2527     case E_ARC_MACH_ARC700:
2528       strcat (buf, ", ARC700");
2529       break;
2530
2531       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2532          new ELF with new architecture being read by an old version of
2533          readelf, or (c) An ELF built with non-GNU compiler that does not
2534          set the architecture in the e_flags.  */
2535     default:
2536       if (e_machine == EM_ARC_COMPACT)
2537         strcat (buf, ", Unknown ARCompact");
2538       else
2539         strcat (buf, ", Unknown ARC");
2540       break;
2541     }
2542
2543   switch (e_flags & EF_ARC_OSABI_MSK)
2544     {
2545     case E_ARC_OSABI_ORIG:
2546       strcat (buf, ", (ABI:legacy)");
2547       break;
2548     case E_ARC_OSABI_V2:
2549       strcat (buf, ", (ABI:v2)");
2550       break;
2551       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2552     case E_ARC_OSABI_V3:
2553       strcat (buf, ", v3 no-legacy-syscalls ABI");
2554       break;
2555     case E_ARC_OSABI_V4:
2556       strcat (buf, ", v4 ABI");
2557       break;
2558     default:
2559       strcat (buf, ", unrecognised ARC OSABI flag");
2560       break;
2561     }
2562 }
2563
2564 static void
2565 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2566 {
2567   unsigned eabi;
2568   bfd_boolean unknown = FALSE;
2569
2570   eabi = EF_ARM_EABI_VERSION (e_flags);
2571   e_flags &= ~ EF_ARM_EABIMASK;
2572
2573   /* Handle "generic" ARM flags.  */
2574   if (e_flags & EF_ARM_RELEXEC)
2575     {
2576       strcat (buf, ", relocatable executable");
2577       e_flags &= ~ EF_ARM_RELEXEC;
2578     }
2579
2580   /* Now handle EABI specific flags.  */
2581   switch (eabi)
2582     {
2583     default:
2584       strcat (buf, ", <unrecognized EABI>");
2585       if (e_flags)
2586         unknown = TRUE;
2587       break;
2588
2589     case EF_ARM_EABI_VER1:
2590       strcat (buf, ", Version1 EABI");
2591       while (e_flags)
2592         {
2593           unsigned flag;
2594
2595           /* Process flags one bit at a time.  */
2596           flag = e_flags & - e_flags;
2597           e_flags &= ~ flag;
2598
2599           switch (flag)
2600             {
2601             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2602               strcat (buf, ", sorted symbol tables");
2603               break;
2604
2605             default:
2606               unknown = TRUE;
2607               break;
2608             }
2609         }
2610       break;
2611
2612     case EF_ARM_EABI_VER2:
2613       strcat (buf, ", Version2 EABI");
2614       while (e_flags)
2615         {
2616           unsigned flag;
2617
2618           /* Process flags one bit at a time.  */
2619           flag = e_flags & - e_flags;
2620           e_flags &= ~ flag;
2621
2622           switch (flag)
2623             {
2624             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2625               strcat (buf, ", sorted symbol tables");
2626               break;
2627
2628             case EF_ARM_DYNSYMSUSESEGIDX:
2629               strcat (buf, ", dynamic symbols use segment index");
2630               break;
2631
2632             case EF_ARM_MAPSYMSFIRST:
2633               strcat (buf, ", mapping symbols precede others");
2634               break;
2635
2636             default:
2637               unknown = TRUE;
2638               break;
2639             }
2640         }
2641       break;
2642
2643     case EF_ARM_EABI_VER3:
2644       strcat (buf, ", Version3 EABI");
2645       break;
2646
2647     case EF_ARM_EABI_VER4:
2648       strcat (buf, ", Version4 EABI");
2649       while (e_flags)
2650         {
2651           unsigned flag;
2652
2653           /* Process flags one bit at a time.  */
2654           flag = e_flags & - e_flags;
2655           e_flags &= ~ flag;
2656
2657           switch (flag)
2658             {
2659             case EF_ARM_BE8:
2660               strcat (buf, ", BE8");
2661               break;
2662
2663             case EF_ARM_LE8:
2664               strcat (buf, ", LE8");
2665               break;
2666
2667             default:
2668               unknown = TRUE;
2669               break;
2670             }
2671         }
2672       break;
2673
2674     case EF_ARM_EABI_VER5:
2675       strcat (buf, ", Version5 EABI");
2676       while (e_flags)
2677         {
2678           unsigned flag;
2679
2680           /* Process flags one bit at a time.  */
2681           flag = e_flags & - e_flags;
2682           e_flags &= ~ flag;
2683
2684           switch (flag)
2685             {
2686             case EF_ARM_BE8:
2687               strcat (buf, ", BE8");
2688               break;
2689
2690             case EF_ARM_LE8:
2691               strcat (buf, ", LE8");
2692               break;
2693
2694             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2695               strcat (buf, ", soft-float ABI");
2696               break;
2697
2698             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2699               strcat (buf, ", hard-float ABI");
2700               break;
2701
2702             default:
2703               unknown = TRUE;
2704               break;
2705             }
2706         }
2707       break;
2708
2709     case EF_ARM_EABI_UNKNOWN:
2710       strcat (buf, ", GNU EABI");
2711       while (e_flags)
2712         {
2713           unsigned flag;
2714
2715           /* Process flags one bit at a time.  */
2716           flag = e_flags & - e_flags;
2717           e_flags &= ~ flag;
2718
2719           switch (flag)
2720             {
2721             case EF_ARM_INTERWORK:
2722               strcat (buf, ", interworking enabled");
2723               break;
2724
2725             case EF_ARM_APCS_26:
2726               strcat (buf, ", uses APCS/26");
2727               break;
2728
2729             case EF_ARM_APCS_FLOAT:
2730               strcat (buf, ", uses APCS/float");
2731               break;
2732
2733             case EF_ARM_PIC:
2734               strcat (buf, ", position independent");
2735               break;
2736
2737             case EF_ARM_ALIGN8:
2738               strcat (buf, ", 8 bit structure alignment");
2739               break;
2740
2741             case EF_ARM_NEW_ABI:
2742               strcat (buf, ", uses new ABI");
2743               break;
2744
2745             case EF_ARM_OLD_ABI:
2746               strcat (buf, ", uses old ABI");
2747               break;
2748
2749             case EF_ARM_SOFT_FLOAT:
2750               strcat (buf, ", software FP");
2751               break;
2752
2753             case EF_ARM_VFP_FLOAT:
2754               strcat (buf, ", VFP");
2755               break;
2756
2757             case EF_ARM_MAVERICK_FLOAT:
2758               strcat (buf, ", Maverick FP");
2759               break;
2760
2761             default:
2762               unknown = TRUE;
2763               break;
2764             }
2765         }
2766     }
2767
2768   if (unknown)
2769     strcat (buf,_(", <unknown>"));
2770 }
2771
2772 static void
2773 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2774 {
2775   --size; /* Leave space for null terminator.  */
2776
2777   switch (e_flags & EF_AVR_MACH)
2778     {
2779     case E_AVR_MACH_AVR1:
2780       strncat (buf, ", avr:1", size);
2781       break;
2782     case E_AVR_MACH_AVR2:
2783       strncat (buf, ", avr:2", size);
2784       break;
2785     case E_AVR_MACH_AVR25:
2786       strncat (buf, ", avr:25", size);
2787       break;
2788     case E_AVR_MACH_AVR3:
2789       strncat (buf, ", avr:3", size);
2790       break;
2791     case E_AVR_MACH_AVR31:
2792       strncat (buf, ", avr:31", size);
2793       break;
2794     case E_AVR_MACH_AVR35:
2795       strncat (buf, ", avr:35", size);
2796       break;
2797     case E_AVR_MACH_AVR4:
2798       strncat (buf, ", avr:4", size);
2799       break;
2800     case E_AVR_MACH_AVR5:
2801       strncat (buf, ", avr:5", size);
2802       break;
2803     case E_AVR_MACH_AVR51:
2804       strncat (buf, ", avr:51", size);
2805       break;
2806     case E_AVR_MACH_AVR6:
2807       strncat (buf, ", avr:6", size);
2808       break;
2809     case E_AVR_MACH_AVRTINY:
2810       strncat (buf, ", avr:100", size);
2811       break;
2812     case E_AVR_MACH_XMEGA1:
2813       strncat (buf, ", avr:101", size);
2814       break;
2815     case E_AVR_MACH_XMEGA2:
2816       strncat (buf, ", avr:102", size);
2817       break;
2818     case E_AVR_MACH_XMEGA3:
2819       strncat (buf, ", avr:103", size);
2820       break;
2821     case E_AVR_MACH_XMEGA4:
2822       strncat (buf, ", avr:104", size);
2823       break;
2824     case E_AVR_MACH_XMEGA5:
2825       strncat (buf, ", avr:105", size);
2826       break;
2827     case E_AVR_MACH_XMEGA6:
2828       strncat (buf, ", avr:106", size);
2829       break;
2830     case E_AVR_MACH_XMEGA7:
2831       strncat (buf, ", avr:107", size);
2832       break;
2833     default:
2834       strncat (buf, ", avr:<unknown>", size);
2835       break;
2836     }
2837
2838   size -= strlen (buf);
2839   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2840     strncat (buf, ", link-relax", size);
2841 }
2842
2843 static void
2844 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2845 {
2846   unsigned abi;
2847   unsigned arch;
2848   unsigned config;
2849   unsigned version;
2850   bfd_boolean has_fpu = FALSE;
2851   unsigned int r = 0;
2852
2853   static const char *ABI_STRINGS[] =
2854   {
2855     "ABI v0", /* use r5 as return register; only used in N1213HC */
2856     "ABI v1", /* use r0 as return register */
2857     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2858     "ABI v2fp", /* for FPU */
2859     "AABI",
2860     "ABI2 FP+"
2861   };
2862   static const char *VER_STRINGS[] =
2863   {
2864     "Andes ELF V1.3 or older",
2865     "Andes ELF V1.3.1",
2866     "Andes ELF V1.4"
2867   };
2868   static const char *ARCH_STRINGS[] =
2869   {
2870     "",
2871     "Andes Star v1.0",
2872     "Andes Star v2.0",
2873     "Andes Star v3.0",
2874     "Andes Star v3.0m"
2875   };
2876
2877   abi = EF_NDS_ABI & e_flags;
2878   arch = EF_NDS_ARCH & e_flags;
2879   config = EF_NDS_INST & e_flags;
2880   version = EF_NDS32_ELF_VERSION & e_flags;
2881
2882   memset (buf, 0, size);
2883
2884   switch (abi)
2885     {
2886     case E_NDS_ABI_V0:
2887     case E_NDS_ABI_V1:
2888     case E_NDS_ABI_V2:
2889     case E_NDS_ABI_V2FP:
2890     case E_NDS_ABI_AABI:
2891     case E_NDS_ABI_V2FP_PLUS:
2892       /* In case there are holes in the array.  */
2893       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2894       break;
2895
2896     default:
2897       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2898       break;
2899     }
2900
2901   switch (version)
2902     {
2903     case E_NDS32_ELF_VER_1_2:
2904     case E_NDS32_ELF_VER_1_3:
2905     case E_NDS32_ELF_VER_1_4:
2906       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2907       break;
2908
2909     default:
2910       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2911       break;
2912     }
2913
2914   if (E_NDS_ABI_V0 == abi)
2915     {
2916       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2917       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2918       if (arch == E_NDS_ARCH_STAR_V1_0)
2919         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2920       return;
2921     }
2922
2923   switch (arch)
2924     {
2925     case E_NDS_ARCH_STAR_V1_0:
2926     case E_NDS_ARCH_STAR_V2_0:
2927     case E_NDS_ARCH_STAR_V3_0:
2928     case E_NDS_ARCH_STAR_V3_M:
2929       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2930       break;
2931
2932     default:
2933       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2934       /* ARCH version determines how the e_flags are interpreted.
2935          If it is unknown, we cannot proceed.  */
2936       return;
2937     }
2938
2939   /* Newer ABI; Now handle architecture specific flags.  */
2940   if (arch == E_NDS_ARCH_STAR_V1_0)
2941     {
2942       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2943         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2944
2945       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2946         r += snprintf (buf + r, size -r, ", MAC");
2947
2948       if (config & E_NDS32_HAS_DIV_INST)
2949         r += snprintf (buf + r, size -r, ", DIV");
2950
2951       if (config & E_NDS32_HAS_16BIT_INST)
2952         r += snprintf (buf + r, size -r, ", 16b");
2953     }
2954   else
2955     {
2956       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2957         {
2958           if (version <= E_NDS32_ELF_VER_1_3)
2959             r += snprintf (buf + r, size -r, ", [B8]");
2960           else
2961             r += snprintf (buf + r, size -r, ", EX9");
2962         }
2963
2964       if (config & E_NDS32_HAS_MAC_DX_INST)
2965         r += snprintf (buf + r, size -r, ", MAC_DX");
2966
2967       if (config & E_NDS32_HAS_DIV_DX_INST)
2968         r += snprintf (buf + r, size -r, ", DIV_DX");
2969
2970       if (config & E_NDS32_HAS_16BIT_INST)
2971         {
2972           if (version <= E_NDS32_ELF_VER_1_3)
2973             r += snprintf (buf + r, size -r, ", 16b");
2974           else
2975             r += snprintf (buf + r, size -r, ", IFC");
2976         }
2977     }
2978
2979   if (config & E_NDS32_HAS_EXT_INST)
2980     r += snprintf (buf + r, size -r, ", PERF1");
2981
2982   if (config & E_NDS32_HAS_EXT2_INST)
2983     r += snprintf (buf + r, size -r, ", PERF2");
2984
2985   if (config & E_NDS32_HAS_FPU_INST)
2986     {
2987       has_fpu = TRUE;
2988       r += snprintf (buf + r, size -r, ", FPU_SP");
2989     }
2990
2991   if (config & E_NDS32_HAS_FPU_DP_INST)
2992     {
2993       has_fpu = TRUE;
2994       r += snprintf (buf + r, size -r, ", FPU_DP");
2995     }
2996
2997   if (config & E_NDS32_HAS_FPU_MAC_INST)
2998     {
2999       has_fpu = TRUE;
3000       r += snprintf (buf + r, size -r, ", FPU_MAC");
3001     }
3002
3003   if (has_fpu)
3004     {
3005       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3006         {
3007         case E_NDS32_FPU_REG_8SP_4DP:
3008           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3009           break;
3010         case E_NDS32_FPU_REG_16SP_8DP:
3011           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3012           break;
3013         case E_NDS32_FPU_REG_32SP_16DP:
3014           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3015           break;
3016         case E_NDS32_FPU_REG_32SP_32DP:
3017           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3018           break;
3019         }
3020     }
3021
3022   if (config & E_NDS32_HAS_AUDIO_INST)
3023     r += snprintf (buf + r, size -r, ", AUDIO");
3024
3025   if (config & E_NDS32_HAS_STRING_INST)
3026     r += snprintf (buf + r, size -r, ", STR");
3027
3028   if (config & E_NDS32_HAS_REDUCED_REGS)
3029     r += snprintf (buf + r, size -r, ", 16REG");
3030
3031   if (config & E_NDS32_HAS_VIDEO_INST)
3032     {
3033       if (version <= E_NDS32_ELF_VER_1_3)
3034         r += snprintf (buf + r, size -r, ", VIDEO");
3035       else
3036         r += snprintf (buf + r, size -r, ", SATURATION");
3037     }
3038
3039   if (config & E_NDS32_HAS_ENCRIPT_INST)
3040     r += snprintf (buf + r, size -r, ", ENCRP");
3041
3042   if (config & E_NDS32_HAS_L2C_INST)
3043     r += snprintf (buf + r, size -r, ", L2C");
3044 }
3045
3046 static char *
3047 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3048 {
3049   static char buf[1024];
3050
3051   buf[0] = '\0';
3052
3053   if (e_flags)
3054     {
3055       switch (e_machine)
3056         {
3057         default:
3058           break;
3059
3060         case EM_ARC_COMPACT2:
3061         case EM_ARC_COMPACT:
3062           decode_ARC_machine_flags (e_flags, e_machine, buf);
3063           break;
3064
3065         case EM_ARM:
3066           decode_ARM_machine_flags (e_flags, buf);
3067           break;
3068
3069         case EM_AVR:
3070           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3071           break;
3072
3073         case EM_BLACKFIN:
3074           if (e_flags & EF_BFIN_PIC)
3075             strcat (buf, ", PIC");
3076
3077           if (e_flags & EF_BFIN_FDPIC)
3078             strcat (buf, ", FDPIC");
3079
3080           if (e_flags & EF_BFIN_CODE_IN_L1)
3081             strcat (buf, ", code in L1");
3082
3083           if (e_flags & EF_BFIN_DATA_IN_L1)
3084             strcat (buf, ", data in L1");
3085
3086           break;
3087
3088         case EM_CYGNUS_FRV:
3089           switch (e_flags & EF_FRV_CPU_MASK)
3090             {
3091             case EF_FRV_CPU_GENERIC:
3092               break;
3093
3094             default:
3095               strcat (buf, ", fr???");
3096               break;
3097
3098             case EF_FRV_CPU_FR300:
3099               strcat (buf, ", fr300");
3100               break;
3101
3102             case EF_FRV_CPU_FR400:
3103               strcat (buf, ", fr400");
3104               break;
3105             case EF_FRV_CPU_FR405:
3106               strcat (buf, ", fr405");
3107               break;
3108
3109             case EF_FRV_CPU_FR450:
3110               strcat (buf, ", fr450");
3111               break;
3112
3113             case EF_FRV_CPU_FR500:
3114               strcat (buf, ", fr500");
3115               break;
3116             case EF_FRV_CPU_FR550:
3117               strcat (buf, ", fr550");
3118               break;
3119
3120             case EF_FRV_CPU_SIMPLE:
3121               strcat (buf, ", simple");
3122               break;
3123             case EF_FRV_CPU_TOMCAT:
3124               strcat (buf, ", tomcat");
3125               break;
3126             }
3127           break;
3128
3129         case EM_68K:
3130           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3131             strcat (buf, ", m68000");
3132           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3133             strcat (buf, ", cpu32");
3134           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3135             strcat (buf, ", fido_a");
3136           else
3137             {
3138               char const * isa = _("unknown");
3139               char const * mac = _("unknown mac");
3140               char const * additional = NULL;
3141
3142               switch (e_flags & EF_M68K_CF_ISA_MASK)
3143                 {
3144                 case EF_M68K_CF_ISA_A_NODIV:
3145                   isa = "A";
3146                   additional = ", nodiv";
3147                   break;
3148                 case EF_M68K_CF_ISA_A:
3149                   isa = "A";
3150                   break;
3151                 case EF_M68K_CF_ISA_A_PLUS:
3152                   isa = "A+";
3153                   break;
3154                 case EF_M68K_CF_ISA_B_NOUSP:
3155                   isa = "B";
3156                   additional = ", nousp";
3157                   break;
3158                 case EF_M68K_CF_ISA_B:
3159                   isa = "B";
3160                   break;
3161                 case EF_M68K_CF_ISA_C:
3162                   isa = "C";
3163                   break;
3164                 case EF_M68K_CF_ISA_C_NODIV:
3165                   isa = "C";
3166                   additional = ", nodiv";
3167                   break;
3168                 }
3169               strcat (buf, ", cf, isa ");
3170               strcat (buf, isa);
3171               if (additional)
3172                 strcat (buf, additional);
3173               if (e_flags & EF_M68K_CF_FLOAT)
3174                 strcat (buf, ", float");
3175               switch (e_flags & EF_M68K_CF_MAC_MASK)
3176                 {
3177                 case 0:
3178                   mac = NULL;
3179                   break;
3180                 case EF_M68K_CF_MAC:
3181                   mac = "mac";
3182                   break;
3183                 case EF_M68K_CF_EMAC:
3184                   mac = "emac";
3185                   break;
3186                 case EF_M68K_CF_EMAC_B:
3187                   mac = "emac_b";
3188                   break;
3189                 }
3190               if (mac)
3191                 {
3192                   strcat (buf, ", ");
3193                   strcat (buf, mac);
3194                 }
3195             }
3196           break;
3197
3198         case EM_CYGNUS_MEP:
3199           switch (e_flags & EF_MEP_CPU_MASK)
3200             {
3201             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3202             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3203             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3204             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3205             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3206             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3207             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3208             }
3209
3210           switch (e_flags & EF_MEP_COP_MASK)
3211             {
3212             case EF_MEP_COP_NONE: break;
3213             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3214             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3215             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3216             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3217             default: strcat (buf, _("<unknown MeP copro type>")); break;
3218             }
3219
3220           if (e_flags & EF_MEP_LIBRARY)
3221             strcat (buf, ", Built for Library");
3222
3223           if (e_flags & EF_MEP_INDEX_MASK)
3224             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3225                      e_flags & EF_MEP_INDEX_MASK);
3226
3227           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3228             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3229                      e_flags & ~ EF_MEP_ALL_FLAGS);
3230           break;
3231
3232         case EM_PPC:
3233           if (e_flags & EF_PPC_EMB)
3234             strcat (buf, ", emb");
3235
3236           if (e_flags & EF_PPC_RELOCATABLE)
3237             strcat (buf, _(", relocatable"));
3238
3239           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3240             strcat (buf, _(", relocatable-lib"));
3241           break;
3242
3243         case EM_PPC64:
3244           if (e_flags & EF_PPC64_ABI)
3245             {
3246               char abi[] = ", abiv0";
3247
3248               abi[6] += e_flags & EF_PPC64_ABI;
3249               strcat (buf, abi);
3250             }
3251           break;
3252
3253         case EM_V800:
3254           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3255             strcat (buf, ", RH850 ABI");
3256
3257           if (e_flags & EF_V800_850E3)
3258             strcat (buf, ", V3 architecture");
3259
3260           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3261             strcat (buf, ", FPU not used");
3262
3263           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3264             strcat (buf, ", regmode: COMMON");
3265
3266           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3267             strcat (buf, ", r4 not used");
3268
3269           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3270             strcat (buf, ", r30 not used");
3271
3272           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3273             strcat (buf, ", r5 not used");
3274
3275           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3276             strcat (buf, ", r2 not used");
3277
3278           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3279             {
3280               switch (e_flags & - e_flags)
3281                 {
3282                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3283                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3284                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3285                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3286                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3287                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3288                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3289                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3290                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3291                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3292                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3293                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3294                 default: break;
3295                 }
3296             }
3297           break;
3298
3299         case EM_V850:
3300         case EM_CYGNUS_V850:
3301           switch (e_flags & EF_V850_ARCH)
3302             {
3303             case E_V850E3V5_ARCH:
3304               strcat (buf, ", v850e3v5");
3305               break;
3306             case E_V850E2V3_ARCH:
3307               strcat (buf, ", v850e2v3");
3308               break;
3309             case E_V850E2_ARCH:
3310               strcat (buf, ", v850e2");
3311               break;
3312             case E_V850E1_ARCH:
3313               strcat (buf, ", v850e1");
3314               break;
3315             case E_V850E_ARCH:
3316               strcat (buf, ", v850e");
3317               break;
3318             case E_V850_ARCH:
3319               strcat (buf, ", v850");
3320               break;
3321             default:
3322               strcat (buf, _(", unknown v850 architecture variant"));
3323               break;
3324             }
3325           break;
3326
3327         case EM_M32R:
3328         case EM_CYGNUS_M32R:
3329           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3330             strcat (buf, ", m32r");
3331           break;
3332
3333         case EM_MIPS:
3334         case EM_MIPS_RS3_LE:
3335           if (e_flags & EF_MIPS_NOREORDER)
3336             strcat (buf, ", noreorder");
3337
3338           if (e_flags & EF_MIPS_PIC)
3339             strcat (buf, ", pic");
3340
3341           if (e_flags & EF_MIPS_CPIC)
3342             strcat (buf, ", cpic");
3343
3344           if (e_flags & EF_MIPS_UCODE)
3345             strcat (buf, ", ugen_reserved");
3346
3347           if (e_flags & EF_MIPS_ABI2)
3348             strcat (buf, ", abi2");
3349
3350           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3351             strcat (buf, ", odk first");
3352
3353           if (e_flags & EF_MIPS_32BITMODE)
3354             strcat (buf, ", 32bitmode");
3355
3356           if (e_flags & EF_MIPS_NAN2008)
3357             strcat (buf, ", nan2008");
3358
3359           if (e_flags & EF_MIPS_FP64)
3360             strcat (buf, ", fp64");
3361
3362           switch ((e_flags & EF_MIPS_MACH))
3363             {
3364             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3365             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3366             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3367             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3368             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3369             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3370             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3371             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3372             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3373             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3374             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3375             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3376             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3377             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3378             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3379             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3380             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3381             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3382             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3383             case 0:
3384             /* We simply ignore the field in this case to avoid confusion:
3385                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3386                extension.  */
3387               break;
3388             default: strcat (buf, _(", unknown CPU")); break;
3389             }
3390
3391           switch ((e_flags & EF_MIPS_ABI))
3392             {
3393             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3394             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3395             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3396             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3397             case 0:
3398             /* We simply ignore the field in this case to avoid confusion:
3399                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3400                This means it is likely to be an o32 file, but not for
3401                sure.  */
3402               break;
3403             default: strcat (buf, _(", unknown ABI")); break;
3404             }
3405
3406           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3407             strcat (buf, ", mdmx");
3408
3409           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3410             strcat (buf, ", mips16");
3411
3412           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3413             strcat (buf, ", micromips");
3414
3415           switch ((e_flags & EF_MIPS_ARCH))
3416             {
3417             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3418             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3419             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3420             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3421             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3422             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3423             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3424             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3425             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3426             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3427             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3428             default: strcat (buf, _(", unknown ISA")); break;
3429             }
3430           break;
3431
3432         case EM_NDS32:
3433           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3434           break;
3435
3436         case EM_RISCV:
3437           if (e_flags & EF_RISCV_RVC)
3438             strcat (buf, ", RVC");
3439
3440           switch (e_flags & EF_RISCV_FLOAT_ABI)
3441             {
3442             case EF_RISCV_FLOAT_ABI_SOFT:
3443               strcat (buf, ", soft-float ABI");
3444               break;
3445
3446             case EF_RISCV_FLOAT_ABI_SINGLE:
3447               strcat (buf, ", single-float ABI");
3448               break;
3449
3450             case EF_RISCV_FLOAT_ABI_DOUBLE:
3451               strcat (buf, ", double-float ABI");
3452               break;
3453
3454             case EF_RISCV_FLOAT_ABI_QUAD:
3455               strcat (buf, ", quad-float ABI");
3456               break;
3457             }
3458           break;
3459
3460         case EM_SH:
3461           switch ((e_flags & EF_SH_MACH_MASK))
3462             {
3463             case EF_SH1: strcat (buf, ", sh1"); break;
3464             case EF_SH2: strcat (buf, ", sh2"); break;
3465             case EF_SH3: strcat (buf, ", sh3"); break;
3466             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3467             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3468             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3469             case EF_SH3E: strcat (buf, ", sh3e"); break;
3470             case EF_SH4: strcat (buf, ", sh4"); break;
3471             case EF_SH5: strcat (buf, ", sh5"); break;
3472             case EF_SH2E: strcat (buf, ", sh2e"); break;
3473             case EF_SH4A: strcat (buf, ", sh4a"); break;
3474             case EF_SH2A: strcat (buf, ", sh2a"); break;
3475             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3476             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3477             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3478             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3479             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3480             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3481             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3482             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3483             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3484             default: strcat (buf, _(", unknown ISA")); break;
3485             }
3486
3487           if (e_flags & EF_SH_PIC)
3488             strcat (buf, ", pic");
3489
3490           if (e_flags & EF_SH_FDPIC)
3491             strcat (buf, ", fdpic");
3492           break;
3493
3494         case EM_OR1K:
3495           if (e_flags & EF_OR1K_NODELAY)
3496             strcat (buf, ", no delay");
3497           break;
3498
3499         case EM_SPARCV9:
3500           if (e_flags & EF_SPARC_32PLUS)
3501             strcat (buf, ", v8+");
3502
3503           if (e_flags & EF_SPARC_SUN_US1)
3504             strcat (buf, ", ultrasparcI");
3505
3506           if (e_flags & EF_SPARC_SUN_US3)
3507             strcat (buf, ", ultrasparcIII");
3508
3509           if (e_flags & EF_SPARC_HAL_R1)
3510             strcat (buf, ", halr1");
3511
3512           if (e_flags & EF_SPARC_LEDATA)
3513             strcat (buf, ", ledata");
3514
3515           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3516             strcat (buf, ", tso");
3517
3518           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3519             strcat (buf, ", pso");
3520
3521           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3522             strcat (buf, ", rmo");
3523           break;
3524
3525         case EM_PARISC:
3526           switch (e_flags & EF_PARISC_ARCH)
3527             {
3528             case EFA_PARISC_1_0:
3529               strcpy (buf, ", PA-RISC 1.0");
3530               break;
3531             case EFA_PARISC_1_1:
3532               strcpy (buf, ", PA-RISC 1.1");
3533               break;
3534             case EFA_PARISC_2_0:
3535               strcpy (buf, ", PA-RISC 2.0");
3536               break;
3537             default:
3538               break;
3539             }
3540           if (e_flags & EF_PARISC_TRAPNIL)
3541             strcat (buf, ", trapnil");
3542           if (e_flags & EF_PARISC_EXT)
3543             strcat (buf, ", ext");
3544           if (e_flags & EF_PARISC_LSB)
3545             strcat (buf, ", lsb");
3546           if (e_flags & EF_PARISC_WIDE)
3547             strcat (buf, ", wide");
3548           if (e_flags & EF_PARISC_NO_KABP)
3549             strcat (buf, ", no kabp");
3550           if (e_flags & EF_PARISC_LAZYSWAP)
3551             strcat (buf, ", lazyswap");
3552           break;
3553
3554         case EM_PJ:
3555         case EM_PJ_OLD:
3556           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3557             strcat (buf, ", new calling convention");
3558
3559           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3560             strcat (buf, ", gnu calling convention");
3561           break;
3562
3563         case EM_IA_64:
3564           if ((e_flags & EF_IA_64_ABI64))
3565             strcat (buf, ", 64-bit");
3566           else
3567             strcat (buf, ", 32-bit");
3568           if ((e_flags & EF_IA_64_REDUCEDFP))
3569             strcat (buf, ", reduced fp model");
3570           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3571             strcat (buf, ", no function descriptors, constant gp");
3572           else if ((e_flags & EF_IA_64_CONS_GP))
3573             strcat (buf, ", constant gp");
3574           if ((e_flags & EF_IA_64_ABSOLUTE))
3575             strcat (buf, ", absolute");
3576           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3577             {
3578               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3579                 strcat (buf, ", vms_linkages");
3580               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3581                 {
3582                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3583                   break;
3584                 case EF_IA_64_VMS_COMCOD_WARNING:
3585                   strcat (buf, ", warning");
3586                   break;
3587                 case EF_IA_64_VMS_COMCOD_ERROR:
3588                   strcat (buf, ", error");
3589                   break;
3590                 case EF_IA_64_VMS_COMCOD_ABORT:
3591                   strcat (buf, ", abort");
3592                   break;
3593                 default:
3594                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3595                         e_flags & EF_IA_64_VMS_COMCOD);
3596                   strcat (buf, ", <unknown>");
3597                 }
3598             }
3599           break;
3600
3601         case EM_VAX:
3602           if ((e_flags & EF_VAX_NONPIC))
3603             strcat (buf, ", non-PIC");
3604           if ((e_flags & EF_VAX_DFLOAT))
3605             strcat (buf, ", D-Float");
3606           if ((e_flags & EF_VAX_GFLOAT))
3607             strcat (buf, ", G-Float");
3608           break;
3609
3610         case EM_VISIUM:
3611           if (e_flags & EF_VISIUM_ARCH_MCM)
3612             strcat (buf, ", mcm");
3613           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3614             strcat (buf, ", mcm24");
3615           if (e_flags & EF_VISIUM_ARCH_GR6)
3616             strcat (buf, ", gr6");
3617           break;
3618
3619         case EM_RL78:
3620           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3621             {
3622             case E_FLAG_RL78_ANY_CPU: break;
3623             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3624             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3625             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3626             }
3627           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3628             strcat (buf, ", 64-bit doubles");
3629           break;
3630
3631         case EM_RX:
3632           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3633             strcat (buf, ", 64-bit doubles");
3634           if (e_flags & E_FLAG_RX_DSP)
3635             strcat (buf, ", dsp");
3636           if (e_flags & E_FLAG_RX_PID)
3637             strcat (buf, ", pid");
3638           if (e_flags & E_FLAG_RX_ABI)
3639             strcat (buf, ", RX ABI");
3640           if (e_flags & E_FLAG_RX_SINSNS_SET)
3641             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3642                     ? ", uses String instructions" : ", bans String instructions");
3643           if (e_flags & E_FLAG_RX_V2)
3644             strcat (buf, ", V2");
3645           break;
3646
3647         case EM_S390:
3648           if (e_flags & EF_S390_HIGH_GPRS)
3649             strcat (buf, ", highgprs");
3650           break;
3651
3652         case EM_TI_C6000:
3653           if ((e_flags & EF_C6000_REL))
3654             strcat (buf, ", relocatable module");
3655           break;
3656
3657         case EM_MSP430:
3658           strcat (buf, _(": architecture variant: "));
3659           switch (e_flags & EF_MSP430_MACH)
3660             {
3661             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3662             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3663             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3664             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3665             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3666             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3667             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3668             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3669             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3670             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3671             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3672             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3673             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3674             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3675             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3676             default:
3677               strcat (buf, _(": unknown")); break;
3678             }
3679
3680           if (e_flags & ~ EF_MSP430_MACH)
3681             strcat (buf, _(": unknown extra flag bits also present"));
3682         }
3683     }
3684
3685   return buf;
3686 }
3687
3688 static const char *
3689 get_osabi_name (Filedata * filedata, unsigned int osabi)
3690 {
3691   static char buff[32];
3692
3693   switch (osabi)
3694     {
3695     case ELFOSABI_NONE:         return "UNIX - System V";
3696     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3697     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3698     case ELFOSABI_GNU:          return "UNIX - GNU";
3699     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3700     case ELFOSABI_AIX:          return "UNIX - AIX";
3701     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3702     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3703     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3704     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3705     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3706     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3707     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3708     case ELFOSABI_AROS:         return "AROS";
3709     case ELFOSABI_FENIXOS:      return "FenixOS";
3710     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3711     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3712     default:
3713       if (osabi >= 64)
3714         switch (filedata->file_header.e_machine)
3715           {
3716           case EM_ARM:
3717             switch (osabi)
3718               {
3719               case ELFOSABI_ARM:        return "ARM";
3720               default:
3721                 break;
3722               }
3723             break;
3724
3725           case EM_MSP430:
3726           case EM_MSP430_OLD:
3727           case EM_VISIUM:
3728             switch (osabi)
3729               {
3730               case ELFOSABI_STANDALONE: return _("Standalone App");
3731               default:
3732                 break;
3733               }
3734             break;
3735
3736           case EM_TI_C6000:
3737             switch (osabi)
3738               {
3739               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3740               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3741               default:
3742                 break;
3743               }
3744             break;
3745
3746           default:
3747             break;
3748           }
3749       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3750       return buff;
3751     }
3752 }
3753
3754 static const char *
3755 get_aarch64_segment_type (unsigned long type)
3756 {
3757   switch (type)
3758     {
3759     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3760     default:                  return NULL;
3761     }
3762 }
3763
3764 static const char *
3765 get_arm_segment_type (unsigned long type)
3766 {
3767   switch (type)
3768     {
3769     case PT_ARM_EXIDX: return "EXIDX";
3770     default:           return NULL;
3771     }
3772 }
3773
3774 static const char *
3775 get_s390_segment_type (unsigned long type)
3776 {
3777   switch (type)
3778     {
3779     case PT_S390_PGSTE: return "S390_PGSTE";
3780     default:            return NULL;
3781     }
3782 }
3783
3784 static const char *
3785 get_mips_segment_type (unsigned long type)
3786 {
3787   switch (type)
3788     {
3789     case PT_MIPS_REGINFO:   return "REGINFO";
3790     case PT_MIPS_RTPROC:    return "RTPROC";
3791     case PT_MIPS_OPTIONS:   return "OPTIONS";
3792     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3793     default:                return NULL;
3794     }
3795 }
3796
3797 static const char *
3798 get_parisc_segment_type (unsigned long type)
3799 {
3800   switch (type)
3801     {
3802     case PT_HP_TLS:             return "HP_TLS";
3803     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3804     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3805     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3806     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3807     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3808     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3809     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3810     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3811     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3812     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3813     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3814     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3815     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3816     case PT_HP_STACK:           return "HP_STACK";
3817     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3818     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3819     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3820     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3821     default:                    return NULL;
3822     }
3823 }
3824
3825 static const char *
3826 get_ia64_segment_type (unsigned long type)
3827 {
3828   switch (type)
3829     {
3830     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3831     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3832     case PT_HP_TLS:             return "HP_TLS";
3833     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3834     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3835     case PT_IA_64_HP_STACK:     return "HP_STACK";
3836     default:                    return NULL;
3837     }
3838 }
3839
3840 static const char *
3841 get_tic6x_segment_type (unsigned long type)
3842 {
3843   switch (type)
3844     {
3845     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3846     default:               return NULL;
3847     }
3848 }
3849
3850 static const char *
3851 get_solaris_segment_type (unsigned long type)
3852 {
3853   switch (type)
3854     {
3855     case 0x6464e550: return "PT_SUNW_UNWIND";
3856     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3857     case 0x6ffffff7: return "PT_LOSUNW";
3858     case 0x6ffffffa: return "PT_SUNWBSS";
3859     case 0x6ffffffb: return "PT_SUNWSTACK";
3860     case 0x6ffffffc: return "PT_SUNWDTRACE";
3861     case 0x6ffffffd: return "PT_SUNWCAP";
3862     case 0x6fffffff: return "PT_HISUNW";
3863     default:         return NULL;
3864     }
3865 }
3866
3867 static const char *
3868 get_segment_type (Filedata * filedata, unsigned long p_type)
3869 {
3870   static char buff[32];
3871
3872   switch (p_type)
3873     {
3874     case PT_NULL:       return "NULL";
3875     case PT_LOAD:       return "LOAD";
3876     case PT_DYNAMIC:    return "DYNAMIC";
3877     case PT_INTERP:     return "INTERP";
3878     case PT_NOTE:       return "NOTE";
3879     case PT_SHLIB:      return "SHLIB";
3880     case PT_PHDR:       return "PHDR";
3881     case PT_TLS:        return "TLS";
3882     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3883     case PT_GNU_STACK:  return "GNU_STACK";
3884     case PT_GNU_RELRO:  return "GNU_RELRO";
3885
3886     default:
3887       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3888         {
3889           sprintf (buff, "GNU_MBIND+%#lx",
3890                    p_type - PT_GNU_MBIND_LO);
3891         }
3892       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3893         {
3894           const char * result;
3895
3896           switch (filedata->file_header.e_machine)
3897             {
3898             case EM_AARCH64:
3899               result = get_aarch64_segment_type (p_type);
3900               break;
3901             case EM_ARM:
3902               result = get_arm_segment_type (p_type);
3903               break;
3904             case EM_MIPS:
3905             case EM_MIPS_RS3_LE:
3906               result = get_mips_segment_type (p_type);
3907               break;
3908             case EM_PARISC:
3909               result = get_parisc_segment_type (p_type);
3910               break;
3911             case EM_IA_64:
3912               result = get_ia64_segment_type (p_type);
3913               break;
3914             case EM_TI_C6000:
3915               result = get_tic6x_segment_type (p_type);
3916               break;
3917             case EM_S390:
3918             case EM_S390_OLD:
3919               result = get_s390_segment_type (p_type);
3920               break;
3921             default:
3922               result = NULL;
3923               break;
3924             }
3925
3926           if (result != NULL)
3927             return result;
3928
3929           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3930         }
3931       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3932         {
3933           const char * result;
3934
3935           switch (filedata->file_header.e_machine)
3936             {
3937             case EM_PARISC:
3938               result = get_parisc_segment_type (p_type);
3939               break;
3940             case EM_IA_64:
3941               result = get_ia64_segment_type (p_type);
3942               break;
3943             default:
3944               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3945                 result = get_solaris_segment_type (p_type);
3946               else
3947                 result = NULL;
3948               break;
3949             }
3950
3951           if (result != NULL)
3952             return result;
3953
3954           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3955         }
3956       else
3957         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3958
3959       return buff;
3960     }
3961 }
3962
3963 static const char *
3964 get_arc_section_type_name (unsigned int sh_type)
3965 {
3966   switch (sh_type)
3967     {
3968     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
3969     default:
3970       break;
3971     }
3972   return NULL;
3973 }
3974
3975 static const char *
3976 get_mips_section_type_name (unsigned int sh_type)
3977 {
3978   switch (sh_type)
3979     {
3980     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3981     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3982     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3983     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3984     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3985     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3986     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3987     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3988     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3989     case SHT_MIPS_RELD:          return "MIPS_RELD";
3990     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3991     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3992     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3993     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3994     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3995     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3996     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3997     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3998     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3999     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4000     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4001     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4002     case SHT_MIPS_LINE:          return "MIPS_LINE";
4003     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4004     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4005     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4006     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4007     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4008     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4009     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4010     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4011     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4012     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4013     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4014     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4015     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4016     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4017     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4018     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4019     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4020     default:
4021       break;
4022     }
4023   return NULL;
4024 }
4025
4026 static const char *
4027 get_parisc_section_type_name (unsigned int sh_type)
4028 {
4029   switch (sh_type)
4030     {
4031     case SHT_PARISC_EXT:        return "PARISC_EXT";
4032     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4033     case SHT_PARISC_DOC:        return "PARISC_DOC";
4034     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4035     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4036     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4037     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4038     default:                    return NULL;
4039     }
4040 }
4041
4042 static const char *
4043 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4044 {
4045   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4046   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4047     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4048
4049   switch (sh_type)
4050     {
4051     case SHT_IA_64_EXT:                return "IA_64_EXT";
4052     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4053     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4054     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4055     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4056     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4057     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4058     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4059     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4060     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4061     default:
4062       break;
4063     }
4064   return NULL;
4065 }
4066
4067 static const char *
4068 get_x86_64_section_type_name (unsigned int sh_type)
4069 {
4070   switch (sh_type)
4071     {
4072     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4073     default:                    return NULL;
4074     }
4075 }
4076
4077 static const char *
4078 get_aarch64_section_type_name (unsigned int sh_type)
4079 {
4080   switch (sh_type)
4081     {
4082     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4083     default:                     return NULL;
4084     }
4085 }
4086
4087 static const char *
4088 get_arm_section_type_name (unsigned int sh_type)
4089 {
4090   switch (sh_type)
4091     {
4092     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4093     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4094     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4095     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4096     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4097     default:                      return NULL;
4098     }
4099 }
4100
4101 static const char *
4102 get_tic6x_section_type_name (unsigned int sh_type)
4103 {
4104   switch (sh_type)
4105     {
4106     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4107     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4108     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4109     case SHT_TI_ICODE:          return "TI_ICODE";
4110     case SHT_TI_XREF:           return "TI_XREF";
4111     case SHT_TI_HANDLER:        return "TI_HANDLER";
4112     case SHT_TI_INITINFO:       return "TI_INITINFO";
4113     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4114     default:                    return NULL;
4115     }
4116 }
4117
4118 static const char *
4119 get_msp430x_section_type_name (unsigned int sh_type)
4120 {
4121   switch (sh_type)
4122     {
4123     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4124     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4125     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4126     default:                      return NULL;
4127     }
4128 }
4129
4130 static const char *
4131 get_v850_section_type_name (unsigned int sh_type)
4132 {
4133   switch (sh_type)
4134     {
4135     case SHT_V850_SCOMMON:  return "V850 Small Common";
4136     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4137     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4138     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4139     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4140     default:                return NULL;
4141     }
4142 }
4143
4144 static const char *
4145 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4146 {
4147   static char buff[32];
4148   const char * result;
4149
4150   switch (sh_type)
4151     {
4152     case SHT_NULL:              return "NULL";
4153     case SHT_PROGBITS:          return "PROGBITS";
4154     case SHT_SYMTAB:            return "SYMTAB";
4155     case SHT_STRTAB:            return "STRTAB";
4156     case SHT_RELA:              return "RELA";
4157     case SHT_HASH:              return "HASH";
4158     case SHT_DYNAMIC:           return "DYNAMIC";
4159     case SHT_NOTE:              return "NOTE";
4160     case SHT_NOBITS:            return "NOBITS";
4161     case SHT_REL:               return "REL";
4162     case SHT_SHLIB:             return "SHLIB";
4163     case SHT_DYNSYM:            return "DYNSYM";
4164     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4165     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4166     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4167     case SHT_GNU_HASH:          return "GNU_HASH";
4168     case SHT_GROUP:             return "GROUP";
4169     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
4170     case SHT_GNU_verdef:        return "VERDEF";
4171     case SHT_GNU_verneed:       return "VERNEED";
4172     case SHT_GNU_versym:        return "VERSYM";
4173     case 0x6ffffff0:            return "VERSYM";
4174     case 0x6ffffffc:            return "VERDEF";
4175     case 0x7ffffffd:            return "AUXILIARY";
4176     case 0x7fffffff:            return "FILTER";
4177     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4178
4179     default:
4180       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4181         {
4182           switch (filedata->file_header.e_machine)
4183             {
4184             case EM_ARC:
4185             case EM_ARC_COMPACT:
4186             case EM_ARC_COMPACT2:
4187               result = get_arc_section_type_name (sh_type);
4188               break;
4189             case EM_MIPS:
4190             case EM_MIPS_RS3_LE:
4191               result = get_mips_section_type_name (sh_type);
4192               break;
4193             case EM_PARISC:
4194               result = get_parisc_section_type_name (sh_type);
4195               break;
4196             case EM_IA_64:
4197               result = get_ia64_section_type_name (filedata, sh_type);
4198               break;
4199             case EM_X86_64:
4200             case EM_L1OM:
4201             case EM_K1OM:
4202               result = get_x86_64_section_type_name (sh_type);
4203               break;
4204             case EM_AARCH64:
4205               result = get_aarch64_section_type_name (sh_type);
4206               break;
4207             case EM_ARM:
4208               result = get_arm_section_type_name (sh_type);
4209               break;
4210             case EM_TI_C6000:
4211               result = get_tic6x_section_type_name (sh_type);
4212               break;
4213             case EM_MSP430:
4214               result = get_msp430x_section_type_name (sh_type);
4215               break;
4216             case EM_V800:
4217             case EM_V850:
4218             case EM_CYGNUS_V850:
4219               result = get_v850_section_type_name (sh_type);
4220               break;
4221             default:
4222               result = NULL;
4223               break;
4224             }
4225
4226           if (result != NULL)
4227             return result;
4228
4229           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4230         }
4231       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4232         {
4233           switch (filedata->file_header.e_machine)
4234             {
4235             case EM_IA_64:
4236               result = get_ia64_section_type_name (filedata, sh_type);
4237               break;
4238             default:
4239               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4240                 result = get_solaris_section_type (sh_type);
4241               else
4242                 {
4243                   switch (sh_type)
4244                     {
4245                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4246                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4247                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4248                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4249                     default:
4250                       result = NULL;
4251                       break;
4252                     }
4253                 }
4254               break;
4255             }
4256
4257           if (result != NULL)
4258             return result;
4259
4260           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4261         }
4262       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4263         {
4264           switch (filedata->file_header.e_machine)
4265             {
4266             case EM_V800:
4267             case EM_V850:
4268             case EM_CYGNUS_V850:
4269               result = get_v850_section_type_name (sh_type);
4270               break;
4271             default:
4272               result = NULL;
4273               break;
4274             }
4275
4276           if (result != NULL)
4277             return result;
4278
4279           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4280         }
4281       else
4282         /* This message is probably going to be displayed in a 15
4283            character wide field, so put the hex value first.  */
4284         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4285
4286       return buff;
4287     }
4288 }
4289
4290 #define OPTION_DEBUG_DUMP       512
4291 #define OPTION_DYN_SYMS         513
4292 #define OPTION_DWARF_DEPTH      514
4293 #define OPTION_DWARF_START      515
4294 #define OPTION_DWARF_CHECK      516
4295
4296 static struct option options[] =
4297 {
4298   {"all",              no_argument, 0, 'a'},
4299   {"file-header",      no_argument, 0, 'h'},
4300   {"program-headers",  no_argument, 0, 'l'},
4301   {"headers",          no_argument, 0, 'e'},
4302   {"histogram",        no_argument, 0, 'I'},
4303   {"segments",         no_argument, 0, 'l'},
4304   {"sections",         no_argument, 0, 'S'},
4305   {"section-headers",  no_argument, 0, 'S'},
4306   {"section-groups",   no_argument, 0, 'g'},
4307   {"section-details",  no_argument, 0, 't'},
4308   {"full-section-name",no_argument, 0, 'N'},
4309   {"symbols",          no_argument, 0, 's'},
4310   {"syms",             no_argument, 0, 's'},
4311   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4312   {"relocs",           no_argument, 0, 'r'},
4313   {"notes",            no_argument, 0, 'n'},
4314   {"dynamic",          no_argument, 0, 'd'},
4315   {"arch-specific",    no_argument, 0, 'A'},
4316   {"version-info",     no_argument, 0, 'V'},
4317   {"use-dynamic",      no_argument, 0, 'D'},
4318   {"unwind",           no_argument, 0, 'u'},
4319   {"archive-index",    no_argument, 0, 'c'},
4320   {"hex-dump",         required_argument, 0, 'x'},
4321   {"relocated-dump",   required_argument, 0, 'R'},
4322   {"string-dump",      required_argument, 0, 'p'},
4323   {"decompress",       no_argument, 0, 'z'},
4324 #ifdef SUPPORT_DISASSEMBLY
4325   {"instruction-dump", required_argument, 0, 'i'},
4326 #endif
4327   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4328
4329   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4330   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4331   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4332
4333   {"version",          no_argument, 0, 'v'},
4334   {"wide",             no_argument, 0, 'W'},
4335   {"help",             no_argument, 0, 'H'},
4336   {0,                  no_argument, 0, 0}
4337 };
4338
4339 static void
4340 usage (FILE * stream)
4341 {
4342   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4343   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4344   fprintf (stream, _(" Options are:\n\
4345   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4346   -h --file-header       Display the ELF file header\n\
4347   -l --program-headers   Display the program headers\n\
4348      --segments          An alias for --program-headers\n\
4349   -S --section-headers   Display the sections' header\n\
4350      --sections          An alias for --section-headers\n\
4351   -g --section-groups    Display the section groups\n\
4352   -t --section-details   Display the section details\n\
4353   -e --headers           Equivalent to: -h -l -S\n\
4354   -s --syms              Display the symbol table\n\
4355      --symbols           An alias for --syms\n\
4356   --dyn-syms             Display the dynamic symbol table\n\
4357   -n --notes             Display the core notes (if present)\n\
4358   -r --relocs            Display the relocations (if present)\n\
4359   -u --unwind            Display the unwind info (if present)\n\
4360   -d --dynamic           Display the dynamic section (if present)\n\
4361   -V --version-info      Display the version sections (if present)\n\
4362   -A --arch-specific     Display architecture specific information (if any)\n\
4363   -c --archive-index     Display the symbol/file index in an archive\n\
4364   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4365   -x --hex-dump=<number|name>\n\
4366                          Dump the contents of section <number|name> as bytes\n\
4367   -p --string-dump=<number|name>\n\
4368                          Dump the contents of section <number|name> as strings\n\
4369   -R --relocated-dump=<number|name>\n\
4370                          Dump the contents of section <number|name> as relocated bytes\n\
4371   -z --decompress        Decompress section before dumping it\n\
4372   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4373   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4374                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4375                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4376                =addr,=cu_index,=links,=follow-links]\n\
4377                          Display the contents of DWARF debug sections\n"));
4378   fprintf (stream, _("\
4379   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4380   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4381                          or deeper\n"));
4382 #ifdef SUPPORT_DISASSEMBLY
4383   fprintf (stream, _("\
4384   -i --instruction-dump=<number|name>\n\
4385                          Disassemble the contents of section <number|name>\n"));
4386 #endif
4387   fprintf (stream, _("\
4388   -I --histogram         Display histogram of bucket list lengths\n\
4389   -W --wide              Allow output width to exceed 80 characters\n\
4390   @<file>                Read options from <file>\n\
4391   -H --help              Display this information\n\
4392   -v --version           Display the version number of readelf\n"));
4393
4394   if (REPORT_BUGS_TO[0] && stream == stdout)
4395     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4396
4397   exit (stream == stdout ? 0 : 1);
4398 }
4399
4400 /* Record the fact that the user wants the contents of section number
4401    SECTION to be displayed using the method(s) encoded as flags bits
4402    in TYPE.  Note, TYPE can be zero if we are creating the array for
4403    the first time.  */
4404
4405 static void
4406 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4407 {
4408   if (section >= filedata->num_dump_sects)
4409     {
4410       dump_type * new_dump_sects;
4411
4412       new_dump_sects = (dump_type *) calloc (section + 1,
4413                                              sizeof (* new_dump_sects));
4414
4415       if (new_dump_sects == NULL)
4416         error (_("Out of memory allocating dump request table.\n"));
4417       else
4418         {
4419           if (filedata->dump_sects)
4420             {
4421               /* Copy current flag settings.  */
4422               memcpy (new_dump_sects, filedata->dump_sects,
4423                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4424
4425               free (filedata->dump_sects);
4426             }
4427
4428           filedata->dump_sects = new_dump_sects;
4429           filedata->num_dump_sects = section + 1;
4430         }
4431     }
4432
4433   if (filedata->dump_sects)
4434     filedata->dump_sects[section] |= type;
4435 }
4436
4437 /* Request a dump by section name.  */
4438
4439 static void
4440 request_dump_byname (const char * section, dump_type type)
4441 {
4442   struct dump_list_entry * new_request;
4443
4444   new_request = (struct dump_list_entry *)
4445       malloc (sizeof (struct dump_list_entry));
4446   if (!new_request)
4447     error (_("Out of memory allocating dump request table.\n"));
4448
4449   new_request->name = strdup (section);
4450   if (!new_request->name)
4451     error (_("Out of memory allocating dump request table.\n"));
4452
4453   new_request->type = type;
4454
4455   new_request->next = dump_sects_byname;
4456   dump_sects_byname = new_request;
4457 }
4458
4459 static inline void
4460 request_dump (Filedata * filedata, dump_type type)
4461 {
4462   int section;
4463   char * cp;
4464
4465   do_dump++;
4466   section = strtoul (optarg, & cp, 0);
4467
4468   if (! *cp && section >= 0)
4469     request_dump_bynumber (filedata, section, type);
4470   else
4471     request_dump_byname (optarg, type);
4472 }
4473
4474 static void
4475 parse_args (Filedata * filedata, int argc, char ** argv)
4476 {
4477   int c;
4478
4479   if (argc < 2)
4480     usage (stderr);
4481
4482   while ((c = getopt_long
4483           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4484     {
4485       switch (c)
4486         {
4487         case 0:
4488           /* Long options.  */
4489           break;
4490         case 'H':
4491           usage (stdout);
4492           break;
4493
4494         case 'a':
4495           do_syms = TRUE;
4496           do_reloc = TRUE;
4497           do_unwind = TRUE;
4498           do_dynamic = TRUE;
4499           do_header = TRUE;
4500           do_sections = TRUE;
4501           do_section_groups = TRUE;
4502           do_segments = TRUE;
4503           do_version = TRUE;
4504           do_histogram = TRUE;
4505           do_arch = TRUE;
4506           do_notes = TRUE;
4507           break;
4508         case 'g':
4509           do_section_groups = TRUE;
4510           break;
4511         case 't':
4512         case 'N':
4513           do_sections = TRUE;
4514           do_section_details = TRUE;
4515           break;
4516         case 'e':
4517           do_header = TRUE;
4518           do_sections = TRUE;
4519           do_segments = TRUE;
4520           break;
4521         case 'A':
4522           do_arch = TRUE;
4523           break;
4524         case 'D':
4525           do_using_dynamic = TRUE;
4526           break;
4527         case 'r':
4528           do_reloc = TRUE;
4529           break;
4530         case 'u':
4531           do_unwind = TRUE;
4532           break;
4533         case 'h':
4534           do_header = TRUE;
4535           break;
4536         case 'l':
4537           do_segments = TRUE;
4538           break;
4539         case 's':
4540           do_syms = TRUE;
4541           break;
4542         case 'S':
4543           do_sections = TRUE;
4544           break;
4545         case 'd':
4546           do_dynamic = TRUE;
4547           break;
4548         case 'I':
4549           do_histogram = TRUE;
4550           break;
4551         case 'n':
4552           do_notes = TRUE;
4553           break;
4554         case 'c':
4555           do_archive_index = TRUE;
4556           break;
4557         case 'x':
4558           request_dump (filedata, HEX_DUMP);
4559           break;
4560         case 'p':
4561           request_dump (filedata, STRING_DUMP);
4562           break;
4563         case 'R':
4564           request_dump (filedata, RELOC_DUMP);
4565           break;
4566         case 'z':
4567           decompress_dumps = TRUE;
4568           break;
4569         case 'w':
4570           do_dump = TRUE;
4571           if (optarg == 0)
4572             {
4573               do_debugging = TRUE;
4574               dwarf_select_sections_all ();
4575             }
4576           else
4577             {
4578               do_debugging = FALSE;
4579               dwarf_select_sections_by_letters (optarg);
4580             }
4581           break;
4582         case OPTION_DEBUG_DUMP:
4583           do_dump = TRUE;
4584           if (optarg == 0)
4585             do_debugging = TRUE;
4586           else
4587             {
4588               do_debugging = FALSE;
4589               dwarf_select_sections_by_names (optarg);
4590             }
4591           break;
4592         case OPTION_DWARF_DEPTH:
4593           {
4594             char *cp;
4595
4596             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4597           }
4598           break;
4599         case OPTION_DWARF_START:
4600           {
4601             char *cp;
4602
4603             dwarf_start_die = strtoul (optarg, & cp, 0);
4604           }
4605           break;
4606         case OPTION_DWARF_CHECK:
4607           dwarf_check = TRUE;
4608           break;
4609         case OPTION_DYN_SYMS:
4610           do_dyn_syms = TRUE;
4611           break;
4612 #ifdef SUPPORT_DISASSEMBLY
4613         case 'i':
4614           request_dump (filedata, DISASS_DUMP);
4615           break;
4616 #endif
4617         case 'v':
4618           print_version (program_name);
4619           break;
4620         case 'V':
4621           do_version = TRUE;
4622           break;
4623         case 'W':
4624           do_wide = TRUE;
4625           break;
4626         default:
4627           /* xgettext:c-format */
4628           error (_("Invalid option '-%c'\n"), c);
4629           /* Fall through.  */
4630         case '?':
4631           usage (stderr);
4632         }
4633     }
4634
4635   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4636       && !do_segments && !do_header && !do_dump && !do_version
4637       && !do_histogram && !do_debugging && !do_arch && !do_notes
4638       && !do_section_groups && !do_archive_index
4639       && !do_dyn_syms)
4640     usage (stderr);
4641 }
4642
4643 static const char *
4644 get_elf_class (unsigned int elf_class)
4645 {
4646   static char buff[32];
4647
4648   switch (elf_class)
4649     {
4650     case ELFCLASSNONE: return _("none");
4651     case ELFCLASS32:   return "ELF32";
4652     case ELFCLASS64:   return "ELF64";
4653     default:
4654       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4655       return buff;
4656     }
4657 }
4658
4659 static const char *
4660 get_data_encoding (unsigned int encoding)
4661 {
4662   static char buff[32];
4663
4664   switch (encoding)
4665     {
4666     case ELFDATANONE: return _("none");
4667     case ELFDATA2LSB: return _("2's complement, little endian");
4668     case ELFDATA2MSB: return _("2's complement, big endian");
4669     default:
4670       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4671       return buff;
4672     }
4673 }
4674
4675 /* Decode the data held in 'filedata->file_header'.  */
4676
4677 static bfd_boolean
4678 process_file_header (Filedata * filedata)
4679 {
4680   Elf_Internal_Ehdr * header = & filedata->file_header;
4681
4682   if (   header->e_ident[EI_MAG0] != ELFMAG0
4683       || header->e_ident[EI_MAG1] != ELFMAG1
4684       || header->e_ident[EI_MAG2] != ELFMAG2
4685       || header->e_ident[EI_MAG3] != ELFMAG3)
4686     {
4687       error
4688         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4689       return FALSE;
4690     }
4691
4692   init_dwarf_regnames (header->e_machine);
4693
4694   if (do_header)
4695     {
4696       unsigned i;
4697
4698       printf (_("ELF Header:\n"));
4699       printf (_("  Magic:   "));
4700       for (i = 0; i < EI_NIDENT; i++)
4701         printf ("%2.2x ", header->e_ident[i]);
4702       printf ("\n");
4703       printf (_("  Class:                             %s\n"),
4704               get_elf_class (header->e_ident[EI_CLASS]));
4705       printf (_("  Data:                              %s\n"),
4706               get_data_encoding (header->e_ident[EI_DATA]));
4707       printf (_("  Version:                           %d %s\n"),
4708               header->e_ident[EI_VERSION],
4709               (header->e_ident[EI_VERSION] == EV_CURRENT
4710                ? "(current)"
4711                : (header->e_ident[EI_VERSION] != EV_NONE
4712                   ? _("<unknown: %lx>")
4713                   : "")));
4714       printf (_("  OS/ABI:                            %s\n"),
4715               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4716       printf (_("  ABI Version:                       %d\n"),
4717               header->e_ident[EI_ABIVERSION]);
4718       printf (_("  Type:                              %s\n"),
4719               get_file_type (header->e_type));
4720       printf (_("  Machine:                           %s\n"),
4721               get_machine_name (header->e_machine));
4722       printf (_("  Version:                           0x%lx\n"),
4723               (unsigned long) header->e_version);
4724
4725       printf (_("  Entry point address:               "));
4726       print_vma ((bfd_vma) header->e_entry, PREFIX_HEX);
4727       printf (_("\n  Start of program headers:          "));
4728       print_vma ((bfd_vma) header->e_phoff, DEC);
4729       printf (_(" (bytes into file)\n  Start of section headers:          "));
4730       print_vma ((bfd_vma) header->e_shoff, DEC);
4731       printf (_(" (bytes into file)\n"));
4732
4733       printf (_("  Flags:                             0x%lx%s\n"),
4734               (unsigned long) header->e_flags,
4735               get_machine_flags (filedata, header->e_flags, header->e_machine));
4736       printf (_("  Size of this header:               %ld (bytes)\n"),
4737               (long) header->e_ehsize);
4738       printf (_("  Size of program headers:           %ld (bytes)\n"),
4739               (long) header->e_phentsize);
4740       printf (_("  Number of program headers:         %ld"),
4741               (long) header->e_phnum);
4742       if (filedata->section_headers != NULL
4743           && header->e_phnum == PN_XNUM
4744           && filedata->section_headers[0].sh_info != 0)
4745         printf (" (%ld)", (long) filedata->section_headers[0].sh_info);
4746       putc ('\n', stdout);
4747       printf (_("  Size of section headers:           %ld (bytes)\n"),
4748               (long) header->e_shentsize);
4749       printf (_("  Number of section headers:         %ld"),
4750               (long) header->e_shnum);
4751       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4752         printf (" (%ld)", (long) filedata->section_headers[0].sh_size);
4753       putc ('\n', stdout);
4754       printf (_("  Section header string table index: %ld"),
4755               (long) header->e_shstrndx);
4756       if (filedata->section_headers != NULL
4757           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4758         printf (" (%u)", filedata->section_headers[0].sh_link);
4759       else if (header->e_shstrndx != SHN_UNDEF
4760                && header->e_shstrndx >= header->e_shnum)
4761         printf (_(" <corrupt: out of range>"));
4762       putc ('\n', stdout);
4763     }
4764
4765   if (filedata->section_headers != NULL)
4766     {
4767       if (header->e_phnum == PN_XNUM
4768           && filedata->section_headers[0].sh_info != 0)
4769         header->e_phnum = filedata->section_headers[0].sh_info;
4770       if (header->e_shnum == SHN_UNDEF)
4771         header->e_shnum = filedata->section_headers[0].sh_size;
4772       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4773         header->e_shstrndx = filedata->section_headers[0].sh_link;
4774       if (header->e_shstrndx >= header->e_shnum)
4775         header->e_shstrndx = SHN_UNDEF;
4776       free (filedata->section_headers);
4777       filedata->section_headers = NULL;
4778     }
4779
4780   return TRUE;
4781 }
4782
4783 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4784    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4785
4786 static bfd_boolean
4787 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4788 {
4789   Elf32_External_Phdr * phdrs;
4790   Elf32_External_Phdr * external;
4791   Elf_Internal_Phdr *   internal;
4792   unsigned int i;
4793   unsigned int size = filedata->file_header.e_phentsize;
4794   unsigned int num  = filedata->file_header.e_phnum;
4795
4796   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4797   if (size == 0 || num == 0)
4798     return FALSE;
4799   if (size < sizeof * phdrs)
4800     {
4801       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4802       return FALSE;
4803     }
4804   if (size > sizeof * phdrs)
4805     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4806
4807   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4808                                             size, num, _("program headers"));
4809   if (phdrs == NULL)
4810     return FALSE;
4811
4812   for (i = 0, internal = pheaders, external = phdrs;
4813        i < filedata->file_header.e_phnum;
4814        i++, internal++, external++)
4815     {
4816       internal->p_type   = BYTE_GET (external->p_type);
4817       internal->p_offset = BYTE_GET (external->p_offset);
4818       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4819       internal->p_paddr  = BYTE_GET (external->p_paddr);
4820       internal->p_filesz = BYTE_GET (external->p_filesz);
4821       internal->p_memsz  = BYTE_GET (external->p_memsz);
4822       internal->p_flags  = BYTE_GET (external->p_flags);
4823       internal->p_align  = BYTE_GET (external->p_align);
4824     }
4825
4826   free (phdrs);
4827   return TRUE;
4828 }
4829
4830 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4831    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4832
4833 static bfd_boolean
4834 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4835 {
4836   Elf64_External_Phdr * phdrs;
4837   Elf64_External_Phdr * external;
4838   Elf_Internal_Phdr *   internal;
4839   unsigned int i;
4840   unsigned int size = filedata->file_header.e_phentsize;
4841   unsigned int num  = filedata->file_header.e_phnum;
4842
4843   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4844   if (size == 0 || num == 0)
4845     return FALSE;
4846   if (size < sizeof * phdrs)
4847     {
4848       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4849       return FALSE;
4850     }
4851   if (size > sizeof * phdrs)
4852     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4853
4854   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4855                                             size, num, _("program headers"));
4856   if (!phdrs)
4857     return FALSE;
4858
4859   for (i = 0, internal = pheaders, external = phdrs;
4860        i < filedata->file_header.e_phnum;
4861        i++, internal++, external++)
4862     {
4863       internal->p_type   = BYTE_GET (external->p_type);
4864       internal->p_flags  = BYTE_GET (external->p_flags);
4865       internal->p_offset = BYTE_GET (external->p_offset);
4866       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4867       internal->p_paddr  = BYTE_GET (external->p_paddr);
4868       internal->p_filesz = BYTE_GET (external->p_filesz);
4869       internal->p_memsz  = BYTE_GET (external->p_memsz);
4870       internal->p_align  = BYTE_GET (external->p_align);
4871     }
4872
4873   free (phdrs);
4874   return TRUE;
4875 }
4876
4877 /* Returns TRUE if the program headers were read into `program_headers'.  */
4878
4879 static bfd_boolean
4880 get_program_headers (Filedata * filedata)
4881 {
4882   Elf_Internal_Phdr * phdrs;
4883
4884   /* Check cache of prior read.  */
4885   if (filedata->program_headers != NULL)
4886     return TRUE;
4887
4888   /* Be kind to memory checkers by looking for
4889      e_phnum values which we know must be invalid.  */
4890   if (filedata->file_header.e_phnum
4891       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4892       >= filedata->file_size)
4893     {
4894       error (_("Too many program headers - %#x - the file is not that big\n"),
4895              filedata->file_header.e_phnum);
4896       return FALSE;
4897     }
4898
4899   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4900                                          sizeof (Elf_Internal_Phdr));
4901   if (phdrs == NULL)
4902     {
4903       error (_("Out of memory reading %u program headers\n"),
4904              filedata->file_header.e_phnum);
4905       return FALSE;
4906     }
4907
4908   if (is_32bit_elf
4909       ? get_32bit_program_headers (filedata, phdrs)
4910       : get_64bit_program_headers (filedata, phdrs))
4911     {
4912       filedata->program_headers = phdrs;
4913       return TRUE;
4914     }
4915
4916   free (phdrs);
4917   return FALSE;
4918 }
4919
4920 /* Returns TRUE if the program headers were loaded.  */
4921
4922 static bfd_boolean
4923 process_program_headers (Filedata * filedata)
4924 {
4925   Elf_Internal_Phdr * segment;
4926   unsigned int i;
4927   Elf_Internal_Phdr * previous_load = NULL;
4928
4929   if (filedata->file_header.e_phnum == 0)
4930     {
4931       /* PR binutils/12467.  */
4932       if (filedata->file_header.e_phoff != 0)
4933         {
4934           warn (_("possibly corrupt ELF header - it has a non-zero program"
4935                   " header offset, but no program headers\n"));
4936           return FALSE;
4937         }
4938       else if (do_segments)
4939         printf (_("\nThere are no program headers in this file.\n"));
4940       return TRUE;
4941     }
4942
4943   if (do_segments && !do_header)
4944     {
4945       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
4946       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
4947       printf (ngettext ("There is %d program header, starting at offset %s\n",
4948                         "There are %d program headers, starting at offset %s\n",
4949                         filedata->file_header.e_phnum),
4950               filedata->file_header.e_phnum,
4951               bfd_vmatoa ("u", filedata->file_header.e_phoff));
4952     }
4953
4954   if (! get_program_headers (filedata))
4955     return TRUE;
4956
4957   if (do_segments)
4958     {
4959       if (filedata->file_header.e_phnum > 1)
4960         printf (_("\nProgram Headers:\n"));
4961       else
4962         printf (_("\nProgram Headers:\n"));
4963
4964       if (is_32bit_elf)
4965         printf
4966           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4967       else if (do_wide)
4968         printf
4969           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4970       else
4971         {
4972           printf
4973             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4974           printf
4975             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4976         }
4977     }
4978
4979   dynamic_addr = 0;
4980   dynamic_size = 0;
4981
4982   for (i = 0, segment = filedata->program_headers;
4983        i < filedata->file_header.e_phnum;
4984        i++, segment++)
4985     {
4986       if (do_segments)
4987         {
4988           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
4989
4990           if (is_32bit_elf)
4991             {
4992               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4993               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4994               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4995               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4996               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4997               printf ("%c%c%c ",
4998                       (segment->p_flags & PF_R ? 'R' : ' '),
4999                       (segment->p_flags & PF_W ? 'W' : ' '),
5000                       (segment->p_flags & PF_X ? 'E' : ' '));
5001               printf ("%#lx", (unsigned long) segment->p_align);
5002             }
5003           else if (do_wide)
5004             {
5005               if ((unsigned long) segment->p_offset == segment->p_offset)
5006                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5007               else
5008                 {
5009                   print_vma (segment->p_offset, FULL_HEX);
5010                   putchar (' ');
5011                 }
5012
5013               print_vma (segment->p_vaddr, FULL_HEX);
5014               putchar (' ');
5015               print_vma (segment->p_paddr, FULL_HEX);
5016               putchar (' ');
5017
5018               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5019                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5020               else
5021                 {
5022                   print_vma (segment->p_filesz, FULL_HEX);
5023                   putchar (' ');
5024                 }
5025
5026               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5027                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5028               else
5029                 {
5030                   print_vma (segment->p_memsz, FULL_HEX);
5031                 }
5032
5033               printf (" %c%c%c ",
5034                       (segment->p_flags & PF_R ? 'R' : ' '),
5035                       (segment->p_flags & PF_W ? 'W' : ' '),
5036                       (segment->p_flags & PF_X ? 'E' : ' '));
5037
5038               if ((unsigned long) segment->p_align == segment->p_align)
5039                 printf ("%#lx", (unsigned long) segment->p_align);
5040               else
5041                 {
5042                   print_vma (segment->p_align, PREFIX_HEX);
5043                 }
5044             }
5045           else
5046             {
5047               print_vma (segment->p_offset, FULL_HEX);
5048               putchar (' ');
5049               print_vma (segment->p_vaddr, FULL_HEX);
5050               putchar (' ');
5051               print_vma (segment->p_paddr, FULL_HEX);
5052               printf ("\n                 ");
5053               print_vma (segment->p_filesz, FULL_HEX);
5054               putchar (' ');
5055               print_vma (segment->p_memsz, FULL_HEX);
5056               printf ("  %c%c%c    ",
5057                       (segment->p_flags & PF_R ? 'R' : ' '),
5058                       (segment->p_flags & PF_W ? 'W' : ' '),
5059                       (segment->p_flags & PF_X ? 'E' : ' '));
5060               print_vma (segment->p_align, PREFIX_HEX);
5061             }
5062
5063           putc ('\n', stdout);
5064         }
5065
5066       switch (segment->p_type)
5067         {
5068         case PT_LOAD:
5069 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5070          required by the ELF standard, several programs, including the Linux
5071          kernel, make use of non-ordered segments.  */
5072           if (previous_load
5073               && previous_load->p_vaddr > segment->p_vaddr)
5074             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5075 #endif
5076           if (segment->p_memsz < segment->p_filesz)
5077             error (_("the segment's file size is larger than its memory size\n"));
5078           previous_load = segment;
5079           break;
5080
5081         case PT_PHDR:
5082           /* PR 20815 - Verify that the program header is loaded into memory.  */
5083           if (i > 0 && previous_load != NULL)
5084             error (_("the PHDR segment must occur before any LOAD segment\n"));
5085           if (filedata->file_header.e_machine != EM_PARISC)
5086             {
5087               unsigned int j;
5088
5089               for (j = 1; j < filedata->file_header.e_phnum; j++)
5090                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5091                     && (filedata->program_headers[j].p_vaddr
5092                         + filedata->program_headers[j].p_memsz)
5093                     >= (segment->p_vaddr + segment->p_filesz))
5094                   break;
5095               if (j == filedata->file_header.e_phnum)
5096                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5097             }
5098           break;
5099
5100         case PT_DYNAMIC:
5101           if (dynamic_addr)
5102             error (_("more than one dynamic segment\n"));
5103
5104           /* By default, assume that the .dynamic section is the first
5105              section in the DYNAMIC segment.  */
5106           dynamic_addr = segment->p_offset;
5107           dynamic_size = segment->p_filesz;
5108
5109           /* Try to locate the .dynamic section. If there is
5110              a section header table, we can easily locate it.  */
5111           if (filedata->section_headers != NULL)
5112             {
5113               Elf_Internal_Shdr * sec;
5114
5115               sec = find_section (filedata, ".dynamic");
5116               if (sec == NULL || sec->sh_size == 0)
5117                 {
5118                   /* A corresponding .dynamic section is expected, but on
5119                      IA-64/OpenVMS it is OK for it to be missing.  */
5120                   if (!is_ia64_vms (filedata))
5121                     error (_("no .dynamic section in the dynamic segment\n"));
5122                   break;
5123                 }
5124
5125               if (sec->sh_type == SHT_NOBITS)
5126                 {
5127                   dynamic_size = 0;
5128                   break;
5129                 }
5130
5131               dynamic_addr = sec->sh_offset;
5132               dynamic_size = sec->sh_size;
5133
5134               if (dynamic_addr < segment->p_offset
5135                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5136                 warn (_("the .dynamic section is not contained"
5137                         " within the dynamic segment\n"));
5138               else if (dynamic_addr > segment->p_offset)
5139                 warn (_("the .dynamic section is not the first section"
5140                         " in the dynamic segment.\n"));
5141             }
5142
5143           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5144              segment.  Check this after matching against the section headers
5145              so we don't warn on debuginfo file (which have NOBITS .dynamic
5146              sections).  */
5147           if (dynamic_addr + dynamic_size >= filedata->file_size)
5148             {
5149               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5150               dynamic_addr = dynamic_size = 0;
5151             }
5152           break;
5153
5154         case PT_INTERP:
5155           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5156                      SEEK_SET))
5157             error (_("Unable to find program interpreter name\n"));
5158           else
5159             {
5160               char fmt [32];
5161               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5162
5163               if (ret >= (int) sizeof (fmt) || ret < 0)
5164                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5165
5166               program_interpreter[0] = 0;
5167               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5168                 error (_("Unable to read program interpreter name\n"));
5169
5170               if (do_segments)
5171                 printf (_("      [Requesting program interpreter: %s]\n"),
5172                     program_interpreter);
5173             }
5174           break;
5175         }
5176     }
5177
5178   if (do_segments
5179       && filedata->section_headers != NULL
5180       && filedata->string_table != NULL)
5181     {
5182       printf (_("\n Section to Segment mapping:\n"));
5183       printf (_("  Segment Sections...\n"));
5184
5185       for (i = 0; i < filedata->file_header.e_phnum; i++)
5186         {
5187           unsigned int j;
5188           Elf_Internal_Shdr * section;
5189
5190           segment = filedata->program_headers + i;
5191           section = filedata->section_headers + 1;
5192
5193           printf ("   %2.2d     ", i);
5194
5195           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5196             {
5197               if (!ELF_TBSS_SPECIAL (section, segment)
5198                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5199                 printf ("%s ", printable_section_name (filedata, section));
5200             }
5201
5202           putc ('\n',stdout);
5203         }
5204     }
5205
5206   return TRUE;
5207 }
5208
5209
5210 /* Find the file offset corresponding to VMA by using the program headers.  */
5211
5212 static long
5213 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5214 {
5215   Elf_Internal_Phdr * seg;
5216
5217   if (! get_program_headers (filedata))
5218     {
5219       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5220       return (long) vma;
5221     }
5222
5223   for (seg = filedata->program_headers;
5224        seg < filedata->program_headers + filedata->file_header.e_phnum;
5225        ++seg)
5226     {
5227       if (seg->p_type != PT_LOAD)
5228         continue;
5229
5230       if (vma >= (seg->p_vaddr & -seg->p_align)
5231           && vma + size <= seg->p_vaddr + seg->p_filesz)
5232         return vma - seg->p_vaddr + seg->p_offset;
5233     }
5234
5235   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5236         (unsigned long) vma);
5237   return (long) vma;
5238 }
5239
5240
5241 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5242    If PROBE is true, this is just a probe and we do not generate any error
5243    messages if the load fails.  */
5244
5245 static bfd_boolean
5246 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5247 {
5248   Elf32_External_Shdr * shdrs;
5249   Elf_Internal_Shdr *   internal;
5250   unsigned int          i;
5251   unsigned int          size = filedata->file_header.e_shentsize;
5252   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5253
5254   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5255   if (size == 0 || num == 0)
5256     return FALSE;
5257   if (size < sizeof * shdrs)
5258     {
5259       if (! probe)
5260         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5261       return FALSE;
5262     }
5263   if (!probe && size > sizeof * shdrs)
5264     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5265
5266   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5267                                             size, num,
5268                                             probe ? NULL : _("section headers"));
5269   if (shdrs == NULL)
5270     return FALSE;
5271
5272   free (filedata->section_headers);
5273   filedata->section_headers = (Elf_Internal_Shdr *)
5274     cmalloc (num, sizeof (Elf_Internal_Shdr));
5275   if (filedata->section_headers == NULL)
5276     {
5277       if (!probe)
5278         error (_("Out of memory reading %u section headers\n"), num);
5279       return FALSE;
5280     }
5281
5282   for (i = 0, internal = filedata->section_headers;
5283        i < num;
5284        i++, internal++)
5285     {
5286       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5287       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5288       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5289       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5290       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5291       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5292       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5293       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5294       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5295       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5296       if (!probe && internal->sh_link > num)
5297         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5298       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5299         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5300     }
5301
5302   free (shdrs);
5303   return TRUE;
5304 }
5305
5306 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5307
5308 static bfd_boolean
5309 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5310 {
5311   Elf64_External_Shdr *  shdrs;
5312   Elf_Internal_Shdr *    internal;
5313   unsigned int           i;
5314   unsigned int           size = filedata->file_header.e_shentsize;
5315   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5316
5317   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5318   if (size == 0 || num == 0)
5319     return FALSE;
5320
5321   if (size < sizeof * shdrs)
5322     {
5323       if (! probe)
5324         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5325       return FALSE;
5326     }
5327
5328   if (! probe && size > sizeof * shdrs)
5329     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5330
5331   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5332                                             filedata->file_header.e_shoff,
5333                                             size, num,
5334                                             probe ? NULL : _("section headers"));
5335   if (shdrs == NULL)
5336     return FALSE;
5337
5338   free (filedata->section_headers);
5339   filedata->section_headers = (Elf_Internal_Shdr *)
5340     cmalloc (num, sizeof (Elf_Internal_Shdr));
5341   if (filedata->section_headers == NULL)
5342     {
5343       if (! probe)
5344         error (_("Out of memory reading %u section headers\n"), num);
5345       return FALSE;
5346     }
5347
5348   for (i = 0, internal = filedata->section_headers;
5349        i < num;
5350        i++, internal++)
5351     {
5352       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5353       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5354       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5355       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5356       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5357       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5358       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5359       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5360       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5361       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5362       if (!probe && internal->sh_link > num)
5363         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5364       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5365         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5366     }
5367
5368   free (shdrs);
5369   return TRUE;
5370 }
5371
5372 static Elf_Internal_Sym *
5373 get_32bit_elf_symbols (Filedata *           filedata,
5374                        Elf_Internal_Shdr *  section,
5375                        unsigned long *      num_syms_return)
5376 {
5377   unsigned long number = 0;
5378   Elf32_External_Sym * esyms = NULL;
5379   Elf_External_Sym_Shndx * shndx = NULL;
5380   Elf_Internal_Sym * isyms = NULL;
5381   Elf_Internal_Sym * psym;
5382   unsigned int j;
5383
5384   if (section->sh_size == 0)
5385     {
5386       if (num_syms_return != NULL)
5387         * num_syms_return = 0;
5388       return NULL;
5389     }
5390
5391   /* Run some sanity checks first.  */
5392   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5393     {
5394       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5395              printable_section_name (filedata, section),
5396              (unsigned long) section->sh_entsize);
5397       goto exit_point;
5398     }
5399
5400   if (section->sh_size > filedata->file_size)
5401     {
5402       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5403              printable_section_name (filedata, section),
5404              (unsigned long) section->sh_size);
5405       goto exit_point;
5406     }
5407
5408   number = section->sh_size / section->sh_entsize;
5409
5410   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5411     {
5412       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5413              (unsigned long) section->sh_size,
5414              printable_section_name (filedata, section),
5415              (unsigned long) section->sh_entsize);
5416       goto exit_point;
5417     }
5418
5419   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5420                                            section->sh_size, _("symbols"));
5421   if (esyms == NULL)
5422     goto exit_point;
5423
5424   {
5425     elf_section_list * entry;
5426
5427     shndx = NULL;
5428     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5429       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5430         {
5431           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5432                                                        entry->hdr->sh_offset,
5433                                                        1, entry->hdr->sh_size,
5434                                                        _("symbol table section indicies"));
5435           if (shndx == NULL)
5436             goto exit_point;
5437           /* PR17531: file: heap-buffer-overflow */
5438           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5439             {
5440               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5441                      printable_section_name (filedata, entry->hdr),
5442                      (unsigned long) entry->hdr->sh_size,
5443                      (unsigned long) section->sh_size);
5444               goto exit_point;
5445             }
5446         }
5447   }
5448
5449   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5450
5451   if (isyms == NULL)
5452     {
5453       error (_("Out of memory reading %lu symbols\n"),
5454              (unsigned long) number);
5455       goto exit_point;
5456     }
5457
5458   for (j = 0, psym = isyms; j < number; j++, psym++)
5459     {
5460       psym->st_name  = BYTE_GET (esyms[j].st_name);
5461       psym->st_value = BYTE_GET (esyms[j].st_value);
5462       psym->st_size  = BYTE_GET (esyms[j].st_size);
5463       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5464       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5465         psym->st_shndx
5466           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5467       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5468         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5469       psym->st_info  = BYTE_GET (esyms[j].st_info);
5470       psym->st_other = BYTE_GET (esyms[j].st_other);
5471     }
5472
5473  exit_point:
5474   if (shndx != NULL)
5475     free (shndx);
5476   if (esyms != NULL)
5477     free (esyms);
5478
5479   if (num_syms_return != NULL)
5480     * num_syms_return = isyms == NULL ? 0 : number;
5481
5482   return isyms;
5483 }
5484
5485 static Elf_Internal_Sym *
5486 get_64bit_elf_symbols (Filedata *           filedata,
5487                        Elf_Internal_Shdr *  section,
5488                        unsigned long *      num_syms_return)
5489 {
5490   unsigned long number = 0;
5491   Elf64_External_Sym * esyms = NULL;
5492   Elf_External_Sym_Shndx * shndx = NULL;
5493   Elf_Internal_Sym * isyms = NULL;
5494   Elf_Internal_Sym * psym;
5495   unsigned int j;
5496
5497   if (section->sh_size == 0)
5498     {
5499       if (num_syms_return != NULL)
5500         * num_syms_return = 0;
5501       return NULL;
5502     }
5503
5504   /* Run some sanity checks first.  */
5505   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5506     {
5507       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5508              printable_section_name (filedata, section),
5509              (unsigned long) section->sh_entsize);
5510       goto exit_point;
5511     }
5512
5513   if (section->sh_size > filedata->file_size)
5514     {
5515       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5516              printable_section_name (filedata, section),
5517              (unsigned long) section->sh_size);
5518       goto exit_point;
5519     }
5520
5521   number = section->sh_size / section->sh_entsize;
5522
5523   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5524     {
5525       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5526              (unsigned long) section->sh_size,
5527              printable_section_name (filedata, section),
5528              (unsigned long) section->sh_entsize);
5529       goto exit_point;
5530     }
5531
5532   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5533                                            section->sh_size, _("symbols"));
5534   if (!esyms)
5535     goto exit_point;
5536
5537   {
5538     elf_section_list * entry;
5539
5540     shndx = NULL;
5541     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5542       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5543         {
5544           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5545                                                        entry->hdr->sh_offset,
5546                                                        1, entry->hdr->sh_size,
5547                                                        _("symbol table section indicies"));
5548           if (shndx == NULL)
5549             goto exit_point;
5550           /* PR17531: file: heap-buffer-overflow */
5551           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5552             {
5553               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5554                      printable_section_name (filedata, entry->hdr),
5555                      (unsigned long) entry->hdr->sh_size,
5556                      (unsigned long) section->sh_size);
5557               goto exit_point;
5558             }
5559         }
5560   }
5561
5562   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5563
5564   if (isyms == NULL)
5565     {
5566       error (_("Out of memory reading %lu symbols\n"),
5567              (unsigned long) number);
5568       goto exit_point;
5569     }
5570
5571   for (j = 0, psym = isyms; j < number; j++, psym++)
5572     {
5573       psym->st_name  = BYTE_GET (esyms[j].st_name);
5574       psym->st_info  = BYTE_GET (esyms[j].st_info);
5575       psym->st_other = BYTE_GET (esyms[j].st_other);
5576       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5577
5578       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5579         psym->st_shndx
5580           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5581       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5582         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5583
5584       psym->st_value = BYTE_GET (esyms[j].st_value);
5585       psym->st_size  = BYTE_GET (esyms[j].st_size);
5586     }
5587
5588  exit_point:
5589   if (shndx != NULL)
5590     free (shndx);
5591   if (esyms != NULL)
5592     free (esyms);
5593
5594   if (num_syms_return != NULL)
5595     * num_syms_return = isyms == NULL ? 0 : number;
5596
5597   return isyms;
5598 }
5599
5600 static const char *
5601 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5602 {
5603   static char buff[1024];
5604   char * p = buff;
5605   unsigned int field_size = is_32bit_elf ? 8 : 16;
5606   signed int sindex;
5607   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5608   bfd_vma os_flags = 0;
5609   bfd_vma proc_flags = 0;
5610   bfd_vma unknown_flags = 0;
5611   static const struct
5612     {
5613       const char * str;
5614       unsigned int len;
5615     }
5616   flags [] =
5617     {
5618       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5619       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5620       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5621       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5622       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5623       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5624       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5625       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5626       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5627       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5628       /* IA-64 specific.  */
5629       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5630       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5631       /* IA-64 OpenVMS specific.  */
5632       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5633       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5634       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5635       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5636       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5637       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5638       /* Generic.  */
5639       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5640       /* SPARC specific.  */
5641       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5642       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5643       /* ARM specific.  */
5644       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5645       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5646       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5647       /* GNU specific.  */
5648       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5649       /* VLE specific.  */
5650       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5651     };
5652
5653   if (do_section_details)
5654     {
5655       sprintf (buff, "[%*.*lx]: ",
5656                field_size, field_size, (unsigned long) sh_flags);
5657       p += field_size + 4;
5658     }
5659
5660   while (sh_flags)
5661     {
5662       bfd_vma flag;
5663
5664       flag = sh_flags & - sh_flags;
5665       sh_flags &= ~ flag;
5666
5667       if (do_section_details)
5668         {
5669           switch (flag)
5670             {
5671             case SHF_WRITE:             sindex = 0; break;
5672             case SHF_ALLOC:             sindex = 1; break;
5673             case SHF_EXECINSTR:         sindex = 2; break;
5674             case SHF_MERGE:             sindex = 3; break;
5675             case SHF_STRINGS:           sindex = 4; break;
5676             case SHF_INFO_LINK:         sindex = 5; break;
5677             case SHF_LINK_ORDER:        sindex = 6; break;
5678             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5679             case SHF_GROUP:             sindex = 8; break;
5680             case SHF_TLS:               sindex = 9; break;
5681             case SHF_EXCLUDE:           sindex = 18; break;
5682             case SHF_COMPRESSED:        sindex = 20; break;
5683             case SHF_GNU_MBIND:         sindex = 24; break;
5684
5685             default:
5686               sindex = -1;
5687               switch (filedata->file_header.e_machine)
5688                 {
5689                 case EM_IA_64:
5690                   if (flag == SHF_IA_64_SHORT)
5691                     sindex = 10;
5692                   else if (flag == SHF_IA_64_NORECOV)
5693                     sindex = 11;
5694 #ifdef BFD64
5695                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5696                     switch (flag)
5697                       {
5698                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5699                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5700                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5701                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5702                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5703                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5704                       default:                        break;
5705                       }
5706 #endif
5707                   break;
5708
5709                 case EM_386:
5710                 case EM_IAMCU:
5711                 case EM_X86_64:
5712                 case EM_L1OM:
5713                 case EM_K1OM:
5714                 case EM_OLD_SPARCV9:
5715                 case EM_SPARC32PLUS:
5716                 case EM_SPARCV9:
5717                 case EM_SPARC:
5718                   if (flag == SHF_ORDERED)
5719                     sindex = 19;
5720                   break;
5721
5722                 case EM_ARM:
5723                   switch (flag)
5724                     {
5725                     case SHF_ENTRYSECT: sindex = 21; break;
5726                     case SHF_ARM_PURECODE: sindex = 22; break;
5727                     case SHF_COMDEF: sindex = 23; break;
5728                     default: break;
5729                     }
5730                   break;
5731                 case EM_PPC:
5732                   if (flag == SHF_PPC_VLE)
5733                     sindex = 25;
5734                   break;
5735
5736                 default:
5737                   break;
5738                 }
5739             }
5740
5741           if (sindex != -1)
5742             {
5743               if (p != buff + field_size + 4)
5744                 {
5745                   if (size < (10 + 2))
5746                     {
5747                       warn (_("Internal error: not enough buffer room for section flag info"));
5748                       return _("<unknown>");
5749                     }
5750                   size -= 2;
5751                   *p++ = ',';
5752                   *p++ = ' ';
5753                 }
5754
5755               size -= flags [sindex].len;
5756               p = stpcpy (p, flags [sindex].str);
5757             }
5758           else if (flag & SHF_MASKOS)
5759             os_flags |= flag;
5760           else if (flag & SHF_MASKPROC)
5761             proc_flags |= flag;
5762           else
5763             unknown_flags |= flag;
5764         }
5765       else
5766         {
5767           switch (flag)
5768             {
5769             case SHF_WRITE:             *p = 'W'; break;
5770             case SHF_ALLOC:             *p = 'A'; break;
5771             case SHF_EXECINSTR:         *p = 'X'; break;
5772             case SHF_MERGE:             *p = 'M'; break;
5773             case SHF_STRINGS:           *p = 'S'; break;
5774             case SHF_INFO_LINK:         *p = 'I'; break;
5775             case SHF_LINK_ORDER:        *p = 'L'; break;
5776             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5777             case SHF_GROUP:             *p = 'G'; break;
5778             case SHF_TLS:               *p = 'T'; break;
5779             case SHF_EXCLUDE:           *p = 'E'; break;
5780             case SHF_COMPRESSED:        *p = 'C'; break;
5781             case SHF_GNU_MBIND:         *p = 'D'; break;
5782
5783             default:
5784               if ((filedata->file_header.e_machine == EM_X86_64
5785                    || filedata->file_header.e_machine == EM_L1OM
5786                    || filedata->file_header.e_machine == EM_K1OM)
5787                   && flag == SHF_X86_64_LARGE)
5788                 *p = 'l';
5789               else if (filedata->file_header.e_machine == EM_ARM
5790                        && flag == SHF_ARM_PURECODE)
5791                   *p = 'y';
5792               else if (filedata->file_header.e_machine == EM_PPC
5793                        && flag == SHF_PPC_VLE)
5794                   *p = 'v';
5795               else if (flag & SHF_MASKOS)
5796                 {
5797                   *p = 'o';
5798                   sh_flags &= ~ SHF_MASKOS;
5799                 }
5800               else if (flag & SHF_MASKPROC)
5801                 {
5802                   *p = 'p';
5803                   sh_flags &= ~ SHF_MASKPROC;
5804                 }
5805               else
5806                 *p = 'x';
5807               break;
5808             }
5809           p++;
5810         }
5811     }
5812
5813   if (do_section_details)
5814     {
5815       if (os_flags)
5816         {
5817           size -= 5 + field_size;
5818           if (p != buff + field_size + 4)
5819             {
5820               if (size < (2 + 1))
5821                 {
5822                   warn (_("Internal error: not enough buffer room for section flag info"));
5823                   return _("<unknown>");
5824                 }
5825               size -= 2;
5826               *p++ = ',';
5827               *p++ = ' ';
5828             }
5829           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5830                    (unsigned long) os_flags);
5831           p += 5 + field_size;
5832         }
5833       if (proc_flags)
5834         {
5835           size -= 7 + field_size;
5836           if (p != buff + field_size + 4)
5837             {
5838               if (size < (2 + 1))
5839                 {
5840                   warn (_("Internal error: not enough buffer room for section flag info"));
5841                   return _("<unknown>");
5842                 }
5843               size -= 2;
5844               *p++ = ',';
5845               *p++ = ' ';
5846             }
5847           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5848                    (unsigned long) proc_flags);
5849           p += 7 + field_size;
5850         }
5851       if (unknown_flags)
5852         {
5853           size -= 10 + field_size;
5854           if (p != buff + field_size + 4)
5855             {
5856               if (size < (2 + 1))
5857                 {
5858                   warn (_("Internal error: not enough buffer room for section flag info"));
5859                   return _("<unknown>");
5860                 }
5861               size -= 2;
5862               *p++ = ',';
5863               *p++ = ' ';
5864             }
5865           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5866                    (unsigned long) unknown_flags);
5867           p += 10 + field_size;
5868         }
5869     }
5870
5871   *p = '\0';
5872   return buff;
5873 }
5874
5875 static unsigned int
5876 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5877 {
5878   if (is_32bit_elf)
5879     {
5880       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5881
5882       if (size < sizeof (* echdr))
5883         {
5884           error (_("Compressed section is too small even for a compression header\n"));
5885           return 0;
5886         }
5887
5888       chdr->ch_type = BYTE_GET (echdr->ch_type);
5889       chdr->ch_size = BYTE_GET (echdr->ch_size);
5890       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5891       return sizeof (*echdr);
5892     }
5893   else
5894     {
5895       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5896
5897       if (size < sizeof (* echdr))
5898         {
5899           error (_("Compressed section is too small even for a compression header\n"));
5900           return 0;
5901         }
5902
5903       chdr->ch_type = BYTE_GET (echdr->ch_type);
5904       chdr->ch_size = BYTE_GET (echdr->ch_size);
5905       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5906       return sizeof (*echdr);
5907     }
5908 }
5909
5910 static bfd_boolean
5911 process_section_headers (Filedata * filedata)
5912 {
5913   Elf_Internal_Shdr * section;
5914   unsigned int i;
5915
5916   filedata->section_headers = NULL;
5917
5918   if (filedata->file_header.e_shnum == 0)
5919     {
5920       /* PR binutils/12467.  */
5921       if (filedata->file_header.e_shoff != 0)
5922         {
5923           warn (_("possibly corrupt ELF file header - it has a non-zero"
5924                   " section header offset, but no section headers\n"));
5925           return FALSE;
5926         }
5927       else if (do_sections)
5928         printf (_("\nThere are no sections in this file.\n"));
5929
5930       return TRUE;
5931     }
5932
5933   if (do_sections && !do_header)
5934     printf (ngettext ("There is %d section header, "
5935                       "starting at offset 0x%lx:\n",
5936                       "There are %d section headers, "
5937                       "starting at offset 0x%lx:\n",
5938                       filedata->file_header.e_shnum),
5939             filedata->file_header.e_shnum,
5940             (unsigned long) filedata->file_header.e_shoff);
5941
5942   if (is_32bit_elf)
5943     {
5944       if (! get_32bit_section_headers (filedata, FALSE))
5945         return FALSE;
5946     }
5947   else
5948     {
5949       if (! get_64bit_section_headers (filedata, FALSE))
5950         return FALSE;
5951     }
5952
5953   /* Read in the string table, so that we have names to display.  */
5954   if (filedata->file_header.e_shstrndx != SHN_UNDEF
5955        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
5956     {
5957       section = filedata->section_headers + filedata->file_header.e_shstrndx;
5958
5959       if (section->sh_size != 0)
5960         {
5961           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
5962                                                       1, section->sh_size,
5963                                                       _("string table"));
5964
5965           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
5966         }
5967     }
5968
5969   /* Scan the sections for the dynamic symbol table
5970      and dynamic string table and debug sections.  */
5971   dynamic_symbols = NULL;
5972   dynamic_strings = NULL;
5973   dynamic_syminfo = NULL;
5974   symtab_shndx_list = NULL;
5975
5976   eh_addr_size = is_32bit_elf ? 4 : 8;
5977   switch (filedata->file_header.e_machine)
5978     {
5979     case EM_MIPS:
5980     case EM_MIPS_RS3_LE:
5981       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5982          FDE addresses.  However, the ABI also has a semi-official ILP32
5983          variant for which the normal FDE address size rules apply.
5984
5985          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5986          section, where XX is the size of longs in bits.  Unfortunately,
5987          earlier compilers provided no way of distinguishing ILP32 objects
5988          from LP64 objects, so if there's any doubt, we should assume that
5989          the official LP64 form is being used.  */
5990       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5991           && find_section (filedata, ".gcc_compiled_long32") == NULL)
5992         eh_addr_size = 8;
5993       break;
5994
5995     case EM_H8_300:
5996     case EM_H8_300H:
5997       switch (filedata->file_header.e_flags & EF_H8_MACH)
5998         {
5999         case E_H8_MACH_H8300:
6000         case E_H8_MACH_H8300HN:
6001         case E_H8_MACH_H8300SN:
6002         case E_H8_MACH_H8300SXN:
6003           eh_addr_size = 2;
6004           break;
6005         case E_H8_MACH_H8300H:
6006         case E_H8_MACH_H8300S:
6007         case E_H8_MACH_H8300SX:
6008           eh_addr_size = 4;
6009           break;
6010         }
6011       break;
6012
6013     case EM_M32C_OLD:
6014     case EM_M32C:
6015       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6016         {
6017         case EF_M32C_CPU_M16C:
6018           eh_addr_size = 2;
6019           break;
6020         }
6021       break;
6022     }
6023
6024 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6025   do                                                                    \
6026     {                                                                   \
6027       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6028       if (section->sh_entsize != expected_entsize)                      \
6029         {                                                               \
6030           char buf[40];                                                 \
6031           sprintf_vma (buf, section->sh_entsize);                       \
6032           /* Note: coded this way so that there is a single string for  \
6033              translation.  */ \
6034           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6035           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6036                    (unsigned) expected_entsize);                        \
6037           section->sh_entsize = expected_entsize;                       \
6038         }                                                               \
6039     }                                                                   \
6040   while (0)
6041
6042 #define CHECK_ENTSIZE(section, i, type)                                 \
6043   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6044                         sizeof (Elf64_External_##type))
6045
6046   for (i = 0, section = filedata->section_headers;
6047        i < filedata->file_header.e_shnum;
6048        i++, section++)
6049     {
6050       char * name = SECTION_NAME (section);
6051
6052       if (section->sh_type == SHT_DYNSYM)
6053         {
6054           if (dynamic_symbols != NULL)
6055             {
6056               error (_("File contains multiple dynamic symbol tables\n"));
6057               continue;
6058             }
6059
6060           CHECK_ENTSIZE (section, i, Sym);
6061           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6062         }
6063       else if (section->sh_type == SHT_STRTAB
6064                && streq (name, ".dynstr"))
6065         {
6066           if (dynamic_strings != NULL)
6067             {
6068               error (_("File contains multiple dynamic string tables\n"));
6069               continue;
6070             }
6071
6072           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6073                                                1, section->sh_size,
6074                                                _("dynamic strings"));
6075           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6076         }
6077       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6078         {
6079           elf_section_list * entry = xmalloc (sizeof * entry);
6080
6081           entry->hdr = section;
6082           entry->next = symtab_shndx_list;
6083           symtab_shndx_list = entry;
6084         }
6085       else if (section->sh_type == SHT_SYMTAB)
6086         CHECK_ENTSIZE (section, i, Sym);
6087       else if (section->sh_type == SHT_GROUP)
6088         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6089       else if (section->sh_type == SHT_REL)
6090         CHECK_ENTSIZE (section, i, Rel);
6091       else if (section->sh_type == SHT_RELA)
6092         CHECK_ENTSIZE (section, i, Rela);
6093       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6094                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6095                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6096                 || do_debug_str || do_debug_loc || do_debug_ranges
6097                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6098                && (const_strneq (name, ".debug_")
6099                    || const_strneq (name, ".zdebug_")))
6100         {
6101           if (name[1] == 'z')
6102             name += sizeof (".zdebug_") - 1;
6103           else
6104             name += sizeof (".debug_") - 1;
6105
6106           if (do_debugging
6107               || (do_debug_info     && const_strneq (name, "info"))
6108               || (do_debug_info     && const_strneq (name, "types"))
6109               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6110               || (do_debug_lines    && strcmp (name, "line") == 0)
6111               || (do_debug_lines    && const_strneq (name, "line."))
6112               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6113               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6114               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6115               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6116               || (do_debug_aranges  && const_strneq (name, "aranges"))
6117               || (do_debug_ranges   && const_strneq (name, "ranges"))
6118               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6119               || (do_debug_frames   && const_strneq (name, "frame"))
6120               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6121               || (do_debug_macinfo  && const_strneq (name, "macro"))
6122               || (do_debug_str      && const_strneq (name, "str"))
6123               || (do_debug_loc      && const_strneq (name, "loc"))
6124               || (do_debug_loc      && const_strneq (name, "loclists"))
6125               || (do_debug_addr     && const_strneq (name, "addr"))
6126               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6127               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6128               )
6129             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6130         }
6131       /* Linkonce section to be combined with .debug_info at link time.  */
6132       else if ((do_debugging || do_debug_info)
6133                && const_strneq (name, ".gnu.linkonce.wi."))
6134         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6135       else if (do_debug_frames && streq (name, ".eh_frame"))
6136         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6137       else if (do_gdb_index && (streq (name, ".gdb_index")
6138                                 || streq (name, ".debug_names")))
6139         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6140       /* Trace sections for Itanium VMS.  */
6141       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6142                 || do_trace_aranges)
6143                && const_strneq (name, ".trace_"))
6144         {
6145           name += sizeof (".trace_") - 1;
6146
6147           if (do_debugging
6148               || (do_trace_info     && streq (name, "info"))
6149               || (do_trace_abbrevs  && streq (name, "abbrev"))
6150               || (do_trace_aranges  && streq (name, "aranges"))
6151               )
6152             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6153         }
6154       else if ((do_debugging || do_debug_links)
6155                && (const_strneq (name, ".gnu_debuglink")
6156                    || const_strneq (name, ".gnu_debugaltlink")))
6157         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6158     }
6159
6160   if (! do_sections)
6161     return TRUE;
6162
6163   if (filedata->file_header.e_shnum > 1)
6164     printf (_("\nSection Headers:\n"));
6165   else
6166     printf (_("\nSection Header:\n"));
6167
6168   if (is_32bit_elf)
6169     {
6170       if (do_section_details)
6171         {
6172           printf (_("  [Nr] Name\n"));
6173           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6174         }
6175       else
6176         printf
6177           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6178     }
6179   else if (do_wide)
6180     {
6181       if (do_section_details)
6182         {
6183           printf (_("  [Nr] Name\n"));
6184           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6185         }
6186       else
6187         printf
6188           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6189     }
6190   else
6191     {
6192       if (do_section_details)
6193         {
6194           printf (_("  [Nr] Name\n"));
6195           printf (_("       Type              Address          Offset            Link\n"));
6196           printf (_("       Size              EntSize          Info              Align\n"));
6197         }
6198       else
6199         {
6200           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6201           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6202         }
6203     }
6204
6205   if (do_section_details)
6206     printf (_("       Flags\n"));
6207
6208   for (i = 0, section = filedata->section_headers;
6209        i < filedata->file_header.e_shnum;
6210        i++, section++)
6211     {
6212       /* Run some sanity checks on the section header.  */
6213
6214       /* Check the sh_link field.  */
6215       switch (section->sh_type)
6216         {
6217         case SHT_SYMTAB_SHNDX:
6218         case SHT_GROUP:
6219         case SHT_HASH:
6220         case SHT_GNU_HASH:
6221         case SHT_GNU_versym:
6222         case SHT_REL:
6223         case SHT_RELA:
6224           if (section->sh_link < 1
6225               || section->sh_link >= filedata->file_header.e_shnum
6226               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6227                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6228             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6229                   i, section->sh_link);
6230           break;
6231
6232         case SHT_DYNAMIC:
6233         case SHT_SYMTAB:
6234         case SHT_DYNSYM:
6235         case SHT_GNU_verneed:
6236         case SHT_GNU_verdef:
6237         case SHT_GNU_LIBLIST:
6238           if (section->sh_link < 1
6239               || section->sh_link >= filedata->file_header.e_shnum
6240               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6241             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6242                   i, section->sh_link);
6243           break;
6244
6245         case SHT_INIT_ARRAY:
6246         case SHT_FINI_ARRAY:
6247         case SHT_PREINIT_ARRAY:
6248           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6249             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6250                   i, section->sh_link);
6251           break;
6252
6253         default:
6254           /* FIXME: Add support for target specific section types.  */
6255 #if 0     /* Currently we do not check other section types as there are too
6256              many special cases.  Stab sections for example have a type
6257              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6258              section.  */
6259           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6260             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6261                   i, section->sh_link);
6262 #endif
6263           break;
6264         }
6265
6266       /* Check the sh_info field.  */
6267       switch (section->sh_type)
6268         {
6269         case SHT_REL:
6270         case SHT_RELA:
6271           if (section->sh_info < 1
6272               || section->sh_info >= filedata->file_header.e_shnum
6273               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6274                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6275                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6276                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6277                   /* FIXME: Are other section types valid ?  */
6278                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6279             {
6280               if (section->sh_info == 0
6281                   && (filedata->file_header.e_type == ET_EXEC
6282                       || filedata->file_header.e_type == ET_DYN
6283                       /* These next two tests may be redundant, but
6284                          they have been left in for paranoia's sake.  */
6285                       || streq (SECTION_NAME (section), ".rel.dyn")
6286                       || streq (SECTION_NAME (section), ".rela.dyn")))
6287                 /* Dynamic relocations apply to segments, not sections, so
6288                    they do not need an sh_info value.  */
6289                 ;
6290               else
6291                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6292                       i, section->sh_info);
6293             }
6294           break;
6295
6296         case SHT_DYNAMIC:
6297         case SHT_HASH:
6298         case SHT_SYMTAB_SHNDX:
6299         case SHT_INIT_ARRAY:
6300         case SHT_FINI_ARRAY:
6301         case SHT_PREINIT_ARRAY:
6302           if (section->sh_info != 0)
6303             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6304                   i, section->sh_info);
6305           break;
6306
6307         case SHT_GROUP:
6308         case SHT_SYMTAB:
6309         case SHT_DYNSYM:
6310           /* A symbol index - we assume that it is valid.  */
6311           break;
6312
6313         default:
6314           /* FIXME: Add support for target specific section types.  */
6315           if (section->sh_type == SHT_NOBITS)
6316             /* NOBITS section headers with non-zero sh_info fields can be
6317                created when a binary is stripped of everything but its debug
6318                information.  The stripped sections have their headers
6319                preserved but their types set to SHT_NOBITS.  So do not check
6320                this type of section.  */
6321             ;
6322           else if (section->sh_flags & SHF_INFO_LINK)
6323             {
6324               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6325                 warn (_("[%2u]: Expected link to another section in info field"), i);
6326             }
6327           else if (section->sh_type < SHT_LOOS
6328                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6329                    && section->sh_info != 0)
6330             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6331                   i, section->sh_info);
6332           break;
6333         }
6334
6335       /* Check the sh_size field.  */
6336       if (section->sh_size > filedata->file_size
6337           && section->sh_type != SHT_NOBITS
6338           && section->sh_type != SHT_NULL
6339           && section->sh_type < SHT_LOOS)
6340         warn (_("Size of section %u is larger than the entire file!\n"), i);
6341
6342       printf ("  [%2u] ", i);
6343       if (do_section_details)
6344         printf ("%s\n      ", printable_section_name (filedata, section));
6345       else
6346         print_symbol (-17, SECTION_NAME (section));
6347
6348       printf (do_wide ? " %-15s " : " %-15.15s ",
6349               get_section_type_name (filedata, section->sh_type));
6350
6351       if (is_32bit_elf)
6352         {
6353           const char * link_too_big = NULL;
6354
6355           print_vma (section->sh_addr, LONG_HEX);
6356
6357           printf ( " %6.6lx %6.6lx %2.2lx",
6358                    (unsigned long) section->sh_offset,
6359                    (unsigned long) section->sh_size,
6360                    (unsigned long) section->sh_entsize);
6361
6362           if (do_section_details)
6363             fputs ("  ", stdout);
6364           else
6365             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6366
6367           if (section->sh_link >= filedata->file_header.e_shnum)
6368             {
6369               link_too_big = "";
6370               /* The sh_link value is out of range.  Normally this indicates
6371                  an error but it can have special values in Solaris binaries.  */
6372               switch (filedata->file_header.e_machine)
6373                 {
6374                 case EM_386:
6375                 case EM_IAMCU:
6376                 case EM_X86_64:
6377                 case EM_L1OM:
6378                 case EM_K1OM:
6379                 case EM_OLD_SPARCV9:
6380                 case EM_SPARC32PLUS:
6381                 case EM_SPARCV9:
6382                 case EM_SPARC:
6383                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6384                     link_too_big = "BEFORE";
6385                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6386                     link_too_big = "AFTER";
6387                   break;
6388                 default:
6389                   break;
6390                 }
6391             }
6392
6393           if (do_section_details)
6394             {
6395               if (link_too_big != NULL && * link_too_big)
6396                 printf ("<%s> ", link_too_big);
6397               else
6398                 printf ("%2u ", section->sh_link);
6399               printf ("%3u %2lu\n", section->sh_info,
6400                       (unsigned long) section->sh_addralign);
6401             }
6402           else
6403             printf ("%2u %3u %2lu\n",
6404                     section->sh_link,
6405                     section->sh_info,
6406                     (unsigned long) section->sh_addralign);
6407
6408           if (link_too_big && ! * link_too_big)
6409             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6410                   i, section->sh_link);
6411         }
6412       else if (do_wide)
6413         {
6414           print_vma (section->sh_addr, LONG_HEX);
6415
6416           if ((long) section->sh_offset == section->sh_offset)
6417             printf (" %6.6lx", (unsigned long) section->sh_offset);
6418           else
6419             {
6420               putchar (' ');
6421               print_vma (section->sh_offset, LONG_HEX);
6422             }
6423
6424           if ((unsigned long) section->sh_size == section->sh_size)
6425             printf (" %6.6lx", (unsigned long) section->sh_size);
6426           else
6427             {
6428               putchar (' ');
6429               print_vma (section->sh_size, LONG_HEX);
6430             }
6431
6432           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6433             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6434           else
6435             {
6436               putchar (' ');
6437               print_vma (section->sh_entsize, LONG_HEX);
6438             }
6439
6440           if (do_section_details)
6441             fputs ("  ", stdout);
6442           else
6443             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6444
6445           printf ("%2u %3u ", section->sh_link, section->sh_info);
6446
6447           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6448             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6449           else
6450             {
6451               print_vma (section->sh_addralign, DEC);
6452               putchar ('\n');
6453             }
6454         }
6455       else if (do_section_details)
6456         {
6457           printf ("       %-15.15s  ",
6458                   get_section_type_name (filedata, section->sh_type));
6459           print_vma (section->sh_addr, LONG_HEX);
6460           if ((long) section->sh_offset == section->sh_offset)
6461             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6462           else
6463             {
6464               printf ("  ");
6465               print_vma (section->sh_offset, LONG_HEX);
6466             }
6467           printf ("  %u\n       ", section->sh_link);
6468           print_vma (section->sh_size, LONG_HEX);
6469           putchar (' ');
6470           print_vma (section->sh_entsize, LONG_HEX);
6471
6472           printf ("  %-16u  %lu\n",
6473                   section->sh_info,
6474                   (unsigned long) section->sh_addralign);
6475         }
6476       else
6477         {
6478           putchar (' ');
6479           print_vma (section->sh_addr, LONG_HEX);
6480           if ((long) section->sh_offset == section->sh_offset)
6481             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6482           else
6483             {
6484               printf ("  ");
6485               print_vma (section->sh_offset, LONG_HEX);
6486             }
6487           printf ("\n       ");
6488           print_vma (section->sh_size, LONG_HEX);
6489           printf ("  ");
6490           print_vma (section->sh_entsize, LONG_HEX);
6491
6492           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6493
6494           printf ("     %2u   %3u     %lu\n",
6495                   section->sh_link,
6496                   section->sh_info,
6497                   (unsigned long) section->sh_addralign);
6498         }
6499
6500       if (do_section_details)
6501         {
6502           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6503           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6504             {
6505               /* Minimum section size is 12 bytes for 32-bit compression
6506                  header + 12 bytes for compressed data header.  */
6507               unsigned char buf[24];
6508
6509               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6510               if (get_data (&buf, filedata, section->sh_offset, 1,
6511                             sizeof (buf), _("compression header")))
6512                 {
6513                   Elf_Internal_Chdr chdr;
6514
6515                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6516
6517                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6518                     printf ("       ZLIB, ");
6519                   else
6520                     printf (_("       [<unknown>: 0x%x], "),
6521                             chdr.ch_type);
6522                   print_vma (chdr.ch_size, LONG_HEX);
6523                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6524                 }
6525             }
6526         }
6527     }
6528
6529   if (!do_section_details)
6530     {
6531       /* The ordering of the letters shown here matches the ordering of the
6532          corresponding SHF_xxx values, and hence the order in which these
6533          letters will be displayed to the user.  */
6534       printf (_("Key to Flags:\n\
6535   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6536   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6537   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6538       if (filedata->file_header.e_machine == EM_X86_64
6539           || filedata->file_header.e_machine == EM_L1OM
6540           || filedata->file_header.e_machine == EM_K1OM)
6541         printf (_("l (large), "));
6542       else if (filedata->file_header.e_machine == EM_ARM)
6543         printf (_("y (purecode), "));
6544       else if (filedata->file_header.e_machine == EM_PPC)
6545         printf (_("v (VLE), "));
6546       printf ("p (processor specific)\n");
6547     }
6548
6549   return TRUE;
6550 }
6551
6552 static const char *
6553 get_group_flags (unsigned int flags)
6554 {
6555   static char buff[128];
6556
6557   if (flags == 0)
6558     return "";
6559   else if (flags == GRP_COMDAT)
6560     return "COMDAT ";
6561
6562   snprintf (buff, 14, _("[0x%x: "), flags);
6563
6564   flags &= ~ GRP_COMDAT;
6565   if (flags & GRP_MASKOS)
6566     {
6567       strcat (buff, "<OS specific>");
6568       flags &= ~ GRP_MASKOS;
6569     }
6570
6571   if (flags & GRP_MASKPROC)
6572     {
6573       strcat (buff, "<PROC specific>");
6574       flags &= ~ GRP_MASKPROC;
6575     }
6576
6577   if (flags)
6578     strcat (buff, "<unknown>");
6579
6580   strcat (buff, "]");
6581   return buff;
6582 }
6583
6584 static bfd_boolean
6585 process_section_groups (Filedata * filedata)
6586 {
6587   Elf_Internal_Shdr * section;
6588   unsigned int i;
6589   struct group * group;
6590   Elf_Internal_Shdr * symtab_sec;
6591   Elf_Internal_Shdr * strtab_sec;
6592   Elf_Internal_Sym * symtab;
6593   unsigned long num_syms;
6594   char * strtab;
6595   size_t strtab_size;
6596
6597   /* Don't process section groups unless needed.  */
6598   if (!do_unwind && !do_section_groups)
6599     return TRUE;
6600
6601   if (filedata->file_header.e_shnum == 0)
6602     {
6603       if (do_section_groups)
6604         printf (_("\nThere are no sections to group in this file.\n"));
6605
6606       return TRUE;
6607     }
6608
6609   if (filedata->section_headers == NULL)
6610     {
6611       error (_("Section headers are not available!\n"));
6612       /* PR 13622: This can happen with a corrupt ELF header.  */
6613       return FALSE;
6614     }
6615
6616   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6617                                                      sizeof (struct group *));
6618
6619   if (section_headers_groups == NULL)
6620     {
6621       error (_("Out of memory reading %u section group headers\n"),
6622              filedata->file_header.e_shnum);
6623       return FALSE;
6624     }
6625
6626   /* Scan the sections for the group section.  */
6627   group_count = 0;
6628   for (i = 0, section = filedata->section_headers;
6629        i < filedata->file_header.e_shnum;
6630        i++, section++)
6631     if (section->sh_type == SHT_GROUP)
6632       group_count++;
6633
6634   if (group_count == 0)
6635     {
6636       if (do_section_groups)
6637         printf (_("\nThere are no section groups in this file.\n"));
6638
6639       return TRUE;
6640     }
6641
6642   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6643
6644   if (section_groups == NULL)
6645     {
6646       error (_("Out of memory reading %lu groups\n"),
6647              (unsigned long) group_count);
6648       return FALSE;
6649     }
6650
6651   symtab_sec = NULL;
6652   strtab_sec = NULL;
6653   symtab = NULL;
6654   num_syms = 0;
6655   strtab = NULL;
6656   strtab_size = 0;
6657   for (i = 0, section = filedata->section_headers, group = section_groups;
6658        i < filedata->file_header.e_shnum;
6659        i++, section++)
6660     {
6661       if (section->sh_type == SHT_GROUP)
6662         {
6663           const char * name = printable_section_name (filedata, section);
6664           const char * group_name;
6665           unsigned char * start;
6666           unsigned char * indices;
6667           unsigned int entry, j, size;
6668           Elf_Internal_Shdr * sec;
6669           Elf_Internal_Sym * sym;
6670
6671           /* Get the symbol table.  */
6672           if (section->sh_link >= filedata->file_header.e_shnum
6673               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6674                   != SHT_SYMTAB))
6675             {
6676               error (_("Bad sh_link in group section `%s'\n"), name);
6677               continue;
6678             }
6679
6680           if (symtab_sec != sec)
6681             {
6682               symtab_sec = sec;
6683               if (symtab)
6684                 free (symtab);
6685               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6686             }
6687
6688           if (symtab == NULL)
6689             {
6690               error (_("Corrupt header in group section `%s'\n"), name);
6691               continue;
6692             }
6693
6694           if (section->sh_info >= num_syms)
6695             {
6696               error (_("Bad sh_info in group section `%s'\n"), name);
6697               continue;
6698             }
6699
6700           sym = symtab + section->sh_info;
6701
6702           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6703             {
6704               if (sym->st_shndx == 0
6705                   || sym->st_shndx >= filedata->file_header.e_shnum)
6706                 {
6707                   error (_("Bad sh_info in group section `%s'\n"), name);
6708                   continue;
6709                 }
6710
6711               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6712               strtab_sec = NULL;
6713               if (strtab)
6714                 free (strtab);
6715               strtab = NULL;
6716               strtab_size = 0;
6717             }
6718           else
6719             {
6720               /* Get the string table.  */
6721               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6722                 {
6723                   strtab_sec = NULL;
6724                   if (strtab)
6725                     free (strtab);
6726                   strtab = NULL;
6727                   strtab_size = 0;
6728                 }
6729               else if (strtab_sec
6730                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6731                 {
6732                   strtab_sec = sec;
6733                   if (strtab)
6734                     free (strtab);
6735
6736                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6737                                               1, strtab_sec->sh_size,
6738                                               _("string table"));
6739                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6740                 }
6741               group_name = sym->st_name < strtab_size
6742                 ? strtab + sym->st_name : _("<corrupt>");
6743             }
6744
6745           /* PR 17531: file: loop.  */
6746           if (section->sh_entsize > section->sh_size)
6747             {
6748               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6749                      printable_section_name (filedata, section),
6750                      (unsigned long) section->sh_entsize,
6751                      (unsigned long) section->sh_size);
6752               break;
6753             }
6754
6755           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6756                                               1, section->sh_size,
6757                                               _("section data"));
6758           if (start == NULL)
6759             continue;
6760
6761           indices = start;
6762           size = (section->sh_size / section->sh_entsize) - 1;
6763           entry = byte_get (indices, 4);
6764           indices += 4;
6765
6766           if (do_section_groups)
6767             {
6768               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6769                       get_group_flags (entry), i, name, group_name, size);
6770
6771               printf (_("   [Index]    Name\n"));
6772             }
6773
6774           group->group_index = i;
6775
6776           for (j = 0; j < size; j++)
6777             {
6778               struct group_list * g;
6779
6780               entry = byte_get (indices, 4);
6781               indices += 4;
6782
6783               if (entry >= filedata->file_header.e_shnum)
6784                 {
6785                   static unsigned num_group_errors = 0;
6786
6787                   if (num_group_errors ++ < 10)
6788                     {
6789                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6790                              entry, i, filedata->file_header.e_shnum - 1);
6791                       if (num_group_errors == 10)
6792                         warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6793                     }
6794                   continue;
6795                 }
6796
6797               if (section_headers_groups [entry] != NULL)
6798                 {
6799                   if (entry)
6800                     {
6801                       static unsigned num_errs = 0;
6802
6803                       if (num_errs ++ < 10)
6804                         {
6805                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6806                                  entry, i,
6807                                  section_headers_groups [entry]->group_index);
6808                           if (num_errs == 10)
6809                             warn (_("Further error messages about already contained group sections suppressed\n"));
6810                         }
6811                       continue;
6812                     }
6813                   else
6814                     {
6815                       /* Intel C/C++ compiler may put section 0 in a
6816                          section group.  We just warn it the first time
6817                          and ignore it afterwards.  */
6818                       static bfd_boolean warned = FALSE;
6819                       if (!warned)
6820                         {
6821                           error (_("section 0 in group section [%5u]\n"),
6822                                  section_headers_groups [entry]->group_index);
6823                           warned = TRUE;
6824                         }
6825                     }
6826                 }
6827
6828               section_headers_groups [entry] = group;
6829
6830               if (do_section_groups)
6831                 {
6832                   sec = filedata->section_headers + entry;
6833                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6834                 }
6835
6836               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6837               g->section_index = entry;
6838               g->next = group->root;
6839               group->root = g;
6840             }
6841
6842           if (start)
6843             free (start);
6844
6845           group++;
6846         }
6847     }
6848
6849   if (symtab)
6850     free (symtab);
6851   if (strtab)
6852     free (strtab);
6853   return TRUE;
6854 }
6855
6856 /* Data used to display dynamic fixups.  */
6857
6858 struct ia64_vms_dynfixup
6859 {
6860   bfd_vma needed_ident;         /* Library ident number.  */
6861   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6862   bfd_vma fixup_needed;         /* Index of the library.  */
6863   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6864   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6865 };
6866
6867 /* Data used to display dynamic relocations.  */
6868
6869 struct ia64_vms_dynimgrela
6870 {
6871   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6872   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6873 };
6874
6875 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6876    library).  */
6877
6878 static bfd_boolean
6879 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6880                               struct ia64_vms_dynfixup *  fixup,
6881                               const char *                strtab,
6882                               unsigned int                strtab_sz)
6883 {
6884   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6885   long i;
6886   const char * lib_name;
6887
6888   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6889                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6890                    _("dynamic section image fixups"));
6891   if (!imfs)
6892     return FALSE;
6893
6894   if (fixup->needed < strtab_sz)
6895     lib_name = strtab + fixup->needed;
6896   else
6897     {
6898       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6899             (unsigned long) fixup->needed);
6900       lib_name = "???";
6901     }
6902   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6903           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6904   printf
6905     (_("Seg Offset           Type                             SymVec DataType\n"));
6906
6907   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6908     {
6909       unsigned int type;
6910       const char *rtype;
6911
6912       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6913       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6914       type = BYTE_GET (imfs [i].type);
6915       rtype = elf_ia64_reloc_type (type);
6916       if (rtype == NULL)
6917         printf (" 0x%08x                       ", type);
6918       else
6919         printf (" %-32s ", rtype);
6920       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6921       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6922     }
6923
6924   free (imfs);
6925   return TRUE;
6926 }
6927
6928 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6929
6930 static bfd_boolean
6931 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
6932 {
6933   Elf64_External_VMS_IMAGE_RELA *imrs;
6934   long i;
6935
6936   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
6937                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6938                    _("dynamic section image relocations"));
6939   if (!imrs)
6940     return FALSE;
6941
6942   printf (_("\nImage relocs\n"));
6943   printf
6944     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6945
6946   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6947     {
6948       unsigned int type;
6949       const char *rtype;
6950
6951       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6952       printf ("%08" BFD_VMA_FMT "x ",
6953               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6954       type = BYTE_GET (imrs [i].type);
6955       rtype = elf_ia64_reloc_type (type);
6956       if (rtype == NULL)
6957         printf ("0x%08x                      ", type);
6958       else
6959         printf ("%-31s ", rtype);
6960       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6961       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6962       printf ("%08" BFD_VMA_FMT "x\n",
6963               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6964     }
6965
6966   free (imrs);
6967   return TRUE;
6968 }
6969
6970 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6971
6972 static bfd_boolean
6973 process_ia64_vms_dynamic_relocs (Filedata * filedata)
6974 {
6975   struct ia64_vms_dynfixup fixup;
6976   struct ia64_vms_dynimgrela imgrela;
6977   Elf_Internal_Dyn *entry;
6978   bfd_vma strtab_off = 0;
6979   bfd_vma strtab_sz = 0;
6980   char *strtab = NULL;
6981   bfd_boolean res = TRUE;
6982
6983   memset (&fixup, 0, sizeof (fixup));
6984   memset (&imgrela, 0, sizeof (imgrela));
6985
6986   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6987   for (entry = dynamic_section;
6988        entry < dynamic_section + dynamic_nent;
6989        entry++)
6990     {
6991       switch (entry->d_tag)
6992         {
6993         case DT_IA_64_VMS_STRTAB_OFFSET:
6994           strtab_off = entry->d_un.d_val;
6995           break;
6996         case DT_STRSZ:
6997           strtab_sz = entry->d_un.d_val;
6998           if (strtab == NULL)
6999             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7000                                1, strtab_sz, _("dynamic string section"));
7001           break;
7002
7003         case DT_IA_64_VMS_NEEDED_IDENT:
7004           fixup.needed_ident = entry->d_un.d_val;
7005           break;
7006         case DT_NEEDED:
7007           fixup.needed = entry->d_un.d_val;
7008           break;
7009         case DT_IA_64_VMS_FIXUP_NEEDED:
7010           fixup.fixup_needed = entry->d_un.d_val;
7011           break;
7012         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7013           fixup.fixup_rela_cnt = entry->d_un.d_val;
7014           break;
7015         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7016           fixup.fixup_rela_off = entry->d_un.d_val;
7017           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7018             res = FALSE;
7019           break;
7020         case DT_IA_64_VMS_IMG_RELA_CNT:
7021           imgrela.img_rela_cnt = entry->d_un.d_val;
7022           break;
7023         case DT_IA_64_VMS_IMG_RELA_OFF:
7024           imgrela.img_rela_off = entry->d_un.d_val;
7025           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7026             res = FALSE;
7027           break;
7028
7029         default:
7030           break;
7031         }
7032     }
7033
7034   if (strtab != NULL)
7035     free (strtab);
7036
7037   return res;
7038 }
7039
7040 static struct
7041 {
7042   const char * name;
7043   int reloc;
7044   int size;
7045   int rela;
7046 }
7047   dynamic_relocations [] =
7048 {
7049   { "REL", DT_REL, DT_RELSZ, FALSE },
7050   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7051   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7052 };
7053
7054 /* Process the reloc section.  */
7055
7056 static bfd_boolean
7057 process_relocs (Filedata * filedata)
7058 {
7059   unsigned long rel_size;
7060   unsigned long rel_offset;
7061
7062   if (!do_reloc)
7063     return TRUE;
7064
7065   if (do_using_dynamic)
7066     {
7067       int          is_rela;
7068       const char * name;
7069       bfd_boolean  has_dynamic_reloc;
7070       unsigned int i;
7071
7072       has_dynamic_reloc = FALSE;
7073
7074       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7075         {
7076           is_rela = dynamic_relocations [i].rela;
7077           name = dynamic_relocations [i].name;
7078           rel_size = dynamic_info [dynamic_relocations [i].size];
7079           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7080
7081           if (rel_size)
7082             has_dynamic_reloc = TRUE;
7083
7084           if (is_rela == UNKNOWN)
7085             {
7086               if (dynamic_relocations [i].reloc == DT_JMPREL)
7087                 switch (dynamic_info[DT_PLTREL])
7088                   {
7089                   case DT_REL:
7090                     is_rela = FALSE;
7091                     break;
7092                   case DT_RELA:
7093                     is_rela = TRUE;
7094                     break;
7095                   }
7096             }
7097
7098           if (rel_size)
7099             {
7100               printf
7101                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7102                  name, rel_offset, rel_size);
7103
7104               dump_relocations (filedata,
7105                                 offset_from_vma (filedata, rel_offset, rel_size),
7106                                 rel_size,
7107                                 dynamic_symbols, num_dynamic_syms,
7108                                 dynamic_strings, dynamic_strings_length,
7109                                 is_rela, TRUE /* is_dynamic */);
7110             }
7111         }
7112
7113       if (is_ia64_vms (filedata))
7114         if (process_ia64_vms_dynamic_relocs (filedata))
7115           has_dynamic_reloc = TRUE;
7116
7117       if (! has_dynamic_reloc)
7118         printf (_("\nThere are no dynamic relocations in this file.\n"));
7119     }
7120   else
7121     {
7122       Elf_Internal_Shdr * section;
7123       unsigned long i;
7124       bfd_boolean found = FALSE;
7125
7126       for (i = 0, section = filedata->section_headers;
7127            i < filedata->file_header.e_shnum;
7128            i++, section++)
7129         {
7130           if (   section->sh_type != SHT_RELA
7131               && section->sh_type != SHT_REL)
7132             continue;
7133
7134           rel_offset = section->sh_offset;
7135           rel_size   = section->sh_size;
7136
7137           if (rel_size)
7138             {
7139               Elf_Internal_Shdr * strsec;
7140               int is_rela;
7141               unsigned long num_rela;
7142
7143               printf (_("\nRelocation section "));
7144
7145               if (filedata->string_table == NULL)
7146                 printf ("%d", section->sh_name);
7147               else
7148                 printf ("'%s'", printable_section_name (filedata, section));
7149
7150               num_rela = rel_size / section->sh_entsize;
7151               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7152                                 " at offset 0x%lx contains %lu entries:\n",
7153                                 num_rela),
7154                       rel_offset, num_rela);
7155
7156               is_rela = section->sh_type == SHT_RELA;
7157
7158               if (section->sh_link != 0
7159                   && section->sh_link < filedata->file_header.e_shnum)
7160                 {
7161                   Elf_Internal_Shdr * symsec;
7162                   Elf_Internal_Sym *  symtab;
7163                   unsigned long nsyms;
7164                   unsigned long strtablen = 0;
7165                   char * strtab = NULL;
7166
7167                   symsec = filedata->section_headers + section->sh_link;
7168                   if (symsec->sh_type != SHT_SYMTAB
7169                       && symsec->sh_type != SHT_DYNSYM)
7170                     continue;
7171
7172                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7173
7174                   if (symtab == NULL)
7175                     continue;
7176
7177                   if (symsec->sh_link != 0
7178                       && symsec->sh_link < filedata->file_header.e_shnum)
7179                     {
7180                       strsec = filedata->section_headers + symsec->sh_link;
7181
7182                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7183                                                   1, strsec->sh_size,
7184                                                   _("string table"));
7185                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7186                     }
7187
7188                   dump_relocations (filedata, rel_offset, rel_size,
7189                                     symtab, nsyms, strtab, strtablen,
7190                                     is_rela,
7191                                     symsec->sh_type == SHT_DYNSYM);
7192                   if (strtab)
7193                     free (strtab);
7194                   free (symtab);
7195                 }
7196               else
7197                 dump_relocations (filedata, rel_offset, rel_size,
7198                                   NULL, 0, NULL, 0, is_rela,
7199                                   FALSE /* is_dynamic */);
7200
7201               found = TRUE;
7202             }
7203         }
7204
7205       if (! found)
7206         {
7207           /* Users sometimes forget the -D option, so try to be helpful.  */
7208           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7209             {
7210               if (dynamic_info [dynamic_relocations [i].size])
7211                 {
7212                   printf (_("\nThere are no static relocations in this file."));
7213                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7214
7215                   break;
7216                 }
7217             }
7218           if (i == ARRAY_SIZE (dynamic_relocations))
7219             printf (_("\nThere are no relocations in this file.\n"));
7220         }
7221     }
7222
7223   return TRUE;
7224 }
7225
7226 /* An absolute address consists of a section and an offset.  If the
7227    section is NULL, the offset itself is the address, otherwise, the
7228    address equals to LOAD_ADDRESS(section) + offset.  */
7229
7230 struct absaddr
7231 {
7232   unsigned short section;
7233   bfd_vma offset;
7234 };
7235
7236 #define ABSADDR(a) \
7237   ((a).section \
7238    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7239    : (a).offset)
7240
7241 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7242    name, if found, and the offset from the symbol to ADDR.  */
7243
7244 static void
7245 find_symbol_for_address (Filedata *          filedata,
7246                          Elf_Internal_Sym *  symtab,
7247                          unsigned long       nsyms,
7248                          const char *        strtab,
7249                          unsigned long       strtab_size,
7250                          struct absaddr      addr,
7251                          const char **       symname,
7252                          bfd_vma *           offset)
7253 {
7254   bfd_vma dist = 0x100000;
7255   Elf_Internal_Sym * sym;
7256   Elf_Internal_Sym * beg;
7257   Elf_Internal_Sym * end;
7258   Elf_Internal_Sym * best = NULL;
7259
7260   REMOVE_ARCH_BITS (addr.offset);
7261   beg = symtab;
7262   end = symtab + nsyms;
7263
7264   while (beg < end)
7265     {
7266       bfd_vma value;
7267
7268       sym = beg + (end - beg) / 2;
7269
7270       value = sym->st_value;
7271       REMOVE_ARCH_BITS (value);
7272
7273       if (sym->st_name != 0
7274           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7275           && addr.offset >= value
7276           && addr.offset - value < dist)
7277         {
7278           best = sym;
7279           dist = addr.offset - value;
7280           if (!dist)
7281             break;
7282         }
7283
7284       if (addr.offset < value)
7285         end = sym;
7286       else
7287         beg = sym + 1;
7288     }
7289
7290   if (best)
7291     {
7292       *symname = (best->st_name >= strtab_size
7293                   ? _("<corrupt>") : strtab + best->st_name);
7294       *offset = dist;
7295       return;
7296     }
7297
7298   *symname = NULL;
7299   *offset = addr.offset;
7300 }
7301
7302 static /* signed */ int
7303 symcmp (const void *p, const void *q)
7304 {
7305   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7306   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7307
7308   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7309 }
7310
7311 /* Process the unwind section.  */
7312
7313 #include "unwind-ia64.h"
7314
7315 struct ia64_unw_table_entry
7316 {
7317   struct absaddr start;
7318   struct absaddr end;
7319   struct absaddr info;
7320 };
7321
7322 struct ia64_unw_aux_info
7323 {
7324   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7325   unsigned long                 table_len;      /* Length of unwind table.  */
7326   unsigned char *               info;           /* Unwind info.  */
7327   unsigned long                 info_size;      /* Size of unwind info.  */
7328   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7329   bfd_vma                       seg_base;       /* Starting address of segment.  */
7330   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7331   unsigned long                 nsyms;          /* Number of symbols.  */
7332   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7333   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7334   char *                        strtab;         /* The string table.  */
7335   unsigned long                 strtab_size;    /* Size of string table.  */
7336 };
7337
7338 static bfd_boolean
7339 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7340 {
7341   struct ia64_unw_table_entry * tp;
7342   unsigned long j, nfuns;
7343   int in_body;
7344   bfd_boolean res = TRUE;
7345
7346   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7347   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7348     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7349       aux->funtab[nfuns++] = aux->symtab[j];
7350   aux->nfuns = nfuns;
7351   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7352
7353   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7354     {
7355       bfd_vma stamp;
7356       bfd_vma offset;
7357       const unsigned char * dp;
7358       const unsigned char * head;
7359       const unsigned char * end;
7360       const char * procname;
7361
7362       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7363                                aux->strtab_size, tp->start, &procname, &offset);
7364
7365       fputs ("\n<", stdout);
7366
7367       if (procname)
7368         {
7369           fputs (procname, stdout);
7370
7371           if (offset)
7372             printf ("+%lx", (unsigned long) offset);
7373         }
7374
7375       fputs (">: [", stdout);
7376       print_vma (tp->start.offset, PREFIX_HEX);
7377       fputc ('-', stdout);
7378       print_vma (tp->end.offset, PREFIX_HEX);
7379       printf ("], info at +0x%lx\n",
7380               (unsigned long) (tp->info.offset - aux->seg_base));
7381
7382       /* PR 17531: file: 86232b32.  */
7383       if (aux->info == NULL)
7384         continue;
7385
7386       /* PR 17531: file: 0997b4d1.  */
7387       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7388         {
7389           warn (_("Invalid offset %lx in table entry %ld\n"),
7390                 (long) tp->info.offset, (long) (tp - aux->table));
7391           res = FALSE;
7392           continue;
7393         }
7394
7395       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7396       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7397
7398       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7399               (unsigned) UNW_VER (stamp),
7400               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7401               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7402               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7403               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7404
7405       if (UNW_VER (stamp) != 1)
7406         {
7407           printf (_("\tUnknown version.\n"));
7408           continue;
7409         }
7410
7411       in_body = 0;
7412       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7413       /* PR 17531: file: 16ceda89.  */
7414       if (end > aux->info + aux->info_size)
7415         end = aux->info + aux->info_size;
7416       for (dp = head + 8; dp < end;)
7417         dp = unw_decode (dp, in_body, & in_body, end);
7418     }
7419
7420   free (aux->funtab);
7421
7422   return res;
7423 }
7424
7425 static bfd_boolean
7426 slurp_ia64_unwind_table (Filedata *                  filedata,
7427                          struct ia64_unw_aux_info *  aux,
7428                          Elf_Internal_Shdr *         sec)
7429 {
7430   unsigned long size, nrelas, i;
7431   Elf_Internal_Phdr * seg;
7432   struct ia64_unw_table_entry * tep;
7433   Elf_Internal_Shdr * relsec;
7434   Elf_Internal_Rela * rela;
7435   Elf_Internal_Rela * rp;
7436   unsigned char * table;
7437   unsigned char * tp;
7438   Elf_Internal_Sym * sym;
7439   const char * relname;
7440
7441   aux->table_len = 0;
7442
7443   /* First, find the starting address of the segment that includes
7444      this section: */
7445
7446   if (filedata->file_header.e_phnum)
7447     {
7448       if (! get_program_headers (filedata))
7449           return FALSE;
7450
7451       for (seg = filedata->program_headers;
7452            seg < filedata->program_headers + filedata->file_header.e_phnum;
7453            ++seg)
7454         {
7455           if (seg->p_type != PT_LOAD)
7456             continue;
7457
7458           if (sec->sh_addr >= seg->p_vaddr
7459               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7460             {
7461               aux->seg_base = seg->p_vaddr;
7462               break;
7463             }
7464         }
7465     }
7466
7467   /* Second, build the unwind table from the contents of the unwind section:  */
7468   size = sec->sh_size;
7469   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7470                                       _("unwind table"));
7471   if (!table)
7472     return FALSE;
7473
7474   aux->table_len = size / (3 * eh_addr_size);
7475   aux->table = (struct ia64_unw_table_entry *)
7476     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7477   tep = aux->table;
7478
7479   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7480     {
7481       tep->start.section = SHN_UNDEF;
7482       tep->end.section   = SHN_UNDEF;
7483       tep->info.section  = SHN_UNDEF;
7484       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7485       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7486       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7487       tep->start.offset += aux->seg_base;
7488       tep->end.offset   += aux->seg_base;
7489       tep->info.offset  += aux->seg_base;
7490     }
7491   free (table);
7492
7493   /* Third, apply any relocations to the unwind table:  */
7494   for (relsec = filedata->section_headers;
7495        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7496        ++relsec)
7497     {
7498       if (relsec->sh_type != SHT_RELA
7499           || relsec->sh_info >= filedata->file_header.e_shnum
7500           || filedata->section_headers + relsec->sh_info != sec)
7501         continue;
7502
7503       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7504                               & rela, & nrelas))
7505         {
7506           free (aux->table);
7507           aux->table = NULL;
7508           aux->table_len = 0;
7509           return FALSE;
7510         }
7511
7512       for (rp = rela; rp < rela + nrelas; ++rp)
7513         {
7514           relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7515           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7516
7517           /* PR 17531: file: 9fa67536.  */
7518           if (relname == NULL)
7519             {
7520               warn (_("Skipping unknown relocation type: %u\n"),
7521                     get_reloc_type (filedata, rp->r_info));
7522               continue;
7523             }
7524
7525           if (! const_strneq (relname, "R_IA64_SEGREL"))
7526             {
7527               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7528               continue;
7529             }
7530
7531           i = rp->r_offset / (3 * eh_addr_size);
7532
7533           /* PR 17531: file: 5bc8d9bf.  */
7534           if (i >= aux->table_len)
7535             {
7536               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7537               continue;
7538             }
7539
7540           switch (rp->r_offset / eh_addr_size % 3)
7541             {
7542             case 0:
7543               aux->table[i].start.section = sym->st_shndx;
7544               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7545               break;
7546             case 1:
7547               aux->table[i].end.section   = sym->st_shndx;
7548               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7549               break;
7550             case 2:
7551               aux->table[i].info.section  = sym->st_shndx;
7552               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7553               break;
7554             default:
7555               break;
7556             }
7557         }
7558
7559       free (rela);
7560     }
7561
7562   return TRUE;
7563 }
7564
7565 static bfd_boolean
7566 ia64_process_unwind (Filedata * filedata)
7567 {
7568   Elf_Internal_Shdr * sec;
7569   Elf_Internal_Shdr * unwsec = NULL;
7570   Elf_Internal_Shdr * strsec;
7571   unsigned long i, unwcount = 0, unwstart = 0;
7572   struct ia64_unw_aux_info aux;
7573   bfd_boolean res = TRUE;
7574
7575   memset (& aux, 0, sizeof (aux));
7576
7577   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7578     {
7579       if (sec->sh_type == SHT_SYMTAB
7580           && sec->sh_link < filedata->file_header.e_shnum)
7581         {
7582           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7583
7584           strsec = filedata->section_headers + sec->sh_link;
7585           if (aux.strtab != NULL)
7586             {
7587               error (_("Multiple auxillary string tables encountered\n"));
7588               free (aux.strtab);
7589               res = FALSE;
7590             }
7591           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7592                                           1, strsec->sh_size,
7593                                           _("string table"));
7594           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7595         }
7596       else if (sec->sh_type == SHT_IA_64_UNWIND)
7597         unwcount++;
7598     }
7599
7600   if (!unwcount)
7601     printf (_("\nThere are no unwind sections in this file.\n"));
7602
7603   while (unwcount-- > 0)
7604     {
7605       char * suffix;
7606       size_t len, len2;
7607
7608       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7609            i < filedata->file_header.e_shnum; ++i, ++sec)
7610         if (sec->sh_type == SHT_IA_64_UNWIND)
7611           {
7612             unwsec = sec;
7613             break;
7614           }
7615       /* We have already counted the number of SHT_IA64_UNWIND
7616          sections so the loop above should never fail.  */
7617       assert (unwsec != NULL);
7618
7619       unwstart = i + 1;
7620       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7621
7622       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7623         {
7624           /* We need to find which section group it is in.  */
7625           struct group_list * g;
7626
7627           if (section_headers_groups == NULL
7628               || section_headers_groups [i] == NULL)
7629             i = filedata->file_header.e_shnum;
7630           else
7631             {
7632               g = section_headers_groups [i]->root;
7633
7634               for (; g != NULL; g = g->next)
7635                 {
7636                   sec = filedata->section_headers + g->section_index;
7637
7638                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7639                     break;
7640                 }
7641
7642               if (g == NULL)
7643                 i = filedata->file_header.e_shnum;
7644             }
7645         }
7646       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7647         {
7648           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7649           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7650           suffix = SECTION_NAME (unwsec) + len;
7651           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7652                ++i, ++sec)
7653             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7654                 && streq (SECTION_NAME (sec) + len2, suffix))
7655               break;
7656         }
7657       else
7658         {
7659           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7660              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7661           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7662           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7663           suffix = "";
7664           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7665             suffix = SECTION_NAME (unwsec) + len;
7666           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7667                ++i, ++sec)
7668             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7669                 && streq (SECTION_NAME (sec) + len2, suffix))
7670               break;
7671         }
7672
7673       if (i == filedata->file_header.e_shnum)
7674         {
7675           printf (_("\nCould not find unwind info section for "));
7676
7677           if (filedata->string_table == NULL)
7678             printf ("%d", unwsec->sh_name);
7679           else
7680             printf ("'%s'", printable_section_name (filedata, unwsec));
7681         }
7682       else
7683         {
7684           aux.info_addr = sec->sh_addr;
7685           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7686                                                  sec->sh_size,
7687                                                  _("unwind info"));
7688           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7689
7690           printf (_("\nUnwind section "));
7691
7692           if (filedata->string_table == NULL)
7693             printf ("%d", unwsec->sh_name);
7694           else
7695             printf ("'%s'", printable_section_name (filedata, unwsec));
7696
7697           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7698                   (unsigned long) unwsec->sh_offset,
7699                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7700
7701           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7702               && aux.table_len > 0)
7703             dump_ia64_unwind (filedata, & aux);
7704
7705           if (aux.table)
7706             free ((char *) aux.table);
7707           if (aux.info)
7708             free ((char *) aux.info);
7709           aux.table = NULL;
7710           aux.info = NULL;
7711         }
7712     }
7713
7714   if (aux.symtab)
7715     free (aux.symtab);
7716   if (aux.strtab)
7717     free ((char *) aux.strtab);
7718
7719   return res;
7720 }
7721
7722 struct hppa_unw_table_entry
7723 {
7724   struct absaddr start;
7725   struct absaddr end;
7726   unsigned int Cannot_unwind:1;                 /* 0 */
7727   unsigned int Millicode:1;                     /* 1 */
7728   unsigned int Millicode_save_sr0:1;            /* 2 */
7729   unsigned int Region_description:2;            /* 3..4 */
7730   unsigned int reserved1:1;                     /* 5 */
7731   unsigned int Entry_SR:1;                      /* 6 */
7732   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7733   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7734   unsigned int Args_stored:1;                   /* 16 */
7735   unsigned int Variable_Frame:1;                /* 17 */
7736   unsigned int Separate_Package_Body:1;         /* 18 */
7737   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7738   unsigned int Stack_Overflow_Check:1;          /* 20 */
7739   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7740   unsigned int Ada_Region:1;                    /* 22 */
7741   unsigned int cxx_info:1;                      /* 23 */
7742   unsigned int cxx_try_catch:1;                 /* 24 */
7743   unsigned int sched_entry_seq:1;               /* 25 */
7744   unsigned int reserved2:1;                     /* 26 */
7745   unsigned int Save_SP:1;                       /* 27 */
7746   unsigned int Save_RP:1;                       /* 28 */
7747   unsigned int Save_MRP_in_frame:1;             /* 29 */
7748   unsigned int extn_ptr_defined:1;              /* 30 */
7749   unsigned int Cleanup_defined:1;               /* 31 */
7750
7751   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7752   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7753   unsigned int Large_frame:1;                   /* 2 */
7754   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7755   unsigned int reserved4:1;                     /* 4 */
7756   unsigned int Total_frame_size:27;             /* 5..31 */
7757 };
7758
7759 struct hppa_unw_aux_info
7760 {
7761   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7762   unsigned long                  table_len;     /* Length of unwind table.  */
7763   bfd_vma                        seg_base;      /* Starting address of segment.  */
7764   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7765   unsigned long                  nsyms;         /* Number of symbols.  */
7766   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7767   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7768   char *                         strtab;        /* The string table.  */
7769   unsigned long                  strtab_size;   /* Size of string table.  */
7770 };
7771
7772 static bfd_boolean
7773 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7774 {
7775   struct hppa_unw_table_entry * tp;
7776   unsigned long j, nfuns;
7777   bfd_boolean res = TRUE;
7778
7779   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7780   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7781     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7782       aux->funtab[nfuns++] = aux->symtab[j];
7783   aux->nfuns = nfuns;
7784   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7785
7786   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7787     {
7788       bfd_vma offset;
7789       const char * procname;
7790
7791       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7792                                aux->strtab_size, tp->start, &procname,
7793                                &offset);
7794
7795       fputs ("\n<", stdout);
7796
7797       if (procname)
7798         {
7799           fputs (procname, stdout);
7800
7801           if (offset)
7802             printf ("+%lx", (unsigned long) offset);
7803         }
7804
7805       fputs (">: [", stdout);
7806       print_vma (tp->start.offset, PREFIX_HEX);
7807       fputc ('-', stdout);
7808       print_vma (tp->end.offset, PREFIX_HEX);
7809       printf ("]\n\t");
7810
7811 #define PF(_m) if (tp->_m) printf (#_m " ");
7812 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7813       PF(Cannot_unwind);
7814       PF(Millicode);
7815       PF(Millicode_save_sr0);
7816       /* PV(Region_description);  */
7817       PF(Entry_SR);
7818       PV(Entry_FR);
7819       PV(Entry_GR);
7820       PF(Args_stored);
7821       PF(Variable_Frame);
7822       PF(Separate_Package_Body);
7823       PF(Frame_Extension_Millicode);
7824       PF(Stack_Overflow_Check);
7825       PF(Two_Instruction_SP_Increment);
7826       PF(Ada_Region);
7827       PF(cxx_info);
7828       PF(cxx_try_catch);
7829       PF(sched_entry_seq);
7830       PF(Save_SP);
7831       PF(Save_RP);
7832       PF(Save_MRP_in_frame);
7833       PF(extn_ptr_defined);
7834       PF(Cleanup_defined);
7835       PF(MPE_XL_interrupt_marker);
7836       PF(HP_UX_interrupt_marker);
7837       PF(Large_frame);
7838       PF(Pseudo_SP_Set);
7839       PV(Total_frame_size);
7840 #undef PF
7841 #undef PV
7842     }
7843
7844   printf ("\n");
7845
7846   free (aux->funtab);
7847
7848   return res;
7849 }
7850
7851 static bfd_boolean
7852 slurp_hppa_unwind_table (Filedata *                  filedata,
7853                          struct hppa_unw_aux_info *  aux,
7854                          Elf_Internal_Shdr *         sec)
7855 {
7856   unsigned long size, unw_ent_size, nentries, nrelas, i;
7857   Elf_Internal_Phdr * seg;
7858   struct hppa_unw_table_entry * tep;
7859   Elf_Internal_Shdr * relsec;
7860   Elf_Internal_Rela * rela;
7861   Elf_Internal_Rela * rp;
7862   unsigned char * table;
7863   unsigned char * tp;
7864   Elf_Internal_Sym * sym;
7865   const char * relname;
7866
7867   /* First, find the starting address of the segment that includes
7868      this section.  */
7869   if (filedata->file_header.e_phnum)
7870     {
7871       if (! get_program_headers (filedata))
7872         return FALSE;
7873
7874       for (seg = filedata->program_headers;
7875            seg < filedata->program_headers + filedata->file_header.e_phnum;
7876            ++seg)
7877         {
7878           if (seg->p_type != PT_LOAD)
7879             continue;
7880
7881           if (sec->sh_addr >= seg->p_vaddr
7882               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7883             {
7884               aux->seg_base = seg->p_vaddr;
7885               break;
7886             }
7887         }
7888     }
7889
7890   /* Second, build the unwind table from the contents of the unwind
7891      section.  */
7892   size = sec->sh_size;
7893   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7894                                       _("unwind table"));
7895   if (!table)
7896     return FALSE;
7897
7898   unw_ent_size = 16;
7899   nentries = size / unw_ent_size;
7900   size = unw_ent_size * nentries;
7901
7902   tep = aux->table = (struct hppa_unw_table_entry *)
7903       xcmalloc (nentries, sizeof (aux->table[0]));
7904
7905   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7906     {
7907       unsigned int tmp1, tmp2;
7908
7909       tep->start.section = SHN_UNDEF;
7910       tep->end.section   = SHN_UNDEF;
7911
7912       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7913       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7914       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7915       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7916
7917       tep->start.offset += aux->seg_base;
7918       tep->end.offset   += aux->seg_base;
7919
7920       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7921       tep->Millicode = (tmp1 >> 30) & 0x1;
7922       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7923       tep->Region_description = (tmp1 >> 27) & 0x3;
7924       tep->reserved1 = (tmp1 >> 26) & 0x1;
7925       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7926       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7927       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7928       tep->Args_stored = (tmp1 >> 15) & 0x1;
7929       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7930       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7931       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7932       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7933       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7934       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7935       tep->cxx_info = (tmp1 >> 8) & 0x1;
7936       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7937       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7938       tep->reserved2 = (tmp1 >> 5) & 0x1;
7939       tep->Save_SP = (tmp1 >> 4) & 0x1;
7940       tep->Save_RP = (tmp1 >> 3) & 0x1;
7941       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7942       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7943       tep->Cleanup_defined = tmp1 & 0x1;
7944
7945       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7946       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7947       tep->Large_frame = (tmp2 >> 29) & 0x1;
7948       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7949       tep->reserved4 = (tmp2 >> 27) & 0x1;
7950       tep->Total_frame_size = tmp2 & 0x7ffffff;
7951     }
7952   free (table);
7953
7954   /* Third, apply any relocations to the unwind table.  */
7955   for (relsec = filedata->section_headers;
7956        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7957        ++relsec)
7958     {
7959       if (relsec->sh_type != SHT_RELA
7960           || relsec->sh_info >= filedata->file_header.e_shnum
7961           || filedata->section_headers + relsec->sh_info != sec)
7962         continue;
7963
7964       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7965                               & rela, & nrelas))
7966         return FALSE;
7967
7968       for (rp = rela; rp < rela + nrelas; ++rp)
7969         {
7970           relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
7971           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7972
7973           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7974           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7975             {
7976               warn (_("Skipping unexpected relocation type %s\n"), relname);
7977               continue;
7978             }
7979
7980           i = rp->r_offset / unw_ent_size;
7981
7982           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7983             {
7984             case 0:
7985               aux->table[i].start.section = sym->st_shndx;
7986               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7987               break;
7988             case 1:
7989               aux->table[i].end.section   = sym->st_shndx;
7990               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7991               break;
7992             default:
7993               break;
7994             }
7995         }
7996
7997       free (rela);
7998     }
7999
8000   aux->table_len = nentries;
8001
8002   return TRUE;
8003 }
8004
8005 static bfd_boolean
8006 hppa_process_unwind (Filedata * filedata)
8007 {
8008   struct hppa_unw_aux_info aux;
8009   Elf_Internal_Shdr * unwsec = NULL;
8010   Elf_Internal_Shdr * strsec;
8011   Elf_Internal_Shdr * sec;
8012   unsigned long i;
8013   bfd_boolean res = TRUE;
8014
8015   if (filedata->string_table == NULL)
8016     return FALSE;
8017
8018   memset (& aux, 0, sizeof (aux));
8019
8020   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8021     {
8022       if (sec->sh_type == SHT_SYMTAB
8023           && sec->sh_link < filedata->file_header.e_shnum)
8024         {
8025           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8026
8027           strsec = filedata->section_headers + sec->sh_link;
8028           if (aux.strtab != NULL)
8029             {
8030               error (_("Multiple auxillary string tables encountered\n"));
8031               free (aux.strtab);
8032               res = FALSE;
8033             }
8034           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8035                                           1, strsec->sh_size,
8036                                           _("string table"));
8037           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8038         }
8039       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8040         unwsec = sec;
8041     }
8042
8043   if (!unwsec)
8044     printf (_("\nThere are no unwind sections in this file.\n"));
8045
8046   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8047     {
8048       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8049         {
8050           unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8051
8052           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8053                             "contains %lu entry:\n",
8054                             "\nUnwind section '%s' at offset 0x%lx "
8055                             "contains %lu entries:\n",
8056                             num_unwind),
8057                   printable_section_name (filedata, sec),
8058                   (unsigned long) sec->sh_offset,
8059                   num_unwind);
8060
8061           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8062             res = FALSE;
8063
8064           if (aux.table_len > 0)
8065             {
8066               if (! dump_hppa_unwind (filedata, &aux))
8067                 res = FALSE;
8068             }
8069
8070           if (aux.table)
8071             free ((char *) aux.table);
8072           aux.table = NULL;
8073         }
8074     }
8075
8076   if (aux.symtab)
8077     free (aux.symtab);
8078   if (aux.strtab)
8079     free ((char *) aux.strtab);
8080
8081   return res;
8082 }
8083
8084 struct arm_section
8085 {
8086   unsigned char *      data;            /* The unwind data.  */
8087   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8088   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8089   unsigned long        nrelas;          /* The number of relocations.  */
8090   unsigned int         rel_type;        /* REL or RELA ?  */
8091   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8092 };
8093
8094 struct arm_unw_aux_info
8095 {
8096   Filedata *          filedata;         /* The file containing the unwind sections.  */
8097   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8098   unsigned long       nsyms;            /* Number of symbols.  */
8099   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8100   unsigned long       nfuns;            /* Number of these symbols.  */
8101   char *              strtab;           /* The file's string table.  */
8102   unsigned long       strtab_size;      /* Size of string table.  */
8103 };
8104
8105 static const char *
8106 arm_print_vma_and_name (Filedata *                 filedata,
8107                         struct arm_unw_aux_info *  aux,
8108                         bfd_vma                    fn,
8109                         struct absaddr             addr)
8110 {
8111   const char *procname;
8112   bfd_vma sym_offset;
8113
8114   if (addr.section == SHN_UNDEF)
8115     addr.offset = fn;
8116
8117   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8118                            aux->strtab_size, addr, &procname,
8119                            &sym_offset);
8120
8121   print_vma (fn, PREFIX_HEX);
8122
8123   if (procname)
8124     {
8125       fputs (" <", stdout);
8126       fputs (procname, stdout);
8127
8128       if (sym_offset)
8129         printf ("+0x%lx", (unsigned long) sym_offset);
8130       fputc ('>', stdout);
8131     }
8132
8133   return procname;
8134 }
8135
8136 static void
8137 arm_free_section (struct arm_section *arm_sec)
8138 {
8139   if (arm_sec->data != NULL)
8140     free (arm_sec->data);
8141
8142   if (arm_sec->rela != NULL)
8143     free (arm_sec->rela);
8144 }
8145
8146 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8147       cached section and install SEC instead.
8148    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8149       and return its valued in * WORDP, relocating if necessary.
8150    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8151       relocation's offset in ADDR.
8152    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8153       into the string table of the symbol associated with the reloc.  If no
8154       reloc was applied store -1 there.
8155    5) Return TRUE upon success, FALSE otherwise.  */
8156
8157 static bfd_boolean
8158 get_unwind_section_word (Filedata *                 filedata,
8159                          struct arm_unw_aux_info *  aux,
8160                          struct arm_section *       arm_sec,
8161                          Elf_Internal_Shdr *        sec,
8162                          bfd_vma                    word_offset,
8163                          unsigned int *             wordp,
8164                          struct absaddr *           addr,
8165                          bfd_vma *                  sym_name)
8166 {
8167   Elf_Internal_Rela *rp;
8168   Elf_Internal_Sym *sym;
8169   const char * relname;
8170   unsigned int word;
8171   bfd_boolean wrapped;
8172
8173   if (sec == NULL || arm_sec == NULL)
8174     return FALSE;
8175
8176   addr->section = SHN_UNDEF;
8177   addr->offset = 0;
8178
8179   if (sym_name != NULL)
8180     *sym_name = (bfd_vma) -1;
8181
8182   /* If necessary, update the section cache.  */
8183   if (sec != arm_sec->sec)
8184     {
8185       Elf_Internal_Shdr *relsec;
8186
8187       arm_free_section (arm_sec);
8188
8189       arm_sec->sec = sec;
8190       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8191                                 sec->sh_size, _("unwind data"));
8192       arm_sec->rela = NULL;
8193       arm_sec->nrelas = 0;
8194
8195       for (relsec = filedata->section_headers;
8196            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8197            ++relsec)
8198         {
8199           if (relsec->sh_info >= filedata->file_header.e_shnum
8200               || filedata->section_headers + relsec->sh_info != sec
8201               /* PR 15745: Check the section type as well.  */
8202               || (relsec->sh_type != SHT_REL
8203                   && relsec->sh_type != SHT_RELA))
8204             continue;
8205
8206           arm_sec->rel_type = relsec->sh_type;
8207           if (relsec->sh_type == SHT_REL)
8208             {
8209               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8210                                      relsec->sh_size,
8211                                      & arm_sec->rela, & arm_sec->nrelas))
8212                 return FALSE;
8213             }
8214           else /* relsec->sh_type == SHT_RELA */
8215             {
8216               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8217                                       relsec->sh_size,
8218                                       & arm_sec->rela, & arm_sec->nrelas))
8219                 return FALSE;
8220             }
8221           break;
8222         }
8223
8224       arm_sec->next_rela = arm_sec->rela;
8225     }
8226
8227   /* If there is no unwind data we can do nothing.  */
8228   if (arm_sec->data == NULL)
8229     return FALSE;
8230
8231   /* If the offset is invalid then fail.  */
8232   if (/* PR 21343 *//* PR 18879 */
8233       sec->sh_size < 4
8234       || word_offset > (sec->sh_size - 4)
8235       || ((bfd_signed_vma) word_offset) < 0)
8236     return FALSE;
8237
8238   /* Get the word at the required offset.  */
8239   word = byte_get (arm_sec->data + word_offset, 4);
8240
8241   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8242   if (arm_sec->rela == NULL)
8243     {
8244       * wordp = word;
8245       return TRUE;
8246     }
8247
8248   /* Look through the relocs to find the one that applies to the provided offset.  */
8249   wrapped = FALSE;
8250   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8251     {
8252       bfd_vma prelval, offset;
8253
8254       if (rp->r_offset > word_offset && !wrapped)
8255         {
8256           rp = arm_sec->rela;
8257           wrapped = TRUE;
8258         }
8259       if (rp->r_offset > word_offset)
8260         break;
8261
8262       if (rp->r_offset & 3)
8263         {
8264           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8265                 (unsigned long) rp->r_offset);
8266           continue;
8267         }
8268
8269       if (rp->r_offset < word_offset)
8270         continue;
8271
8272       /* PR 17531: file: 027-161405-0.004  */
8273       if (aux->symtab == NULL)
8274         continue;
8275
8276       if (arm_sec->rel_type == SHT_REL)
8277         {
8278           offset = word & 0x7fffffff;
8279           if (offset & 0x40000000)
8280             offset |= ~ (bfd_vma) 0x7fffffff;
8281         }
8282       else if (arm_sec->rel_type == SHT_RELA)
8283         offset = rp->r_addend;
8284       else
8285         {
8286           error (_("Unknown section relocation type %d encountered\n"),
8287                  arm_sec->rel_type);
8288           break;
8289         }
8290
8291       /* PR 17531 file: 027-1241568-0.004.  */
8292       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8293         {
8294           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8295                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8296           break;
8297         }
8298
8299       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8300       offset += sym->st_value;
8301       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8302
8303       /* Check that we are processing the expected reloc type.  */
8304       if (filedata->file_header.e_machine == EM_ARM)
8305         {
8306           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8307           if (relname == NULL)
8308             {
8309               warn (_("Skipping unknown ARM relocation type: %d\n"),
8310                     (int) ELF32_R_TYPE (rp->r_info));
8311               continue;
8312             }
8313
8314           if (streq (relname, "R_ARM_NONE"))
8315               continue;
8316
8317           if (! streq (relname, "R_ARM_PREL31"))
8318             {
8319               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8320               continue;
8321             }
8322         }
8323       else if (filedata->file_header.e_machine == EM_TI_C6000)
8324         {
8325           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8326           if (relname == NULL)
8327             {
8328               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8329                     (int) ELF32_R_TYPE (rp->r_info));
8330               continue;
8331             }
8332
8333           if (streq (relname, "R_C6000_NONE"))
8334             continue;
8335
8336           if (! streq (relname, "R_C6000_PREL31"))
8337             {
8338               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8339               continue;
8340             }
8341
8342           prelval >>= 1;
8343         }
8344       else
8345         {
8346           /* This function currently only supports ARM and TI unwinders.  */
8347           warn (_("Only TI and ARM unwinders are currently supported\n"));
8348           break;
8349         }
8350
8351       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8352       addr->section = sym->st_shndx;
8353       addr->offset = offset;
8354
8355       if (sym_name)
8356         * sym_name = sym->st_name;
8357       break;
8358     }
8359
8360   *wordp = word;
8361   arm_sec->next_rela = rp;
8362
8363   return TRUE;
8364 }
8365
8366 static const char *tic6x_unwind_regnames[16] =
8367 {
8368   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8369   "A14", "A13", "A12", "A11", "A10",
8370   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8371 };
8372
8373 static void
8374 decode_tic6x_unwind_regmask (unsigned int mask)
8375 {
8376   int i;
8377
8378   for (i = 12; mask; mask >>= 1, i--)
8379     {
8380       if (mask & 1)
8381         {
8382           fputs (tic6x_unwind_regnames[i], stdout);
8383           if (mask > 1)
8384             fputs (", ", stdout);
8385         }
8386     }
8387 }
8388
8389 #define ADVANCE                                                 \
8390   if (remaining == 0 && more_words)                             \
8391     {                                                           \
8392       data_offset += 4;                                         \
8393       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8394                                      data_offset, & word, & addr, NULL))        \
8395         return FALSE;                                           \
8396       remaining = 4;                                            \
8397       more_words--;                                             \
8398     }                                                           \
8399
8400 #define GET_OP(OP)                      \
8401   ADVANCE;                              \
8402   if (remaining)                        \
8403     {                                   \
8404       remaining--;                      \
8405       (OP) = word >> 24;                \
8406       word <<= 8;                       \
8407     }                                   \
8408   else                                  \
8409     {                                   \
8410       printf (_("[Truncated opcode]\n"));       \
8411       return FALSE;                     \
8412     }                                   \
8413   printf ("0x%02x ", OP)
8414
8415 static bfd_boolean
8416 decode_arm_unwind_bytecode (Filedata *                 filedata,
8417                             struct arm_unw_aux_info *  aux,
8418                             unsigned int               word,
8419                             unsigned int               remaining,
8420                             unsigned int               more_words,
8421                             bfd_vma                    data_offset,
8422                             Elf_Internal_Shdr *        data_sec,
8423                             struct arm_section *       data_arm_sec)
8424 {
8425   struct absaddr addr;
8426   bfd_boolean res = TRUE;
8427
8428   /* Decode the unwinding instructions.  */
8429   while (1)
8430     {
8431       unsigned int op, op2;
8432
8433       ADVANCE;
8434       if (remaining == 0)
8435         break;
8436       remaining--;
8437       op = word >> 24;
8438       word <<= 8;
8439
8440       printf ("  0x%02x ", op);
8441
8442       if ((op & 0xc0) == 0x00)
8443         {
8444           int offset = ((op & 0x3f) << 2) + 4;
8445
8446           printf ("     vsp = vsp + %d", offset);
8447         }
8448       else if ((op & 0xc0) == 0x40)
8449         {
8450           int offset = ((op & 0x3f) << 2) + 4;
8451
8452           printf ("     vsp = vsp - %d", offset);
8453         }
8454       else if ((op & 0xf0) == 0x80)
8455         {
8456           GET_OP (op2);
8457           if (op == 0x80 && op2 == 0)
8458             printf (_("Refuse to unwind"));
8459           else
8460             {
8461               unsigned int mask = ((op & 0x0f) << 8) | op2;
8462               bfd_boolean first = TRUE;
8463               int i;
8464
8465               printf ("pop {");
8466               for (i = 0; i < 12; i++)
8467                 if (mask & (1 << i))
8468                   {
8469                     if (first)
8470                       first = FALSE;
8471                     else
8472                       printf (", ");
8473                     printf ("r%d", 4 + i);
8474                   }
8475               printf ("}");
8476             }
8477         }
8478       else if ((op & 0xf0) == 0x90)
8479         {
8480           if (op == 0x9d || op == 0x9f)
8481             printf (_("     [Reserved]"));
8482           else
8483             printf ("     vsp = r%d", op & 0x0f);
8484         }
8485       else if ((op & 0xf0) == 0xa0)
8486         {
8487           int end = 4 + (op & 0x07);
8488           bfd_boolean first = TRUE;
8489           int i;
8490
8491           printf ("     pop {");
8492           for (i = 4; i <= end; i++)
8493             {
8494               if (first)
8495                 first = FALSE;
8496               else
8497                 printf (", ");
8498               printf ("r%d", i);
8499             }
8500           if (op & 0x08)
8501             {
8502               if (!first)
8503                 printf (", ");
8504               printf ("r14");
8505             }
8506           printf ("}");
8507         }
8508       else if (op == 0xb0)
8509         printf (_("     finish"));
8510       else if (op == 0xb1)
8511         {
8512           GET_OP (op2);
8513           if (op2 == 0 || (op2 & 0xf0) != 0)
8514             printf (_("[Spare]"));
8515           else
8516             {
8517               unsigned int mask = op2 & 0x0f;
8518               bfd_boolean first = TRUE;
8519               int i;
8520
8521               printf ("pop {");
8522               for (i = 0; i < 12; i++)
8523                 if (mask & (1 << i))
8524                   {
8525                     if (first)
8526                       first = FALSE;
8527                     else
8528                       printf (", ");
8529                     printf ("r%d", i);
8530                   }
8531               printf ("}");
8532             }
8533         }
8534       else if (op == 0xb2)
8535         {
8536           unsigned char buf[9];
8537           unsigned int i, len;
8538           unsigned long offset;
8539
8540           for (i = 0; i < sizeof (buf); i++)
8541             {
8542               GET_OP (buf[i]);
8543               if ((buf[i] & 0x80) == 0)
8544                 break;
8545             }
8546           if (i == sizeof (buf))
8547             {
8548               error (_("corrupt change to vsp"));
8549               res = FALSE;
8550             }
8551           else
8552             {
8553               offset = read_uleb128 (buf, &len, buf + i + 1);
8554               assert (len == i + 1);
8555               offset = offset * 4 + 0x204;
8556               printf ("vsp = vsp + %ld", offset);
8557             }
8558         }
8559       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8560         {
8561           unsigned int first, last;
8562
8563           GET_OP (op2);
8564           first = op2 >> 4;
8565           last = op2 & 0x0f;
8566           if (op == 0xc8)
8567             first = first + 16;
8568           printf ("pop {D%d", first);
8569           if (last)
8570             printf ("-D%d", first + last);
8571           printf ("}");
8572         }
8573       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8574         {
8575           unsigned int count = op & 0x07;
8576
8577           printf ("pop {D8");
8578           if (count)
8579             printf ("-D%d", 8 + count);
8580           printf ("}");
8581         }
8582       else if (op >= 0xc0 && op <= 0xc5)
8583         {
8584           unsigned int count = op & 0x07;
8585
8586           printf ("     pop {wR10");
8587           if (count)
8588             printf ("-wR%d", 10 + count);
8589           printf ("}");
8590         }
8591       else if (op == 0xc6)
8592         {
8593           unsigned int first, last;
8594
8595           GET_OP (op2);
8596           first = op2 >> 4;
8597           last = op2 & 0x0f;
8598           printf ("pop {wR%d", first);
8599           if (last)
8600             printf ("-wR%d", first + last);
8601           printf ("}");
8602         }
8603       else if (op == 0xc7)
8604         {
8605           GET_OP (op2);
8606           if (op2 == 0 || (op2 & 0xf0) != 0)
8607             printf (_("[Spare]"));
8608           else
8609             {
8610               unsigned int mask = op2 & 0x0f;
8611               bfd_boolean first = TRUE;
8612               int i;
8613
8614               printf ("pop {");
8615               for (i = 0; i < 4; i++)
8616                 if (mask & (1 << i))
8617                   {
8618                     if (first)
8619                       first = FALSE;
8620                     else
8621                       printf (", ");
8622                     printf ("wCGR%d", i);
8623                   }
8624               printf ("}");
8625             }
8626         }
8627       else
8628         {
8629           printf (_("     [unsupported opcode]"));
8630           res = FALSE;
8631         }
8632
8633       printf ("\n");
8634     }
8635
8636   return res;
8637 }
8638
8639 static bfd_boolean
8640 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8641                               struct arm_unw_aux_info *  aux,
8642                               unsigned int               word,
8643                               unsigned int               remaining,
8644                               unsigned int               more_words,
8645                               bfd_vma                    data_offset,
8646                               Elf_Internal_Shdr *        data_sec,
8647                               struct arm_section *       data_arm_sec)
8648 {
8649   struct absaddr addr;
8650
8651   /* Decode the unwinding instructions.  */
8652   while (1)
8653     {
8654       unsigned int op, op2;
8655
8656       ADVANCE;
8657       if (remaining == 0)
8658         break;
8659       remaining--;
8660       op = word >> 24;
8661       word <<= 8;
8662
8663       printf ("  0x%02x ", op);
8664
8665       if ((op & 0xc0) == 0x00)
8666         {
8667           int offset = ((op & 0x3f) << 3) + 8;
8668           printf ("     sp = sp + %d", offset);
8669         }
8670       else if ((op & 0xc0) == 0x80)
8671         {
8672           GET_OP (op2);
8673           if (op == 0x80 && op2 == 0)
8674             printf (_("Refuse to unwind"));
8675           else
8676             {
8677               unsigned int mask = ((op & 0x1f) << 8) | op2;
8678               if (op & 0x20)
8679                 printf ("pop compact {");
8680               else
8681                 printf ("pop {");
8682
8683               decode_tic6x_unwind_regmask (mask);
8684               printf("}");
8685             }
8686         }
8687       else if ((op & 0xf0) == 0xc0)
8688         {
8689           unsigned int reg;
8690           unsigned int nregs;
8691           unsigned int i;
8692           const char *name;
8693           struct
8694           {
8695             unsigned int offset;
8696             unsigned int reg;
8697           } regpos[16];
8698
8699           /* Scan entire instruction first so that GET_OP output is not
8700              interleaved with disassembly.  */
8701           nregs = 0;
8702           for (i = 0; nregs < (op & 0xf); i++)
8703             {
8704               GET_OP (op2);
8705               reg = op2 >> 4;
8706               if (reg != 0xf)
8707                 {
8708                   regpos[nregs].offset = i * 2;
8709                   regpos[nregs].reg = reg;
8710                   nregs++;
8711                 }
8712
8713               reg = op2 & 0xf;
8714               if (reg != 0xf)
8715                 {
8716                   regpos[nregs].offset = i * 2 + 1;
8717                   regpos[nregs].reg = reg;
8718                   nregs++;
8719                 }
8720             }
8721
8722           printf (_("pop frame {"));
8723           reg = nregs - 1;
8724           for (i = i * 2; i > 0; i--)
8725             {
8726               if (regpos[reg].offset == i - 1)
8727                 {
8728                   name = tic6x_unwind_regnames[regpos[reg].reg];
8729                   if (reg > 0)
8730                     reg--;
8731                 }
8732               else
8733                 name = _("[pad]");
8734
8735               fputs (name, stdout);
8736               if (i > 1)
8737                 printf (", ");
8738             }
8739
8740           printf ("}");
8741         }
8742       else if (op == 0xd0)
8743         printf ("     MOV FP, SP");
8744       else if (op == 0xd1)
8745         printf ("     __c6xabi_pop_rts");
8746       else if (op == 0xd2)
8747         {
8748           unsigned char buf[9];
8749           unsigned int i, len;
8750           unsigned long offset;
8751
8752           for (i = 0; i < sizeof (buf); i++)
8753             {
8754               GET_OP (buf[i]);
8755               if ((buf[i] & 0x80) == 0)
8756                 break;
8757             }
8758           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8759           if (i == sizeof (buf))
8760             {
8761               warn (_("Corrupt stack pointer adjustment detected\n"));
8762               return FALSE;
8763             }
8764
8765           offset = read_uleb128 (buf, &len, buf + i + 1);
8766           assert (len == i + 1);
8767           offset = offset * 8 + 0x408;
8768           printf (_("sp = sp + %ld"), offset);
8769         }
8770       else if ((op & 0xf0) == 0xe0)
8771         {
8772           if ((op & 0x0f) == 7)
8773             printf ("     RETURN");
8774           else
8775             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8776         }
8777       else
8778         {
8779           printf (_("     [unsupported opcode]"));
8780         }
8781       putchar ('\n');
8782     }
8783
8784   return TRUE;
8785 }
8786
8787 static bfd_vma
8788 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8789 {
8790   bfd_vma offset;
8791
8792   offset = word & 0x7fffffff;
8793   if (offset & 0x40000000)
8794     offset |= ~ (bfd_vma) 0x7fffffff;
8795
8796   if (filedata->file_header.e_machine == EM_TI_C6000)
8797     offset <<= 1;
8798
8799   return offset + where;
8800 }
8801
8802 static bfd_boolean
8803 decode_arm_unwind (Filedata *                 filedata,
8804                    struct arm_unw_aux_info *  aux,
8805                    unsigned int               word,
8806                    unsigned int               remaining,
8807                    bfd_vma                    data_offset,
8808                    Elf_Internal_Shdr *        data_sec,
8809                    struct arm_section *       data_arm_sec)
8810 {
8811   int per_index;
8812   unsigned int more_words = 0;
8813   struct absaddr addr;
8814   bfd_vma sym_name = (bfd_vma) -1;
8815   bfd_boolean res = TRUE;
8816
8817   if (remaining == 0)
8818     {
8819       /* Fetch the first word.
8820          Note - when decoding an object file the address extracted
8821          here will always be 0.  So we also pass in the sym_name
8822          parameter so that we can find the symbol associated with
8823          the personality routine.  */
8824       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8825                                      & word, & addr, & sym_name))
8826         return FALSE;
8827
8828       remaining = 4;
8829     }
8830
8831   if ((word & 0x80000000) == 0)
8832     {
8833       /* Expand prel31 for personality routine.  */
8834       bfd_vma fn;
8835       const char *procname;
8836
8837       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8838       printf (_("  Personality routine: "));
8839       if (fn == 0
8840           && addr.section == SHN_UNDEF && addr.offset == 0
8841           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8842         {
8843           procname = aux->strtab + sym_name;
8844           print_vma (fn, PREFIX_HEX);
8845           if (procname)
8846             {
8847               fputs (" <", stdout);
8848               fputs (procname, stdout);
8849               fputc ('>', stdout);
8850             }
8851         }
8852       else
8853         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8854       fputc ('\n', stdout);
8855
8856       /* The GCC personality routines use the standard compact
8857          encoding, starting with one byte giving the number of
8858          words.  */
8859       if (procname != NULL
8860           && (const_strneq (procname, "__gcc_personality_v0")
8861               || const_strneq (procname, "__gxx_personality_v0")
8862               || const_strneq (procname, "__gcj_personality_v0")
8863               || const_strneq (procname, "__gnu_objc_personality_v0")))
8864         {
8865           remaining = 0;
8866           more_words = 1;
8867           ADVANCE;
8868           if (!remaining)
8869             {
8870               printf (_("  [Truncated data]\n"));
8871               return FALSE;
8872             }
8873           more_words = word >> 24;
8874           word <<= 8;
8875           remaining--;
8876           per_index = -1;
8877         }
8878       else
8879         return TRUE;
8880     }
8881   else
8882     {
8883       /* ARM EHABI Section 6.3:
8884
8885          An exception-handling table entry for the compact model looks like:
8886
8887            31 30-28 27-24 23-0
8888            -- ----- ----- ----
8889             1   0   index Data for personalityRoutine[index]    */
8890
8891       if (filedata->file_header.e_machine == EM_ARM
8892           && (word & 0x70000000))
8893         {
8894           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8895           res = FALSE;
8896         }
8897
8898       per_index = (word >> 24) & 0x7f;
8899       printf (_("  Compact model index: %d\n"), per_index);
8900       if (per_index == 0)
8901         {
8902           more_words = 0;
8903           word <<= 8;
8904           remaining--;
8905         }
8906       else if (per_index < 3)
8907         {
8908           more_words = (word >> 16) & 0xff;
8909           word <<= 16;
8910           remaining -= 2;
8911         }
8912     }
8913
8914   switch (filedata->file_header.e_machine)
8915     {
8916     case EM_ARM:
8917       if (per_index < 3)
8918         {
8919           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
8920                                             data_offset, data_sec, data_arm_sec))
8921             res = FALSE;
8922         }
8923       else
8924         {
8925           warn (_("Unknown ARM compact model index encountered\n"));
8926           printf (_("  [reserved]\n"));
8927           res = FALSE;
8928         }
8929       break;
8930
8931     case EM_TI_C6000:
8932       if (per_index < 3)
8933         {
8934           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
8935                                               data_offset, data_sec, data_arm_sec))
8936             res = FALSE;
8937         }
8938       else if (per_index < 5)
8939         {
8940           if (((word >> 17) & 0x7f) == 0x7f)
8941             printf (_("  Restore stack from frame pointer\n"));
8942           else
8943             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8944           printf (_("  Registers restored: "));
8945           if (per_index == 4)
8946             printf (" (compact) ");
8947           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8948           putchar ('\n');
8949           printf (_("  Return register: %s\n"),
8950                   tic6x_unwind_regnames[word & 0xf]);
8951         }
8952       else
8953         printf (_("  [reserved (%d)]\n"), per_index);
8954       break;
8955
8956     default:
8957       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8958              filedata->file_header.e_machine);
8959       res = FALSE;
8960     }
8961
8962   /* Decode the descriptors.  Not implemented.  */
8963
8964   return res;
8965 }
8966
8967 static bfd_boolean
8968 dump_arm_unwind (Filedata *                 filedata,
8969                  struct arm_unw_aux_info *  aux,
8970                  Elf_Internal_Shdr *        exidx_sec)
8971 {
8972   struct arm_section exidx_arm_sec, extab_arm_sec;
8973   unsigned int i, exidx_len;
8974   unsigned long j, nfuns;
8975   bfd_boolean res = TRUE;
8976
8977   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8978   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8979   exidx_len = exidx_sec->sh_size / 8;
8980
8981   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8982   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8983     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8984       aux->funtab[nfuns++] = aux->symtab[j];
8985   aux->nfuns = nfuns;
8986   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8987
8988   for (i = 0; i < exidx_len; i++)
8989     {
8990       unsigned int exidx_fn, exidx_entry;
8991       struct absaddr fn_addr, entry_addr;
8992       bfd_vma fn;
8993
8994       fputc ('\n', stdout);
8995
8996       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
8997                                      8 * i, & exidx_fn, & fn_addr, NULL)
8998           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
8999                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9000         {
9001           free (aux->funtab);
9002           arm_free_section (& exidx_arm_sec);
9003           arm_free_section (& extab_arm_sec);
9004           return FALSE;
9005         }
9006
9007       /* ARM EHABI, Section 5:
9008          An index table entry consists of 2 words.
9009          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9010       if (exidx_fn & 0x80000000)
9011         {
9012           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9013           res = FALSE;
9014         }
9015
9016       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9017
9018       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9019       fputs (": ", stdout);
9020
9021       if (exidx_entry == 1)
9022         {
9023           print_vma (exidx_entry, PREFIX_HEX);
9024           fputs (" [cantunwind]\n", stdout);
9025         }
9026       else if (exidx_entry & 0x80000000)
9027         {
9028           print_vma (exidx_entry, PREFIX_HEX);
9029           fputc ('\n', stdout);
9030           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9031         }
9032       else
9033         {
9034           bfd_vma table, table_offset = 0;
9035           Elf_Internal_Shdr *table_sec;
9036
9037           fputs ("@", stdout);
9038           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9039           print_vma (table, PREFIX_HEX);
9040           printf ("\n");
9041
9042           /* Locate the matching .ARM.extab.  */
9043           if (entry_addr.section != SHN_UNDEF
9044               && entry_addr.section < filedata->file_header.e_shnum)
9045             {
9046               table_sec = filedata->section_headers + entry_addr.section;
9047               table_offset = entry_addr.offset;
9048               /* PR 18879 */
9049               if (table_offset > table_sec->sh_size
9050                   || ((bfd_signed_vma) table_offset) < 0)
9051                 {
9052                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9053                         (unsigned long) table_offset,
9054                         printable_section_name (filedata, table_sec));
9055                   res = FALSE;
9056                   continue;
9057                 }
9058             }
9059           else
9060             {
9061               table_sec = find_section_by_address (filedata, table);
9062               if (table_sec != NULL)
9063                 table_offset = table - table_sec->sh_addr;
9064             }
9065
9066           if (table_sec == NULL)
9067             {
9068               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9069                     (unsigned long) table);
9070               res = FALSE;
9071               continue;
9072             }
9073
9074           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9075                                    &extab_arm_sec))
9076             res = FALSE;
9077         }
9078     }
9079
9080   printf ("\n");
9081
9082   free (aux->funtab);
9083   arm_free_section (&exidx_arm_sec);
9084   arm_free_section (&extab_arm_sec);
9085
9086   return res;
9087 }
9088
9089 /* Used for both ARM and C6X unwinding tables.  */
9090
9091 static bfd_boolean
9092 arm_process_unwind (Filedata * filedata)
9093 {
9094   struct arm_unw_aux_info aux;
9095   Elf_Internal_Shdr *unwsec = NULL;
9096   Elf_Internal_Shdr *strsec;
9097   Elf_Internal_Shdr *sec;
9098   unsigned long i;
9099   unsigned int sec_type;
9100   bfd_boolean res = TRUE;
9101
9102   switch (filedata->file_header.e_machine)
9103     {
9104     case EM_ARM:
9105       sec_type = SHT_ARM_EXIDX;
9106       break;
9107
9108     case EM_TI_C6000:
9109       sec_type = SHT_C6000_UNWIND;
9110       break;
9111
9112     default:
9113       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9114              filedata->file_header.e_machine);
9115       return FALSE;
9116     }
9117
9118   if (filedata->string_table == NULL)
9119     return FALSE;
9120
9121   memset (& aux, 0, sizeof (aux));
9122   aux.filedata = filedata;
9123
9124   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9125     {
9126       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9127         {
9128           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9129
9130           strsec = filedata->section_headers + sec->sh_link;
9131
9132           /* PR binutils/17531 file: 011-12666-0.004.  */
9133           if (aux.strtab != NULL)
9134             {
9135               error (_("Multiple string tables found in file.\n"));
9136               free (aux.strtab);
9137               res = FALSE;
9138             }
9139           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9140                                  1, strsec->sh_size, _("string table"));
9141           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9142         }
9143       else if (sec->sh_type == sec_type)
9144         unwsec = sec;
9145     }
9146
9147   if (unwsec == NULL)
9148     printf (_("\nThere are no unwind sections in this file.\n"));
9149   else
9150     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9151       {
9152         if (sec->sh_type == sec_type)
9153           {
9154             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9155             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9156                               "contains %lu entry:\n",
9157                               "\nUnwind section '%s' at offset 0x%lx "
9158                               "contains %lu entries:\n",
9159                               num_unwind),
9160                     printable_section_name (filedata, sec),
9161                     (unsigned long) sec->sh_offset,
9162                     num_unwind);
9163
9164             if (! dump_arm_unwind (filedata, &aux, sec))
9165               res = FALSE;
9166           }
9167       }
9168
9169   if (aux.symtab)
9170     free (aux.symtab);
9171   if (aux.strtab)
9172     free ((char *) aux.strtab);
9173
9174   return res;
9175 }
9176
9177 static bfd_boolean
9178 process_unwind (Filedata * filedata)
9179 {
9180   struct unwind_handler
9181   {
9182     unsigned int machtype;
9183     bfd_boolean (* handler)(Filedata *);
9184   } handlers[] =
9185   {
9186     { EM_ARM, arm_process_unwind },
9187     { EM_IA_64, ia64_process_unwind },
9188     { EM_PARISC, hppa_process_unwind },
9189     { EM_TI_C6000, arm_process_unwind },
9190     { 0, NULL }
9191   };
9192   int i;
9193
9194   if (!do_unwind)
9195     return TRUE;
9196
9197   for (i = 0; handlers[i].handler != NULL; i++)
9198     if (filedata->file_header.e_machine == handlers[i].machtype)
9199       return handlers[i].handler (filedata);
9200
9201   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9202           get_machine_name (filedata->file_header.e_machine));
9203   return TRUE;
9204 }
9205
9206 static void
9207 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9208 {
9209   switch (entry->d_tag)
9210     {
9211     case DT_MIPS_FLAGS:
9212       if (entry->d_un.d_val == 0)
9213         printf (_("NONE"));
9214       else
9215         {
9216           static const char * opts[] =
9217           {
9218             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9219             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9220             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9221             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9222             "RLD_ORDER_SAFE"
9223           };
9224           unsigned int cnt;
9225           bfd_boolean first = TRUE;
9226
9227           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9228             if (entry->d_un.d_val & (1 << cnt))
9229               {
9230                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9231                 first = FALSE;
9232               }
9233         }
9234       break;
9235
9236     case DT_MIPS_IVERSION:
9237       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9238         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9239       else
9240         {
9241           char buf[40];
9242           sprintf_vma (buf, entry->d_un.d_ptr);
9243           /* Note: coded this way so that there is a single string for translation.  */
9244           printf (_("<corrupt: %s>"), buf);
9245         }
9246       break;
9247
9248     case DT_MIPS_TIME_STAMP:
9249       {
9250         char timebuf[128];
9251         struct tm * tmp;
9252         time_t atime = entry->d_un.d_val;
9253
9254         tmp = gmtime (&atime);
9255         /* PR 17531: file: 6accc532.  */
9256         if (tmp == NULL)
9257           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9258         else
9259           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9260                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9261                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9262         printf (_("Time Stamp: %s"), timebuf);
9263       }
9264       break;
9265
9266     case DT_MIPS_RLD_VERSION:
9267     case DT_MIPS_LOCAL_GOTNO:
9268     case DT_MIPS_CONFLICTNO:
9269     case DT_MIPS_LIBLISTNO:
9270     case DT_MIPS_SYMTABNO:
9271     case DT_MIPS_UNREFEXTNO:
9272     case DT_MIPS_HIPAGENO:
9273     case DT_MIPS_DELTA_CLASS_NO:
9274     case DT_MIPS_DELTA_INSTANCE_NO:
9275     case DT_MIPS_DELTA_RELOC_NO:
9276     case DT_MIPS_DELTA_SYM_NO:
9277     case DT_MIPS_DELTA_CLASSSYM_NO:
9278     case DT_MIPS_COMPACT_SIZE:
9279       print_vma (entry->d_un.d_val, DEC);
9280       break;
9281
9282     default:
9283       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9284     }
9285     putchar ('\n');
9286 }
9287
9288 static void
9289 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9290 {
9291   switch (entry->d_tag)
9292     {
9293     case DT_HP_DLD_FLAGS:
9294       {
9295         static struct
9296         {
9297           long int bit;
9298           const char * str;
9299         }
9300         flags[] =
9301         {
9302           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9303           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9304           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9305           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9306           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9307           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9308           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9309           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9310           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9311           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9312           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9313           { DT_HP_GST, "HP_GST" },
9314           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9315           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9316           { DT_HP_NODELETE, "HP_NODELETE" },
9317           { DT_HP_GROUP, "HP_GROUP" },
9318           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9319         };
9320         bfd_boolean first = TRUE;
9321         size_t cnt;
9322         bfd_vma val = entry->d_un.d_val;
9323
9324         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9325           if (val & flags[cnt].bit)
9326             {
9327               if (! first)
9328                 putchar (' ');
9329               fputs (flags[cnt].str, stdout);
9330               first = FALSE;
9331               val ^= flags[cnt].bit;
9332             }
9333
9334         if (val != 0 || first)
9335           {
9336             if (! first)
9337               putchar (' ');
9338             print_vma (val, HEX);
9339           }
9340       }
9341       break;
9342
9343     default:
9344       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9345       break;
9346     }
9347   putchar ('\n');
9348 }
9349
9350 #ifdef BFD64
9351
9352 /* VMS vs Unix time offset and factor.  */
9353
9354 #define VMS_EPOCH_OFFSET 35067168000000000LL
9355 #define VMS_GRANULARITY_FACTOR 10000000
9356
9357 /* Display a VMS time in a human readable format.  */
9358
9359 static void
9360 print_vms_time (bfd_int64_t vmstime)
9361 {
9362   struct tm *tm;
9363   time_t unxtime;
9364
9365   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9366   tm = gmtime (&unxtime);
9367   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9368           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9369           tm->tm_hour, tm->tm_min, tm->tm_sec);
9370 }
9371 #endif /* BFD64 */
9372
9373 static void
9374 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9375 {
9376   switch (entry->d_tag)
9377     {
9378     case DT_IA_64_PLT_RESERVE:
9379       /* First 3 slots reserved.  */
9380       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9381       printf (" -- ");
9382       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9383       break;
9384
9385     case DT_IA_64_VMS_LINKTIME:
9386 #ifdef BFD64
9387       print_vms_time (entry->d_un.d_val);
9388 #endif
9389       break;
9390
9391     case DT_IA_64_VMS_LNKFLAGS:
9392       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9393       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9394         printf (" CALL_DEBUG");
9395       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9396         printf (" NOP0BUFS");
9397       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9398         printf (" P0IMAGE");
9399       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9400         printf (" MKTHREADS");
9401       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9402         printf (" UPCALLS");
9403       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9404         printf (" IMGSTA");
9405       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9406         printf (" INITIALIZE");
9407       if (entry->d_un.d_val & VMS_LF_MAIN)
9408         printf (" MAIN");
9409       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9410         printf (" EXE_INIT");
9411       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9412         printf (" TBK_IN_IMG");
9413       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9414         printf (" DBG_IN_IMG");
9415       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9416         printf (" TBK_IN_DSF");
9417       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9418         printf (" DBG_IN_DSF");
9419       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9420         printf (" SIGNATURES");
9421       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9422         printf (" REL_SEG_OFF");
9423       break;
9424
9425     default:
9426       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9427       break;
9428     }
9429   putchar ('\n');
9430 }
9431
9432 static bfd_boolean
9433 get_32bit_dynamic_section (Filedata * filedata)
9434 {
9435   Elf32_External_Dyn * edyn;
9436   Elf32_External_Dyn * ext;
9437   Elf_Internal_Dyn * entry;
9438
9439   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9440                                           dynamic_size, _("dynamic section"));
9441   if (!edyn)
9442     return FALSE;
9443
9444   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9445      might not have the luxury of section headers.  Look for the DT_NULL
9446      terminator to determine the number of entries.  */
9447   for (ext = edyn, dynamic_nent = 0;
9448        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9449        ext++)
9450     {
9451       dynamic_nent++;
9452       if (BYTE_GET (ext->d_tag) == DT_NULL)
9453         break;
9454     }
9455
9456   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9457                                                   sizeof (* entry));
9458   if (dynamic_section == NULL)
9459     {
9460       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9461              (unsigned long) dynamic_nent);
9462       free (edyn);
9463       return FALSE;
9464     }
9465
9466   for (ext = edyn, entry = dynamic_section;
9467        entry < dynamic_section + dynamic_nent;
9468        ext++, entry++)
9469     {
9470       entry->d_tag      = BYTE_GET (ext->d_tag);
9471       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9472     }
9473
9474   free (edyn);
9475
9476   return TRUE;
9477 }
9478
9479 static bfd_boolean
9480 get_64bit_dynamic_section (Filedata * filedata)
9481 {
9482   Elf64_External_Dyn * edyn;
9483   Elf64_External_Dyn * ext;
9484   Elf_Internal_Dyn * entry;
9485
9486   /* Read in the data.  */
9487   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9488                                           dynamic_size, _("dynamic section"));
9489   if (!edyn)
9490     return FALSE;
9491
9492   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9493      might not have the luxury of section headers.  Look for the DT_NULL
9494      terminator to determine the number of entries.  */
9495   for (ext = edyn, dynamic_nent = 0;
9496        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9497        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9498        ext++)
9499     {
9500       dynamic_nent++;
9501       if (BYTE_GET (ext->d_tag) == DT_NULL)
9502         break;
9503     }
9504
9505   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9506                                                   sizeof (* entry));
9507   if (dynamic_section == NULL)
9508     {
9509       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9510              (unsigned long) dynamic_nent);
9511       free (edyn);
9512       return FALSE;
9513     }
9514
9515   /* Convert from external to internal formats.  */
9516   for (ext = edyn, entry = dynamic_section;
9517        entry < dynamic_section + dynamic_nent;
9518        ext++, entry++)
9519     {
9520       entry->d_tag      = BYTE_GET (ext->d_tag);
9521       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9522     }
9523
9524   free (edyn);
9525
9526   return TRUE;
9527 }
9528
9529 static void
9530 print_dynamic_flags (bfd_vma flags)
9531 {
9532   bfd_boolean first = TRUE;
9533
9534   while (flags)
9535     {
9536       bfd_vma flag;
9537
9538       flag = flags & - flags;
9539       flags &= ~ flag;
9540
9541       if (first)
9542         first = FALSE;
9543       else
9544         putc (' ', stdout);
9545
9546       switch (flag)
9547         {
9548         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9549         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9550         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9551         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9552         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9553         default:                fputs (_("unknown"), stdout); break;
9554         }
9555     }
9556   puts ("");
9557 }
9558
9559 /* Parse and display the contents of the dynamic section.  */
9560
9561 static bfd_boolean
9562 process_dynamic_section (Filedata * filedata)
9563 {
9564   Elf_Internal_Dyn * entry;
9565
9566   if (dynamic_size == 0)
9567     {
9568       if (do_dynamic)
9569         printf (_("\nThere is no dynamic section in this file.\n"));
9570
9571       return TRUE;
9572     }
9573
9574   if (is_32bit_elf)
9575     {
9576       if (! get_32bit_dynamic_section (filedata))
9577         return FALSE;
9578     }
9579   else
9580     {
9581       if (! get_64bit_dynamic_section (filedata))
9582         return FALSE;
9583     }
9584
9585   /* Find the appropriate symbol table.  */
9586   if (dynamic_symbols == NULL)
9587     {
9588       for (entry = dynamic_section;
9589            entry < dynamic_section + dynamic_nent;
9590            ++entry)
9591         {
9592           Elf_Internal_Shdr section;
9593
9594           if (entry->d_tag != DT_SYMTAB)
9595             continue;
9596
9597           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9598
9599           /* Since we do not know how big the symbol table is,
9600              we default to reading in the entire file (!) and
9601              processing that.  This is overkill, I know, but it
9602              should work.  */
9603           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9604           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9605             {
9606               /* See PR 21379 for a reproducer.  */
9607               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9608               return FALSE;
9609             }
9610
9611           if (archive_file_offset != 0)
9612             section.sh_size = archive_file_size - section.sh_offset;
9613           else
9614             section.sh_size = filedata->file_size - section.sh_offset;
9615
9616           if (is_32bit_elf)
9617             section.sh_entsize = sizeof (Elf32_External_Sym);
9618           else
9619             section.sh_entsize = sizeof (Elf64_External_Sym);
9620           section.sh_name = filedata->string_table_length;
9621
9622           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9623           if (num_dynamic_syms < 1)
9624             {
9625               error (_("Unable to determine the number of symbols to load\n"));
9626               continue;
9627             }
9628         }
9629     }
9630
9631   /* Similarly find a string table.  */
9632   if (dynamic_strings == NULL)
9633     {
9634       for (entry = dynamic_section;
9635            entry < dynamic_section + dynamic_nent;
9636            ++entry)
9637         {
9638           unsigned long offset;
9639           long str_tab_len;
9640
9641           if (entry->d_tag != DT_STRTAB)
9642             continue;
9643
9644           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9645
9646           /* Since we do not know how big the string table is,
9647              we default to reading in the entire file (!) and
9648              processing that.  This is overkill, I know, but it
9649              should work.  */
9650
9651           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9652
9653           if (archive_file_offset != 0)
9654             str_tab_len = archive_file_size - offset;
9655           else
9656             str_tab_len = filedata->file_size;
9657
9658           if (str_tab_len < 1)
9659             {
9660               error
9661                 (_("Unable to determine the length of the dynamic string table\n"));
9662               continue;
9663             }
9664
9665           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9666                                                str_tab_len,
9667                                                _("dynamic string table"));
9668           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9669           break;
9670         }
9671     }
9672
9673   /* And find the syminfo section if available.  */
9674   if (dynamic_syminfo == NULL)
9675     {
9676       unsigned long syminsz = 0;
9677
9678       for (entry = dynamic_section;
9679            entry < dynamic_section + dynamic_nent;
9680            ++entry)
9681         {
9682           if (entry->d_tag == DT_SYMINENT)
9683             {
9684               /* Note: these braces are necessary to avoid a syntax
9685                  error from the SunOS4 C compiler.  */
9686               /* PR binutils/17531: A corrupt file can trigger this test.
9687                  So do not use an assert, instead generate an error message.  */
9688               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9689                 error (_("Bad value (%d) for SYMINENT entry\n"),
9690                        (int) entry->d_un.d_val);
9691             }
9692           else if (entry->d_tag == DT_SYMINSZ)
9693             syminsz = entry->d_un.d_val;
9694           else if (entry->d_tag == DT_SYMINFO)
9695             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9696                                                       syminsz);
9697         }
9698
9699       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9700         {
9701           Elf_External_Syminfo * extsyminfo;
9702           Elf_External_Syminfo * extsym;
9703           Elf_Internal_Syminfo * syminfo;
9704
9705           /* There is a syminfo section.  Read the data.  */
9706           extsyminfo = (Elf_External_Syminfo *)
9707               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9708                         _("symbol information"));
9709           if (!extsyminfo)
9710             return FALSE;
9711
9712           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9713           if (dynamic_syminfo == NULL)
9714             {
9715               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9716                      (unsigned long) syminsz);
9717               return FALSE;
9718             }
9719
9720           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9721           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9722                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9723                ++syminfo, ++extsym)
9724             {
9725               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9726               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9727             }
9728
9729           free (extsyminfo);
9730         }
9731     }
9732
9733   if (do_dynamic && dynamic_addr)
9734     printf (ngettext ("\nDynamic section at offset 0x%lx "
9735                       "contains %lu entry:\n",
9736                       "\nDynamic section at offset 0x%lx "
9737                       "contains %lu entries:\n",
9738                       dynamic_nent),
9739             dynamic_addr, (unsigned long) dynamic_nent);
9740   if (do_dynamic)
9741     printf (_("  Tag        Type                         Name/Value\n"));
9742
9743   for (entry = dynamic_section;
9744        entry < dynamic_section + dynamic_nent;
9745        entry++)
9746     {
9747       if (do_dynamic)
9748         {
9749           const char * dtype;
9750
9751           putchar (' ');
9752           print_vma (entry->d_tag, FULL_HEX);
9753           dtype = get_dynamic_type (filedata, entry->d_tag);
9754           printf (" (%s)%*s", dtype,
9755                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9756         }
9757
9758       switch (entry->d_tag)
9759         {
9760         case DT_FLAGS:
9761           if (do_dynamic)
9762             print_dynamic_flags (entry->d_un.d_val);
9763           break;
9764
9765         case DT_AUXILIARY:
9766         case DT_FILTER:
9767         case DT_CONFIG:
9768         case DT_DEPAUDIT:
9769         case DT_AUDIT:
9770           if (do_dynamic)
9771             {
9772               switch (entry->d_tag)
9773                 {
9774                 case DT_AUXILIARY:
9775                   printf (_("Auxiliary library"));
9776                   break;
9777
9778                 case DT_FILTER:
9779                   printf (_("Filter library"));
9780                   break;
9781
9782                 case DT_CONFIG:
9783                   printf (_("Configuration file"));
9784                   break;
9785
9786                 case DT_DEPAUDIT:
9787                   printf (_("Dependency audit library"));
9788                   break;
9789
9790                 case DT_AUDIT:
9791                   printf (_("Audit library"));
9792                   break;
9793                 }
9794
9795               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9796                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9797               else
9798                 {
9799                   printf (": ");
9800                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9801                   putchar ('\n');
9802                 }
9803             }
9804           break;
9805
9806         case DT_FEATURE:
9807           if (do_dynamic)
9808             {
9809               printf (_("Flags:"));
9810
9811               if (entry->d_un.d_val == 0)
9812                 printf (_(" None\n"));
9813               else
9814                 {
9815                   unsigned long int val = entry->d_un.d_val;
9816
9817                   if (val & DTF_1_PARINIT)
9818                     {
9819                       printf (" PARINIT");
9820                       val ^= DTF_1_PARINIT;
9821                     }
9822                   if (val & DTF_1_CONFEXP)
9823                     {
9824                       printf (" CONFEXP");
9825                       val ^= DTF_1_CONFEXP;
9826                     }
9827                   if (val != 0)
9828                     printf (" %lx", val);
9829                   puts ("");
9830                 }
9831             }
9832           break;
9833
9834         case DT_POSFLAG_1:
9835           if (do_dynamic)
9836             {
9837               printf (_("Flags:"));
9838
9839               if (entry->d_un.d_val == 0)
9840                 printf (_(" None\n"));
9841               else
9842                 {
9843                   unsigned long int val = entry->d_un.d_val;
9844
9845                   if (val & DF_P1_LAZYLOAD)
9846                     {
9847                       printf (" LAZYLOAD");
9848                       val ^= DF_P1_LAZYLOAD;
9849                     }
9850                   if (val & DF_P1_GROUPPERM)
9851                     {
9852                       printf (" GROUPPERM");
9853                       val ^= DF_P1_GROUPPERM;
9854                     }
9855                   if (val != 0)
9856                     printf (" %lx", val);
9857                   puts ("");
9858                 }
9859             }
9860           break;
9861
9862         case DT_FLAGS_1:
9863           if (do_dynamic)
9864             {
9865               printf (_("Flags:"));
9866               if (entry->d_un.d_val == 0)
9867                 printf (_(" None\n"));
9868               else
9869                 {
9870                   unsigned long int val = entry->d_un.d_val;
9871
9872                   if (val & DF_1_NOW)
9873                     {
9874                       printf (" NOW");
9875                       val ^= DF_1_NOW;
9876                     }
9877                   if (val & DF_1_GLOBAL)
9878                     {
9879                       printf (" GLOBAL");
9880                       val ^= DF_1_GLOBAL;
9881                     }
9882                   if (val & DF_1_GROUP)
9883                     {
9884                       printf (" GROUP");
9885                       val ^= DF_1_GROUP;
9886                     }
9887                   if (val & DF_1_NODELETE)
9888                     {
9889                       printf (" NODELETE");
9890                       val ^= DF_1_NODELETE;
9891                     }
9892                   if (val & DF_1_LOADFLTR)
9893                     {
9894                       printf (" LOADFLTR");
9895                       val ^= DF_1_LOADFLTR;
9896                     }
9897                   if (val & DF_1_INITFIRST)
9898                     {
9899                       printf (" INITFIRST");
9900                       val ^= DF_1_INITFIRST;
9901                     }
9902                   if (val & DF_1_NOOPEN)
9903                     {
9904                       printf (" NOOPEN");
9905                       val ^= DF_1_NOOPEN;
9906                     }
9907                   if (val & DF_1_ORIGIN)
9908                     {
9909                       printf (" ORIGIN");
9910                       val ^= DF_1_ORIGIN;
9911                     }
9912                   if (val & DF_1_DIRECT)
9913                     {
9914                       printf (" DIRECT");
9915                       val ^= DF_1_DIRECT;
9916                     }
9917                   if (val & DF_1_TRANS)
9918                     {
9919                       printf (" TRANS");
9920                       val ^= DF_1_TRANS;
9921                     }
9922                   if (val & DF_1_INTERPOSE)
9923                     {
9924                       printf (" INTERPOSE");
9925                       val ^= DF_1_INTERPOSE;
9926                     }
9927                   if (val & DF_1_NODEFLIB)
9928                     {
9929                       printf (" NODEFLIB");
9930                       val ^= DF_1_NODEFLIB;
9931                     }
9932                   if (val & DF_1_NODUMP)
9933                     {
9934                       printf (" NODUMP");
9935                       val ^= DF_1_NODUMP;
9936                     }
9937                   if (val & DF_1_CONFALT)
9938                     {
9939                       printf (" CONFALT");
9940                       val ^= DF_1_CONFALT;
9941                     }
9942                   if (val & DF_1_ENDFILTEE)
9943                     {
9944                       printf (" ENDFILTEE");
9945                       val ^= DF_1_ENDFILTEE;
9946                     }
9947                   if (val & DF_1_DISPRELDNE)
9948                     {
9949                       printf (" DISPRELDNE");
9950                       val ^= DF_1_DISPRELDNE;
9951                     }
9952                   if (val & DF_1_DISPRELPND)
9953                     {
9954                       printf (" DISPRELPND");
9955                       val ^= DF_1_DISPRELPND;
9956                     }
9957                   if (val & DF_1_NODIRECT)
9958                     {
9959                       printf (" NODIRECT");
9960                       val ^= DF_1_NODIRECT;
9961                     }
9962                   if (val & DF_1_IGNMULDEF)
9963                     {
9964                       printf (" IGNMULDEF");
9965                       val ^= DF_1_IGNMULDEF;
9966                     }
9967                   if (val & DF_1_NOKSYMS)
9968                     {
9969                       printf (" NOKSYMS");
9970                       val ^= DF_1_NOKSYMS;
9971                     }
9972                   if (val & DF_1_NOHDR)
9973                     {
9974                       printf (" NOHDR");
9975                       val ^= DF_1_NOHDR;
9976                     }
9977                   if (val & DF_1_EDITED)
9978                     {
9979                       printf (" EDITED");
9980                       val ^= DF_1_EDITED;
9981                     }
9982                   if (val & DF_1_NORELOC)
9983                     {
9984                       printf (" NORELOC");
9985                       val ^= DF_1_NORELOC;
9986                     }
9987                   if (val & DF_1_SYMINTPOSE)
9988                     {
9989                       printf (" SYMINTPOSE");
9990                       val ^= DF_1_SYMINTPOSE;
9991                     }
9992                   if (val & DF_1_GLOBAUDIT)
9993                     {
9994                       printf (" GLOBAUDIT");
9995                       val ^= DF_1_GLOBAUDIT;
9996                     }
9997                   if (val & DF_1_SINGLETON)
9998                     {
9999                       printf (" SINGLETON");
10000                       val ^= DF_1_SINGLETON;
10001                     }
10002                   if (val & DF_1_STUB)
10003                     {
10004                       printf (" STUB");
10005                       val ^= DF_1_STUB;
10006                     }
10007                   if (val & DF_1_PIE)
10008                     {
10009                       printf (" PIE");
10010                       val ^= DF_1_PIE;
10011                     }
10012                   if (val & DF_1_KMOD)
10013                     {
10014                       printf (" KMOD");
10015                       val ^= DF_1_KMOD;
10016                     }
10017                   if (val & DF_1_WEAKFILTER)
10018                     {
10019                       printf (" WEAKFILTER");
10020                       val ^= DF_1_WEAKFILTER;
10021                     }
10022                   if (val & DF_1_NOCOMMON)
10023                     {
10024                       printf (" NOCOMMON");
10025                       val ^= DF_1_NOCOMMON;
10026                     }
10027                   if (val != 0)
10028                     printf (" %lx", val);
10029                   puts ("");
10030                 }
10031             }
10032           break;
10033
10034         case DT_PLTREL:
10035           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10036           if (do_dynamic)
10037             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10038           break;
10039
10040         case DT_NULL    :
10041         case DT_NEEDED  :
10042         case DT_PLTGOT  :
10043         case DT_HASH    :
10044         case DT_STRTAB  :
10045         case DT_SYMTAB  :
10046         case DT_RELA    :
10047         case DT_INIT    :
10048         case DT_FINI    :
10049         case DT_SONAME  :
10050         case DT_RPATH   :
10051         case DT_SYMBOLIC:
10052         case DT_REL     :
10053         case DT_DEBUG   :
10054         case DT_TEXTREL :
10055         case DT_JMPREL  :
10056         case DT_RUNPATH :
10057           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10058
10059           if (do_dynamic)
10060             {
10061               char * name;
10062
10063               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10064                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10065               else
10066                 name = NULL;
10067
10068               if (name)
10069                 {
10070                   switch (entry->d_tag)
10071                     {
10072                     case DT_NEEDED:
10073                       printf (_("Shared library: [%s]"), name);
10074
10075                       if (streq (name, program_interpreter))
10076                         printf (_(" program interpreter"));
10077                       break;
10078
10079                     case DT_SONAME:
10080                       printf (_("Library soname: [%s]"), name);
10081                       break;
10082
10083                     case DT_RPATH:
10084                       printf (_("Library rpath: [%s]"), name);
10085                       break;
10086
10087                     case DT_RUNPATH:
10088                       printf (_("Library runpath: [%s]"), name);
10089                       break;
10090
10091                     default:
10092                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10093                       break;
10094                     }
10095                 }
10096               else
10097                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10098
10099               putchar ('\n');
10100             }
10101           break;
10102
10103         case DT_PLTRELSZ:
10104         case DT_RELASZ  :
10105         case DT_STRSZ   :
10106         case DT_RELSZ   :
10107         case DT_RELAENT :
10108         case DT_SYMENT  :
10109         case DT_RELENT  :
10110           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10111           /* Fall through.  */
10112         case DT_PLTPADSZ:
10113         case DT_MOVEENT :
10114         case DT_MOVESZ  :
10115         case DT_INIT_ARRAYSZ:
10116         case DT_FINI_ARRAYSZ:
10117         case DT_GNU_CONFLICTSZ:
10118         case DT_GNU_LIBLISTSZ:
10119           if (do_dynamic)
10120             {
10121               print_vma (entry->d_un.d_val, UNSIGNED);
10122               printf (_(" (bytes)\n"));
10123             }
10124           break;
10125
10126         case DT_VERDEFNUM:
10127         case DT_VERNEEDNUM:
10128         case DT_RELACOUNT:
10129         case DT_RELCOUNT:
10130           if (do_dynamic)
10131             {
10132               print_vma (entry->d_un.d_val, UNSIGNED);
10133               putchar ('\n');
10134             }
10135           break;
10136
10137         case DT_SYMINSZ:
10138         case DT_SYMINENT:
10139         case DT_SYMINFO:
10140         case DT_USED:
10141         case DT_INIT_ARRAY:
10142         case DT_FINI_ARRAY:
10143           if (do_dynamic)
10144             {
10145               if (entry->d_tag == DT_USED
10146                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10147                 {
10148                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10149
10150                   if (*name)
10151                     {
10152                       printf (_("Not needed object: [%s]\n"), name);
10153                       break;
10154                     }
10155                 }
10156
10157               print_vma (entry->d_un.d_val, PREFIX_HEX);
10158               putchar ('\n');
10159             }
10160           break;
10161
10162         case DT_BIND_NOW:
10163           /* The value of this entry is ignored.  */
10164           if (do_dynamic)
10165             putchar ('\n');
10166           break;
10167
10168         case DT_GNU_PRELINKED:
10169           if (do_dynamic)
10170             {
10171               struct tm * tmp;
10172               time_t atime = entry->d_un.d_val;
10173
10174               tmp = gmtime (&atime);
10175               /* PR 17533 file: 041-1244816-0.004.  */
10176               if (tmp == NULL)
10177                 printf (_("<corrupt time val: %lx"),
10178                         (unsigned long) atime);
10179               else
10180                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10181                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10182                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10183
10184             }
10185           break;
10186
10187         case DT_GNU_HASH:
10188           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10189           if (do_dynamic)
10190             {
10191               print_vma (entry->d_un.d_val, PREFIX_HEX);
10192               putchar ('\n');
10193             }
10194           break;
10195
10196         default:
10197           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10198             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10199               entry->d_un.d_val;
10200
10201           if (do_dynamic)
10202             {
10203               switch (filedata->file_header.e_machine)
10204                 {
10205                 case EM_MIPS:
10206                 case EM_MIPS_RS3_LE:
10207                   dynamic_section_mips_val (entry);
10208                   break;
10209                 case EM_PARISC:
10210                   dynamic_section_parisc_val (entry);
10211                   break;
10212                 case EM_IA_64:
10213                   dynamic_section_ia64_val (entry);
10214                   break;
10215                 default:
10216                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10217                   putchar ('\n');
10218                 }
10219             }
10220           break;
10221         }
10222     }
10223
10224   return TRUE;
10225 }
10226
10227 static char *
10228 get_ver_flags (unsigned int flags)
10229 {
10230   static char buff[128];
10231
10232   buff[0] = 0;
10233
10234   if (flags == 0)
10235     return _("none");
10236
10237   if (flags & VER_FLG_BASE)
10238     strcat (buff, "BASE");
10239
10240   if (flags & VER_FLG_WEAK)
10241     {
10242       if (flags & VER_FLG_BASE)
10243         strcat (buff, " | ");
10244
10245       strcat (buff, "WEAK");
10246     }
10247
10248   if (flags & VER_FLG_INFO)
10249     {
10250       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10251         strcat (buff, " | ");
10252
10253       strcat (buff, "INFO");
10254     }
10255
10256   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10257     {
10258       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10259         strcat (buff, " | ");
10260
10261       strcat (buff, _("<unknown>"));
10262     }
10263
10264   return buff;
10265 }
10266
10267 /* Display the contents of the version sections.  */
10268
10269 static bfd_boolean
10270 process_version_sections (Filedata * filedata)
10271 {
10272   Elf_Internal_Shdr * section;
10273   unsigned i;
10274   bfd_boolean found = FALSE;
10275
10276   if (! do_version)
10277     return TRUE;
10278
10279   for (i = 0, section = filedata->section_headers;
10280        i < filedata->file_header.e_shnum;
10281        i++, section++)
10282     {
10283       switch (section->sh_type)
10284         {
10285         case SHT_GNU_verdef:
10286           {
10287             Elf_External_Verdef * edefs;
10288             unsigned long idx;
10289             unsigned long cnt;
10290             char * endbuf;
10291
10292             found = TRUE;
10293
10294             printf (ngettext ("\nVersion definition section '%s' "
10295                               "contains %u entry:\n",
10296                               "\nVersion definition section '%s' "
10297                               "contains %u entries:\n",
10298                               section->sh_info),
10299                     printable_section_name (filedata, section),
10300                     section->sh_info);
10301
10302             printf (_("  Addr: 0x"));
10303             printf_vma (section->sh_addr);
10304             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10305                     (unsigned long) section->sh_offset, section->sh_link,
10306                     printable_section_name_from_index (filedata, section->sh_link));
10307
10308             edefs = (Elf_External_Verdef *)
10309                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10310                           _("version definition section"));
10311             if (!edefs)
10312               break;
10313             endbuf = (char *) edefs + section->sh_size;
10314
10315             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10316               {
10317                 char * vstart;
10318                 Elf_External_Verdef * edef;
10319                 Elf_Internal_Verdef ent;
10320                 Elf_External_Verdaux * eaux;
10321                 Elf_Internal_Verdaux aux;
10322                 unsigned long isum;
10323                 int j;
10324
10325                 vstart = ((char *) edefs) + idx;
10326                 if (vstart + sizeof (*edef) > endbuf)
10327                   break;
10328
10329                 edef = (Elf_External_Verdef *) vstart;
10330
10331                 ent.vd_version = BYTE_GET (edef->vd_version);
10332                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10333                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10334                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10335                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10336                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10337                 ent.vd_next    = BYTE_GET (edef->vd_next);
10338
10339                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10340                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10341
10342                 printf (_("  Index: %d  Cnt: %d  "),
10343                         ent.vd_ndx, ent.vd_cnt);
10344
10345                 /* Check for overflow.  */
10346                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10347                   break;
10348
10349                 vstart += ent.vd_aux;
10350
10351                 if (vstart + sizeof (*eaux) > endbuf)
10352                   break;
10353                 eaux = (Elf_External_Verdaux *) vstart;
10354
10355                 aux.vda_name = BYTE_GET (eaux->vda_name);
10356                 aux.vda_next = BYTE_GET (eaux->vda_next);
10357
10358                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10359                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10360                 else
10361                   printf (_("Name index: %ld\n"), aux.vda_name);
10362
10363                 isum = idx + ent.vd_aux;
10364
10365                 for (j = 1; j < ent.vd_cnt; j++)
10366                   {
10367                     if (aux.vda_next < sizeof (*eaux)
10368                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10369                       {
10370                         warn (_("Invalid vda_next field of %lx\n"),
10371                               aux.vda_next);
10372                         j = ent.vd_cnt;
10373                         break;
10374                       }
10375                     /* Check for overflow.  */
10376                     if (aux.vda_next > (size_t) (endbuf - vstart))
10377                       break;
10378
10379                     isum   += aux.vda_next;
10380                     vstart += aux.vda_next;
10381
10382                     if (vstart + sizeof (*eaux) > endbuf)
10383                       break;
10384                     eaux = (Elf_External_Verdaux *) vstart;
10385
10386                     aux.vda_name = BYTE_GET (eaux->vda_name);
10387                     aux.vda_next = BYTE_GET (eaux->vda_next);
10388
10389                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10390                       printf (_("  %#06lx: Parent %d: %s\n"),
10391                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10392                     else
10393                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10394                               isum, j, aux.vda_name);
10395                   }
10396
10397                 if (j < ent.vd_cnt)
10398                   printf (_("  Version def aux past end of section\n"));
10399
10400                 /* PR 17531:
10401                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10402                 if (ent.vd_next < sizeof (*edef)
10403                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10404                   {
10405                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10406                     cnt = section->sh_info;
10407                     break;
10408                   }
10409                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10410                   break;
10411
10412                 idx += ent.vd_next;
10413               }
10414
10415             if (cnt < section->sh_info)
10416               printf (_("  Version definition past end of section\n"));
10417
10418             free (edefs);
10419           }
10420           break;
10421
10422         case SHT_GNU_verneed:
10423           {
10424             Elf_External_Verneed * eneed;
10425             unsigned long idx;
10426             unsigned long cnt;
10427             char * endbuf;
10428
10429             found = TRUE;
10430
10431             printf (ngettext ("\nVersion needs section '%s' "
10432                               "contains %u entry:\n",
10433                               "\nVersion needs section '%s' "
10434                               "contains %u entries:\n",
10435                               section->sh_info),
10436                     printable_section_name (filedata, section), section->sh_info);
10437
10438             printf (_(" Addr: 0x"));
10439             printf_vma (section->sh_addr);
10440             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10441                     (unsigned long) section->sh_offset, section->sh_link,
10442                     printable_section_name_from_index (filedata, section->sh_link));
10443
10444             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10445                                                        section->sh_offset, 1,
10446                                                        section->sh_size,
10447                                                        _("Version Needs section"));
10448             if (!eneed)
10449               break;
10450             endbuf = (char *) eneed + section->sh_size;
10451
10452             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10453               {
10454                 Elf_External_Verneed * entry;
10455                 Elf_Internal_Verneed ent;
10456                 unsigned long isum;
10457                 int j;
10458                 char * vstart;
10459
10460                 vstart = ((char *) eneed) + idx;
10461                 if (vstart + sizeof (*entry) > endbuf)
10462                   break;
10463
10464                 entry = (Elf_External_Verneed *) vstart;
10465
10466                 ent.vn_version = BYTE_GET (entry->vn_version);
10467                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10468                 ent.vn_file    = BYTE_GET (entry->vn_file);
10469                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10470                 ent.vn_next    = BYTE_GET (entry->vn_next);
10471
10472                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10473
10474                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10475                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10476                 else
10477                   printf (_("  File: %lx"), ent.vn_file);
10478
10479                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10480
10481                 /* Check for overflow.  */
10482                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10483                   break;
10484                 vstart += ent.vn_aux;
10485
10486                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10487                   {
10488                     Elf_External_Vernaux * eaux;
10489                     Elf_Internal_Vernaux aux;
10490
10491                     if (vstart + sizeof (*eaux) > endbuf)
10492                       break;
10493                     eaux = (Elf_External_Vernaux *) vstart;
10494
10495                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10496                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10497                     aux.vna_other = BYTE_GET (eaux->vna_other);
10498                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10499                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10500
10501                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10502                       printf (_("  %#06lx:   Name: %s"),
10503                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10504                     else
10505                       printf (_("  %#06lx:   Name index: %lx"),
10506                               isum, aux.vna_name);
10507
10508                     printf (_("  Flags: %s  Version: %d\n"),
10509                             get_ver_flags (aux.vna_flags), aux.vna_other);
10510
10511                     if (aux.vna_next < sizeof (*eaux)
10512                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10513                       {
10514                         warn (_("Invalid vna_next field of %lx\n"),
10515                               aux.vna_next);
10516                         j = ent.vn_cnt;
10517                         break;
10518                       }
10519                     /* Check for overflow.  */
10520                     if (aux.vna_next > (size_t) (endbuf - vstart))
10521                       break;
10522                     isum   += aux.vna_next;
10523                     vstart += aux.vna_next;
10524                   }
10525
10526                 if (j < ent.vn_cnt)
10527                   warn (_("Missing Version Needs auxillary information\n"));
10528
10529                 if (ent.vn_next < sizeof (*entry)
10530                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10531                   {
10532                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10533                     cnt = section->sh_info;
10534                     break;
10535                   }
10536                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10537                   break;
10538                 idx += ent.vn_next;
10539               }
10540
10541             if (cnt < section->sh_info)
10542               warn (_("Missing Version Needs information\n"));
10543
10544             free (eneed);
10545           }
10546           break;
10547
10548         case SHT_GNU_versym:
10549           {
10550             Elf_Internal_Shdr * link_section;
10551             size_t total;
10552             unsigned int cnt;
10553             unsigned char * edata;
10554             unsigned short * data;
10555             char * strtab;
10556             Elf_Internal_Sym * symbols;
10557             Elf_Internal_Shdr * string_sec;
10558             unsigned long num_syms;
10559             long off;
10560
10561             if (section->sh_link >= filedata->file_header.e_shnum)
10562               break;
10563
10564             link_section = filedata->section_headers + section->sh_link;
10565             total = section->sh_size / sizeof (Elf_External_Versym);
10566
10567             if (link_section->sh_link >= filedata->file_header.e_shnum)
10568               break;
10569
10570             found = TRUE;
10571
10572             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10573             if (symbols == NULL)
10574               break;
10575
10576             string_sec = filedata->section_headers + link_section->sh_link;
10577
10578             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10579                                         string_sec->sh_size,
10580                                         _("version string table"));
10581             if (!strtab)
10582               {
10583                 free (symbols);
10584                 break;
10585               }
10586
10587             printf (ngettext ("\nVersion symbols section '%s' "
10588                               "contains %lu entry:\n",
10589                               "\nVersion symbols section '%s' "
10590                               "contains %lu entries:\n",
10591                               total),
10592                     printable_section_name (filedata, section), (unsigned long) total);
10593
10594             printf (_(" Addr: "));
10595             printf_vma (section->sh_addr);
10596             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10597                     (unsigned long) section->sh_offset, section->sh_link,
10598                     printable_section_name (filedata, link_section));
10599
10600             off = offset_from_vma (filedata,
10601                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10602                                    total * sizeof (short));
10603             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10604                                                 sizeof (short),
10605                                                 _("version symbol data"));
10606             if (!edata)
10607               {
10608                 free (strtab);
10609                 free (symbols);
10610                 break;
10611               }
10612
10613             data = (short unsigned int *) cmalloc (total, sizeof (short));
10614
10615             for (cnt = total; cnt --;)
10616               data[cnt] = byte_get (edata + cnt * sizeof (short),
10617                                     sizeof (short));
10618
10619             free (edata);
10620
10621             for (cnt = 0; cnt < total; cnt += 4)
10622               {
10623                 int j, nn;
10624                 char *name;
10625                 char *invalid = _("*invalid*");
10626
10627                 printf ("  %03x:", cnt);
10628
10629                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10630                   switch (data[cnt + j])
10631                     {
10632                     case 0:
10633                       fputs (_("   0 (*local*)    "), stdout);
10634                       break;
10635
10636                     case 1:
10637                       fputs (_("   1 (*global*)   "), stdout);
10638                       break;
10639
10640                     default:
10641                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10642                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10643
10644                       /* If this index value is greater than the size of the symbols
10645                          array, break to avoid an out-of-bounds read.  */
10646                       if ((unsigned long)(cnt + j) >= num_syms)
10647                         {
10648                           warn (_("invalid index into symbol array\n"));
10649                           break;
10650                         }
10651
10652                       name = NULL;
10653                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10654                         {
10655                           Elf_Internal_Verneed ivn;
10656                           unsigned long offset;
10657
10658                           offset = offset_from_vma
10659                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10660                              sizeof (Elf_External_Verneed));
10661
10662                           do
10663                             {
10664                               Elf_Internal_Vernaux ivna;
10665                               Elf_External_Verneed evn;
10666                               Elf_External_Vernaux evna;
10667                               unsigned long a_off;
10668
10669                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10670                                             _("version need")) == NULL)
10671                                 break;
10672
10673                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10674                               ivn.vn_next = BYTE_GET (evn.vn_next);
10675
10676                               a_off = offset + ivn.vn_aux;
10677
10678                               do
10679                                 {
10680                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10681                                                 1, _("version need aux (2)")) == NULL)
10682                                     {
10683                                       ivna.vna_next  = 0;
10684                                       ivna.vna_other = 0;
10685                                     }
10686                                   else
10687                                     {
10688                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10689                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10690                                     }
10691
10692                                   a_off += ivna.vna_next;
10693                                 }
10694                               while (ivna.vna_other != data[cnt + j]
10695                                      && ivna.vna_next != 0);
10696
10697                               if (ivna.vna_other == data[cnt + j])
10698                                 {
10699                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10700
10701                                   if (ivna.vna_name >= string_sec->sh_size)
10702                                     name = invalid;
10703                                   else
10704                                     name = strtab + ivna.vna_name;
10705                                   break;
10706                                 }
10707
10708                               offset += ivn.vn_next;
10709                             }
10710                           while (ivn.vn_next);
10711                         }
10712
10713                       if (data[cnt + j] != 0x8001
10714                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10715                         {
10716                           Elf_Internal_Verdef ivd;
10717                           Elf_External_Verdef evd;
10718                           unsigned long offset;
10719
10720                           offset = offset_from_vma
10721                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10722                              sizeof evd);
10723
10724                           do
10725                             {
10726                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10727                                             _("version def")) == NULL)
10728                                 {
10729                                   ivd.vd_next = 0;
10730                                   /* PR 17531: file: 046-1082287-0.004.  */
10731                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10732                                   break;
10733                                 }
10734                               else
10735                                 {
10736                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10737                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10738                                 }
10739
10740                               offset += ivd.vd_next;
10741                             }
10742                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10743                                  && ivd.vd_next != 0);
10744
10745                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10746                             {
10747                               Elf_External_Verdaux evda;
10748                               Elf_Internal_Verdaux ivda;
10749
10750                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10751
10752                               if (get_data (&evda, filedata,
10753                                             offset - ivd.vd_next + ivd.vd_aux,
10754                                             sizeof (evda), 1,
10755                                             _("version def aux")) == NULL)
10756                                 break;
10757
10758                               ivda.vda_name = BYTE_GET (evda.vda_name);
10759
10760                               if (ivda.vda_name >= string_sec->sh_size)
10761                                 name = invalid;
10762                               else if (name != NULL && name != invalid)
10763                                 name = _("*both*");
10764                               else
10765                                 name = strtab + ivda.vda_name;
10766                             }
10767                         }
10768                       if (name != NULL)
10769                         nn += printf ("(%s%-*s",
10770                                       name,
10771                                       12 - (int) strlen (name),
10772                                       ")");
10773
10774                       if (nn < 18)
10775                         printf ("%*c", 18 - nn, ' ');
10776                     }
10777
10778                 putchar ('\n');
10779               }
10780
10781             free (data);
10782             free (strtab);
10783             free (symbols);
10784           }
10785           break;
10786
10787         default:
10788           break;
10789         }
10790     }
10791
10792   if (! found)
10793     printf (_("\nNo version information found in this file.\n"));
10794
10795   return TRUE;
10796 }
10797
10798 static const char *
10799 get_symbol_binding (Filedata * filedata, unsigned int binding)
10800 {
10801   static char buff[32];
10802
10803   switch (binding)
10804     {
10805     case STB_LOCAL:     return "LOCAL";
10806     case STB_GLOBAL:    return "GLOBAL";
10807     case STB_WEAK:      return "WEAK";
10808     default:
10809       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10810         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10811                   binding);
10812       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10813         {
10814           if (binding == STB_GNU_UNIQUE
10815               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10816                   /* GNU is still using the default value 0.  */
10817                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10818             return "UNIQUE";
10819           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10820         }
10821       else
10822         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10823       return buff;
10824     }
10825 }
10826
10827 static const char *
10828 get_symbol_type (Filedata * filedata, unsigned int type)
10829 {
10830   static char buff[32];
10831
10832   switch (type)
10833     {
10834     case STT_NOTYPE:    return "NOTYPE";
10835     case STT_OBJECT:    return "OBJECT";
10836     case STT_FUNC:      return "FUNC";
10837     case STT_SECTION:   return "SECTION";
10838     case STT_FILE:      return "FILE";
10839     case STT_COMMON:    return "COMMON";
10840     case STT_TLS:       return "TLS";
10841     case STT_RELC:      return "RELC";
10842     case STT_SRELC:     return "SRELC";
10843     default:
10844       if (type >= STT_LOPROC && type <= STT_HIPROC)
10845         {
10846           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10847             return "THUMB_FUNC";
10848
10849           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10850             return "REGISTER";
10851
10852           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10853             return "PARISC_MILLI";
10854
10855           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10856         }
10857       else if (type >= STT_LOOS && type <= STT_HIOS)
10858         {
10859           if (filedata->file_header.e_machine == EM_PARISC)
10860             {
10861               if (type == STT_HP_OPAQUE)
10862                 return "HP_OPAQUE";
10863               if (type == STT_HP_STUB)
10864                 return "HP_STUB";
10865             }
10866
10867           if (type == STT_GNU_IFUNC
10868               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10869                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10870                   /* GNU is still using the default value 0.  */
10871                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10872             return "IFUNC";
10873
10874           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10875         }
10876       else
10877         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10878       return buff;
10879     }
10880 }
10881
10882 static const char *
10883 get_symbol_visibility (unsigned int visibility)
10884 {
10885   switch (visibility)
10886     {
10887     case STV_DEFAULT:   return "DEFAULT";
10888     case STV_INTERNAL:  return "INTERNAL";
10889     case STV_HIDDEN:    return "HIDDEN";
10890     case STV_PROTECTED: return "PROTECTED";
10891     default:
10892       error (_("Unrecognized visibility value: %u"), visibility);
10893       return _("<unknown>");
10894     }
10895 }
10896
10897 static const char *
10898 get_solaris_symbol_visibility (unsigned int visibility)
10899 {
10900   switch (visibility)
10901     {
10902     case 4: return "EXPORTED";
10903     case 5: return "SINGLETON";
10904     case 6: return "ELIMINATE";
10905     default: return get_symbol_visibility (visibility);
10906     }
10907 }
10908
10909 static const char *
10910 get_mips_symbol_other (unsigned int other)
10911 {
10912   switch (other)
10913     {
10914     case STO_OPTIONAL:      return "OPTIONAL";
10915     case STO_MIPS_PLT:      return "MIPS PLT";
10916     case STO_MIPS_PIC:      return "MIPS PIC";
10917     case STO_MICROMIPS:     return "MICROMIPS";
10918     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10919     case STO_MIPS16:        return "MIPS16";
10920     default:                return NULL;
10921     }
10922 }
10923
10924 static const char *
10925 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
10926 {
10927   if (is_ia64_vms (filedata))
10928     {
10929       static char res[32];
10930
10931       res[0] = 0;
10932
10933       /* Function types is for images and .STB files only.  */
10934       switch (filedata->file_header.e_type)
10935         {
10936         case ET_DYN:
10937         case ET_EXEC:
10938           switch (VMS_ST_FUNC_TYPE (other))
10939             {
10940             case VMS_SFT_CODE_ADDR:
10941               strcat (res, " CA");
10942               break;
10943             case VMS_SFT_SYMV_IDX:
10944               strcat (res, " VEC");
10945               break;
10946             case VMS_SFT_FD:
10947               strcat (res, " FD");
10948               break;
10949             case VMS_SFT_RESERVE:
10950               strcat (res, " RSV");
10951               break;
10952             default:
10953               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10954                     VMS_ST_FUNC_TYPE (other));
10955               strcat (res, " <unknown>");
10956               break;
10957             }
10958           break;
10959         default:
10960           break;
10961         }
10962       switch (VMS_ST_LINKAGE (other))
10963         {
10964         case VMS_STL_IGNORE:
10965           strcat (res, " IGN");
10966           break;
10967         case VMS_STL_RESERVE:
10968           strcat (res, " RSV");
10969           break;
10970         case VMS_STL_STD:
10971           strcat (res, " STD");
10972           break;
10973         case VMS_STL_LNK:
10974           strcat (res, " LNK");
10975           break;
10976         default:
10977           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10978                 VMS_ST_LINKAGE (other));
10979           strcat (res, " <unknown>");
10980           break;
10981         }
10982
10983       if (res[0] != 0)
10984         return res + 1;
10985       else
10986         return res;
10987     }
10988   return NULL;
10989 }
10990
10991 static const char *
10992 get_ppc64_symbol_other (unsigned int other)
10993 {
10994   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10995     {
10996       static char buf[32];
10997       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10998                 PPC64_LOCAL_ENTRY_OFFSET (other));
10999       return buf;
11000     }
11001   return NULL;
11002 }
11003
11004 static const char *
11005 get_symbol_other (Filedata * filedata, unsigned int other)
11006 {
11007   const char * result = NULL;
11008   static char buff [32];
11009
11010   if (other == 0)
11011     return "";
11012
11013   switch (filedata->file_header.e_machine)
11014     {
11015     case EM_MIPS:
11016       result = get_mips_symbol_other (other);
11017       break;
11018     case EM_IA_64:
11019       result = get_ia64_symbol_other (filedata, other);
11020       break;
11021     case EM_PPC64:
11022       result = get_ppc64_symbol_other (other);
11023       break;
11024     default:
11025       result = NULL;
11026       break;
11027     }
11028
11029   if (result)
11030     return result;
11031
11032   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11033   return buff;
11034 }
11035
11036 static const char *
11037 get_symbol_index_type (Filedata * filedata, unsigned int type)
11038 {
11039   static char buff[32];
11040
11041   switch (type)
11042     {
11043     case SHN_UNDEF:     return "UND";
11044     case SHN_ABS:       return "ABS";
11045     case SHN_COMMON:    return "COM";
11046     default:
11047       if (type == SHN_IA_64_ANSI_COMMON
11048           && filedata->file_header.e_machine == EM_IA_64
11049           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11050         return "ANSI_COM";
11051       else if ((filedata->file_header.e_machine == EM_X86_64
11052                 || filedata->file_header.e_machine == EM_L1OM
11053                 || filedata->file_header.e_machine == EM_K1OM)
11054                && type == SHN_X86_64_LCOMMON)
11055         return "LARGE_COM";
11056       else if ((type == SHN_MIPS_SCOMMON
11057                 && filedata->file_header.e_machine == EM_MIPS)
11058                || (type == SHN_TIC6X_SCOMMON
11059                    && filedata->file_header.e_machine == EM_TI_C6000))
11060         return "SCOM";
11061       else if (type == SHN_MIPS_SUNDEFINED
11062                && filedata->file_header.e_machine == EM_MIPS)
11063         return "SUND";
11064       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11065         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11066       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11067         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11068       else if (type >= SHN_LORESERVE)
11069         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11070       else if (type >= filedata->file_header.e_shnum)
11071         sprintf (buff, _("bad section index[%3d]"), type);
11072       else
11073         sprintf (buff, "%3d", type);
11074       break;
11075     }
11076
11077   return buff;
11078 }
11079
11080 static bfd_vma *
11081 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11082 {
11083   unsigned char * e_data;
11084   bfd_vma * i_data;
11085
11086   /* If the size_t type is smaller than the bfd_size_type, eg because
11087      you are building a 32-bit tool on a 64-bit host, then make sure
11088      that when (number) is cast to (size_t) no information is lost.  */
11089   if (sizeof (size_t) < sizeof (bfd_size_type)
11090       && (bfd_size_type) ((size_t) number) != number)
11091     {
11092       error (_("Size truncation prevents reading %s elements of size %u\n"),
11093              bfd_vmatoa ("u", number), ent_size);
11094       return NULL;
11095     }
11096
11097   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11098      attempting to allocate memory when the read is bound to fail.  */
11099   if (ent_size * number > filedata->file_size)
11100     {
11101       error (_("Invalid number of dynamic entries: %s\n"),
11102              bfd_vmatoa ("u", number));
11103       return NULL;
11104     }
11105
11106   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11107   if (e_data == NULL)
11108     {
11109       error (_("Out of memory reading %s dynamic entries\n"),
11110              bfd_vmatoa ("u", number));
11111       return NULL;
11112     }
11113
11114   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11115     {
11116       error (_("Unable to read in %s bytes of dynamic data\n"),
11117              bfd_vmatoa ("u", number * ent_size));
11118       free (e_data);
11119       return NULL;
11120     }
11121
11122   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11123   if (i_data == NULL)
11124     {
11125       error (_("Out of memory allocating space for %s dynamic entries\n"),
11126              bfd_vmatoa ("u", number));
11127       free (e_data);
11128       return NULL;
11129     }
11130
11131   while (number--)
11132     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11133
11134   free (e_data);
11135
11136   return i_data;
11137 }
11138
11139 static void
11140 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11141 {
11142   Elf_Internal_Sym * psym;
11143   int n;
11144
11145   n = print_vma (si, DEC_5);
11146   if (n < 5)
11147     fputs (&"     "[n], stdout);
11148   printf (" %3lu: ", hn);
11149
11150   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11151     {
11152       printf (_("<No info available for dynamic symbol number %lu>\n"),
11153               (unsigned long) si);
11154       return;
11155     }
11156
11157   psym = dynamic_symbols + si;
11158   print_vma (psym->st_value, LONG_HEX);
11159   putchar (' ');
11160   print_vma (psym->st_size, DEC_5);
11161
11162   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11163   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11164
11165   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11166     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11167   else
11168     {
11169       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11170
11171       printf (" %-7s",  get_symbol_visibility (vis));
11172       /* Check to see if any other bits in the st_other field are set.
11173          Note - displaying this information disrupts the layout of the
11174          table being generated, but for the moment this case is very
11175          rare.  */
11176       if (psym->st_other ^ vis)
11177         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11178     }
11179
11180   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11181   if (VALID_DYNAMIC_NAME (psym->st_name))
11182     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11183   else
11184     printf (_(" <corrupt: %14ld>"), psym->st_name);
11185   putchar ('\n');
11186 }
11187
11188 static const char *
11189 get_symbol_version_string (Filedata *                   filedata,
11190                            bfd_boolean                  is_dynsym,
11191                            const char *                 strtab,
11192                            unsigned long int            strtab_size,
11193                            unsigned int                 si,
11194                            Elf_Internal_Sym *           psym,
11195                            enum versioned_symbol_info * sym_info,
11196                            unsigned short *             vna_other)
11197 {
11198   unsigned char data[2];
11199   unsigned short vers_data;
11200   unsigned long offset;
11201
11202   if (!is_dynsym
11203       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11204     return NULL;
11205
11206   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11207                             sizeof data + si * sizeof (vers_data));
11208
11209   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11210                 sizeof (data), 1, _("version data")) == NULL)
11211     return NULL;
11212
11213   vers_data = byte_get (data, 2);
11214
11215   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11216     return NULL;
11217
11218   /* Usually we'd only see verdef for defined symbols, and verneed for
11219      undefined symbols.  However, symbols defined by the linker in
11220      .dynbss for variables copied from a shared library in order to
11221      avoid text relocations are defined yet have verneed.  We could
11222      use a heuristic to detect the special case, for example, check
11223      for verneed first on symbols defined in SHT_NOBITS sections, but
11224      it is simpler and more reliable to just look for both verdef and
11225      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11226
11227   if (psym->st_shndx != SHN_UNDEF
11228       && vers_data != 0x8001
11229       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11230     {
11231       Elf_Internal_Verdef ivd;
11232       Elf_Internal_Verdaux ivda;
11233       Elf_External_Verdaux evda;
11234       unsigned long off;
11235
11236       off = offset_from_vma (filedata,
11237                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11238                              sizeof (Elf_External_Verdef));
11239
11240       do
11241         {
11242           Elf_External_Verdef evd;
11243
11244           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11245                         _("version def")) == NULL)
11246             {
11247               ivd.vd_ndx = 0;
11248               ivd.vd_aux = 0;
11249               ivd.vd_next = 0;
11250             }
11251           else
11252             {
11253               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11254               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11255               ivd.vd_next = BYTE_GET (evd.vd_next);
11256             }
11257
11258           off += ivd.vd_next;
11259         }
11260       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11261
11262       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11263         {
11264           off -= ivd.vd_next;
11265           off += ivd.vd_aux;
11266
11267           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11268                         _("version def aux")) != NULL)
11269             {
11270               ivda.vda_name = BYTE_GET (evda.vda_name);
11271
11272               if (psym->st_name != ivda.vda_name)
11273                 {
11274                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11275                                ? symbol_hidden : symbol_public);
11276                   return (ivda.vda_name < strtab_size
11277                           ? strtab + ivda.vda_name : _("<corrupt>"));
11278                 }
11279             }
11280         }
11281     }
11282
11283   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11284     {
11285       Elf_External_Verneed evn;
11286       Elf_Internal_Verneed ivn;
11287       Elf_Internal_Vernaux ivna;
11288
11289       offset = offset_from_vma (filedata,
11290                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11291                                 sizeof evn);
11292       do
11293         {
11294           unsigned long vna_off;
11295
11296           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11297                         _("version need")) == NULL)
11298             {
11299               ivna.vna_next = 0;
11300               ivna.vna_other = 0;
11301               ivna.vna_name = 0;
11302               break;
11303             }
11304
11305           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11306           ivn.vn_next = BYTE_GET (evn.vn_next);
11307
11308           vna_off = offset + ivn.vn_aux;
11309
11310           do
11311             {
11312               Elf_External_Vernaux evna;
11313
11314               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11315                             _("version need aux (3)")) == NULL)
11316                 {
11317                   ivna.vna_next = 0;
11318                   ivna.vna_other = 0;
11319                   ivna.vna_name = 0;
11320                 }
11321               else
11322                 {
11323                   ivna.vna_other = BYTE_GET (evna.vna_other);
11324                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11325                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11326                 }
11327
11328               vna_off += ivna.vna_next;
11329             }
11330           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11331
11332           if (ivna.vna_other == vers_data)
11333             break;
11334
11335           offset += ivn.vn_next;
11336         }
11337       while (ivn.vn_next != 0);
11338
11339       if (ivna.vna_other == vers_data)
11340         {
11341           *sym_info = symbol_undefined;
11342           *vna_other = ivna.vna_other;
11343           return (ivna.vna_name < strtab_size
11344                   ? strtab + ivna.vna_name : _("<corrupt>"));
11345         }
11346     }
11347   return NULL;
11348 }
11349
11350 /* Dump the symbol table.  */
11351 static bfd_boolean
11352 process_symbol_table (Filedata * filedata)
11353 {
11354   Elf_Internal_Shdr * section;
11355   bfd_size_type nbuckets = 0;
11356   bfd_size_type nchains = 0;
11357   bfd_vma * buckets = NULL;
11358   bfd_vma * chains = NULL;
11359   bfd_vma ngnubuckets = 0;
11360   bfd_vma * gnubuckets = NULL;
11361   bfd_vma * gnuchains = NULL;
11362   bfd_vma gnusymidx = 0;
11363   bfd_size_type ngnuchains = 0;
11364
11365   if (!do_syms && !do_dyn_syms && !do_histogram)
11366     return TRUE;
11367
11368   if (dynamic_info[DT_HASH]
11369       && (do_histogram
11370           || (do_using_dynamic
11371               && !do_dyn_syms
11372               && dynamic_strings != NULL)))
11373     {
11374       unsigned char nb[8];
11375       unsigned char nc[8];
11376       unsigned int hash_ent_size = 4;
11377
11378       if ((filedata->file_header.e_machine == EM_ALPHA
11379            || filedata->file_header.e_machine == EM_S390
11380            || filedata->file_header.e_machine == EM_S390_OLD)
11381           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11382         hash_ent_size = 8;
11383
11384       if (fseek (filedata->handle,
11385                  (archive_file_offset
11386                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11387                                      sizeof nb + sizeof nc)),
11388                  SEEK_SET))
11389         {
11390           error (_("Unable to seek to start of dynamic information\n"));
11391           goto no_hash;
11392         }
11393
11394       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11395         {
11396           error (_("Failed to read in number of buckets\n"));
11397           goto no_hash;
11398         }
11399
11400       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11401         {
11402           error (_("Failed to read in number of chains\n"));
11403           goto no_hash;
11404         }
11405
11406       nbuckets = byte_get (nb, hash_ent_size);
11407       nchains  = byte_get (nc, hash_ent_size);
11408
11409       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11410       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11411
11412     no_hash:
11413       if (buckets == NULL || chains == NULL)
11414         {
11415           if (do_using_dynamic)
11416             return FALSE;
11417           free (buckets);
11418           free (chains);
11419           buckets = NULL;
11420           chains = NULL;
11421           nbuckets = 0;
11422           nchains = 0;
11423         }
11424     }
11425
11426   if (dynamic_info_DT_GNU_HASH
11427       && (do_histogram
11428           || (do_using_dynamic
11429               && !do_dyn_syms
11430               && dynamic_strings != NULL)))
11431     {
11432       unsigned char nb[16];
11433       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11434       bfd_vma buckets_vma;
11435
11436       if (fseek (filedata->handle,
11437                  (archive_file_offset
11438                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11439                                      sizeof nb)),
11440                  SEEK_SET))
11441         {
11442           error (_("Unable to seek to start of dynamic information\n"));
11443           goto no_gnu_hash;
11444         }
11445
11446       if (fread (nb, 16, 1, filedata->handle) != 1)
11447         {
11448           error (_("Failed to read in number of buckets\n"));
11449           goto no_gnu_hash;
11450         }
11451
11452       ngnubuckets = byte_get (nb, 4);
11453       gnusymidx = byte_get (nb + 4, 4);
11454       bitmaskwords = byte_get (nb + 8, 4);
11455       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11456       if (is_32bit_elf)
11457         buckets_vma += bitmaskwords * 4;
11458       else
11459         buckets_vma += bitmaskwords * 8;
11460
11461       if (fseek (filedata->handle,
11462                  (archive_file_offset
11463                   + offset_from_vma (filedata, buckets_vma, 4)),
11464                  SEEK_SET))
11465         {
11466           error (_("Unable to seek to start of dynamic information\n"));
11467           goto no_gnu_hash;
11468         }
11469
11470       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11471
11472       if (gnubuckets == NULL)
11473         goto no_gnu_hash;
11474
11475       for (i = 0; i < ngnubuckets; i++)
11476         if (gnubuckets[i] != 0)
11477           {
11478             if (gnubuckets[i] < gnusymidx)
11479               return FALSE;
11480
11481             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11482               maxchain = gnubuckets[i];
11483           }
11484
11485       if (maxchain == 0xffffffff)
11486         goto no_gnu_hash;
11487
11488       maxchain -= gnusymidx;
11489
11490       if (fseek (filedata->handle,
11491                  (archive_file_offset
11492                   + offset_from_vma (filedata, buckets_vma
11493                                            + 4 * (ngnubuckets + maxchain), 4)),
11494                  SEEK_SET))
11495         {
11496           error (_("Unable to seek to start of dynamic information\n"));
11497           goto no_gnu_hash;
11498         }
11499
11500       do
11501         {
11502           if (fread (nb, 4, 1, filedata->handle) != 1)
11503             {
11504               error (_("Failed to determine last chain length\n"));
11505               goto no_gnu_hash;
11506             }
11507
11508           if (maxchain + 1 == 0)
11509             goto no_gnu_hash;
11510
11511           ++maxchain;
11512         }
11513       while ((byte_get (nb, 4) & 1) == 0);
11514
11515       if (fseek (filedata->handle,
11516                  (archive_file_offset
11517                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11518                  SEEK_SET))
11519         {
11520           error (_("Unable to seek to start of dynamic information\n"));
11521           goto no_gnu_hash;
11522         }
11523
11524       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11525       ngnuchains = maxchain;
11526
11527     no_gnu_hash:
11528       if (gnuchains == NULL)
11529         {
11530           free (gnubuckets);
11531           gnubuckets = NULL;
11532           ngnubuckets = 0;
11533           if (do_using_dynamic)
11534             return FALSE;
11535         }
11536     }
11537
11538   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11539       && do_syms
11540       && do_using_dynamic
11541       && dynamic_strings != NULL
11542       && dynamic_symbols != NULL)
11543     {
11544       unsigned long hn;
11545
11546       if (dynamic_info[DT_HASH])
11547         {
11548           bfd_vma si;
11549           char *visited;
11550
11551           printf (_("\nSymbol table for image:\n"));
11552           if (is_32bit_elf)
11553             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11554           else
11555             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11556
11557           visited = xcmalloc (nchains, 1);
11558           memset (visited, 0, nchains);
11559           for (hn = 0; hn < nbuckets; hn++)
11560             {
11561               for (si = buckets[hn]; si > 0; si = chains[si])
11562                 {
11563                   print_dynamic_symbol (filedata, si, hn);
11564                   if (si >= nchains || visited[si])
11565                     {
11566                       error (_("histogram chain is corrupt\n"));
11567                       break;
11568                     }
11569                   visited[si] = 1;
11570                 }
11571             }
11572           free (visited);
11573         }
11574
11575       if (dynamic_info_DT_GNU_HASH)
11576         {
11577           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11578           if (is_32bit_elf)
11579             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11580           else
11581             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11582
11583           for (hn = 0; hn < ngnubuckets; ++hn)
11584             if (gnubuckets[hn] != 0)
11585               {
11586                 bfd_vma si = gnubuckets[hn];
11587                 bfd_vma off = si - gnusymidx;
11588
11589                 do
11590                   {
11591                     print_dynamic_symbol (filedata, si, hn);
11592                     si++;
11593                   }
11594                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11595               }
11596         }
11597     }
11598   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11599            && filedata->section_headers != NULL)
11600     {
11601       unsigned int i;
11602
11603       for (i = 0, section = filedata->section_headers;
11604            i < filedata->file_header.e_shnum;
11605            i++, section++)
11606         {
11607           unsigned int si;
11608           char * strtab = NULL;
11609           unsigned long int strtab_size = 0;
11610           Elf_Internal_Sym * symtab;
11611           Elf_Internal_Sym * psym;
11612           unsigned long num_syms;
11613
11614           if ((section->sh_type != SHT_SYMTAB
11615                && section->sh_type != SHT_DYNSYM)
11616               || (!do_syms
11617                   && section->sh_type == SHT_SYMTAB))
11618             continue;
11619
11620           if (section->sh_entsize == 0)
11621             {
11622               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11623                       printable_section_name (filedata, section));
11624               continue;
11625             }
11626
11627           num_syms = section->sh_size / section->sh_entsize;
11628           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11629                             "\nSymbol table '%s' contains %lu entries:\n",
11630                             num_syms),
11631                   printable_section_name (filedata, section),
11632                   num_syms);
11633
11634           if (is_32bit_elf)
11635             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11636           else
11637             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11638
11639           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11640           if (symtab == NULL)
11641             continue;
11642
11643           if (section->sh_link == filedata->file_header.e_shstrndx)
11644             {
11645               strtab = filedata->string_table;
11646               strtab_size = filedata->string_table_length;
11647             }
11648           else if (section->sh_link < filedata->file_header.e_shnum)
11649             {
11650               Elf_Internal_Shdr * string_sec;
11651
11652               string_sec = filedata->section_headers + section->sh_link;
11653
11654               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11655                                           1, string_sec->sh_size,
11656                                           _("string table"));
11657               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11658             }
11659
11660           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11661             {
11662               const char *version_string;
11663               enum versioned_symbol_info sym_info;
11664               unsigned short vna_other;
11665
11666               printf ("%6d: ", si);
11667               print_vma (psym->st_value, LONG_HEX);
11668               putchar (' ');
11669               print_vma (psym->st_size, DEC_5);
11670               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11671               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11672               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11673                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11674               else
11675                 {
11676                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11677
11678                   printf (" %-7s", get_symbol_visibility (vis));
11679                   /* Check to see if any other bits in the st_other field are set.
11680                      Note - displaying this information disrupts the layout of the
11681                      table being generated, but for the moment this case is very rare.  */
11682                   if (psym->st_other ^ vis)
11683                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11684                 }
11685               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11686               print_symbol (25, psym->st_name < strtab_size
11687                             ? strtab + psym->st_name : _("<corrupt>"));
11688
11689               version_string
11690                 = get_symbol_version_string (filedata,
11691                                              section->sh_type == SHT_DYNSYM,
11692                                              strtab, strtab_size, si,
11693                                              psym, &sym_info, &vna_other);
11694               if (version_string)
11695                 {
11696                   if (sym_info == symbol_undefined)
11697                     printf ("@%s (%d)", version_string, vna_other);
11698                   else
11699                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11700                             version_string);
11701                 }
11702
11703               putchar ('\n');
11704
11705               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11706                   && si >= section->sh_info
11707                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11708                   && filedata->file_header.e_machine != EM_MIPS
11709                   /* Solaris binaries have been found to violate this requirement as
11710                      well.  Not sure if this is a bug or an ABI requirement.  */
11711                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11712                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11713                       si, printable_section_name (filedata, section), section->sh_info);
11714             }
11715
11716           free (symtab);
11717           if (strtab != filedata->string_table)
11718             free (strtab);
11719         }
11720     }
11721   else if (do_syms)
11722     printf
11723       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11724
11725   if (do_histogram && buckets != NULL)
11726     {
11727       unsigned long * lengths;
11728       unsigned long * counts;
11729       unsigned long hn;
11730       bfd_vma si;
11731       unsigned long maxlength = 0;
11732       unsigned long nzero_counts = 0;
11733       unsigned long nsyms = 0;
11734       char *visited;
11735
11736       printf (ngettext ("\nHistogram for bucket list length "
11737                         "(total of %lu bucket):\n",
11738                         "\nHistogram for bucket list length "
11739                         "(total of %lu buckets):\n",
11740                         (unsigned long) nbuckets),
11741               (unsigned long) nbuckets);
11742
11743       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11744       if (lengths == NULL)
11745         {
11746           error (_("Out of memory allocating space for histogram buckets\n"));
11747           return FALSE;
11748         }
11749       visited = xcmalloc (nchains, 1);
11750       memset (visited, 0, nchains);
11751
11752       printf (_(" Length  Number     %% of total  Coverage\n"));
11753       for (hn = 0; hn < nbuckets; ++hn)
11754         {
11755           for (si = buckets[hn]; si > 0; si = chains[si])
11756             {
11757               ++nsyms;
11758               if (maxlength < ++lengths[hn])
11759                 ++maxlength;
11760               if (si >= nchains || visited[si])
11761                 {
11762                   error (_("histogram chain is corrupt\n"));
11763                   break;
11764                 }
11765               visited[si] = 1;
11766             }
11767         }
11768       free (visited);
11769
11770       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11771       if (counts == NULL)
11772         {
11773           free (lengths);
11774           error (_("Out of memory allocating space for histogram counts\n"));
11775           return FALSE;
11776         }
11777
11778       for (hn = 0; hn < nbuckets; ++hn)
11779         ++counts[lengths[hn]];
11780
11781       if (nbuckets > 0)
11782         {
11783           unsigned long i;
11784           printf ("      0  %-10lu (%5.1f%%)\n",
11785                   counts[0], (counts[0] * 100.0) / nbuckets);
11786           for (i = 1; i <= maxlength; ++i)
11787             {
11788               nzero_counts += counts[i] * i;
11789               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11790                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11791                       (nzero_counts * 100.0) / nsyms);
11792             }
11793         }
11794
11795       free (counts);
11796       free (lengths);
11797     }
11798
11799   if (buckets != NULL)
11800     {
11801       free (buckets);
11802       free (chains);
11803     }
11804
11805   if (do_histogram && gnubuckets != NULL)
11806     {
11807       unsigned long * lengths;
11808       unsigned long * counts;
11809       unsigned long hn;
11810       unsigned long maxlength = 0;
11811       unsigned long nzero_counts = 0;
11812       unsigned long nsyms = 0;
11813
11814       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11815                         "(total of %lu bucket):\n",
11816                         "\nHistogram for `.gnu.hash' bucket list length "
11817                         "(total of %lu buckets):\n",
11818                         (unsigned long) ngnubuckets),
11819               (unsigned long) ngnubuckets);
11820
11821       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11822       if (lengths == NULL)
11823         {
11824           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11825           return FALSE;
11826         }
11827
11828       printf (_(" Length  Number     %% of total  Coverage\n"));
11829
11830       for (hn = 0; hn < ngnubuckets; ++hn)
11831         if (gnubuckets[hn] != 0)
11832           {
11833             bfd_vma off, length = 1;
11834
11835             for (off = gnubuckets[hn] - gnusymidx;
11836                  /* PR 17531 file: 010-77222-0.004.  */
11837                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11838                  ++off)
11839               ++length;
11840             lengths[hn] = length;
11841             if (length > maxlength)
11842               maxlength = length;
11843             nsyms += length;
11844           }
11845
11846       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11847       if (counts == NULL)
11848         {
11849           free (lengths);
11850           error (_("Out of memory allocating space for gnu histogram counts\n"));
11851           return FALSE;
11852         }
11853
11854       for (hn = 0; hn < ngnubuckets; ++hn)
11855         ++counts[lengths[hn]];
11856
11857       if (ngnubuckets > 0)
11858         {
11859           unsigned long j;
11860           printf ("      0  %-10lu (%5.1f%%)\n",
11861                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11862           for (j = 1; j <= maxlength; ++j)
11863             {
11864               nzero_counts += counts[j] * j;
11865               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11866                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11867                       (nzero_counts * 100.0) / nsyms);
11868             }
11869         }
11870
11871       free (counts);
11872       free (lengths);
11873       free (gnubuckets);
11874       free (gnuchains);
11875     }
11876
11877   return TRUE;
11878 }
11879
11880 static bfd_boolean
11881 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11882 {
11883   unsigned int i;
11884
11885   if (dynamic_syminfo == NULL
11886       || !do_dynamic)
11887     /* No syminfo, this is ok.  */
11888     return TRUE;
11889
11890   /* There better should be a dynamic symbol section.  */
11891   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11892     return FALSE;
11893
11894   if (dynamic_addr)
11895     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11896                       "contains %d entry:\n",
11897                       "\nDynamic info segment at offset 0x%lx "
11898                       "contains %d entries:\n",
11899                       dynamic_syminfo_nent),
11900             dynamic_syminfo_offset, dynamic_syminfo_nent);
11901
11902   printf (_(" Num: Name                           BoundTo     Flags\n"));
11903   for (i = 0; i < dynamic_syminfo_nent; ++i)
11904     {
11905       unsigned short int flags = dynamic_syminfo[i].si_flags;
11906
11907       printf ("%4d: ", i);
11908       if (i >= num_dynamic_syms)
11909         printf (_("<corrupt index>"));
11910       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11911         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11912       else
11913         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11914       putchar (' ');
11915
11916       switch (dynamic_syminfo[i].si_boundto)
11917         {
11918         case SYMINFO_BT_SELF:
11919           fputs ("SELF       ", stdout);
11920           break;
11921         case SYMINFO_BT_PARENT:
11922           fputs ("PARENT     ", stdout);
11923           break;
11924         default:
11925           if (dynamic_syminfo[i].si_boundto > 0
11926               && dynamic_syminfo[i].si_boundto < dynamic_nent
11927               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11928             {
11929               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11930               putchar (' ' );
11931             }
11932           else
11933             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11934           break;
11935         }
11936
11937       if (flags & SYMINFO_FLG_DIRECT)
11938         printf (" DIRECT");
11939       if (flags & SYMINFO_FLG_PASSTHRU)
11940         printf (" PASSTHRU");
11941       if (flags & SYMINFO_FLG_COPY)
11942         printf (" COPY");
11943       if (flags & SYMINFO_FLG_LAZYLOAD)
11944         printf (" LAZYLOAD");
11945
11946       puts ("");
11947     }
11948
11949   return TRUE;
11950 }
11951
11952 #define IN_RANGE(START,END,ADDR,OFF)            \
11953   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11954
11955 /* Check to see if the given reloc needs to be handled in a target specific
11956    manner.  If so then process the reloc and return TRUE otherwise return
11957    FALSE.
11958
11959    If called with reloc == NULL, then this is a signal that reloc processing
11960    for the current section has finished, and any saved state should be
11961    discarded.  */
11962
11963 static bfd_boolean
11964 target_specific_reloc_handling (Filedata *           filedata,
11965                                 Elf_Internal_Rela *  reloc,
11966                                 unsigned char *      start,
11967                                 unsigned char *      end,
11968                                 Elf_Internal_Sym *   symtab,
11969                                 unsigned long        num_syms)
11970 {
11971   unsigned int reloc_type = 0;
11972   unsigned long sym_index = 0;
11973
11974   if (reloc)
11975     {
11976       reloc_type = get_reloc_type (filedata, reloc->r_info);
11977       sym_index = get_reloc_symindex (reloc->r_info);
11978     }
11979
11980   switch (filedata->file_header.e_machine)
11981     {
11982     case EM_MSP430:
11983     case EM_MSP430_OLD:
11984       {
11985         static Elf_Internal_Sym * saved_sym = NULL;
11986
11987         if (reloc == NULL)
11988           {
11989             saved_sym = NULL;
11990             return TRUE;
11991           }
11992
11993         switch (reloc_type)
11994           {
11995           case 10: /* R_MSP430_SYM_DIFF */
11996             if (uses_msp430x_relocs (filedata))
11997               break;
11998             /* Fall through.  */
11999           case 21: /* R_MSP430X_SYM_DIFF */
12000             /* PR 21139.  */
12001             if (sym_index >= num_syms)
12002               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12003                      sym_index);
12004             else
12005               saved_sym = symtab + sym_index;
12006             return TRUE;
12007
12008           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12009           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12010             goto handle_sym_diff;
12011
12012           case 5: /* R_MSP430_16_BYTE */
12013           case 9: /* R_MSP430_8 */
12014             if (uses_msp430x_relocs (filedata))
12015               break;
12016             goto handle_sym_diff;
12017
12018           case 2: /* R_MSP430_ABS16 */
12019           case 15: /* R_MSP430X_ABS16 */
12020             if (! uses_msp430x_relocs (filedata))
12021               break;
12022             goto handle_sym_diff;
12023
12024           handle_sym_diff:
12025             if (saved_sym != NULL)
12026               {
12027                 int reloc_size = reloc_type == 1 ? 4 : 2;
12028                 bfd_vma value;
12029
12030                 if (sym_index >= num_syms)
12031                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12032                          sym_index);
12033                 else
12034                   {
12035                     value = reloc->r_addend + (symtab[sym_index].st_value
12036                                                - saved_sym->st_value);
12037
12038                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12039                       byte_put (start + reloc->r_offset, value, reloc_size);
12040                     else
12041                       /* PR 21137 */
12042                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12043                              (long) reloc->r_offset);
12044                   }
12045
12046                 saved_sym = NULL;
12047                 return TRUE;
12048               }
12049             break;
12050
12051           default:
12052             if (saved_sym != NULL)
12053               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12054             break;
12055           }
12056         break;
12057       }
12058
12059     case EM_MN10300:
12060     case EM_CYGNUS_MN10300:
12061       {
12062         static Elf_Internal_Sym * saved_sym = NULL;
12063
12064         if (reloc == NULL)
12065           {
12066             saved_sym = NULL;
12067             return TRUE;
12068           }
12069
12070         switch (reloc_type)
12071           {
12072           case 34: /* R_MN10300_ALIGN */
12073             return TRUE;
12074           case 33: /* R_MN10300_SYM_DIFF */
12075             if (sym_index >= num_syms)
12076               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12077                      sym_index);
12078             else
12079               saved_sym = symtab + sym_index;
12080             return TRUE;
12081
12082           case 1: /* R_MN10300_32 */
12083           case 2: /* R_MN10300_16 */
12084             if (saved_sym != NULL)
12085               {
12086                 int reloc_size = reloc_type == 1 ? 4 : 2;
12087                 bfd_vma value;
12088
12089                 if (sym_index >= num_syms)
12090                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12091                          sym_index);
12092                 else
12093                   {
12094                     value = reloc->r_addend + (symtab[sym_index].st_value
12095                                                - saved_sym->st_value);
12096
12097                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12098                       byte_put (start + reloc->r_offset, value, reloc_size);
12099                     else
12100                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12101                              (long) reloc->r_offset);
12102                   }
12103
12104                 saved_sym = NULL;
12105                 return TRUE;
12106               }
12107             break;
12108           default:
12109             if (saved_sym != NULL)
12110               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12111             break;
12112           }
12113         break;
12114       }
12115
12116     case EM_RL78:
12117       {
12118         static bfd_vma saved_sym1 = 0;
12119         static bfd_vma saved_sym2 = 0;
12120         static bfd_vma value;
12121
12122         if (reloc == NULL)
12123           {
12124             saved_sym1 = saved_sym2 = 0;
12125             return TRUE;
12126           }
12127
12128         switch (reloc_type)
12129           {
12130           case 0x80: /* R_RL78_SYM.  */
12131             saved_sym1 = saved_sym2;
12132             if (sym_index >= num_syms)
12133               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12134                      sym_index);
12135             else
12136               {
12137                 saved_sym2 = symtab[sym_index].st_value;
12138                 saved_sym2 += reloc->r_addend;
12139               }
12140             return TRUE;
12141
12142           case 0x83: /* R_RL78_OPsub.  */
12143             value = saved_sym1 - saved_sym2;
12144             saved_sym2 = saved_sym1 = 0;
12145             return TRUE;
12146             break;
12147
12148           case 0x41: /* R_RL78_ABS32.  */
12149             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12150               byte_put (start + reloc->r_offset, value, 4);
12151             else
12152               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12153                      (long) reloc->r_offset);
12154             value = 0;
12155             return TRUE;
12156
12157           case 0x43: /* R_RL78_ABS16.  */
12158             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12159               byte_put (start + reloc->r_offset, value, 2);
12160             else
12161               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12162                      (long) reloc->r_offset);
12163             value = 0;
12164             return TRUE;
12165
12166           default:
12167             break;
12168           }
12169         break;
12170       }
12171     }
12172
12173   return FALSE;
12174 }
12175
12176 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12177    DWARF debug sections.  This is a target specific test.  Note - we do not
12178    go through the whole including-target-headers-multiple-times route, (as
12179    we have already done with <elf/h8.h>) because this would become very
12180    messy and even then this function would have to contain target specific
12181    information (the names of the relocs instead of their numeric values).
12182    FIXME: This is not the correct way to solve this problem.  The proper way
12183    is to have target specific reloc sizing and typing functions created by
12184    the reloc-macros.h header, in the same way that it already creates the
12185    reloc naming functions.  */
12186
12187 static bfd_boolean
12188 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12189 {
12190   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12191   switch (filedata->file_header.e_machine)
12192     {
12193     case EM_386:
12194     case EM_IAMCU:
12195       return reloc_type == 1; /* R_386_32.  */
12196     case EM_68K:
12197       return reloc_type == 1; /* R_68K_32.  */
12198     case EM_860:
12199       return reloc_type == 1; /* R_860_32.  */
12200     case EM_960:
12201       return reloc_type == 2; /* R_960_32.  */
12202     case EM_AARCH64:
12203       return (reloc_type == 258
12204               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12205     case EM_ADAPTEVA_EPIPHANY:
12206       return reloc_type == 3;
12207     case EM_ALPHA:
12208       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12209     case EM_ARC:
12210       return reloc_type == 1; /* R_ARC_32.  */
12211     case EM_ARC_COMPACT:
12212     case EM_ARC_COMPACT2:
12213       return reloc_type == 4; /* R_ARC_32.  */
12214     case EM_ARM:
12215       return reloc_type == 2; /* R_ARM_ABS32 */
12216     case EM_AVR_OLD:
12217     case EM_AVR:
12218       return reloc_type == 1;
12219     case EM_BLACKFIN:
12220       return reloc_type == 0x12; /* R_byte4_data.  */
12221     case EM_CRIS:
12222       return reloc_type == 3; /* R_CRIS_32.  */
12223     case EM_CR16:
12224       return reloc_type == 3; /* R_CR16_NUM32.  */
12225     case EM_CRX:
12226       return reloc_type == 15; /* R_CRX_NUM32.  */
12227     case EM_CYGNUS_FRV:
12228       return reloc_type == 1;
12229     case EM_CYGNUS_D10V:
12230     case EM_D10V:
12231       return reloc_type == 6; /* R_D10V_32.  */
12232     case EM_CYGNUS_D30V:
12233     case EM_D30V:
12234       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12235     case EM_DLX:
12236       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12237     case EM_CYGNUS_FR30:
12238     case EM_FR30:
12239       return reloc_type == 3; /* R_FR30_32.  */
12240     case EM_FT32:
12241       return reloc_type == 1; /* R_FT32_32.  */
12242     case EM_H8S:
12243     case EM_H8_300:
12244     case EM_H8_300H:
12245       return reloc_type == 1; /* R_H8_DIR32.  */
12246     case EM_IA_64:
12247       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12248               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12249               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12250               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12251     case EM_IP2K_OLD:
12252     case EM_IP2K:
12253       return reloc_type == 2; /* R_IP2K_32.  */
12254     case EM_IQ2000:
12255       return reloc_type == 2; /* R_IQ2000_32.  */
12256     case EM_LATTICEMICO32:
12257       return reloc_type == 3; /* R_LM32_32.  */
12258     case EM_M32C_OLD:
12259     case EM_M32C:
12260       return reloc_type == 3; /* R_M32C_32.  */
12261     case EM_M32R:
12262       return reloc_type == 34; /* R_M32R_32_RELA.  */
12263     case EM_68HC11:
12264     case EM_68HC12:
12265       return reloc_type == 6; /* R_M68HC11_32.  */
12266     case EM_MCORE:
12267       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12268     case EM_CYGNUS_MEP:
12269       return reloc_type == 4; /* R_MEP_32.  */
12270     case EM_METAG:
12271       return reloc_type == 2; /* R_METAG_ADDR32.  */
12272     case EM_MICROBLAZE:
12273       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12274     case EM_MIPS:
12275       return reloc_type == 2; /* R_MIPS_32.  */
12276     case EM_MMIX:
12277       return reloc_type == 4; /* R_MMIX_32.  */
12278     case EM_CYGNUS_MN10200:
12279     case EM_MN10200:
12280       return reloc_type == 1; /* R_MN10200_32.  */
12281     case EM_CYGNUS_MN10300:
12282     case EM_MN10300:
12283       return reloc_type == 1; /* R_MN10300_32.  */
12284     case EM_MOXIE:
12285       return reloc_type == 1; /* R_MOXIE_32.  */
12286     case EM_MSP430_OLD:
12287     case EM_MSP430:
12288       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12289     case EM_MT:
12290       return reloc_type == 2; /* R_MT_32.  */
12291     case EM_NDS32:
12292       return reloc_type == 20; /* R_NDS32_RELA.  */
12293     case EM_ALTERA_NIOS2:
12294       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12295     case EM_NIOS32:
12296       return reloc_type == 1; /* R_NIOS_32.  */
12297     case EM_OR1K:
12298       return reloc_type == 1; /* R_OR1K_32.  */
12299     case EM_PARISC:
12300       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12301               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12302     case EM_PJ:
12303     case EM_PJ_OLD:
12304       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12305     case EM_PPC64:
12306       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12307     case EM_PPC:
12308       return reloc_type == 1; /* R_PPC_ADDR32.  */
12309     case EM_TI_PRU:
12310       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12311     case EM_RISCV:
12312       return reloc_type == 1; /* R_RISCV_32.  */
12313     case EM_RL78:
12314       return reloc_type == 1; /* R_RL78_DIR32.  */
12315     case EM_RX:
12316       return reloc_type == 1; /* R_RX_DIR32.  */
12317     case EM_S370:
12318       return reloc_type == 1; /* R_I370_ADDR31.  */
12319     case EM_S390_OLD:
12320     case EM_S390:
12321       return reloc_type == 4; /* R_S390_32.  */
12322     case EM_SCORE:
12323       return reloc_type == 8; /* R_SCORE_ABS32.  */
12324     case EM_SH:
12325       return reloc_type == 1; /* R_SH_DIR32.  */
12326     case EM_SPARC32PLUS:
12327     case EM_SPARCV9:
12328     case EM_SPARC:
12329       return reloc_type == 3 /* R_SPARC_32.  */
12330         || reloc_type == 23; /* R_SPARC_UA32.  */
12331     case EM_SPU:
12332       return reloc_type == 6; /* R_SPU_ADDR32 */
12333     case EM_TI_C6000:
12334       return reloc_type == 1; /* R_C6000_ABS32.  */
12335     case EM_TILEGX:
12336       return reloc_type == 2; /* R_TILEGX_32.  */
12337     case EM_TILEPRO:
12338       return reloc_type == 1; /* R_TILEPRO_32.  */
12339     case EM_CYGNUS_V850:
12340     case EM_V850:
12341       return reloc_type == 6; /* R_V850_ABS32.  */
12342     case EM_V800:
12343       return reloc_type == 0x33; /* R_V810_WORD.  */
12344     case EM_VAX:
12345       return reloc_type == 1; /* R_VAX_32.  */
12346     case EM_VISIUM:
12347       return reloc_type == 3;  /* R_VISIUM_32. */
12348     case EM_WEBASSEMBLY:
12349       return reloc_type == 1;  /* R_WASM32_32.  */
12350     case EM_X86_64:
12351     case EM_L1OM:
12352     case EM_K1OM:
12353       return reloc_type == 10; /* R_X86_64_32.  */
12354     case EM_XC16X:
12355     case EM_C166:
12356       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12357     case EM_XGATE:
12358       return reloc_type == 4; /* R_XGATE_32.  */
12359     case EM_XSTORMY16:
12360       return reloc_type == 1; /* R_XSTROMY16_32.  */
12361     case EM_XTENSA_OLD:
12362     case EM_XTENSA:
12363       return reloc_type == 1; /* R_XTENSA_32.  */
12364     default:
12365       {
12366         static unsigned int prev_warn = 0;
12367
12368         /* Avoid repeating the same warning multiple times.  */
12369         if (prev_warn != filedata->file_header.e_machine)
12370           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12371                  filedata->file_header.e_machine);
12372         prev_warn = filedata->file_header.e_machine;
12373         return FALSE;
12374       }
12375     }
12376 }
12377
12378 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12379    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12380
12381 static bfd_boolean
12382 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12383 {
12384   switch (filedata->file_header.e_machine)
12385   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12386     {
12387     case EM_386:
12388     case EM_IAMCU:
12389       return reloc_type == 2;  /* R_386_PC32.  */
12390     case EM_68K:
12391       return reloc_type == 4;  /* R_68K_PC32.  */
12392     case EM_AARCH64:
12393       return reloc_type == 261; /* R_AARCH64_PREL32 */
12394     case EM_ADAPTEVA_EPIPHANY:
12395       return reloc_type == 6;
12396     case EM_ALPHA:
12397       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12398     case EM_ARC_COMPACT:
12399     case EM_ARC_COMPACT2:
12400       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12401     case EM_ARM:
12402       return reloc_type == 3;  /* R_ARM_REL32 */
12403     case EM_AVR_OLD:
12404     case EM_AVR:
12405       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12406     case EM_MICROBLAZE:
12407       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12408     case EM_OR1K:
12409       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12410     case EM_PARISC:
12411       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12412     case EM_PPC:
12413       return reloc_type == 26; /* R_PPC_REL32.  */
12414     case EM_PPC64:
12415       return reloc_type == 26; /* R_PPC64_REL32.  */
12416     case EM_S390_OLD:
12417     case EM_S390:
12418       return reloc_type == 5;  /* R_390_PC32.  */
12419     case EM_SH:
12420       return reloc_type == 2;  /* R_SH_REL32.  */
12421     case EM_SPARC32PLUS:
12422     case EM_SPARCV9:
12423     case EM_SPARC:
12424       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12425     case EM_SPU:
12426       return reloc_type == 13; /* R_SPU_REL32.  */
12427     case EM_TILEGX:
12428       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12429     case EM_TILEPRO:
12430       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12431     case EM_VISIUM:
12432       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12433     case EM_X86_64:
12434     case EM_L1OM:
12435     case EM_K1OM:
12436       return reloc_type == 2;  /* R_X86_64_PC32.  */
12437     case EM_XTENSA_OLD:
12438     case EM_XTENSA:
12439       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12440     default:
12441       /* Do not abort or issue an error message here.  Not all targets use
12442          pc-relative 32-bit relocs in their DWARF debug information and we
12443          have already tested for target coverage in is_32bit_abs_reloc.  A
12444          more helpful warning message will be generated by apply_relocations
12445          anyway, so just return.  */
12446       return FALSE;
12447     }
12448 }
12449
12450 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12451    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12452
12453 static bfd_boolean
12454 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12455 {
12456   switch (filedata->file_header.e_machine)
12457     {
12458     case EM_AARCH64:
12459       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12460     case EM_ALPHA:
12461       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12462     case EM_IA_64:
12463       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12464               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12465     case EM_PARISC:
12466       return reloc_type == 80; /* R_PARISC_DIR64.  */
12467     case EM_PPC64:
12468       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12469     case EM_RISCV:
12470       return reloc_type == 2; /* R_RISCV_64.  */
12471     case EM_SPARC32PLUS:
12472     case EM_SPARCV9:
12473     case EM_SPARC:
12474       return reloc_type == 32 /* R_SPARC_64.  */
12475         || reloc_type == 54; /* R_SPARC_UA64.  */
12476     case EM_X86_64:
12477     case EM_L1OM:
12478     case EM_K1OM:
12479       return reloc_type == 1; /* R_X86_64_64.  */
12480     case EM_S390_OLD:
12481     case EM_S390:
12482       return reloc_type == 22;  /* R_S390_64.  */
12483     case EM_TILEGX:
12484       return reloc_type == 1; /* R_TILEGX_64.  */
12485     case EM_MIPS:
12486       return reloc_type == 18;  /* R_MIPS_64.  */
12487     default:
12488       return FALSE;
12489     }
12490 }
12491
12492 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12493    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12494
12495 static bfd_boolean
12496 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12497 {
12498   switch (filedata->file_header.e_machine)
12499     {
12500     case EM_AARCH64:
12501       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12502     case EM_ALPHA:
12503       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12504     case EM_IA_64:
12505       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12506               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12507     case EM_PARISC:
12508       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12509     case EM_PPC64:
12510       return reloc_type == 44; /* R_PPC64_REL64.  */
12511     case EM_SPARC32PLUS:
12512     case EM_SPARCV9:
12513     case EM_SPARC:
12514       return reloc_type == 46; /* R_SPARC_DISP64.  */
12515     case EM_X86_64:
12516     case EM_L1OM:
12517     case EM_K1OM:
12518       return reloc_type == 24; /* R_X86_64_PC64.  */
12519     case EM_S390_OLD:
12520     case EM_S390:
12521       return reloc_type == 23;  /* R_S390_PC64.  */
12522     case EM_TILEGX:
12523       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12524     default:
12525       return FALSE;
12526     }
12527 }
12528
12529 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12530    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12531
12532 static bfd_boolean
12533 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12534 {
12535   switch (filedata->file_header.e_machine)
12536     {
12537     case EM_CYGNUS_MN10200:
12538     case EM_MN10200:
12539       return reloc_type == 4; /* R_MN10200_24.  */
12540     case EM_FT32:
12541       return reloc_type == 5; /* R_FT32_20.  */
12542     default:
12543       return FALSE;
12544     }
12545 }
12546
12547 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12548    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12549
12550 static bfd_boolean
12551 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12552 {
12553   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12554   switch (filedata->file_header.e_machine)
12555     {
12556     case EM_ARC:
12557     case EM_ARC_COMPACT:
12558     case EM_ARC_COMPACT2:
12559       return reloc_type == 2; /* R_ARC_16.  */
12560     case EM_ADAPTEVA_EPIPHANY:
12561       return reloc_type == 5;
12562     case EM_AVR_OLD:
12563     case EM_AVR:
12564       return reloc_type == 4; /* R_AVR_16.  */
12565     case EM_CYGNUS_D10V:
12566     case EM_D10V:
12567       return reloc_type == 3; /* R_D10V_16.  */
12568     case EM_FT32:
12569       return reloc_type == 2; /* R_FT32_16.  */
12570     case EM_H8S:
12571     case EM_H8_300:
12572     case EM_H8_300H:
12573       return reloc_type == R_H8_DIR16;
12574     case EM_IP2K_OLD:
12575     case EM_IP2K:
12576       return reloc_type == 1; /* R_IP2K_16.  */
12577     case EM_M32C_OLD:
12578     case EM_M32C:
12579       return reloc_type == 1; /* R_M32C_16 */
12580     case EM_CYGNUS_MN10200:
12581     case EM_MN10200:
12582       return reloc_type == 2; /* R_MN10200_16.  */
12583     case EM_CYGNUS_MN10300:
12584     case EM_MN10300:
12585       return reloc_type == 2; /* R_MN10300_16.  */
12586     case EM_MSP430:
12587       if (uses_msp430x_relocs (filedata))
12588         return reloc_type == 2; /* R_MSP430_ABS16.  */
12589       /* Fall through.  */
12590     case EM_MSP430_OLD:
12591       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12592     case EM_NDS32:
12593       return reloc_type == 19; /* R_NDS32_RELA.  */
12594     case EM_ALTERA_NIOS2:
12595       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12596     case EM_NIOS32:
12597       return reloc_type == 9; /* R_NIOS_16.  */
12598     case EM_OR1K:
12599       return reloc_type == 2; /* R_OR1K_16.  */
12600     case EM_TI_PRU:
12601       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12602     case EM_TI_C6000:
12603       return reloc_type == 2; /* R_C6000_ABS16.  */
12604     case EM_VISIUM:
12605       return reloc_type == 2; /* R_VISIUM_16. */
12606     case EM_XC16X:
12607     case EM_C166:
12608       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12609     case EM_XGATE:
12610       return reloc_type == 3; /* R_XGATE_16.  */
12611     default:
12612       return FALSE;
12613     }
12614 }
12615
12616 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12617    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12618
12619 static bfd_boolean
12620 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12621 {
12622   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12623   switch (filedata->file_header.e_machine)
12624     {
12625     case EM_RISCV:
12626       return reloc_type == 35; /* R_RISCV_ADD32.  */
12627     default:
12628       return FALSE;
12629     }
12630 }
12631
12632 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12633    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12634
12635 static bfd_boolean
12636 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12637 {
12638   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12639   switch (filedata->file_header.e_machine)
12640     {
12641     case EM_RISCV:
12642       return reloc_type == 39; /* R_RISCV_SUB32.  */
12643     default:
12644       return FALSE;
12645     }
12646 }
12647
12648 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12649    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12650
12651 static bfd_boolean
12652 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12653 {
12654   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12655   switch (filedata->file_header.e_machine)
12656     {
12657     case EM_RISCV:
12658       return reloc_type == 36; /* R_RISCV_ADD64.  */
12659     default:
12660       return FALSE;
12661     }
12662 }
12663
12664 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12665    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12666
12667 static bfd_boolean
12668 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12669 {
12670   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12671   switch (filedata->file_header.e_machine)
12672     {
12673     case EM_RISCV:
12674       return reloc_type == 40; /* R_RISCV_SUB64.  */
12675     default:
12676       return FALSE;
12677     }
12678 }
12679
12680 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12681    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12682
12683 static bfd_boolean
12684 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12685 {
12686   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12687   switch (filedata->file_header.e_machine)
12688     {
12689     case EM_RISCV:
12690       return reloc_type == 34; /* R_RISCV_ADD16.  */
12691     default:
12692       return FALSE;
12693     }
12694 }
12695
12696 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12697    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12698
12699 static bfd_boolean
12700 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12701 {
12702   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12703   switch (filedata->file_header.e_machine)
12704     {
12705     case EM_RISCV:
12706       return reloc_type == 38; /* R_RISCV_SUB16.  */
12707     default:
12708       return FALSE;
12709     }
12710 }
12711
12712 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12713    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12714
12715 static bfd_boolean
12716 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12717 {
12718   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12719   switch (filedata->file_header.e_machine)
12720     {
12721     case EM_RISCV:
12722       return reloc_type == 33; /* R_RISCV_ADD8.  */
12723     default:
12724       return FALSE;
12725     }
12726 }
12727
12728 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12729    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12730
12731 static bfd_boolean
12732 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12733 {
12734   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12735   switch (filedata->file_header.e_machine)
12736     {
12737     case EM_RISCV:
12738       return reloc_type == 37; /* R_RISCV_SUB8.  */
12739     default:
12740       return FALSE;
12741     }
12742 }
12743
12744 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12745    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12746
12747 static bfd_boolean
12748 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12749 {
12750   switch (filedata->file_header.e_machine)
12751     {
12752     case EM_386:     /* R_386_NONE.  */
12753     case EM_68K:     /* R_68K_NONE.  */
12754     case EM_ADAPTEVA_EPIPHANY:
12755     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12756     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12757     case EM_ARC:     /* R_ARC_NONE.  */
12758     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12759     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12760     case EM_ARM:     /* R_ARM_NONE.  */
12761     case EM_C166:    /* R_XC16X_NONE.  */
12762     case EM_CRIS:    /* R_CRIS_NONE.  */
12763     case EM_FT32:    /* R_FT32_NONE.  */
12764     case EM_IA_64:   /* R_IA64_NONE.  */
12765     case EM_K1OM:    /* R_X86_64_NONE.  */
12766     case EM_L1OM:    /* R_X86_64_NONE.  */
12767     case EM_M32R:    /* R_M32R_NONE.  */
12768     case EM_MIPS:    /* R_MIPS_NONE.  */
12769     case EM_MN10300: /* R_MN10300_NONE.  */
12770     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12771     case EM_NIOS32:  /* R_NIOS_NONE.  */
12772     case EM_OR1K:    /* R_OR1K_NONE. */
12773     case EM_PARISC:  /* R_PARISC_NONE.  */
12774     case EM_PPC64:   /* R_PPC64_NONE.  */
12775     case EM_PPC:     /* R_PPC_NONE.  */
12776     case EM_RISCV:   /* R_RISCV_NONE.  */
12777     case EM_S390:    /* R_390_NONE.  */
12778     case EM_S390_OLD:
12779     case EM_SH:      /* R_SH_NONE.  */
12780     case EM_SPARC32PLUS:
12781     case EM_SPARC:   /* R_SPARC_NONE.  */
12782     case EM_SPARCV9:
12783     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12784     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12785     case EM_TI_C6000:/* R_C6000_NONE.  */
12786     case EM_X86_64:  /* R_X86_64_NONE.  */
12787     case EM_XC16X:
12788     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12789       return reloc_type == 0;
12790
12791     case EM_AARCH64:
12792       return reloc_type == 0 || reloc_type == 256;
12793     case EM_AVR_OLD:
12794     case EM_AVR:
12795       return (reloc_type == 0 /* R_AVR_NONE.  */
12796               || reloc_type == 30 /* R_AVR_DIFF8.  */
12797               || reloc_type == 31 /* R_AVR_DIFF16.  */
12798               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12799     case EM_METAG:
12800       return reloc_type == 3; /* R_METAG_NONE.  */
12801     case EM_NDS32:
12802       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12803               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12804               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12805               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12806               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12807     case EM_TI_PRU:
12808       return (reloc_type == 0       /* R_PRU_NONE.  */
12809               || reloc_type == 65   /* R_PRU_DIFF8.  */
12810               || reloc_type == 66   /* R_PRU_DIFF16.  */
12811               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12812     case EM_XTENSA_OLD:
12813     case EM_XTENSA:
12814       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12815               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12816               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12817               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12818     }
12819   return FALSE;
12820 }
12821
12822 /* Returns TRUE if there is a relocation against
12823    section NAME at OFFSET bytes.  */
12824
12825 bfd_boolean
12826 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12827 {
12828   Elf_Internal_Rela * relocs;
12829   Elf_Internal_Rela * rp;
12830
12831   if (dsec == NULL || dsec->reloc_info == NULL)
12832     return FALSE;
12833
12834   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12835
12836   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12837     if (rp->r_offset == offset)
12838       return TRUE;
12839
12840    return FALSE;
12841 }
12842
12843 /* Apply relocations to a section.
12844    Returns TRUE upon success, FALSE otherwise.
12845    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12846    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12847    will be set to the number of relocs loaded.
12848
12849    Note: So far support has been added only for those relocations
12850    which can be found in debug sections. FIXME: Add support for
12851    more relocations ?  */
12852
12853 static bfd_boolean
12854 apply_relocations (Filedata *                 filedata,
12855                    const Elf_Internal_Shdr *  section,
12856                    unsigned char *            start,
12857                    bfd_size_type              size,
12858                    void **                    relocs_return,
12859                    unsigned long *            num_relocs_return)
12860 {
12861   Elf_Internal_Shdr * relsec;
12862   unsigned char * end = start + size;
12863   bfd_boolean res = TRUE;
12864
12865   if (relocs_return != NULL)
12866     {
12867       * (Elf_Internal_Rela **) relocs_return = NULL;
12868       * num_relocs_return = 0;
12869     }
12870
12871   if (filedata->file_header.e_type != ET_REL)
12872     /* No relocs to apply.  */
12873     return TRUE;
12874
12875   /* Find the reloc section associated with the section.  */
12876   for (relsec = filedata->section_headers;
12877        relsec < filedata->section_headers + filedata->file_header.e_shnum;
12878        ++relsec)
12879     {
12880       bfd_boolean is_rela;
12881       unsigned long num_relocs;
12882       Elf_Internal_Rela * relocs;
12883       Elf_Internal_Rela * rp;
12884       Elf_Internal_Shdr * symsec;
12885       Elf_Internal_Sym * symtab;
12886       unsigned long num_syms;
12887       Elf_Internal_Sym * sym;
12888
12889       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12890           || relsec->sh_info >= filedata->file_header.e_shnum
12891           || filedata->section_headers + relsec->sh_info != section
12892           || relsec->sh_size == 0
12893           || relsec->sh_link >= filedata->file_header.e_shnum)
12894         continue;
12895
12896       is_rela = relsec->sh_type == SHT_RELA;
12897
12898       if (is_rela)
12899         {
12900           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
12901                                   relsec->sh_size, & relocs, & num_relocs))
12902             return FALSE;
12903         }
12904       else
12905         {
12906           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
12907                                  relsec->sh_size, & relocs, & num_relocs))
12908             return FALSE;
12909         }
12910
12911       /* SH uses RELA but uses in place value instead of the addend field.  */
12912       if (filedata->file_header.e_machine == EM_SH)
12913         is_rela = FALSE;
12914
12915       symsec = filedata->section_headers + relsec->sh_link;
12916       if (symsec->sh_type != SHT_SYMTAB
12917           && symsec->sh_type != SHT_DYNSYM)
12918         return FALSE;
12919       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
12920
12921       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12922         {
12923           bfd_vma         addend;
12924           unsigned int    reloc_type;
12925           unsigned int    reloc_size;
12926           bfd_boolean     reloc_inplace = FALSE;
12927           bfd_boolean     reloc_subtract = FALSE;
12928           unsigned char * rloc;
12929           unsigned long   sym_index;
12930
12931           reloc_type = get_reloc_type (filedata, rp->r_info);
12932
12933           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
12934             continue;
12935           else if (is_none_reloc (filedata, reloc_type))
12936             continue;
12937           else if (is_32bit_abs_reloc (filedata, reloc_type)
12938                    || is_32bit_pcrel_reloc (filedata, reloc_type))
12939             reloc_size = 4;
12940           else if (is_64bit_abs_reloc (filedata, reloc_type)
12941                    || is_64bit_pcrel_reloc (filedata, reloc_type))
12942             reloc_size = 8;
12943           else if (is_24bit_abs_reloc (filedata, reloc_type))
12944             reloc_size = 3;
12945           else if (is_16bit_abs_reloc (filedata, reloc_type))
12946             reloc_size = 2;
12947           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
12948                                                                  reloc_type))
12949                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
12950             {
12951               reloc_size = 4;
12952               reloc_inplace = TRUE;
12953             }
12954           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
12955                                                                  reloc_type))
12956                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
12957             {
12958               reloc_size = 8;
12959               reloc_inplace = TRUE;
12960             }
12961           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
12962                                                                  reloc_type))
12963                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
12964             {
12965               reloc_size = 2;
12966               reloc_inplace = TRUE;
12967             }
12968           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
12969                                                                 reloc_type))
12970                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
12971             {
12972               reloc_size = 1;
12973               reloc_inplace = TRUE;
12974             }
12975           else
12976             {
12977               static unsigned int prev_reloc = 0;
12978
12979               if (reloc_type != prev_reloc)
12980                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12981                       reloc_type, printable_section_name (filedata, section));
12982               prev_reloc = reloc_type;
12983               res = FALSE;
12984               continue;
12985             }
12986
12987           rloc = start + rp->r_offset;
12988           if ((rloc + reloc_size) > end || (rloc < start))
12989             {
12990               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12991                     (unsigned long) rp->r_offset,
12992                     printable_section_name (filedata, section));
12993               res = FALSE;
12994               continue;
12995             }
12996
12997           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12998           if (sym_index >= num_syms)
12999             {
13000               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13001                     sym_index, printable_section_name (filedata, section));
13002               res = FALSE;
13003               continue;
13004             }
13005           sym = symtab + sym_index;
13006
13007           /* If the reloc has a symbol associated with it,
13008              make sure that it is of an appropriate type.
13009
13010              Relocations against symbols without type can happen.
13011              Gcc -feliminate-dwarf2-dups may generate symbols
13012              without type for debug info.
13013
13014              Icc generates relocations against function symbols
13015              instead of local labels.
13016
13017              Relocations against object symbols can happen, eg when
13018              referencing a global array.  For an example of this see
13019              the _clz.o binary in libgcc.a.  */
13020           if (sym != symtab
13021               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13022               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13023             {
13024               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13025                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13026                     printable_section_name (filedata, relsec),
13027                     (long int)(rp - relocs));
13028               res = FALSE;
13029               continue;
13030             }
13031
13032           addend = 0;
13033           if (is_rela)
13034             addend += rp->r_addend;
13035           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13036              partial_inplace.  */
13037           if (!is_rela
13038               || (filedata->file_header.e_machine == EM_XTENSA
13039                   && reloc_type == 1)
13040               || ((filedata->file_header.e_machine == EM_PJ
13041                    || filedata->file_header.e_machine == EM_PJ_OLD)
13042                   && reloc_type == 1)
13043               || ((filedata->file_header.e_machine == EM_D30V
13044                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13045                   && reloc_type == 12)
13046               || reloc_inplace)
13047             addend += byte_get (rloc, reloc_size);
13048
13049           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13050               || is_64bit_pcrel_reloc (filedata, reloc_type))
13051             {
13052               /* On HPPA, all pc-relative relocations are biased by 8.  */
13053               if (filedata->file_header.e_machine == EM_PARISC)
13054                 addend -= 8;
13055               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13056                         reloc_size);
13057             }
13058           else if (reloc_subtract)
13059             byte_put (rloc, addend - sym->st_value, reloc_size);
13060           else
13061             byte_put (rloc, addend + sym->st_value, reloc_size);
13062         }
13063
13064       free (symtab);
13065       /* Let the target specific reloc processing code know that
13066          we have finished with these relocs.  */
13067       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13068
13069       if (relocs_return)
13070         {
13071           * (Elf_Internal_Rela **) relocs_return = relocs;
13072           * num_relocs_return = num_relocs;
13073         }
13074       else
13075         free (relocs);
13076
13077       break;
13078     }
13079
13080   return res;
13081 }
13082
13083 #ifdef SUPPORT_DISASSEMBLY
13084 static bfd_boolean
13085 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13086 {
13087   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13088
13089   /* FIXME: XXX -- to be done --- XXX */
13090
13091   return TRUE;
13092 }
13093 #endif
13094
13095 /* Reads in the contents of SECTION from FILE, returning a pointer
13096    to a malloc'ed buffer or NULL if something went wrong.  */
13097
13098 static char *
13099 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13100 {
13101   bfd_size_type num_bytes = section->sh_size;
13102
13103   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13104     {
13105       printf (_("Section '%s' has no data to dump.\n"),
13106               printable_section_name (filedata, section));
13107       return NULL;
13108     }
13109
13110   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13111                              _("section contents"));
13112 }
13113
13114 /* Uncompresses a section that was compressed using zlib, in place.  */
13115
13116 static bfd_boolean
13117 uncompress_section_contents (unsigned char **   buffer,
13118                              dwarf_size_type    uncompressed_size,
13119                              dwarf_size_type *  size)
13120 {
13121   dwarf_size_type compressed_size = *size;
13122   unsigned char * compressed_buffer = *buffer;
13123   unsigned char * uncompressed_buffer;
13124   z_stream strm;
13125   int rc;
13126
13127   /* It is possible the section consists of several compressed
13128      buffers concatenated together, so we uncompress in a loop.  */
13129   /* PR 18313: The state field in the z_stream structure is supposed
13130      to be invisible to the user (ie us), but some compilers will
13131      still complain about it being used without initialisation.  So
13132      we first zero the entire z_stream structure and then set the fields
13133      that we need.  */
13134   memset (& strm, 0, sizeof strm);
13135   strm.avail_in = compressed_size;
13136   strm.next_in = (Bytef *) compressed_buffer;
13137   strm.avail_out = uncompressed_size;
13138   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13139
13140   rc = inflateInit (& strm);
13141   while (strm.avail_in > 0)
13142     {
13143       if (rc != Z_OK)
13144         goto fail;
13145       strm.next_out = ((Bytef *) uncompressed_buffer
13146                        + (uncompressed_size - strm.avail_out));
13147       rc = inflate (&strm, Z_FINISH);
13148       if (rc != Z_STREAM_END)
13149         goto fail;
13150       rc = inflateReset (& strm);
13151     }
13152   rc = inflateEnd (& strm);
13153   if (rc != Z_OK
13154       || strm.avail_out != 0)
13155     goto fail;
13156
13157   *buffer = uncompressed_buffer;
13158   *size = uncompressed_size;
13159   return TRUE;
13160
13161  fail:
13162   free (uncompressed_buffer);
13163   /* Indicate decompression failure.  */
13164   *buffer = NULL;
13165   return FALSE;
13166 }
13167
13168 static bfd_boolean
13169 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13170 {
13171   Elf_Internal_Shdr *  relsec;
13172   bfd_size_type        num_bytes;
13173   unsigned char *      data;
13174   unsigned char *      end;
13175   unsigned char *      real_start;
13176   unsigned char *      start;
13177   bfd_boolean          some_strings_shown;
13178
13179   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13180   if (start == NULL)
13181     /* PR 21820: Do not fail if the section was empty.  */
13182     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13183
13184   num_bytes = section->sh_size;
13185
13186   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13187
13188   if (decompress_dumps)
13189     {
13190       dwarf_size_type new_size = num_bytes;
13191       dwarf_size_type uncompressed_size = 0;
13192
13193       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13194         {
13195           Elf_Internal_Chdr chdr;
13196           unsigned int compression_header_size
13197             = get_compression_header (& chdr, (unsigned char *) start,
13198                                       num_bytes);
13199
13200           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13201             {
13202               warn (_("section '%s' has unsupported compress type: %d\n"),
13203                     printable_section_name (filedata, section), chdr.ch_type);
13204               return FALSE;
13205             }
13206           else if (chdr.ch_addralign != section->sh_addralign)
13207             {
13208               warn (_("compressed section '%s' is corrupted\n"),
13209                     printable_section_name (filedata, section));
13210               return FALSE;
13211             }
13212           uncompressed_size = chdr.ch_size;
13213           start += compression_header_size;
13214           new_size -= compression_header_size;
13215         }
13216       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13217         {
13218           /* Read the zlib header.  In this case, it should be "ZLIB"
13219              followed by the uncompressed section size, 8 bytes in
13220              big-endian order.  */
13221           uncompressed_size = start[4]; uncompressed_size <<= 8;
13222           uncompressed_size += start[5]; uncompressed_size <<= 8;
13223           uncompressed_size += start[6]; uncompressed_size <<= 8;
13224           uncompressed_size += start[7]; uncompressed_size <<= 8;
13225           uncompressed_size += start[8]; uncompressed_size <<= 8;
13226           uncompressed_size += start[9]; uncompressed_size <<= 8;
13227           uncompressed_size += start[10]; uncompressed_size <<= 8;
13228           uncompressed_size += start[11];
13229           start += 12;
13230           new_size -= 12;
13231         }
13232
13233       if (uncompressed_size)
13234         {
13235           if (uncompress_section_contents (& start,
13236                                            uncompressed_size, & new_size))
13237             num_bytes = new_size;
13238           else
13239             {
13240               error (_("Unable to decompress section %s\n"),
13241                      printable_section_name (filedata, section));
13242               return FALSE;
13243             }
13244         }
13245       else
13246         start = real_start;
13247     }
13248
13249   /* If the section being dumped has relocations against it the user might
13250      be expecting these relocations to have been applied.  Check for this
13251      case and issue a warning message in order to avoid confusion.
13252      FIXME: Maybe we ought to have an option that dumps a section with
13253      relocs applied ?  */
13254   for (relsec = filedata->section_headers;
13255        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13256        ++relsec)
13257     {
13258       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13259           || relsec->sh_info >= filedata->file_header.e_shnum
13260           || filedata->section_headers + relsec->sh_info != section
13261           || relsec->sh_size == 0
13262           || relsec->sh_link >= filedata->file_header.e_shnum)
13263         continue;
13264
13265       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13266       break;
13267     }
13268
13269   data = start;
13270   end  = start + num_bytes;
13271   some_strings_shown = FALSE;
13272
13273   while (data < end)
13274     {
13275       while (!ISPRINT (* data))
13276         if (++ data >= end)
13277           break;
13278
13279       if (data < end)
13280         {
13281           size_t maxlen = end - data;
13282
13283 #ifndef __MSVCRT__
13284           /* PR 11128: Use two separate invocations in order to work
13285              around bugs in the Solaris 8 implementation of printf.  */
13286           printf ("  [%6tx]  ", data - start);
13287 #else
13288           printf ("  [%6Ix]  ", (size_t) (data - start));
13289 #endif
13290           if (maxlen > 0)
13291             {
13292               print_symbol ((int) maxlen, (const char *) data);
13293               putchar ('\n');
13294               data += strnlen ((const char *) data, maxlen);
13295             }
13296           else
13297             {
13298               printf (_("<corrupt>\n"));
13299               data = end;
13300             }
13301           some_strings_shown = TRUE;
13302         }
13303     }
13304
13305   if (! some_strings_shown)
13306     printf (_("  No strings found in this section."));
13307
13308   free (real_start);
13309
13310   putchar ('\n');
13311   return TRUE;
13312 }
13313
13314 static bfd_boolean
13315 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13316                        Filedata *           filedata,
13317                        bfd_boolean          relocate)
13318 {
13319   Elf_Internal_Shdr * relsec;
13320   bfd_size_type       bytes;
13321   bfd_size_type       section_size;
13322   bfd_vma             addr;
13323   unsigned char *     data;
13324   unsigned char *     real_start;
13325   unsigned char *     start;
13326
13327   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13328   if (start == NULL)
13329     /* PR 21820: Do not fail if the section was empty.  */
13330     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13331
13332   section_size = section->sh_size;
13333
13334   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13335
13336   if (decompress_dumps)
13337     {
13338       dwarf_size_type new_size = section_size;
13339       dwarf_size_type uncompressed_size = 0;
13340
13341       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13342         {
13343           Elf_Internal_Chdr chdr;
13344           unsigned int compression_header_size
13345             = get_compression_header (& chdr, start, section_size);
13346
13347           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13348             {
13349               warn (_("section '%s' has unsupported compress type: %d\n"),
13350                     printable_section_name (filedata, section), chdr.ch_type);
13351               return FALSE;
13352             }
13353           else if (chdr.ch_addralign != section->sh_addralign)
13354             {
13355               warn (_("compressed section '%s' is corrupted\n"),
13356                     printable_section_name (filedata, section));
13357               return FALSE;
13358             }
13359           uncompressed_size = chdr.ch_size;
13360           start += compression_header_size;
13361           new_size -= compression_header_size;
13362         }
13363       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13364         {
13365           /* Read the zlib header.  In this case, it should be "ZLIB"
13366              followed by the uncompressed section size, 8 bytes in
13367              big-endian order.  */
13368           uncompressed_size = start[4]; uncompressed_size <<= 8;
13369           uncompressed_size += start[5]; uncompressed_size <<= 8;
13370           uncompressed_size += start[6]; uncompressed_size <<= 8;
13371           uncompressed_size += start[7]; uncompressed_size <<= 8;
13372           uncompressed_size += start[8]; uncompressed_size <<= 8;
13373           uncompressed_size += start[9]; uncompressed_size <<= 8;
13374           uncompressed_size += start[10]; uncompressed_size <<= 8;
13375           uncompressed_size += start[11];
13376           start += 12;
13377           new_size -= 12;
13378         }
13379
13380       if (uncompressed_size)
13381         {
13382           if (uncompress_section_contents (& start, uncompressed_size,
13383                                            & new_size))
13384             {
13385               section_size = new_size;
13386             }
13387           else
13388             {
13389               error (_("Unable to decompress section %s\n"),
13390                      printable_section_name (filedata, section));
13391               /* FIXME: Print the section anyway ?  */
13392               return FALSE;
13393             }
13394         }
13395       else
13396         start = real_start;
13397     }
13398
13399   if (relocate)
13400     {
13401       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13402         return FALSE;
13403     }
13404   else
13405     {
13406       /* If the section being dumped has relocations against it the user might
13407          be expecting these relocations to have been applied.  Check for this
13408          case and issue a warning message in order to avoid confusion.
13409          FIXME: Maybe we ought to have an option that dumps a section with
13410          relocs applied ?  */
13411       for (relsec = filedata->section_headers;
13412            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13413            ++relsec)
13414         {
13415           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13416               || relsec->sh_info >= filedata->file_header.e_shnum
13417               || filedata->section_headers + relsec->sh_info != section
13418               || relsec->sh_size == 0
13419               || relsec->sh_link >= filedata->file_header.e_shnum)
13420             continue;
13421
13422           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13423           break;
13424         }
13425     }
13426
13427   addr = section->sh_addr;
13428   bytes = section_size;
13429   data = start;
13430
13431   while (bytes)
13432     {
13433       int j;
13434       int k;
13435       int lbytes;
13436
13437       lbytes = (bytes > 16 ? 16 : bytes);
13438
13439       printf ("  0x%8.8lx ", (unsigned long) addr);
13440
13441       for (j = 0; j < 16; j++)
13442         {
13443           if (j < lbytes)
13444             printf ("%2.2x", data[j]);
13445           else
13446             printf ("  ");
13447
13448           if ((j & 3) == 3)
13449             printf (" ");
13450         }
13451
13452       for (j = 0; j < lbytes; j++)
13453         {
13454           k = data[j];
13455           if (k >= ' ' && k < 0x7f)
13456             printf ("%c", k);
13457           else
13458             printf (".");
13459         }
13460
13461       putchar ('\n');
13462
13463       data  += lbytes;
13464       addr  += lbytes;
13465       bytes -= lbytes;
13466     }
13467
13468   free (real_start);
13469
13470   putchar ('\n');
13471   return TRUE;
13472 }
13473
13474 static bfd_boolean
13475 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13476                              const Elf_Internal_Shdr *        sec,
13477                              void *                           data)
13478 {
13479   struct dwarf_section * section = &debug_displays [debug].section;
13480   char buf [64];
13481   Filedata * filedata = (Filedata *) data;
13482
13483   if (section->start != NULL)
13484     {
13485       /* If it is already loaded, do nothing.  */
13486       if (streq (section->filename, filedata->file_name))
13487         return TRUE;
13488       free (section->start);
13489     }
13490
13491   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13492   section->address = sec->sh_addr;
13493   section->user_data = NULL;
13494   section->filename = filedata->file_name;
13495   section->start = (unsigned char *) get_data (NULL, filedata,
13496                                                sec->sh_offset, 1,
13497                                                sec->sh_size, buf);
13498   if (section->start == NULL)
13499     section->size = 0;
13500   else
13501     {
13502       unsigned char *start = section->start;
13503       dwarf_size_type size = sec->sh_size;
13504       dwarf_size_type uncompressed_size = 0;
13505
13506       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13507         {
13508           Elf_Internal_Chdr chdr;
13509           unsigned int compression_header_size;
13510
13511           if (size < (is_32bit_elf
13512                       ? sizeof (Elf32_External_Chdr)
13513                       : sizeof (Elf64_External_Chdr)))
13514             {
13515               warn (_("compressed section %s is too small to contain a compression header"),
13516                     section->name);
13517               return FALSE;
13518             }
13519
13520           compression_header_size = get_compression_header (&chdr, start, size);
13521
13522           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13523             {
13524               warn (_("section '%s' has unsupported compress type: %d\n"),
13525                     section->name, chdr.ch_type);
13526               return FALSE;
13527             }
13528           else if (chdr.ch_addralign != sec->sh_addralign)
13529             {
13530               warn (_("compressed section '%s' is corrupted\n"),
13531                     section->name);
13532               return FALSE;
13533             }
13534           uncompressed_size = chdr.ch_size;
13535           start += compression_header_size;
13536           size -= compression_header_size;
13537         }
13538       else if (size > 12 && streq ((char *) start, "ZLIB"))
13539         {
13540           /* Read the zlib header.  In this case, it should be "ZLIB"
13541              followed by the uncompressed section size, 8 bytes in
13542              big-endian order.  */
13543           uncompressed_size = start[4]; uncompressed_size <<= 8;
13544           uncompressed_size += start[5]; uncompressed_size <<= 8;
13545           uncompressed_size += start[6]; uncompressed_size <<= 8;
13546           uncompressed_size += start[7]; uncompressed_size <<= 8;
13547           uncompressed_size += start[8]; uncompressed_size <<= 8;
13548           uncompressed_size += start[9]; uncompressed_size <<= 8;
13549           uncompressed_size += start[10]; uncompressed_size <<= 8;
13550           uncompressed_size += start[11];
13551           start += 12;
13552           size -= 12;
13553         }
13554
13555       if (uncompressed_size)
13556         {
13557           if (uncompress_section_contents (&start, uncompressed_size,
13558                                            &size))
13559             {
13560               /* Free the compressed buffer, update the section buffer
13561                  and the section size if uncompress is successful.  */
13562               free (section->start);
13563               section->start = start;
13564             }
13565           else
13566             {
13567               error (_("Unable to decompress section %s\n"),
13568                      printable_section_name (filedata, sec));
13569               return FALSE;
13570             }
13571         }
13572
13573       section->size = size;
13574     }
13575
13576   if (section->start == NULL)
13577     return FALSE;
13578
13579   if (debug_displays [debug].relocate)
13580     {
13581       if (! apply_relocations (filedata, sec, section->start, section->size,
13582                                & section->reloc_info, & section->num_relocs))
13583         return FALSE;
13584     }
13585   else
13586     {
13587       section->reloc_info = NULL;
13588       section->num_relocs = 0;
13589     }
13590
13591   return TRUE;
13592 }
13593
13594 /* If this is not NULL, load_debug_section will only look for sections
13595    within the list of sections given here.  */
13596 static unsigned int * section_subset = NULL;
13597
13598 bfd_boolean
13599 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13600 {
13601   struct dwarf_section * section = &debug_displays [debug].section;
13602   Elf_Internal_Shdr * sec;
13603   Filedata * filedata = (Filedata *) data;
13604
13605   /* Without section headers we cannot find any sections.  */
13606   if (filedata->section_headers == NULL)
13607     return FALSE;
13608
13609   if (filedata->string_table == NULL
13610       && filedata->file_header.e_shstrndx != SHN_UNDEF
13611       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13612     {
13613       Elf_Internal_Shdr * strs;
13614
13615       /* Read in the string table, so that we have section names to scan.  */
13616       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13617
13618       if (strs != NULL && strs->sh_size != 0)
13619         {
13620           filedata->string_table
13621             = (char *) get_data (NULL, filedata, strs->sh_offset,
13622                                  1, strs->sh_size, _("string table"));
13623
13624           filedata->string_table_length
13625             = filedata->string_table != NULL ? strs->sh_size : 0;
13626         }
13627     }
13628
13629   /* Locate the debug section.  */
13630   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13631   if (sec != NULL)
13632     section->name = section->uncompressed_name;
13633   else
13634     {
13635       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13636       if (sec != NULL)
13637         section->name = section->compressed_name;
13638     }
13639   if (sec == NULL)
13640     return FALSE;
13641
13642   /* If we're loading from a subset of sections, and we've loaded
13643      a section matching this name before, it's likely that it's a
13644      different one.  */
13645   if (section_subset != NULL)
13646     free_debug_section (debug);
13647
13648   return load_specific_debug_section (debug, sec, data);
13649 }
13650
13651 void
13652 free_debug_section (enum dwarf_section_display_enum debug)
13653 {
13654   struct dwarf_section * section = &debug_displays [debug].section;
13655
13656   if (section->start == NULL)
13657     return;
13658
13659   free ((char *) section->start);
13660   section->start = NULL;
13661   section->address = 0;
13662   section->size = 0;
13663 }
13664
13665 static bfd_boolean
13666 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13667 {
13668   char * name = SECTION_NAME (section);
13669   const char * print_name = printable_section_name (filedata, section);
13670   bfd_size_type length;
13671   bfd_boolean result = TRUE;
13672   int i;
13673
13674   length = section->sh_size;
13675   if (length == 0)
13676     {
13677       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13678       return TRUE;
13679     }
13680   if (section->sh_type == SHT_NOBITS)
13681     {
13682       /* There is no point in dumping the contents of a debugging section
13683          which has the NOBITS type - the bits in the file will be random.
13684          This can happen when a file containing a .eh_frame section is
13685          stripped with the --only-keep-debug command line option.  */
13686       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13687               print_name);
13688       return FALSE;
13689     }
13690
13691   if (const_strneq (name, ".gnu.linkonce.wi."))
13692     name = ".debug_info";
13693
13694   /* See if we know how to display the contents of this section.  */
13695   for (i = 0; i < max; i++)
13696     {
13697       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13698       struct dwarf_section_display *   display = debug_displays + i;
13699       struct dwarf_section *           sec = & display->section;
13700
13701       if (streq (sec->uncompressed_name, name)
13702           || (id == line && const_strneq (name, ".debug_line."))
13703           || streq (sec->compressed_name, name))
13704         {
13705           bfd_boolean secondary = (section != find_section (filedata, name));
13706
13707           if (secondary)
13708             free_debug_section (id);
13709
13710           if (i == line && const_strneq (name, ".debug_line."))
13711             sec->name = name;
13712           else if (streq (sec->uncompressed_name, name))
13713             sec->name = sec->uncompressed_name;
13714           else
13715             sec->name = sec->compressed_name;
13716
13717           if (load_specific_debug_section (id, section, filedata))
13718             {
13719               /* If this debug section is part of a CU/TU set in a .dwp file,
13720                  restrict load_debug_section to the sections in that set.  */
13721               section_subset = find_cu_tu_set (filedata, shndx);
13722
13723               result &= display->display (sec, filedata);
13724
13725               section_subset = NULL;
13726
13727               if (secondary || (id != info && id != abbrev))
13728                 free_debug_section (id);
13729             }
13730           break;
13731         }
13732     }
13733
13734   if (i == max)
13735     {
13736       printf (_("Unrecognized debug section: %s\n"), print_name);
13737       result = FALSE;
13738     }
13739
13740   return result;
13741 }
13742
13743 /* Set DUMP_SECTS for all sections where dumps were requested
13744    based on section name.  */
13745
13746 static void
13747 initialise_dumps_byname (Filedata * filedata)
13748 {
13749   struct dump_list_entry * cur;
13750
13751   for (cur = dump_sects_byname; cur; cur = cur->next)
13752     {
13753       unsigned int i;
13754       bfd_boolean any = FALSE;
13755
13756       for (i = 0; i < filedata->file_header.e_shnum; i++)
13757         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13758           {
13759             request_dump_bynumber (filedata, i, cur->type);
13760             any = TRUE;
13761           }
13762
13763       if (!any)
13764         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13765               cur->name);
13766     }
13767 }
13768
13769 static bfd_boolean
13770 process_section_contents (Filedata * filedata)
13771 {
13772   Elf_Internal_Shdr * section;
13773   unsigned int i;
13774   bfd_boolean res = TRUE;
13775
13776   if (! do_dump)
13777     return TRUE;
13778
13779   initialise_dumps_byname (filedata);
13780
13781   for (i = 0, section = filedata->section_headers;
13782        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13783        i++, section++)
13784     {
13785       dump_type dump = filedata->dump_sects[i];
13786
13787 #ifdef SUPPORT_DISASSEMBLY
13788       if (dump & DISASS_DUMP)
13789         {
13790           if (! disassemble_section (section, filedata))
13791             res = FALSE;
13792         }
13793 #endif
13794       if (dump & HEX_DUMP)
13795         {
13796           if (! dump_section_as_bytes (section, filedata, FALSE))
13797             res = FALSE;
13798         }
13799
13800       if (dump & RELOC_DUMP)
13801         {
13802           if (! dump_section_as_bytes (section, filedata, TRUE))
13803             res = FALSE;
13804         }
13805
13806       if (dump & STRING_DUMP)
13807         {
13808           if (! dump_section_as_strings (section, filedata))
13809             res = FALSE;
13810         }
13811
13812       if (dump & DEBUG_DUMP)
13813         {
13814           if (! display_debug_section (i, section, filedata))
13815             res = FALSE;
13816         }
13817     }
13818
13819   /* Check to see if the user requested a
13820      dump of a section that does not exist.  */
13821   while (i < filedata->num_dump_sects)
13822     {
13823       if (filedata->dump_sects[i])
13824         {
13825           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13826           res = FALSE;
13827         }
13828       i++;
13829     }
13830
13831   return res;
13832 }
13833
13834 static void
13835 process_mips_fpe_exception (int mask)
13836 {
13837   if (mask)
13838     {
13839       bfd_boolean first = TRUE;
13840
13841       if (mask & OEX_FPU_INEX)
13842         fputs ("INEX", stdout), first = FALSE;
13843       if (mask & OEX_FPU_UFLO)
13844         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13845       if (mask & OEX_FPU_OFLO)
13846         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13847       if (mask & OEX_FPU_DIV0)
13848         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13849       if (mask & OEX_FPU_INVAL)
13850         printf ("%sINVAL", first ? "" : "|");
13851     }
13852   else
13853     fputs ("0", stdout);
13854 }
13855
13856 /* Display's the value of TAG at location P.  If TAG is
13857    greater than 0 it is assumed to be an unknown tag, and
13858    a message is printed to this effect.  Otherwise it is
13859    assumed that a message has already been printed.
13860
13861    If the bottom bit of TAG is set it assumed to have a
13862    string value, otherwise it is assumed to have an integer
13863    value.
13864
13865    Returns an updated P pointing to the first unread byte
13866    beyond the end of TAG's value.
13867
13868    Reads at or beyond END will not be made.  */
13869
13870 static unsigned char *
13871 display_tag_value (signed int tag,
13872                    unsigned char * p,
13873                    const unsigned char * const end)
13874 {
13875   unsigned long val;
13876
13877   if (tag > 0)
13878     printf ("  Tag_unknown_%d: ", tag);
13879
13880   if (p >= end)
13881     {
13882       warn (_("<corrupt tag>\n"));
13883     }
13884   else if (tag & 1)
13885     {
13886       /* PR 17531 file: 027-19978-0.004.  */
13887       size_t maxlen = (end - p) - 1;
13888
13889       putchar ('"');
13890       if (maxlen > 0)
13891         {
13892           print_symbol ((int) maxlen, (const char *) p);
13893           p += strnlen ((char *) p, maxlen) + 1;
13894         }
13895       else
13896         {
13897           printf (_("<corrupt string tag>"));
13898           p = (unsigned char *) end;
13899         }
13900       printf ("\"\n");
13901     }
13902   else
13903     {
13904       unsigned int len;
13905
13906       val = read_uleb128 (p, &len, end);
13907       p += len;
13908       printf ("%ld (0x%lx)\n", val, val);
13909     }
13910
13911   assert (p <= end);
13912   return p;
13913 }
13914
13915 /* ARC ABI attributes section.  */
13916
13917 static unsigned char *
13918 display_arc_attribute (unsigned char * p,
13919                        const unsigned char * const end)
13920 {
13921   unsigned int tag;
13922   unsigned int len;
13923   unsigned int val;
13924
13925   tag = read_uleb128 (p, &len, end);
13926   p += len;
13927
13928   switch (tag)
13929     {
13930     case Tag_ARC_PCS_config:
13931       val = read_uleb128 (p, &len, end);
13932       p += len;
13933       printf ("  Tag_ARC_PCS_config: ");
13934       switch (val)
13935         {
13936         case 0:
13937           printf (_("Absent/Non standard\n"));
13938           break;
13939         case 1:
13940           printf (_("Bare metal/mwdt\n"));
13941           break;
13942         case 2:
13943           printf (_("Bare metal/newlib\n"));
13944           break;
13945         case 3:
13946           printf (_("Linux/uclibc\n"));
13947           break;
13948         case 4:
13949           printf (_("Linux/glibc\n"));
13950           break;
13951         default:
13952           printf (_("Unknown\n"));
13953           break;
13954         }
13955       break;
13956
13957     case Tag_ARC_CPU_base:
13958       val = read_uleb128 (p, &len, end);
13959       p += len;
13960       printf ("  Tag_ARC_CPU_base: ");
13961       switch (val)
13962         {
13963         default:
13964         case TAG_CPU_NONE:
13965           printf (_("Absent\n"));
13966           break;
13967         case TAG_CPU_ARC6xx:
13968           printf ("ARC6xx\n");
13969           break;
13970         case TAG_CPU_ARC7xx:
13971           printf ("ARC7xx\n");
13972           break;
13973         case TAG_CPU_ARCEM:
13974           printf ("ARCEM\n");
13975           break;
13976         case TAG_CPU_ARCHS:
13977           printf ("ARCHS\n");
13978           break;
13979         }
13980       break;
13981
13982     case Tag_ARC_CPU_variation:
13983       val = read_uleb128 (p, &len, end);
13984       p += len;
13985       printf ("  Tag_ARC_CPU_variation: ");
13986       switch (val)
13987         {
13988         default:
13989           if (val > 0 && val < 16)
13990               printf ("Core%d\n", val);
13991           else
13992               printf ("Unknown\n");
13993           break;
13994
13995         case 0:
13996           printf (_("Absent\n"));
13997           break;
13998         }
13999       break;
14000
14001     case Tag_ARC_CPU_name:
14002       printf ("  Tag_ARC_CPU_name: ");
14003       p = display_tag_value (-1, p, end);
14004       break;
14005
14006     case Tag_ARC_ABI_rf16:
14007       val = read_uleb128 (p, &len, end);
14008       p += len;
14009       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14010       break;
14011
14012     case Tag_ARC_ABI_osver:
14013       val = read_uleb128 (p, &len, end);
14014       p += len;
14015       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14016       break;
14017
14018     case Tag_ARC_ABI_pic:
14019     case Tag_ARC_ABI_sda:
14020       val = read_uleb128 (p, &len, end);
14021       p += len;
14022       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14023               : "  Tag_ARC_ABI_pic: ");
14024       switch (val)
14025         {
14026         case 0:
14027           printf (_("Absent\n"));
14028           break;
14029         case 1:
14030           printf ("MWDT\n");
14031           break;
14032         case 2:
14033           printf ("GNU\n");
14034           break;
14035         default:
14036           printf (_("Unknown\n"));
14037           break;
14038         }
14039       break;
14040
14041     case Tag_ARC_ABI_tls:
14042       val = read_uleb128 (p, &len, end);
14043       p += len;
14044       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14045       break;
14046
14047     case Tag_ARC_ABI_enumsize:
14048       val = read_uleb128 (p, &len, end);
14049       p += len;
14050       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14051               _("smallest"));
14052       break;
14053
14054     case Tag_ARC_ABI_exceptions:
14055       val = read_uleb128 (p, &len, end);
14056       p += len;
14057       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14058               : _("default"));
14059       break;
14060
14061     case Tag_ARC_ABI_double_size:
14062       val = read_uleb128 (p, &len, end);
14063       p += len;
14064       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14065       break;
14066
14067     case Tag_ARC_ISA_config:
14068       printf ("  Tag_ARC_ISA_config: ");
14069       p = display_tag_value (-1, p, end);
14070       break;
14071
14072     case Tag_ARC_ISA_apex:
14073       printf ("  Tag_ARC_ISA_apex: ");
14074       p = display_tag_value (-1, p, end);
14075       break;
14076
14077     case Tag_ARC_ISA_mpy_option:
14078       val = read_uleb128 (p, &len, end);
14079       p += len;
14080       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14081       break;
14082
14083     default:
14084       return display_tag_value (tag & 1, p, end);
14085     }
14086
14087   return p;
14088 }
14089
14090 /* ARM EABI attributes section.  */
14091 typedef struct
14092 {
14093   unsigned int tag;
14094   const char * name;
14095   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14096   unsigned int type;
14097   const char ** table;
14098 } arm_attr_public_tag;
14099
14100 static const char * arm_attr_tag_CPU_arch[] =
14101   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14102    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14103    "v8-M.mainline"};
14104 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14105 static const char * arm_attr_tag_THUMB_ISA_use[] =
14106   {"No", "Thumb-1", "Thumb-2", "Yes"};
14107 static const char * arm_attr_tag_FP_arch[] =
14108   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14109    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14110 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14111 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14112   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14113    "NEON for ARMv8.1"};
14114 static const char * arm_attr_tag_PCS_config[] =
14115   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14116    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14117 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14118   {"V6", "SB", "TLS", "Unused"};
14119 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14120   {"Absolute", "PC-relative", "SB-relative", "None"};
14121 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14122   {"Absolute", "PC-relative", "None"};
14123 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14124   {"None", "direct", "GOT-indirect"};
14125 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14126   {"None", "??? 1", "2", "??? 3", "4"};
14127 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14128 static const char * arm_attr_tag_ABI_FP_denormal[] =
14129   {"Unused", "Needed", "Sign only"};
14130 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14131 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14132 static const char * arm_attr_tag_ABI_FP_number_model[] =
14133   {"Unused", "Finite", "RTABI", "IEEE 754"};
14134 static const char * arm_attr_tag_ABI_enum_size[] =
14135   {"Unused", "small", "int", "forced to int"};
14136 static const char * arm_attr_tag_ABI_HardFP_use[] =
14137   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14138 static const char * arm_attr_tag_ABI_VFP_args[] =
14139   {"AAPCS", "VFP registers", "custom", "compatible"};
14140 static const char * arm_attr_tag_ABI_WMMX_args[] =
14141   {"AAPCS", "WMMX registers", "custom"};
14142 static const char * arm_attr_tag_ABI_optimization_goals[] =
14143   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14144     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14145 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14146   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14147     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14148 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14149 static const char * arm_attr_tag_FP_HP_extension[] =
14150   {"Not Allowed", "Allowed"};
14151 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14152   {"None", "IEEE 754", "Alternative Format"};
14153 static const char * arm_attr_tag_DSP_extension[] =
14154   {"Follow architecture", "Allowed"};
14155 static const char * arm_attr_tag_MPextension_use[] =
14156   {"Not Allowed", "Allowed"};
14157 static const char * arm_attr_tag_DIV_use[] =
14158   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14159     "Allowed in v7-A with integer division extension"};
14160 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14161 static const char * arm_attr_tag_Virtualization_use[] =
14162   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14163     "TrustZone and Virtualization Extensions"};
14164 static const char * arm_attr_tag_MPextension_use_legacy[] =
14165   {"Not Allowed", "Allowed"};
14166
14167 #define LOOKUP(id, name) \
14168   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14169 static arm_attr_public_tag arm_attr_public_tags[] =
14170 {
14171   {4, "CPU_raw_name", 1, NULL},
14172   {5, "CPU_name", 1, NULL},
14173   LOOKUP(6, CPU_arch),
14174   {7, "CPU_arch_profile", 0, NULL},
14175   LOOKUP(8, ARM_ISA_use),
14176   LOOKUP(9, THUMB_ISA_use),
14177   LOOKUP(10, FP_arch),
14178   LOOKUP(11, WMMX_arch),
14179   LOOKUP(12, Advanced_SIMD_arch),
14180   LOOKUP(13, PCS_config),
14181   LOOKUP(14, ABI_PCS_R9_use),
14182   LOOKUP(15, ABI_PCS_RW_data),
14183   LOOKUP(16, ABI_PCS_RO_data),
14184   LOOKUP(17, ABI_PCS_GOT_use),
14185   LOOKUP(18, ABI_PCS_wchar_t),
14186   LOOKUP(19, ABI_FP_rounding),
14187   LOOKUP(20, ABI_FP_denormal),
14188   LOOKUP(21, ABI_FP_exceptions),
14189   LOOKUP(22, ABI_FP_user_exceptions),
14190   LOOKUP(23, ABI_FP_number_model),
14191   {24, "ABI_align_needed", 0, NULL},
14192   {25, "ABI_align_preserved", 0, NULL},
14193   LOOKUP(26, ABI_enum_size),
14194   LOOKUP(27, ABI_HardFP_use),
14195   LOOKUP(28, ABI_VFP_args),
14196   LOOKUP(29, ABI_WMMX_args),
14197   LOOKUP(30, ABI_optimization_goals),
14198   LOOKUP(31, ABI_FP_optimization_goals),
14199   {32, "compatibility", 0, NULL},
14200   LOOKUP(34, CPU_unaligned_access),
14201   LOOKUP(36, FP_HP_extension),
14202   LOOKUP(38, ABI_FP_16bit_format),
14203   LOOKUP(42, MPextension_use),
14204   LOOKUP(44, DIV_use),
14205   LOOKUP(46, DSP_extension),
14206   {64, "nodefaults", 0, NULL},
14207   {65, "also_compatible_with", 0, NULL},
14208   LOOKUP(66, T2EE_use),
14209   {67, "conformance", 1, NULL},
14210   LOOKUP(68, Virtualization_use),
14211   LOOKUP(70, MPextension_use_legacy)
14212 };
14213 #undef LOOKUP
14214
14215 static unsigned char *
14216 display_arm_attribute (unsigned char * p,
14217                        const unsigned char * const end)
14218 {
14219   unsigned int tag;
14220   unsigned int len;
14221   unsigned int val;
14222   arm_attr_public_tag * attr;
14223   unsigned i;
14224   unsigned int type;
14225
14226   tag = read_uleb128 (p, &len, end);
14227   p += len;
14228   attr = NULL;
14229   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14230     {
14231       if (arm_attr_public_tags[i].tag == tag)
14232         {
14233           attr = &arm_attr_public_tags[i];
14234           break;
14235         }
14236     }
14237
14238   if (attr)
14239     {
14240       printf ("  Tag_%s: ", attr->name);
14241       switch (attr->type)
14242         {
14243         case 0:
14244           switch (tag)
14245             {
14246             case 7: /* Tag_CPU_arch_profile.  */
14247               val = read_uleb128 (p, &len, end);
14248               p += len;
14249               switch (val)
14250                 {
14251                 case 0: printf (_("None\n")); break;
14252                 case 'A': printf (_("Application\n")); break;
14253                 case 'R': printf (_("Realtime\n")); break;
14254                 case 'M': printf (_("Microcontroller\n")); break;
14255                 case 'S': printf (_("Application or Realtime\n")); break;
14256                 default: printf ("??? (%d)\n", val); break;
14257                 }
14258               break;
14259
14260             case 24: /* Tag_align_needed.  */
14261               val = read_uleb128 (p, &len, end);
14262               p += len;
14263               switch (val)
14264                 {
14265                 case 0: printf (_("None\n")); break;
14266                 case 1: printf (_("8-byte\n")); break;
14267                 case 2: printf (_("4-byte\n")); break;
14268                 case 3: printf ("??? 3\n"); break;
14269                 default:
14270                   if (val <= 12)
14271                     printf (_("8-byte and up to %d-byte extended\n"),
14272                             1 << val);
14273                   else
14274                     printf ("??? (%d)\n", val);
14275                   break;
14276                 }
14277               break;
14278
14279             case 25: /* Tag_align_preserved.  */
14280               val = read_uleb128 (p, &len, end);
14281               p += len;
14282               switch (val)
14283                 {
14284                 case 0: printf (_("None\n")); break;
14285                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14286                 case 2: printf (_("8-byte\n")); break;
14287                 case 3: printf ("??? 3\n"); break;
14288                 default:
14289                   if (val <= 12)
14290                     printf (_("8-byte and up to %d-byte extended\n"),
14291                             1 << val);
14292                   else
14293                     printf ("??? (%d)\n", val);
14294                   break;
14295                 }
14296               break;
14297
14298             case 32: /* Tag_compatibility.  */
14299               {
14300                 val = read_uleb128 (p, &len, end);
14301                 p += len;
14302                 printf (_("flag = %d, vendor = "), val);
14303                 if (p < end - 1)
14304                   {
14305                     size_t maxlen = (end - p) - 1;
14306
14307                     print_symbol ((int) maxlen, (const char *) p);
14308                     p += strnlen ((char *) p, maxlen) + 1;
14309                   }
14310                 else
14311                   {
14312                     printf (_("<corrupt>"));
14313                     p = (unsigned char *) end;
14314                   }
14315                 putchar ('\n');
14316               }
14317               break;
14318
14319             case 64: /* Tag_nodefaults.  */
14320               /* PR 17531: file: 001-505008-0.01.  */
14321               if (p < end)
14322                 p++;
14323               printf (_("True\n"));
14324               break;
14325
14326             case 65: /* Tag_also_compatible_with.  */
14327               val = read_uleb128 (p, &len, end);
14328               p += len;
14329               if (val == 6 /* Tag_CPU_arch.  */)
14330                 {
14331                   val = read_uleb128 (p, &len, end);
14332                   p += len;
14333                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14334                     printf ("??? (%d)\n", val);
14335                   else
14336                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14337                 }
14338               else
14339                 printf ("???\n");
14340               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14341                 ;
14342               break;
14343
14344             default:
14345               printf (_("<unknown: %d>\n"), tag);
14346               break;
14347             }
14348           return p;
14349
14350         case 1:
14351           return display_tag_value (-1, p, end);
14352         case 2:
14353           return display_tag_value (0, p, end);
14354
14355         default:
14356           assert (attr->type & 0x80);
14357           val = read_uleb128 (p, &len, end);
14358           p += len;
14359           type = attr->type & 0x7f;
14360           if (val >= type)
14361             printf ("??? (%d)\n", val);
14362           else
14363             printf ("%s\n", attr->table[val]);
14364           return p;
14365         }
14366     }
14367
14368   return display_tag_value (tag, p, end);
14369 }
14370
14371 static unsigned char *
14372 display_gnu_attribute (unsigned char * p,
14373                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14374                        const unsigned char * const end)
14375 {
14376   int tag;
14377   unsigned int len;
14378   unsigned int val;
14379
14380   tag = read_uleb128 (p, &len, end);
14381   p += len;
14382
14383   /* Tag_compatibility is the only generic GNU attribute defined at
14384      present.  */
14385   if (tag == 32)
14386     {
14387       val = read_uleb128 (p, &len, end);
14388       p += len;
14389
14390       printf (_("flag = %d, vendor = "), val);
14391       if (p == end)
14392         {
14393           printf (_("<corrupt>\n"));
14394           warn (_("corrupt vendor attribute\n"));
14395         }
14396       else
14397         {
14398           if (p < end - 1)
14399             {
14400               size_t maxlen = (end - p) - 1;
14401
14402               print_symbol ((int) maxlen, (const char *) p);
14403               p += strnlen ((char *) p, maxlen) + 1;
14404             }
14405           else
14406             {
14407               printf (_("<corrupt>"));
14408               p = (unsigned char *) end;
14409             }
14410           putchar ('\n');
14411         }
14412       return p;
14413     }
14414
14415   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14416     return display_proc_gnu_attribute (p, tag, end);
14417
14418   return display_tag_value (tag, p, end);
14419 }
14420
14421 static unsigned char *
14422 display_power_gnu_attribute (unsigned char * p,
14423                              unsigned int tag,
14424                              const unsigned char * const end)
14425 {
14426   unsigned int len;
14427   unsigned int val;
14428
14429   if (tag == Tag_GNU_Power_ABI_FP)
14430     {
14431       val = read_uleb128 (p, &len, end);
14432       p += len;
14433       printf ("  Tag_GNU_Power_ABI_FP: ");
14434       if (len == 0)
14435         {
14436           printf (_("<corrupt>\n"));
14437           return p;
14438         }
14439
14440       if (val > 15)
14441         printf ("(%#x), ", val);
14442
14443       switch (val & 3)
14444         {
14445         case 0:
14446           printf (_("unspecified hard/soft float, "));
14447           break;
14448         case 1:
14449           printf (_("hard float, "));
14450           break;
14451         case 2:
14452           printf (_("soft float, "));
14453           break;
14454         case 3:
14455           printf (_("single-precision hard float, "));
14456           break;
14457         }
14458
14459       switch (val & 0xC)
14460         {
14461         case 0:
14462           printf (_("unspecified long double\n"));
14463           break;
14464         case 4:
14465           printf (_("128-bit IBM long double\n"));
14466           break;
14467         case 8:
14468           printf (_("64-bit long double\n"));
14469           break;
14470         case 12:
14471           printf (_("128-bit IEEE long double\n"));
14472           break;
14473         }
14474       return p;
14475     }
14476
14477   if (tag == Tag_GNU_Power_ABI_Vector)
14478     {
14479       val = read_uleb128 (p, &len, end);
14480       p += len;
14481       printf ("  Tag_GNU_Power_ABI_Vector: ");
14482       if (len == 0)
14483         {
14484           printf (_("<corrupt>\n"));
14485           return p;
14486         }
14487
14488       if (val > 3)
14489         printf ("(%#x), ", val);
14490
14491       switch (val & 3)
14492         {
14493         case 0:
14494           printf (_("unspecified\n"));
14495           break;
14496         case 1:
14497           printf (_("generic\n"));
14498           break;
14499         case 2:
14500           printf ("AltiVec\n");
14501           break;
14502         case 3:
14503           printf ("SPE\n");
14504           break;
14505         }
14506       return p;
14507     }
14508
14509   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14510     {
14511       val = read_uleb128 (p, &len, end);
14512       p += len;
14513       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14514       if (len == 0)
14515         {
14516           printf (_("<corrupt>\n"));
14517           return p;
14518         }
14519
14520       if (val > 2)
14521         printf ("(%#x), ", val);
14522
14523       switch (val & 3)
14524         {
14525         case 0:
14526           printf (_("unspecified\n"));
14527           break;
14528         case 1:
14529           printf ("r3/r4\n");
14530           break;
14531         case 2:
14532           printf (_("memory\n"));
14533           break;
14534         case 3:
14535           printf ("???\n");
14536           break;
14537         }
14538       return p;
14539     }
14540
14541   return display_tag_value (tag & 1, p, end);
14542 }
14543
14544 static unsigned char *
14545 display_s390_gnu_attribute (unsigned char * p,
14546                             unsigned int tag,
14547                             const unsigned char * const end)
14548 {
14549   unsigned int len;
14550   int val;
14551
14552   if (tag == Tag_GNU_S390_ABI_Vector)
14553     {
14554       val = read_uleb128 (p, &len, end);
14555       p += len;
14556       printf ("  Tag_GNU_S390_ABI_Vector: ");
14557
14558       switch (val)
14559         {
14560         case 0:
14561           printf (_("any\n"));
14562           break;
14563         case 1:
14564           printf (_("software\n"));
14565           break;
14566         case 2:
14567           printf (_("hardware\n"));
14568           break;
14569         default:
14570           printf ("??? (%d)\n", val);
14571           break;
14572         }
14573       return p;
14574    }
14575
14576   return display_tag_value (tag & 1, p, end);
14577 }
14578
14579 static void
14580 display_sparc_hwcaps (unsigned int mask)
14581 {
14582   if (mask)
14583     {
14584       bfd_boolean first = TRUE;
14585
14586       if (mask & ELF_SPARC_HWCAP_MUL32)
14587         fputs ("mul32", stdout), first = FALSE;
14588       if (mask & ELF_SPARC_HWCAP_DIV32)
14589         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14590       if (mask & ELF_SPARC_HWCAP_FSMULD)
14591         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14592       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14593         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14594       if (mask & ELF_SPARC_HWCAP_POPC)
14595         printf ("%spopc", first ? "" : "|"), first = FALSE;
14596       if (mask & ELF_SPARC_HWCAP_VIS)
14597         printf ("%svis", first ? "" : "|"), first = FALSE;
14598       if (mask & ELF_SPARC_HWCAP_VIS2)
14599         printf ("%svis2", first ? "" : "|"), first = FALSE;
14600       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14601         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14602       if (mask & ELF_SPARC_HWCAP_FMAF)
14603         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14604       if (mask & ELF_SPARC_HWCAP_VIS3)
14605         printf ("%svis3", first ? "" : "|"), first = FALSE;
14606       if (mask & ELF_SPARC_HWCAP_HPC)
14607         printf ("%shpc", first ? "" : "|"), first = FALSE;
14608       if (mask & ELF_SPARC_HWCAP_RANDOM)
14609         printf ("%srandom", first ? "" : "|"), first = FALSE;
14610       if (mask & ELF_SPARC_HWCAP_TRANS)
14611         printf ("%strans", first ? "" : "|"), first = FALSE;
14612       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14613         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14614       if (mask & ELF_SPARC_HWCAP_IMA)
14615         printf ("%sima", first ? "" : "|"), first = FALSE;
14616       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14617         printf ("%scspare", first ? "" : "|"), first = FALSE;
14618     }
14619   else
14620     fputc ('0', stdout);
14621   fputc ('\n', stdout);
14622 }
14623
14624 static void
14625 display_sparc_hwcaps2 (unsigned int mask)
14626 {
14627   if (mask)
14628     {
14629       bfd_boolean first = TRUE;
14630
14631       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14632         fputs ("fjathplus", stdout), first = FALSE;
14633       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14634         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14635       if (mask & ELF_SPARC_HWCAP2_ADP)
14636         printf ("%sadp", first ? "" : "|"), first = FALSE;
14637       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14638         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14639       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14640         printf ("%smwait", first ? "" : "|"), first = FALSE;
14641       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14642         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14643       if (mask & ELF_SPARC_HWCAP2_XMONT)
14644         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14645       if (mask & ELF_SPARC_HWCAP2_NSEC)
14646         printf ("%snsec", first ? "" : "|"), first = FALSE;
14647       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14648         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14649       if (mask & ELF_SPARC_HWCAP2_FJDES)
14650         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14651       if (mask & ELF_SPARC_HWCAP2_FJAES)
14652         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14653     }
14654   else
14655     fputc ('0', stdout);
14656   fputc ('\n', stdout);
14657 }
14658
14659 static unsigned char *
14660 display_sparc_gnu_attribute (unsigned char * p,
14661                              unsigned int tag,
14662                              const unsigned char * const end)
14663 {
14664   unsigned int len;
14665   int val;
14666
14667   if (tag == Tag_GNU_Sparc_HWCAPS)
14668     {
14669       val = read_uleb128 (p, &len, end);
14670       p += len;
14671       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14672       display_sparc_hwcaps (val);
14673       return p;
14674     }
14675   if (tag == Tag_GNU_Sparc_HWCAPS2)
14676     {
14677       val = read_uleb128 (p, &len, end);
14678       p += len;
14679       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14680       display_sparc_hwcaps2 (val);
14681       return p;
14682     }
14683
14684   return display_tag_value (tag, p, end);
14685 }
14686
14687 static void
14688 print_mips_fp_abi_value (unsigned int val)
14689 {
14690   switch (val)
14691     {
14692     case Val_GNU_MIPS_ABI_FP_ANY:
14693       printf (_("Hard or soft float\n"));
14694       break;
14695     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14696       printf (_("Hard float (double precision)\n"));
14697       break;
14698     case Val_GNU_MIPS_ABI_FP_SINGLE:
14699       printf (_("Hard float (single precision)\n"));
14700       break;
14701     case Val_GNU_MIPS_ABI_FP_SOFT:
14702       printf (_("Soft float\n"));
14703       break;
14704     case Val_GNU_MIPS_ABI_FP_OLD_64:
14705       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14706       break;
14707     case Val_GNU_MIPS_ABI_FP_XX:
14708       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14709       break;
14710     case Val_GNU_MIPS_ABI_FP_64:
14711       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14712       break;
14713     case Val_GNU_MIPS_ABI_FP_64A:
14714       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14715       break;
14716     case Val_GNU_MIPS_ABI_FP_NAN2008:
14717       printf (_("NaN 2008 compatibility\n"));
14718       break;
14719     default:
14720       printf ("??? (%d)\n", val);
14721       break;
14722     }
14723 }
14724
14725 static unsigned char *
14726 display_mips_gnu_attribute (unsigned char * p,
14727                             unsigned int tag,
14728                             const unsigned char * const end)
14729 {
14730   if (tag == Tag_GNU_MIPS_ABI_FP)
14731     {
14732       unsigned int len;
14733       unsigned int val;
14734
14735       val = read_uleb128 (p, &len, end);
14736       p += len;
14737       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14738
14739       print_mips_fp_abi_value (val);
14740
14741       return p;
14742    }
14743
14744   if (tag == Tag_GNU_MIPS_ABI_MSA)
14745     {
14746       unsigned int len;
14747       unsigned int val;
14748
14749       val = read_uleb128 (p, &len, end);
14750       p += len;
14751       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14752
14753       switch (val)
14754         {
14755         case Val_GNU_MIPS_ABI_MSA_ANY:
14756           printf (_("Any MSA or not\n"));
14757           break;
14758         case Val_GNU_MIPS_ABI_MSA_128:
14759           printf (_("128-bit MSA\n"));
14760           break;
14761         default:
14762           printf ("??? (%d)\n", val);
14763           break;
14764         }
14765       return p;
14766     }
14767
14768   return display_tag_value (tag & 1, p, end);
14769 }
14770
14771 static unsigned char *
14772 display_tic6x_attribute (unsigned char * p,
14773                          const unsigned char * const end)
14774 {
14775   unsigned int tag;
14776   unsigned int len;
14777   int val;
14778
14779   tag = read_uleb128 (p, &len, end);
14780   p += len;
14781
14782   switch (tag)
14783     {
14784     case Tag_ISA:
14785       val = read_uleb128 (p, &len, end);
14786       p += len;
14787       printf ("  Tag_ISA: ");
14788
14789       switch (val)
14790         {
14791         case C6XABI_Tag_ISA_none:
14792           printf (_("None\n"));
14793           break;
14794         case C6XABI_Tag_ISA_C62X:
14795           printf ("C62x\n");
14796           break;
14797         case C6XABI_Tag_ISA_C67X:
14798           printf ("C67x\n");
14799           break;
14800         case C6XABI_Tag_ISA_C67XP:
14801           printf ("C67x+\n");
14802           break;
14803         case C6XABI_Tag_ISA_C64X:
14804           printf ("C64x\n");
14805           break;
14806         case C6XABI_Tag_ISA_C64XP:
14807           printf ("C64x+\n");
14808           break;
14809         case C6XABI_Tag_ISA_C674X:
14810           printf ("C674x\n");
14811           break;
14812         default:
14813           printf ("??? (%d)\n", val);
14814           break;
14815         }
14816       return p;
14817
14818     case Tag_ABI_wchar_t:
14819       val = read_uleb128 (p, &len, end);
14820       p += len;
14821       printf ("  Tag_ABI_wchar_t: ");
14822       switch (val)
14823         {
14824         case 0:
14825           printf (_("Not used\n"));
14826           break;
14827         case 1:
14828           printf (_("2 bytes\n"));
14829           break;
14830         case 2:
14831           printf (_("4 bytes\n"));
14832           break;
14833         default:
14834           printf ("??? (%d)\n", val);
14835           break;
14836         }
14837       return p;
14838
14839     case Tag_ABI_stack_align_needed:
14840       val = read_uleb128 (p, &len, end);
14841       p += len;
14842       printf ("  Tag_ABI_stack_align_needed: ");
14843       switch (val)
14844         {
14845         case 0:
14846           printf (_("8-byte\n"));
14847           break;
14848         case 1:
14849           printf (_("16-byte\n"));
14850           break;
14851         default:
14852           printf ("??? (%d)\n", val);
14853           break;
14854         }
14855       return p;
14856
14857     case Tag_ABI_stack_align_preserved:
14858       val = read_uleb128 (p, &len, end);
14859       p += len;
14860       printf ("  Tag_ABI_stack_align_preserved: ");
14861       switch (val)
14862         {
14863         case 0:
14864           printf (_("8-byte\n"));
14865           break;
14866         case 1:
14867           printf (_("16-byte\n"));
14868           break;
14869         default:
14870           printf ("??? (%d)\n", val);
14871           break;
14872         }
14873       return p;
14874
14875     case Tag_ABI_DSBT:
14876       val = read_uleb128 (p, &len, end);
14877       p += len;
14878       printf ("  Tag_ABI_DSBT: ");
14879       switch (val)
14880         {
14881         case 0:
14882           printf (_("DSBT addressing not used\n"));
14883           break;
14884         case 1:
14885           printf (_("DSBT addressing used\n"));
14886           break;
14887         default:
14888           printf ("??? (%d)\n", val);
14889           break;
14890         }
14891       return p;
14892
14893     case Tag_ABI_PID:
14894       val = read_uleb128 (p, &len, end);
14895       p += len;
14896       printf ("  Tag_ABI_PID: ");
14897       switch (val)
14898         {
14899         case 0:
14900           printf (_("Data addressing position-dependent\n"));
14901           break;
14902         case 1:
14903           printf (_("Data addressing position-independent, GOT near DP\n"));
14904           break;
14905         case 2:
14906           printf (_("Data addressing position-independent, GOT far from DP\n"));
14907           break;
14908         default:
14909           printf ("??? (%d)\n", val);
14910           break;
14911         }
14912       return p;
14913
14914     case Tag_ABI_PIC:
14915       val = read_uleb128 (p, &len, end);
14916       p += len;
14917       printf ("  Tag_ABI_PIC: ");
14918       switch (val)
14919         {
14920         case 0:
14921           printf (_("Code addressing position-dependent\n"));
14922           break;
14923         case 1:
14924           printf (_("Code addressing position-independent\n"));
14925           break;
14926         default:
14927           printf ("??? (%d)\n", val);
14928           break;
14929         }
14930       return p;
14931
14932     case Tag_ABI_array_object_alignment:
14933       val = read_uleb128 (p, &len, end);
14934       p += len;
14935       printf ("  Tag_ABI_array_object_alignment: ");
14936       switch (val)
14937         {
14938         case 0:
14939           printf (_("8-byte\n"));
14940           break;
14941         case 1:
14942           printf (_("4-byte\n"));
14943           break;
14944         case 2:
14945           printf (_("16-byte\n"));
14946           break;
14947         default:
14948           printf ("??? (%d)\n", val);
14949           break;
14950         }
14951       return p;
14952
14953     case Tag_ABI_array_object_align_expected:
14954       val = read_uleb128 (p, &len, end);
14955       p += len;
14956       printf ("  Tag_ABI_array_object_align_expected: ");
14957       switch (val)
14958         {
14959         case 0:
14960           printf (_("8-byte\n"));
14961           break;
14962         case 1:
14963           printf (_("4-byte\n"));
14964           break;
14965         case 2:
14966           printf (_("16-byte\n"));
14967           break;
14968         default:
14969           printf ("??? (%d)\n", val);
14970           break;
14971         }
14972       return p;
14973
14974     case Tag_ABI_compatibility:
14975       {
14976         val = read_uleb128 (p, &len, end);
14977         p += len;
14978         printf ("  Tag_ABI_compatibility: ");
14979         printf (_("flag = %d, vendor = "), val);
14980         if (p < end - 1)
14981           {
14982             size_t maxlen = (end - p) - 1;
14983
14984             print_symbol ((int) maxlen, (const char *) p);
14985             p += strnlen ((char *) p, maxlen) + 1;
14986           }
14987         else
14988           {
14989             printf (_("<corrupt>"));
14990             p = (unsigned char *) end;
14991           }
14992         putchar ('\n');
14993         return p;
14994       }
14995
14996     case Tag_ABI_conformance:
14997       {
14998         printf ("  Tag_ABI_conformance: \"");
14999         if (p < end - 1)
15000           {
15001             size_t maxlen = (end - p) - 1;
15002
15003             print_symbol ((int) maxlen, (const char *) p);
15004             p += strnlen ((char *) p, maxlen) + 1;
15005           }
15006         else
15007           {
15008             printf (_("<corrupt>"));
15009             p = (unsigned char *) end;
15010           }
15011         printf ("\"\n");
15012         return p;
15013       }
15014     }
15015
15016   return display_tag_value (tag, p, end);
15017 }
15018
15019 static void
15020 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15021 {
15022   unsigned long addr = 0;
15023   size_t bytes = end - p;
15024
15025   assert (end > p);
15026   while (bytes)
15027     {
15028       int j;
15029       int k;
15030       int lbytes = (bytes > 16 ? 16 : bytes);
15031
15032       printf ("  0x%8.8lx ", addr);
15033
15034       for (j = 0; j < 16; j++)
15035         {
15036           if (j < lbytes)
15037             printf ("%2.2x", p[j]);
15038           else
15039             printf ("  ");
15040
15041           if ((j & 3) == 3)
15042             printf (" ");
15043         }
15044
15045       for (j = 0; j < lbytes; j++)
15046         {
15047           k = p[j];
15048           if (k >= ' ' && k < 0x7f)
15049             printf ("%c", k);
15050           else
15051             printf (".");
15052         }
15053
15054       putchar ('\n');
15055
15056       p  += lbytes;
15057       bytes -= lbytes;
15058       addr += lbytes;
15059     }
15060
15061   putchar ('\n');
15062 }
15063
15064 static unsigned char *
15065 display_msp430x_attribute (unsigned char * p,
15066                            const unsigned char * const end)
15067 {
15068   unsigned int len;
15069   unsigned int val;
15070   unsigned int tag;
15071
15072   tag = read_uleb128 (p, & len, end);
15073   p += len;
15074
15075   switch (tag)
15076     {
15077     case OFBA_MSPABI_Tag_ISA:
15078       val = read_uleb128 (p, &len, end);
15079       p += len;
15080       printf ("  Tag_ISA: ");
15081       switch (val)
15082         {
15083         case 0: printf (_("None\n")); break;
15084         case 1: printf (_("MSP430\n")); break;
15085         case 2: printf (_("MSP430X\n")); break;
15086         default: printf ("??? (%d)\n", val); break;
15087         }
15088       break;
15089
15090     case OFBA_MSPABI_Tag_Code_Model:
15091       val = read_uleb128 (p, &len, end);
15092       p += len;
15093       printf ("  Tag_Code_Model: ");
15094       switch (val)
15095         {
15096         case 0: printf (_("None\n")); break;
15097         case 1: printf (_("Small\n")); break;
15098         case 2: printf (_("Large\n")); break;
15099         default: printf ("??? (%d)\n", val); break;
15100         }
15101       break;
15102
15103     case OFBA_MSPABI_Tag_Data_Model:
15104       val = read_uleb128 (p, &len, end);
15105       p += len;
15106       printf ("  Tag_Data_Model: ");
15107       switch (val)
15108         {
15109         case 0: printf (_("None\n")); break;
15110         case 1: printf (_("Small\n")); break;
15111         case 2: printf (_("Large\n")); break;
15112         case 3: printf (_("Restricted Large\n")); break;
15113         default: printf ("??? (%d)\n", val); break;
15114         }
15115       break;
15116
15117     default:
15118       printf (_("  <unknown tag %d>: "), tag);
15119
15120       if (tag & 1)
15121         {
15122           putchar ('"');
15123           if (p < end - 1)
15124             {
15125               size_t maxlen = (end - p) - 1;
15126
15127               print_symbol ((int) maxlen, (const char *) p);
15128               p += strnlen ((char *) p, maxlen) + 1;
15129             }
15130           else
15131             {
15132               printf (_("<corrupt>"));
15133               p = (unsigned char *) end;
15134             }
15135           printf ("\"\n");
15136         }
15137       else
15138         {
15139           val = read_uleb128 (p, &len, end);
15140           p += len;
15141           printf ("%d (0x%x)\n", val, val);
15142         }
15143       break;
15144    }
15145
15146   assert (p <= end);
15147   return p;
15148 }
15149
15150 static bfd_boolean
15151 process_attributes (Filedata * filedata,
15152                     const char * public_name,
15153                     unsigned int proc_type,
15154                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15155                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15156 {
15157   Elf_Internal_Shdr * sect;
15158   unsigned i;
15159   bfd_boolean res = TRUE;
15160
15161   /* Find the section header so that we get the size.  */
15162   for (i = 0, sect = filedata->section_headers;
15163        i < filedata->file_header.e_shnum;
15164        i++, sect++)
15165     {
15166       unsigned char * contents;
15167       unsigned char * p;
15168
15169       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15170         continue;
15171
15172       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15173                                              sect->sh_size, _("attributes"));
15174       if (contents == NULL)
15175         {
15176           res = FALSE;
15177           continue;
15178         }
15179
15180       p = contents;
15181       /* The first character is the version of the attributes.
15182          Currently only version 1, (aka 'A') is recognised here.  */
15183       if (*p != 'A')
15184         {
15185           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15186           res = FALSE;
15187         }
15188       else
15189         {
15190           bfd_vma section_len;
15191
15192           section_len = sect->sh_size - 1;
15193           p++;
15194
15195           while (section_len > 0)
15196             {
15197               bfd_vma attr_len;
15198               unsigned int namelen;
15199               bfd_boolean public_section;
15200               bfd_boolean gnu_section;
15201
15202               if (section_len <= 4)
15203                 {
15204                   error (_("Tag section ends prematurely\n"));
15205                   res = FALSE;
15206                   break;
15207                 }
15208               attr_len = byte_get (p, 4);
15209               p += 4;
15210
15211               if (attr_len > section_len)
15212                 {
15213                   error (_("Bad attribute length (%u > %u)\n"),
15214                           (unsigned) attr_len, (unsigned) section_len);
15215                   attr_len = section_len;
15216                   res = FALSE;
15217                 }
15218               /* PR 17531: file: 001-101425-0.004  */
15219               else if (attr_len < 5)
15220                 {
15221                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15222                   res = FALSE;
15223                   break;
15224                 }
15225
15226               section_len -= attr_len;
15227               attr_len -= 4;
15228
15229               namelen = strnlen ((char *) p, attr_len) + 1;
15230               if (namelen == 0 || namelen >= attr_len)
15231                 {
15232                   error (_("Corrupt attribute section name\n"));
15233                   res = FALSE;
15234                   break;
15235                 }
15236
15237               printf (_("Attribute Section: "));
15238               print_symbol (INT_MAX, (const char *) p);
15239               putchar ('\n');
15240
15241               if (public_name && streq ((char *) p, public_name))
15242                 public_section = TRUE;
15243               else
15244                 public_section = FALSE;
15245
15246               if (streq ((char *) p, "gnu"))
15247                 gnu_section = TRUE;
15248               else
15249                 gnu_section = FALSE;
15250
15251               p += namelen;
15252               attr_len -= namelen;
15253
15254               while (attr_len > 0 && p < contents + sect->sh_size)
15255                 {
15256                   int tag;
15257                   int val;
15258                   bfd_vma size;
15259                   unsigned char * end;
15260
15261                   /* PR binutils/17531: Safe handling of corrupt files.  */
15262                   if (attr_len < 6)
15263                     {
15264                       error (_("Unused bytes at end of section\n"));
15265                       res = FALSE;
15266                       section_len = 0;
15267                       break;
15268                     }
15269
15270                   tag = *(p++);
15271                   size = byte_get (p, 4);
15272                   if (size > attr_len)
15273                     {
15274                       error (_("Bad subsection length (%u > %u)\n"),
15275                               (unsigned) size, (unsigned) attr_len);
15276                       res = FALSE;
15277                       size = attr_len;
15278                     }
15279                   /* PR binutils/17531: Safe handling of corrupt files.  */
15280                   if (size < 6)
15281                     {
15282                       error (_("Bad subsection length (%u < 6)\n"),
15283                               (unsigned) size);
15284                       res = FALSE;
15285                       section_len = 0;
15286                       break;
15287                     }
15288
15289                   attr_len -= size;
15290                   end = p + size - 1;
15291                   assert (end <= contents + sect->sh_size);
15292                   p += 4;
15293
15294                   switch (tag)
15295                     {
15296                     case 1:
15297                       printf (_("File Attributes\n"));
15298                       break;
15299                     case 2:
15300                       printf (_("Section Attributes:"));
15301                       goto do_numlist;
15302                     case 3:
15303                       printf (_("Symbol Attributes:"));
15304                       /* Fall through.  */
15305                     do_numlist:
15306                       for (;;)
15307                         {
15308                           unsigned int j;
15309
15310                           val = read_uleb128 (p, &j, end);
15311                           p += j;
15312                           if (val == 0)
15313                             break;
15314                           printf (" %d", val);
15315                         }
15316                       printf ("\n");
15317                       break;
15318                     default:
15319                       printf (_("Unknown tag: %d\n"), tag);
15320                       public_section = FALSE;
15321                       break;
15322                     }
15323
15324                   if (public_section && display_pub_attribute != NULL)
15325                     {
15326                       while (p < end)
15327                         p = display_pub_attribute (p, end);
15328                       assert (p == end);
15329                     }
15330                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15331                     {
15332                       while (p < end)
15333                         p = display_gnu_attribute (p,
15334                                                    display_proc_gnu_attribute,
15335                                                    end);
15336                       assert (p == end);
15337                     }
15338                   else if (p < end)
15339                     {
15340                       printf (_("  Unknown attribute:\n"));
15341                       display_raw_attribute (p, end);
15342                       p = end;
15343                     }
15344                   else
15345                     attr_len = 0;
15346                 }
15347             }
15348         }
15349
15350       free (contents);
15351     }
15352
15353   return res;
15354 }
15355
15356 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15357    Print the Address, Access and Initial fields of an entry at VMA ADDR
15358    and return the VMA of the next entry, or -1 if there was a problem.
15359    Does not read from DATA_END or beyond.  */
15360
15361 static bfd_vma
15362 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15363                       unsigned char * data_end)
15364 {
15365   printf ("  ");
15366   print_vma (addr, LONG_HEX);
15367   printf (" ");
15368   if (addr < pltgot + 0xfff0)
15369     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15370   else
15371     printf ("%10s", "");
15372   printf (" ");
15373   if (data == NULL)
15374     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15375   else
15376     {
15377       bfd_vma entry;
15378       unsigned char * from = data + addr - pltgot;
15379
15380       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15381         {
15382           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15383           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15384           return (bfd_vma) -1;
15385         }
15386       else
15387         {
15388           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15389           print_vma (entry, LONG_HEX);
15390         }
15391     }
15392   return addr + (is_32bit_elf ? 4 : 8);
15393 }
15394
15395 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15396    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15397    ADDR and return the VMA of the next entry.  */
15398
15399 static bfd_vma
15400 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15401 {
15402   printf ("  ");
15403   print_vma (addr, LONG_HEX);
15404   printf (" ");
15405   if (data == NULL)
15406     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15407   else
15408     {
15409       bfd_vma entry;
15410
15411       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15412       print_vma (entry, LONG_HEX);
15413     }
15414   return addr + (is_32bit_elf ? 4 : 8);
15415 }
15416
15417 static void
15418 print_mips_ases (unsigned int mask)
15419 {
15420   if (mask & AFL_ASE_DSP)
15421     fputs ("\n\tDSP ASE", stdout);
15422   if (mask & AFL_ASE_DSPR2)
15423     fputs ("\n\tDSP R2 ASE", stdout);
15424   if (mask & AFL_ASE_DSPR3)
15425     fputs ("\n\tDSP R3 ASE", stdout);
15426   if (mask & AFL_ASE_EVA)
15427     fputs ("\n\tEnhanced VA Scheme", stdout);
15428   if (mask & AFL_ASE_MCU)
15429     fputs ("\n\tMCU (MicroController) ASE", stdout);
15430   if (mask & AFL_ASE_MDMX)
15431     fputs ("\n\tMDMX ASE", stdout);
15432   if (mask & AFL_ASE_MIPS3D)
15433     fputs ("\n\tMIPS-3D ASE", stdout);
15434   if (mask & AFL_ASE_MT)
15435     fputs ("\n\tMT ASE", stdout);
15436   if (mask & AFL_ASE_SMARTMIPS)
15437     fputs ("\n\tSmartMIPS ASE", stdout);
15438   if (mask & AFL_ASE_VIRT)
15439     fputs ("\n\tVZ ASE", stdout);
15440   if (mask & AFL_ASE_MSA)
15441     fputs ("\n\tMSA ASE", stdout);
15442   if (mask & AFL_ASE_MIPS16)
15443     fputs ("\n\tMIPS16 ASE", stdout);
15444   if (mask & AFL_ASE_MICROMIPS)
15445     fputs ("\n\tMICROMIPS ASE", stdout);
15446   if (mask & AFL_ASE_XPA)
15447     fputs ("\n\tXPA ASE", stdout);
15448   if (mask & AFL_ASE_MIPS16E2)
15449     fputs ("\n\tMIPS16e2 ASE", stdout);
15450   if (mask == 0)
15451     fprintf (stdout, "\n\t%s", _("None"));
15452   else if ((mask & ~AFL_ASE_MASK) != 0)
15453     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15454 }
15455
15456 static void
15457 print_mips_isa_ext (unsigned int isa_ext)
15458 {
15459   switch (isa_ext)
15460     {
15461     case 0:
15462       fputs (_("None"), stdout);
15463       break;
15464     case AFL_EXT_XLR:
15465       fputs ("RMI XLR", stdout);
15466       break;
15467     case AFL_EXT_OCTEON3:
15468       fputs ("Cavium Networks Octeon3", stdout);
15469       break;
15470     case AFL_EXT_OCTEON2:
15471       fputs ("Cavium Networks Octeon2", stdout);
15472       break;
15473     case AFL_EXT_OCTEONP:
15474       fputs ("Cavium Networks OcteonP", stdout);
15475       break;
15476     case AFL_EXT_LOONGSON_3A:
15477       fputs ("Loongson 3A", stdout);
15478       break;
15479     case AFL_EXT_OCTEON:
15480       fputs ("Cavium Networks Octeon", stdout);
15481       break;
15482     case AFL_EXT_5900:
15483       fputs ("Toshiba R5900", stdout);
15484       break;
15485     case AFL_EXT_4650:
15486       fputs ("MIPS R4650", stdout);
15487       break;
15488     case AFL_EXT_4010:
15489       fputs ("LSI R4010", stdout);
15490       break;
15491     case AFL_EXT_4100:
15492       fputs ("NEC VR4100", stdout);
15493       break;
15494     case AFL_EXT_3900:
15495       fputs ("Toshiba R3900", stdout);
15496       break;
15497     case AFL_EXT_10000:
15498       fputs ("MIPS R10000", stdout);
15499       break;
15500     case AFL_EXT_SB1:
15501       fputs ("Broadcom SB-1", stdout);
15502       break;
15503     case AFL_EXT_4111:
15504       fputs ("NEC VR4111/VR4181", stdout);
15505       break;
15506     case AFL_EXT_4120:
15507       fputs ("NEC VR4120", stdout);
15508       break;
15509     case AFL_EXT_5400:
15510       fputs ("NEC VR5400", stdout);
15511       break;
15512     case AFL_EXT_5500:
15513       fputs ("NEC VR5500", stdout);
15514       break;
15515     case AFL_EXT_LOONGSON_2E:
15516       fputs ("ST Microelectronics Loongson 2E", stdout);
15517       break;
15518     case AFL_EXT_LOONGSON_2F:
15519       fputs ("ST Microelectronics Loongson 2F", stdout);
15520       break;
15521     case AFL_EXT_INTERAPTIV_MR2:
15522       fputs ("Imagination interAptiv MR2", stdout);
15523       break;
15524     default:
15525       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15526     }
15527 }
15528
15529 static signed int
15530 get_mips_reg_size (int reg_size)
15531 {
15532   return (reg_size == AFL_REG_NONE) ? 0
15533          : (reg_size == AFL_REG_32) ? 32
15534          : (reg_size == AFL_REG_64) ? 64
15535          : (reg_size == AFL_REG_128) ? 128
15536          : -1;
15537 }
15538
15539 static bfd_boolean
15540 process_mips_specific (Filedata * filedata)
15541 {
15542   Elf_Internal_Dyn * entry;
15543   Elf_Internal_Shdr *sect = NULL;
15544   size_t liblist_offset = 0;
15545   size_t liblistno = 0;
15546   size_t conflictsno = 0;
15547   size_t options_offset = 0;
15548   size_t conflicts_offset = 0;
15549   size_t pltrelsz = 0;
15550   size_t pltrel = 0;
15551   bfd_vma pltgot = 0;
15552   bfd_vma mips_pltgot = 0;
15553   bfd_vma jmprel = 0;
15554   bfd_vma local_gotno = 0;
15555   bfd_vma gotsym = 0;
15556   bfd_vma symtabno = 0;
15557   bfd_boolean res = TRUE;
15558
15559   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15560                             display_mips_gnu_attribute))
15561     res = FALSE;
15562
15563   sect = find_section (filedata, ".MIPS.abiflags");
15564
15565   if (sect != NULL)
15566     {
15567       Elf_External_ABIFlags_v0 *abiflags_ext;
15568       Elf_Internal_ABIFlags_v0 abiflags_in;
15569
15570       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15571         {
15572           error (_("Corrupt MIPS ABI Flags section.\n"));
15573           res = FALSE;
15574         }
15575       else
15576         {
15577           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15578                                    sect->sh_size, _("MIPS ABI Flags section"));
15579           if (abiflags_ext)
15580             {
15581               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15582               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15583               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15584               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15585               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15586               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15587               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15588               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15589               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15590               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15591               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15592
15593               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15594               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15595               if (abiflags_in.isa_rev > 1)
15596                 printf ("r%d", abiflags_in.isa_rev);
15597               printf ("\nGPR size: %d",
15598                       get_mips_reg_size (abiflags_in.gpr_size));
15599               printf ("\nCPR1 size: %d",
15600                       get_mips_reg_size (abiflags_in.cpr1_size));
15601               printf ("\nCPR2 size: %d",
15602                       get_mips_reg_size (abiflags_in.cpr2_size));
15603               fputs ("\nFP ABI: ", stdout);
15604               print_mips_fp_abi_value (abiflags_in.fp_abi);
15605               fputs ("ISA Extension: ", stdout);
15606               print_mips_isa_ext (abiflags_in.isa_ext);
15607               fputs ("\nASEs:", stdout);
15608               print_mips_ases (abiflags_in.ases);
15609               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15610               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15611               fputc ('\n', stdout);
15612               free (abiflags_ext);
15613             }
15614         }
15615     }
15616
15617   /* We have a lot of special sections.  Thanks SGI!  */
15618   if (dynamic_section == NULL)
15619     {
15620       /* No dynamic information available.  See if there is static GOT.  */
15621       sect = find_section (filedata, ".got");
15622       if (sect != NULL)
15623         {
15624           unsigned char *data_end;
15625           unsigned char *data;
15626           bfd_vma ent, end;
15627           int addr_size;
15628
15629           pltgot = sect->sh_addr;
15630
15631           ent = pltgot;
15632           addr_size = (is_32bit_elf ? 4 : 8);
15633           end = pltgot + sect->sh_size;
15634
15635           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15636                                              end - pltgot, 1,
15637                                              _("Global Offset Table data"));
15638           /* PR 12855: Null data is handled gracefully throughout.  */
15639           data_end = data + (end - pltgot);
15640
15641           printf (_("\nStatic GOT:\n"));
15642           printf (_(" Canonical gp value: "));
15643           print_vma (ent + 0x7ff0, LONG_HEX);
15644           printf ("\n\n");
15645
15646           /* In a dynamic binary GOT[0] is reserved for the dynamic
15647              loader to store the lazy resolver pointer, however in
15648              a static binary it may well have been omitted and GOT
15649              reduced to a table of addresses.
15650              PR 21344: Check for the entry being fully available
15651              before fetching it.  */
15652           if (data
15653               && data + ent - pltgot + addr_size <= data_end
15654               && byte_get (data + ent - pltgot, addr_size) == 0)
15655             {
15656               printf (_(" Reserved entries:\n"));
15657               printf (_("  %*s %10s %*s\n"),
15658                       addr_size * 2, _("Address"), _("Access"),
15659                       addr_size * 2, _("Value"));
15660               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15661               printf ("\n");
15662               if (ent == (bfd_vma) -1)
15663                 goto sgot_print_fail;
15664
15665               /* Check for the MSB of GOT[1] being set, identifying a
15666                  GNU object.  This entry will be used by some runtime
15667                  loaders, to store the module pointer.  Otherwise this
15668                  is an ordinary local entry.
15669                  PR 21344: Check for the entry being fully available
15670                  before fetching it.  */
15671               if (data
15672                   && data + ent - pltgot + addr_size <= data_end
15673                   && (byte_get (data + ent - pltgot, addr_size)
15674                       >> (addr_size * 8 - 1)) != 0)
15675                 {
15676                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15677                   printf ("\n");
15678                   if (ent == (bfd_vma) -1)
15679                     goto sgot_print_fail;
15680                 }
15681               printf ("\n");
15682             }
15683
15684           if (data != NULL && ent < end)
15685             {
15686               printf (_(" Local entries:\n"));
15687               printf ("  %*s %10s %*s\n",
15688                       addr_size * 2, _("Address"), _("Access"),
15689                       addr_size * 2, _("Value"));
15690               while (ent < end)
15691                 {
15692                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15693                   printf ("\n");
15694                   if (ent == (bfd_vma) -1)
15695                     goto sgot_print_fail;
15696                 }
15697               printf ("\n");
15698             }
15699
15700         sgot_print_fail:
15701           if (data)
15702             free (data);
15703         }
15704       return res;
15705     }
15706
15707   for (entry = dynamic_section;
15708        /* PR 17531 file: 012-50589-0.004.  */
15709        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15710        ++entry)
15711     switch (entry->d_tag)
15712       {
15713       case DT_MIPS_LIBLIST:
15714         liblist_offset
15715           = offset_from_vma (filedata, entry->d_un.d_val,
15716                              liblistno * sizeof (Elf32_External_Lib));
15717         break;
15718       case DT_MIPS_LIBLISTNO:
15719         liblistno = entry->d_un.d_val;
15720         break;
15721       case DT_MIPS_OPTIONS:
15722         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15723         break;
15724       case DT_MIPS_CONFLICT:
15725         conflicts_offset
15726           = offset_from_vma (filedata, entry->d_un.d_val,
15727                              conflictsno * sizeof (Elf32_External_Conflict));
15728         break;
15729       case DT_MIPS_CONFLICTNO:
15730         conflictsno = entry->d_un.d_val;
15731         break;
15732       case DT_PLTGOT:
15733         pltgot = entry->d_un.d_ptr;
15734         break;
15735       case DT_MIPS_LOCAL_GOTNO:
15736         local_gotno = entry->d_un.d_val;
15737         break;
15738       case DT_MIPS_GOTSYM:
15739         gotsym = entry->d_un.d_val;
15740         break;
15741       case DT_MIPS_SYMTABNO:
15742         symtabno = entry->d_un.d_val;
15743         break;
15744       case DT_MIPS_PLTGOT:
15745         mips_pltgot = entry->d_un.d_ptr;
15746         break;
15747       case DT_PLTREL:
15748         pltrel = entry->d_un.d_val;
15749         break;
15750       case DT_PLTRELSZ:
15751         pltrelsz = entry->d_un.d_val;
15752         break;
15753       case DT_JMPREL:
15754         jmprel = entry->d_un.d_ptr;
15755         break;
15756       default:
15757         break;
15758       }
15759
15760   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15761     {
15762       Elf32_External_Lib * elib;
15763       size_t cnt;
15764
15765       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15766                                               liblistno,
15767                                               sizeof (Elf32_External_Lib),
15768                                               _("liblist section data"));
15769       if (elib)
15770         {
15771           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15772                             "\nSection '.liblist' contains %lu entries:\n",
15773                             (unsigned long) liblistno),
15774                   (unsigned long) liblistno);
15775           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15776                  stdout);
15777
15778           for (cnt = 0; cnt < liblistno; ++cnt)
15779             {
15780               Elf32_Lib liblist;
15781               time_t atime;
15782               char timebuf[128];
15783               struct tm * tmp;
15784
15785               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15786               atime = BYTE_GET (elib[cnt].l_time_stamp);
15787               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15788               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15789               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15790
15791               tmp = gmtime (&atime);
15792               snprintf (timebuf, sizeof (timebuf),
15793                         "%04u-%02u-%02uT%02u:%02u:%02u",
15794                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15795                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15796
15797               printf ("%3lu: ", (unsigned long) cnt);
15798               if (VALID_DYNAMIC_NAME (liblist.l_name))
15799                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15800               else
15801                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15802               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15803                       liblist.l_version);
15804
15805               if (liblist.l_flags == 0)
15806                 puts (_(" NONE"));
15807               else
15808                 {
15809                   static const struct
15810                   {
15811                     const char * name;
15812                     int bit;
15813                   }
15814                   l_flags_vals[] =
15815                   {
15816                     { " EXACT_MATCH", LL_EXACT_MATCH },
15817                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15818                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15819                     { " EXPORTS", LL_EXPORTS },
15820                     { " DELAY_LOAD", LL_DELAY_LOAD },
15821                     { " DELTA", LL_DELTA }
15822                   };
15823                   int flags = liblist.l_flags;
15824                   size_t fcnt;
15825
15826                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15827                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15828                       {
15829                         fputs (l_flags_vals[fcnt].name, stdout);
15830                         flags ^= l_flags_vals[fcnt].bit;
15831                       }
15832                   if (flags != 0)
15833                     printf (" %#x", (unsigned int) flags);
15834
15835                   puts ("");
15836                 }
15837             }
15838
15839           free (elib);
15840         }
15841       else
15842         res = FALSE;
15843     }
15844
15845   if (options_offset != 0)
15846     {
15847       Elf_External_Options * eopt;
15848       Elf_Internal_Options * iopt;
15849       Elf_Internal_Options * option;
15850       size_t offset;
15851       int cnt;
15852       sect = filedata->section_headers;
15853
15854       /* Find the section header so that we get the size.  */
15855       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
15856       /* PR 17533 file: 012-277276-0.004.  */
15857       if (sect == NULL)
15858         {
15859           error (_("No MIPS_OPTIONS header found\n"));
15860           return FALSE;
15861         }
15862
15863       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
15864                                                 sect->sh_size, _("options"));
15865       if (eopt)
15866         {
15867           iopt = (Elf_Internal_Options *)
15868               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15869           if (iopt == NULL)
15870             {
15871               error (_("Out of memory allocating space for MIPS options\n"));
15872               return FALSE;
15873             }
15874
15875           offset = cnt = 0;
15876           option = iopt;
15877
15878           while (offset <= sect->sh_size - sizeof (* eopt))
15879             {
15880               Elf_External_Options * eoption;
15881
15882               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15883
15884               option->kind = BYTE_GET (eoption->kind);
15885               option->size = BYTE_GET (eoption->size);
15886               option->section = BYTE_GET (eoption->section);
15887               option->info = BYTE_GET (eoption->info);
15888
15889               /* PR 17531: file: ffa0fa3b.  */
15890               if (option->size < sizeof (* eopt)
15891                   || offset + option->size > sect->sh_size)
15892                 {
15893                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15894                   return FALSE;
15895                 }
15896               offset += option->size;
15897
15898               ++option;
15899               ++cnt;
15900             }
15901
15902           printf (ngettext ("\nSection '%s' contains %d entry:\n",
15903                             "\nSection '%s' contains %d entries:\n",
15904                             cnt),
15905                   printable_section_name (filedata, sect), cnt);
15906
15907           option = iopt;
15908           offset = 0;
15909
15910           while (cnt-- > 0)
15911             {
15912               size_t len;
15913
15914               switch (option->kind)
15915                 {
15916                 case ODK_NULL:
15917                   /* This shouldn't happen.  */
15918                   printf (" NULL       %d %lx", option->section, option->info);
15919                   break;
15920                 case ODK_REGINFO:
15921                   printf (" REGINFO    ");
15922                   if (filedata->file_header.e_machine == EM_MIPS)
15923                     {
15924                       /* 32bit form.  */
15925                       Elf32_External_RegInfo * ereg;
15926                       Elf32_RegInfo reginfo;
15927
15928                       ereg = (Elf32_External_RegInfo *) (option + 1);
15929                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15930                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15931                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15932                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15933                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15934                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15935
15936                       printf ("GPR %08lx  GP 0x%lx\n",
15937                               reginfo.ri_gprmask,
15938                               (unsigned long) reginfo.ri_gp_value);
15939                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15940                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15941                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15942                     }
15943                   else
15944                     {
15945                       /* 64 bit form.  */
15946                       Elf64_External_RegInfo * ereg;
15947                       Elf64_Internal_RegInfo reginfo;
15948
15949                       ereg = (Elf64_External_RegInfo *) (option + 1);
15950                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15951                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15952                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15953                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15954                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15955                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15956
15957                       printf ("GPR %08lx  GP 0x",
15958                               reginfo.ri_gprmask);
15959                       printf_vma (reginfo.ri_gp_value);
15960                       printf ("\n");
15961
15962                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15963                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15964                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15965                     }
15966                   ++option;
15967                   continue;
15968                 case ODK_EXCEPTIONS:
15969                   fputs (" EXCEPTIONS fpe_min(", stdout);
15970                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15971                   fputs (") fpe_max(", stdout);
15972                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15973                   fputs (")", stdout);
15974
15975                   if (option->info & OEX_PAGE0)
15976                     fputs (" PAGE0", stdout);
15977                   if (option->info & OEX_SMM)
15978                     fputs (" SMM", stdout);
15979                   if (option->info & OEX_FPDBUG)
15980                     fputs (" FPDBUG", stdout);
15981                   if (option->info & OEX_DISMISS)
15982                     fputs (" DISMISS", stdout);
15983                   break;
15984                 case ODK_PAD:
15985                   fputs (" PAD       ", stdout);
15986                   if (option->info & OPAD_PREFIX)
15987                     fputs (" PREFIX", stdout);
15988                   if (option->info & OPAD_POSTFIX)
15989                     fputs (" POSTFIX", stdout);
15990                   if (option->info & OPAD_SYMBOL)
15991                     fputs (" SYMBOL", stdout);
15992                   break;
15993                 case ODK_HWPATCH:
15994                   fputs (" HWPATCH   ", stdout);
15995                   if (option->info & OHW_R4KEOP)
15996                     fputs (" R4KEOP", stdout);
15997                   if (option->info & OHW_R8KPFETCH)
15998                     fputs (" R8KPFETCH", stdout);
15999                   if (option->info & OHW_R5KEOP)
16000                     fputs (" R5KEOP", stdout);
16001                   if (option->info & OHW_R5KCVTL)
16002                     fputs (" R5KCVTL", stdout);
16003                   break;
16004                 case ODK_FILL:
16005                   fputs (" FILL       ", stdout);
16006                   /* XXX Print content of info word?  */
16007                   break;
16008                 case ODK_TAGS:
16009                   fputs (" TAGS       ", stdout);
16010                   /* XXX Print content of info word?  */
16011                   break;
16012                 case ODK_HWAND:
16013                   fputs (" HWAND     ", stdout);
16014                   if (option->info & OHWA0_R4KEOP_CHECKED)
16015                     fputs (" R4KEOP_CHECKED", stdout);
16016                   if (option->info & OHWA0_R4KEOP_CLEAN)
16017                     fputs (" R4KEOP_CLEAN", stdout);
16018                   break;
16019                 case ODK_HWOR:
16020                   fputs (" HWOR      ", stdout);
16021                   if (option->info & OHWA0_R4KEOP_CHECKED)
16022                     fputs (" R4KEOP_CHECKED", stdout);
16023                   if (option->info & OHWA0_R4KEOP_CLEAN)
16024                     fputs (" R4KEOP_CLEAN", stdout);
16025                   break;
16026                 case ODK_GP_GROUP:
16027                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16028                           option->info & OGP_GROUP,
16029                           (option->info & OGP_SELF) >> 16);
16030                   break;
16031                 case ODK_IDENT:
16032                   printf (" IDENT     %#06lx  self-contained %#06lx",
16033                           option->info & OGP_GROUP,
16034                           (option->info & OGP_SELF) >> 16);
16035                   break;
16036                 default:
16037                   /* This shouldn't happen.  */
16038                   printf (" %3d ???     %d %lx",
16039                           option->kind, option->section, option->info);
16040                   break;
16041                 }
16042
16043               len = sizeof (* eopt);
16044               while (len < option->size)
16045                 {
16046                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16047
16048                   if (ISPRINT (datum))
16049                     printf ("%c", datum);
16050                   else
16051                     printf ("\\%03o", datum);
16052                   len ++;
16053                 }
16054               fputs ("\n", stdout);
16055
16056               offset += option->size;
16057               ++option;
16058             }
16059
16060           free (eopt);
16061         }
16062       else
16063         res = FALSE;
16064     }
16065
16066   if (conflicts_offset != 0 && conflictsno != 0)
16067     {
16068       Elf32_Conflict * iconf;
16069       size_t cnt;
16070
16071       if (dynamic_symbols == NULL)
16072         {
16073           error (_("conflict list found without a dynamic symbol table\n"));
16074           return FALSE;
16075         }
16076
16077       /* PR 21345 - print a slightly more helpful error message
16078          if we are sure that the cmalloc will fail.  */
16079       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16080         {
16081           error (_("Overlarge number of conflicts detected: %lx\n"),
16082                  (long) conflictsno);
16083           return FALSE;
16084         }
16085
16086       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16087       if (iconf == NULL)
16088         {
16089           error (_("Out of memory allocating space for dynamic conflicts\n"));
16090           return FALSE;
16091         }
16092
16093       if (is_32bit_elf)
16094         {
16095           Elf32_External_Conflict * econf32;
16096
16097           econf32 = (Elf32_External_Conflict *)
16098               get_data (NULL, filedata, conflicts_offset, conflictsno,
16099                         sizeof (* econf32), _("conflict"));
16100           if (!econf32)
16101             return FALSE;
16102
16103           for (cnt = 0; cnt < conflictsno; ++cnt)
16104             iconf[cnt] = BYTE_GET (econf32[cnt]);
16105
16106           free (econf32);
16107         }
16108       else
16109         {
16110           Elf64_External_Conflict * econf64;
16111
16112           econf64 = (Elf64_External_Conflict *)
16113               get_data (NULL, filedata, conflicts_offset, conflictsno,
16114                         sizeof (* econf64), _("conflict"));
16115           if (!econf64)
16116             return FALSE;
16117
16118           for (cnt = 0; cnt < conflictsno; ++cnt)
16119             iconf[cnt] = BYTE_GET (econf64[cnt]);
16120
16121           free (econf64);
16122         }
16123
16124       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16125                         "\nSection '.conflict' contains %lu entries:\n",
16126                         (unsigned long) conflictsno),
16127               (unsigned long) conflictsno);
16128       puts (_("  Num:    Index       Value  Name"));
16129
16130       for (cnt = 0; cnt < conflictsno; ++cnt)
16131         {
16132           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16133
16134           if (iconf[cnt] >= num_dynamic_syms)
16135             printf (_("<corrupt symbol index>"));
16136           else
16137             {
16138               Elf_Internal_Sym * psym;
16139
16140               psym = & dynamic_symbols[iconf[cnt]];
16141               print_vma (psym->st_value, FULL_HEX);
16142               putchar (' ');
16143               if (VALID_DYNAMIC_NAME (psym->st_name))
16144                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16145               else
16146                 printf (_("<corrupt: %14ld>"), psym->st_name);
16147             }
16148           putchar ('\n');
16149         }
16150
16151       free (iconf);
16152     }
16153
16154   if (pltgot != 0 && local_gotno != 0)
16155     {
16156       bfd_vma ent, local_end, global_end;
16157       size_t i, offset;
16158       unsigned char * data;
16159       unsigned char * data_end;
16160       int addr_size;
16161
16162       ent = pltgot;
16163       addr_size = (is_32bit_elf ? 4 : 8);
16164       local_end = pltgot + local_gotno * addr_size;
16165
16166       /* PR binutils/17533 file: 012-111227-0.004  */
16167       if (symtabno < gotsym)
16168         {
16169           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16170                  (unsigned long) gotsym, (unsigned long) symtabno);
16171           return FALSE;
16172         }
16173
16174       global_end = local_end + (symtabno - gotsym) * addr_size;
16175       /* PR 17531: file: 54c91a34.  */
16176       if (global_end < local_end)
16177         {
16178           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16179           return FALSE;
16180         }
16181
16182       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16183       data = (unsigned char *) get_data (NULL, filedata, offset,
16184                                          global_end - pltgot, 1,
16185                                          _("Global Offset Table data"));
16186       /* PR 12855: Null data is handled gracefully throughout.  */
16187       data_end = data + (global_end - pltgot);
16188
16189       printf (_("\nPrimary GOT:\n"));
16190       printf (_(" Canonical gp value: "));
16191       print_vma (pltgot + 0x7ff0, LONG_HEX);
16192       printf ("\n\n");
16193
16194       printf (_(" Reserved entries:\n"));
16195       printf (_("  %*s %10s %*s Purpose\n"),
16196               addr_size * 2, _("Address"), _("Access"),
16197               addr_size * 2, _("Initial"));
16198       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16199       printf (_(" Lazy resolver\n"));
16200       if (ent == (bfd_vma) -1)
16201         goto got_print_fail;
16202
16203       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16204          This entry will be used by some runtime loaders, to store the
16205          module pointer.  Otherwise this is an ordinary local entry.
16206          PR 21344: Check for the entry being fully available before
16207          fetching it.  */
16208       if (data
16209           && data + ent - pltgot + addr_size <= data_end
16210           && (byte_get (data + ent - pltgot, addr_size)
16211               >> (addr_size * 8 - 1)) != 0)
16212         {
16213           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16214           printf (_(" Module pointer (GNU extension)\n"));
16215           if (ent == (bfd_vma) -1)
16216             goto got_print_fail;
16217         }
16218       printf ("\n");
16219
16220       if (data != NULL && ent < local_end)
16221         {
16222           printf (_(" Local entries:\n"));
16223           printf ("  %*s %10s %*s\n",
16224                   addr_size * 2, _("Address"), _("Access"),
16225                   addr_size * 2, _("Initial"));
16226           while (ent < local_end)
16227             {
16228               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16229               printf ("\n");
16230               if (ent == (bfd_vma) -1)
16231                 goto got_print_fail;
16232             }
16233           printf ("\n");
16234         }
16235
16236       if (data != NULL && gotsym < symtabno)
16237         {
16238           int sym_width;
16239
16240           printf (_(" Global entries:\n"));
16241           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16242                   addr_size * 2, _("Address"),
16243                   _("Access"),
16244                   addr_size * 2, _("Initial"),
16245                   addr_size * 2, _("Sym.Val."),
16246                   _("Type"),
16247                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16248                   _("Ndx"), _("Name"));
16249
16250           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16251
16252           for (i = gotsym; i < symtabno; i++)
16253             {
16254               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16255               printf (" ");
16256
16257               if (dynamic_symbols == NULL)
16258                 printf (_("<no dynamic symbols>"));
16259               else if (i < num_dynamic_syms)
16260                 {
16261                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16262
16263                   print_vma (psym->st_value, LONG_HEX);
16264                   printf (" %-7s %3s ",
16265                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16266                           get_symbol_index_type (filedata, psym->st_shndx));
16267
16268                   if (VALID_DYNAMIC_NAME (psym->st_name))
16269                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16270                   else
16271                     printf (_("<corrupt: %14ld>"), psym->st_name);
16272                 }
16273               else
16274                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16275                         (unsigned long) i);
16276
16277               printf ("\n");
16278               if (ent == (bfd_vma) -1)
16279                 break;
16280             }
16281           printf ("\n");
16282         }
16283
16284     got_print_fail:
16285       if (data)
16286         free (data);
16287     }
16288
16289   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16290     {
16291       bfd_vma ent, end;
16292       size_t offset, rel_offset;
16293       unsigned long count, i;
16294       unsigned char * data;
16295       int addr_size, sym_width;
16296       Elf_Internal_Rela * rels;
16297
16298       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16299       if (pltrel == DT_RELA)
16300         {
16301           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16302             return FALSE;
16303         }
16304       else
16305         {
16306           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16307             return FALSE;
16308         }
16309
16310       ent = mips_pltgot;
16311       addr_size = (is_32bit_elf ? 4 : 8);
16312       end = mips_pltgot + (2 + count) * addr_size;
16313
16314       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16315       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16316                                          1, _("Procedure Linkage Table data"));
16317       if (data == NULL)
16318         return FALSE;
16319
16320       printf ("\nPLT GOT:\n\n");
16321       printf (_(" Reserved entries:\n"));
16322       printf (_("  %*s %*s Purpose\n"),
16323               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16324       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16325       printf (_(" PLT lazy resolver\n"));
16326       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16327       printf (_(" Module pointer\n"));
16328       printf ("\n");
16329
16330       printf (_(" Entries:\n"));
16331       printf ("  %*s %*s %*s %-7s %3s %s\n",
16332               addr_size * 2, _("Address"),
16333               addr_size * 2, _("Initial"),
16334               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16335       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16336       for (i = 0; i < count; i++)
16337         {
16338           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16339
16340           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16341           printf (" ");
16342
16343           if (idx >= num_dynamic_syms)
16344             printf (_("<corrupt symbol index: %lu>"), idx);
16345           else
16346             {
16347               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16348
16349               print_vma (psym->st_value, LONG_HEX);
16350               printf (" %-7s %3s ",
16351                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16352                       get_symbol_index_type (filedata, psym->st_shndx));
16353               if (VALID_DYNAMIC_NAME (psym->st_name))
16354                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16355               else
16356                 printf (_("<corrupt: %14ld>"), psym->st_name);
16357             }
16358           printf ("\n");
16359         }
16360       printf ("\n");
16361
16362       if (data)
16363         free (data);
16364       free (rels);
16365     }
16366
16367   return res;
16368 }
16369
16370 static bfd_boolean
16371 process_nds32_specific (Filedata * filedata)
16372 {
16373   Elf_Internal_Shdr *sect = NULL;
16374
16375   sect = find_section (filedata, ".nds32_e_flags");
16376   if (sect != NULL)
16377     {
16378       unsigned int *flag;
16379
16380       printf ("\nNDS32 elf flags section:\n");
16381       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16382                        sect->sh_size, _("NDS32 elf flags section"));
16383
16384       if (! flag)
16385         return FALSE;
16386
16387       switch ((*flag) & 0x3)
16388         {
16389         case 0:
16390           printf ("(VEC_SIZE):\tNo entry.\n");
16391           break;
16392         case 1:
16393           printf ("(VEC_SIZE):\t4 bytes\n");
16394           break;
16395         case 2:
16396           printf ("(VEC_SIZE):\t16 bytes\n");
16397           break;
16398         case 3:
16399           printf ("(VEC_SIZE):\treserved\n");
16400           break;
16401         }
16402     }
16403
16404   return TRUE;
16405 }
16406
16407 static bfd_boolean
16408 process_gnu_liblist (Filedata * filedata)
16409 {
16410   Elf_Internal_Shdr * section;
16411   Elf_Internal_Shdr * string_sec;
16412   Elf32_External_Lib * elib;
16413   char * strtab;
16414   size_t strtab_size;
16415   size_t cnt;
16416   unsigned long num_liblist;
16417   unsigned i;
16418   bfd_boolean res = TRUE;
16419
16420   if (! do_arch)
16421     return TRUE;
16422
16423   for (i = 0, section = filedata->section_headers;
16424        i < filedata->file_header.e_shnum;
16425        i++, section++)
16426     {
16427       switch (section->sh_type)
16428         {
16429         case SHT_GNU_LIBLIST:
16430           if (section->sh_link >= filedata->file_header.e_shnum)
16431             break;
16432
16433           elib = (Elf32_External_Lib *)
16434               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16435                         _("liblist section data"));
16436
16437           if (elib == NULL)
16438             {
16439               res = FALSE;
16440               break;
16441             }
16442
16443           string_sec = filedata->section_headers + section->sh_link;
16444           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16445                                       string_sec->sh_size,
16446                                       _("liblist string table"));
16447           if (strtab == NULL
16448               || section->sh_entsize != sizeof (Elf32_External_Lib))
16449             {
16450               free (elib);
16451               free (strtab);
16452               res = FALSE;
16453               break;
16454             }
16455           strtab_size = string_sec->sh_size;
16456
16457           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16458           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16459                             "\nLibrary list section '%s' contains %lu entries:\n",
16460                             num_liblist),
16461                   printable_section_name (filedata, section),
16462                   num_liblist);
16463
16464           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16465
16466           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16467                ++cnt)
16468             {
16469               Elf32_Lib liblist;
16470               time_t atime;
16471               char timebuf[128];
16472               struct tm * tmp;
16473
16474               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16475               atime = BYTE_GET (elib[cnt].l_time_stamp);
16476               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16477               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16478               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16479
16480               tmp = gmtime (&atime);
16481               snprintf (timebuf, sizeof (timebuf),
16482                         "%04u-%02u-%02uT%02u:%02u:%02u",
16483                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16484                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16485
16486               printf ("%3lu: ", (unsigned long) cnt);
16487               if (do_wide)
16488                 printf ("%-20s", liblist.l_name < strtab_size
16489                         ? strtab + liblist.l_name : _("<corrupt>"));
16490               else
16491                 printf ("%-20.20s", liblist.l_name < strtab_size
16492                         ? strtab + liblist.l_name : _("<corrupt>"));
16493               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16494                       liblist.l_version, liblist.l_flags);
16495             }
16496
16497           free (elib);
16498           free (strtab);
16499         }
16500     }
16501
16502   return res;
16503 }
16504
16505 static const char *
16506 get_note_type (Filedata * filedata, unsigned e_type)
16507 {
16508   static char buff[64];
16509
16510   if (filedata->file_header.e_type == ET_CORE)
16511     switch (e_type)
16512       {
16513       case NT_AUXV:
16514         return _("NT_AUXV (auxiliary vector)");
16515       case NT_PRSTATUS:
16516         return _("NT_PRSTATUS (prstatus structure)");
16517       case NT_FPREGSET:
16518         return _("NT_FPREGSET (floating point registers)");
16519       case NT_PRPSINFO:
16520         return _("NT_PRPSINFO (prpsinfo structure)");
16521       case NT_TASKSTRUCT:
16522         return _("NT_TASKSTRUCT (task structure)");
16523       case NT_PRXFPREG:
16524         return _("NT_PRXFPREG (user_xfpregs structure)");
16525       case NT_PPC_VMX:
16526         return _("NT_PPC_VMX (ppc Altivec registers)");
16527       case NT_PPC_VSX:
16528         return _("NT_PPC_VSX (ppc VSX registers)");
16529       case NT_PPC_TAR:
16530         return _("NT_PPC_TAR (ppc TAR register)");
16531       case NT_PPC_PPR:
16532         return _("NT_PPC_PPR (ppc PPR register)");
16533       case NT_PPC_DSCR:
16534         return _("NT_PPC_DSCR (ppc DSCR register)");
16535       case NT_PPC_EBB:
16536         return _("NT_PPC_EBB (ppc EBB registers)");
16537       case NT_PPC_PMU:
16538         return _("NT_PPC_PMU (ppc PMU registers)");
16539       case NT_PPC_TM_CGPR:
16540         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16541       case NT_PPC_TM_CFPR:
16542         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16543       case NT_PPC_TM_CVMX:
16544         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16545       case NT_PPC_TM_CVSX:
16546         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16547       case NT_PPC_TM_SPR:
16548         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16549       case NT_PPC_TM_CTAR:
16550         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16551       case NT_PPC_TM_CPPR:
16552         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16553       case NT_PPC_TM_CDSCR:
16554         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16555       case NT_386_TLS:
16556         return _("NT_386_TLS (x86 TLS information)");
16557       case NT_386_IOPERM:
16558         return _("NT_386_IOPERM (x86 I/O permissions)");
16559       case NT_X86_XSTATE:
16560         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16561       case NT_S390_HIGH_GPRS:
16562         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16563       case NT_S390_TIMER:
16564         return _("NT_S390_TIMER (s390 timer register)");
16565       case NT_S390_TODCMP:
16566         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16567       case NT_S390_TODPREG:
16568         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16569       case NT_S390_CTRS:
16570         return _("NT_S390_CTRS (s390 control registers)");
16571       case NT_S390_PREFIX:
16572         return _("NT_S390_PREFIX (s390 prefix register)");
16573       case NT_S390_LAST_BREAK:
16574         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16575       case NT_S390_SYSTEM_CALL:
16576         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16577       case NT_S390_TDB:
16578         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16579       case NT_S390_VXRS_LOW:
16580         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16581       case NT_S390_VXRS_HIGH:
16582         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16583       case NT_S390_GS_CB:
16584         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16585       case NT_S390_GS_BC:
16586         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16587       case NT_ARM_VFP:
16588         return _("NT_ARM_VFP (arm VFP registers)");
16589       case NT_ARM_TLS:
16590         return _("NT_ARM_TLS (AArch TLS registers)");
16591       case NT_ARM_HW_BREAK:
16592         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16593       case NT_ARM_HW_WATCH:
16594         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16595       case NT_PSTATUS:
16596         return _("NT_PSTATUS (pstatus structure)");
16597       case NT_FPREGS:
16598         return _("NT_FPREGS (floating point registers)");
16599       case NT_PSINFO:
16600         return _("NT_PSINFO (psinfo structure)");
16601       case NT_LWPSTATUS:
16602         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16603       case NT_LWPSINFO:
16604         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16605       case NT_WIN32PSTATUS:
16606         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16607       case NT_SIGINFO:
16608         return _("NT_SIGINFO (siginfo_t data)");
16609       case NT_FILE:
16610         return _("NT_FILE (mapped files)");
16611       default:
16612         break;
16613       }
16614   else
16615     switch (e_type)
16616       {
16617       case NT_VERSION:
16618         return _("NT_VERSION (version)");
16619       case NT_ARCH:
16620         return _("NT_ARCH (architecture)");
16621       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16622         return _("OPEN");
16623       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16624         return _("func");
16625       default:
16626         break;
16627       }
16628
16629   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16630   return buff;
16631 }
16632
16633 static bfd_boolean
16634 print_core_note (Elf_Internal_Note *pnote)
16635 {
16636   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16637   bfd_vma count, page_size;
16638   unsigned char *descdata, *filenames, *descend;
16639
16640   if (pnote->type != NT_FILE)
16641     {
16642       if (do_wide)
16643         printf ("\n");
16644       return TRUE;
16645     }
16646
16647 #ifndef BFD64
16648   if (!is_32bit_elf)
16649     {
16650       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16651       /* Still "successful".  */
16652       return TRUE;
16653     }
16654 #endif
16655
16656   if (pnote->descsz < 2 * addr_size)
16657     {
16658       error (_("    Malformed note - too short for header\n"));
16659       return FALSE;
16660     }
16661
16662   descdata = (unsigned char *) pnote->descdata;
16663   descend = descdata + pnote->descsz;
16664
16665   if (descdata[pnote->descsz - 1] != '\0')
16666     {
16667       error (_("    Malformed note - does not end with \\0\n"));
16668       return FALSE;
16669     }
16670
16671   count = byte_get (descdata, addr_size);
16672   descdata += addr_size;
16673
16674   page_size = byte_get (descdata, addr_size);
16675   descdata += addr_size;
16676
16677   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16678       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16679     {
16680       error (_("    Malformed note - too short for supplied file count\n"));
16681       return FALSE;
16682     }
16683
16684   printf (_("    Page size: "));
16685   print_vma (page_size, DEC);
16686   printf ("\n");
16687
16688   printf (_("    %*s%*s%*s\n"),
16689           (int) (2 + 2 * addr_size), _("Start"),
16690           (int) (4 + 2 * addr_size), _("End"),
16691           (int) (4 + 2 * addr_size), _("Page Offset"));
16692   filenames = descdata + count * 3 * addr_size;
16693   while (count-- > 0)
16694     {
16695       bfd_vma start, end, file_ofs;
16696
16697       if (filenames == descend)
16698         {
16699           error (_("    Malformed note - filenames end too early\n"));
16700           return FALSE;
16701         }
16702
16703       start = byte_get (descdata, addr_size);
16704       descdata += addr_size;
16705       end = byte_get (descdata, addr_size);
16706       descdata += addr_size;
16707       file_ofs = byte_get (descdata, addr_size);
16708       descdata += addr_size;
16709
16710       printf ("    ");
16711       print_vma (start, FULL_HEX);
16712       printf ("  ");
16713       print_vma (end, FULL_HEX);
16714       printf ("  ");
16715       print_vma (file_ofs, FULL_HEX);
16716       printf ("\n        %s\n", filenames);
16717
16718       filenames += 1 + strlen ((char *) filenames);
16719     }
16720
16721   return TRUE;
16722 }
16723
16724 static const char *
16725 get_gnu_elf_note_type (unsigned e_type)
16726 {
16727   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16728   switch (e_type)
16729     {
16730     case NT_GNU_ABI_TAG:
16731       return _("NT_GNU_ABI_TAG (ABI version tag)");
16732     case NT_GNU_HWCAP:
16733       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16734     case NT_GNU_BUILD_ID:
16735       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16736     case NT_GNU_GOLD_VERSION:
16737       return _("NT_GNU_GOLD_VERSION (gold version)");
16738     case NT_GNU_PROPERTY_TYPE_0:
16739       return _("NT_GNU_PROPERTY_TYPE_0");
16740     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16741       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16742     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16743       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16744     default:
16745       {
16746         static char buff[64];
16747
16748         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16749         return buff;
16750       }
16751     }
16752 }
16753
16754 static void
16755 decode_x86_isa (unsigned int bitmask)
16756 {
16757   while (bitmask)
16758     {
16759       unsigned int bit = bitmask & (- bitmask);
16760
16761       bitmask &= ~ bit;
16762       switch (bit)
16763         {
16764         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16765         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16766         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16767         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16768         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16769         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16770         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16771         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16772         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16773         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16774         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16775         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16776         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16777         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16778         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16779         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16780         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16781         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16782         default: printf (_("<unknown: %x>"), bit); break;
16783         }
16784       if (bitmask)
16785         printf (", ");
16786     }
16787 }
16788
16789 static void
16790 decode_x86_feature (unsigned int type, unsigned int bitmask)
16791 {
16792   while (bitmask)
16793     {
16794       unsigned int bit = bitmask & (- bitmask);
16795
16796       bitmask &= ~ bit;
16797       switch (bit)
16798         {
16799         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16800           switch (type)
16801             {
16802             case GNU_PROPERTY_X86_FEATURE_1_AND:
16803               printf ("IBT");
16804               break;
16805             default:
16806               /* This should never happen.  */
16807               abort ();
16808             }
16809           break;
16810         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16811           switch (type)
16812             {
16813             case GNU_PROPERTY_X86_FEATURE_1_AND:
16814               printf ("SHSTK");
16815               break;
16816             default:
16817               /* This should never happen.  */
16818               abort ();
16819             }
16820           break;
16821         default:
16822           printf (_("<unknown: %x>"), bit);
16823           break;
16824         }
16825       if (bitmask)
16826         printf (", ");
16827     }
16828 }
16829
16830 static void
16831 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
16832 {
16833   unsigned char * ptr = (unsigned char *) pnote->descdata;
16834   unsigned char * ptr_end = ptr + pnote->descsz;
16835   unsigned int    size = is_32bit_elf ? 4 : 8;
16836
16837   printf (_("      Properties: "));
16838
16839   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16840     {
16841       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16842       return;
16843     }
16844
16845   while (ptr < ptr_end)
16846     {
16847       unsigned int j;
16848       unsigned int type;
16849       unsigned int datasz;
16850
16851       if ((size_t) (ptr_end - ptr) < 8)
16852         {
16853           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16854           break;
16855         }
16856
16857       type = byte_get (ptr, 4);
16858       datasz = byte_get (ptr + 4, 4);
16859
16860       ptr += 8;
16861
16862       if (datasz > (size_t) (ptr_end - ptr))
16863         {
16864           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16865                   type, datasz);
16866           break;
16867         }
16868
16869       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16870         {
16871           if (filedata->file_header.e_machine == EM_X86_64
16872               || filedata->file_header.e_machine == EM_IAMCU
16873               || filedata->file_header.e_machine == EM_386)
16874             {
16875               switch (type)
16876                 {
16877                 case GNU_PROPERTY_X86_ISA_1_USED:
16878                   printf ("x86 ISA used: ");
16879                   if (datasz != 4)
16880                     printf (_("<corrupt length: %#x> "), datasz);
16881                   else
16882                     decode_x86_isa (byte_get (ptr, 4));
16883                   goto next;
16884
16885                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16886                   printf ("x86 ISA needed: ");
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_FEATURE_1_AND:
16894                   printf ("x86 feature: ");
16895                   if (datasz != 4)
16896                     printf (_("<corrupt length: %#x> "), datasz);
16897                   else
16898                     decode_x86_feature (type, byte_get (ptr, 4));
16899                   goto next;
16900
16901                 default:
16902                   break;
16903                 }
16904             }
16905         }
16906       else
16907         {
16908           switch (type)
16909             {
16910             case GNU_PROPERTY_STACK_SIZE:
16911               printf (_("stack size: "));
16912               if (datasz != size)
16913                 printf (_("<corrupt length: %#x> "), datasz);
16914               else
16915                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16916               goto next;
16917
16918             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16919               printf ("no copy on protected ");
16920               if (datasz)
16921                 printf (_("<corrupt length: %#x> "), datasz);
16922               goto next;
16923
16924             default:
16925               break;
16926             }
16927         }
16928
16929       if (type < GNU_PROPERTY_LOPROC)
16930         printf (_("<unknown type %#x data: "), type);
16931       else if (type < GNU_PROPERTY_LOUSER)
16932         printf (_("<procesor-specific type %#x data: "), type);
16933       else
16934         printf (_("<application-specific type %#x data: "), type);
16935       for (j = 0; j < datasz; ++j)
16936         printf ("%02x ", ptr[j] & 0xff);
16937       printf (">");
16938
16939 next:
16940       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16941       if (ptr == ptr_end)
16942         break;
16943
16944       if (do_wide)
16945         printf (", ");
16946       else
16947         printf ("\n\t");
16948     }
16949
16950   printf ("\n");
16951 }
16952
16953 static bfd_boolean
16954 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
16955 {
16956   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16957   switch (pnote->type)
16958     {
16959     case NT_GNU_BUILD_ID:
16960       {
16961         unsigned long i;
16962
16963         printf (_("    Build ID: "));
16964         for (i = 0; i < pnote->descsz; ++i)
16965           printf ("%02x", pnote->descdata[i] & 0xff);
16966         printf ("\n");
16967       }
16968       break;
16969
16970     case NT_GNU_ABI_TAG:
16971       {
16972         unsigned long os, major, minor, subminor;
16973         const char *osname;
16974
16975         /* PR 17531: file: 030-599401-0.004.  */
16976         if (pnote->descsz < 16)
16977           {
16978             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16979             break;
16980           }
16981
16982         os = byte_get ((unsigned char *) pnote->descdata, 4);
16983         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16984         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16985         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16986
16987         switch (os)
16988           {
16989           case GNU_ABI_TAG_LINUX:
16990             osname = "Linux";
16991             break;
16992           case GNU_ABI_TAG_HURD:
16993             osname = "Hurd";
16994             break;
16995           case GNU_ABI_TAG_SOLARIS:
16996             osname = "Solaris";
16997             break;
16998           case GNU_ABI_TAG_FREEBSD:
16999             osname = "FreeBSD";
17000             break;
17001           case GNU_ABI_TAG_NETBSD:
17002             osname = "NetBSD";
17003             break;
17004           case GNU_ABI_TAG_SYLLABLE:
17005             osname = "Syllable";
17006             break;
17007           case GNU_ABI_TAG_NACL:
17008             osname = "NaCl";
17009             break;
17010           default:
17011             osname = "Unknown";
17012             break;
17013           }
17014
17015         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17016                 major, minor, subminor);
17017       }
17018       break;
17019
17020     case NT_GNU_GOLD_VERSION:
17021       {
17022         unsigned long i;
17023
17024         printf (_("    Version: "));
17025         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17026           printf ("%c", pnote->descdata[i]);
17027         printf ("\n");
17028       }
17029       break;
17030
17031     case NT_GNU_HWCAP:
17032       {
17033         unsigned long num_entries, mask;
17034
17035         /* Hardware capabilities information.  Word 0 is the number of entries.
17036            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17037            is a series of entries, where each entry is a single byte followed
17038            by a nul terminated string.  The byte gives the bit number to test
17039            if enabled in the bitmask.  */
17040         printf (_("      Hardware Capabilities: "));
17041         if (pnote->descsz < 8)
17042           {
17043             error (_("<corrupt GNU_HWCAP>\n"));
17044             return FALSE;
17045           }
17046         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17047         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17048         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17049         /* FIXME: Add code to display the entries... */
17050       }
17051       break;
17052
17053     case NT_GNU_PROPERTY_TYPE_0:
17054       print_gnu_property_note (filedata, pnote);
17055       break;
17056
17057     default:
17058       /* Handle unrecognised types.  An error message should have already been
17059          created by get_gnu_elf_note_type(), so all that we need to do is to
17060          display the data.  */
17061       {
17062         unsigned long i;
17063
17064         printf (_("    Description data: "));
17065         for (i = 0; i < pnote->descsz; ++i)
17066           printf ("%02x ", pnote->descdata[i] & 0xff);
17067         printf ("\n");
17068       }
17069       break;
17070     }
17071
17072   return TRUE;
17073 }
17074
17075 static const char *
17076 get_v850_elf_note_type (enum v850_notes n_type)
17077 {
17078   static char buff[64];
17079
17080   switch (n_type)
17081     {
17082     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17083     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17084     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17085     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17086     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17087     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17088     default:
17089       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17090       return buff;
17091     }
17092 }
17093
17094 static bfd_boolean
17095 print_v850_note (Elf_Internal_Note * pnote)
17096 {
17097   unsigned int val;
17098
17099   if (pnote->descsz != 4)
17100     return FALSE;
17101
17102   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17103
17104   if (val == 0)
17105     {
17106       printf (_("not set\n"));
17107       return TRUE;
17108     }
17109
17110   switch (pnote->type)
17111     {
17112     case V850_NOTE_ALIGNMENT:
17113       switch (val)
17114         {
17115         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17116         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17117         }
17118       break;
17119
17120     case V850_NOTE_DATA_SIZE:
17121       switch (val)
17122         {
17123         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17124         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17125         }
17126       break;
17127
17128     case V850_NOTE_FPU_INFO:
17129       switch (val)
17130         {
17131         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17132         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17133         }
17134       break;
17135
17136     case V850_NOTE_MMU_INFO:
17137     case V850_NOTE_CACHE_INFO:
17138     case V850_NOTE_SIMD_INFO:
17139       if (val == EF_RH850_SIMD)
17140         {
17141           printf (_("yes\n"));
17142           return TRUE;
17143         }
17144       break;
17145
17146     default:
17147       /* An 'unknown note type' message will already have been displayed.  */
17148       break;
17149     }
17150
17151   printf (_("unknown value: %x\n"), val);
17152   return FALSE;
17153 }
17154
17155 static bfd_boolean
17156 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17157 {
17158   unsigned int version;
17159
17160   switch (pnote->type)
17161     {
17162     case NT_NETBSD_IDENT:
17163       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17164       if ((version / 10000) % 100)
17165         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17166                 version, version / 100000000, (version / 1000000) % 100,
17167                 (version / 10000) % 100 > 26 ? "Z" : "",
17168                 'A' + (version / 10000) % 26);
17169       else
17170         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17171                 version, version / 100000000, (version / 1000000) % 100,
17172                 (version / 100) % 100);
17173       return TRUE;
17174
17175     case NT_NETBSD_MARCH:
17176       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17177               pnote->descdata);
17178       return TRUE;
17179
17180     default:
17181       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17182               pnote->type);
17183       return FALSE;
17184     }
17185 }
17186
17187 static const char *
17188 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17189 {
17190   switch (e_type)
17191     {
17192     case NT_FREEBSD_THRMISC:
17193       return _("NT_THRMISC (thrmisc structure)");
17194     case NT_FREEBSD_PROCSTAT_PROC:
17195       return _("NT_PROCSTAT_PROC (proc data)");
17196     case NT_FREEBSD_PROCSTAT_FILES:
17197       return _("NT_PROCSTAT_FILES (files data)");
17198     case NT_FREEBSD_PROCSTAT_VMMAP:
17199       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17200     case NT_FREEBSD_PROCSTAT_GROUPS:
17201       return _("NT_PROCSTAT_GROUPS (groups data)");
17202     case NT_FREEBSD_PROCSTAT_UMASK:
17203       return _("NT_PROCSTAT_UMASK (umask data)");
17204     case NT_FREEBSD_PROCSTAT_RLIMIT:
17205       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17206     case NT_FREEBSD_PROCSTAT_OSREL:
17207       return _("NT_PROCSTAT_OSREL (osreldate data)");
17208     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17209       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17210     case NT_FREEBSD_PROCSTAT_AUXV:
17211       return _("NT_PROCSTAT_AUXV (auxv data)");
17212     case NT_FREEBSD_PTLWPINFO:
17213       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17214     }
17215   return get_note_type (filedata, e_type);
17216 }
17217
17218 static const char *
17219 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17220 {
17221   static char buff[64];
17222
17223   if (e_type == NT_NETBSDCORE_PROCINFO)
17224     return _("NetBSD procinfo structure");
17225
17226   /* As of Jan 2002 there are no other machine-independent notes
17227      defined for NetBSD core files.  If the note type is less
17228      than the start of the machine-dependent note types, we don't
17229      understand it.  */
17230
17231   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17232     {
17233       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17234       return buff;
17235     }
17236
17237   switch (filedata->file_header.e_machine)
17238     {
17239     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17240        and PT_GETFPREGS == mach+2.  */
17241
17242     case EM_OLD_ALPHA:
17243     case EM_ALPHA:
17244     case EM_SPARC:
17245     case EM_SPARC32PLUS:
17246     case EM_SPARCV9:
17247       switch (e_type)
17248         {
17249         case NT_NETBSDCORE_FIRSTMACH + 0:
17250           return _("PT_GETREGS (reg structure)");
17251         case NT_NETBSDCORE_FIRSTMACH + 2:
17252           return _("PT_GETFPREGS (fpreg structure)");
17253         default:
17254           break;
17255         }
17256       break;
17257
17258     /* On all other arch's, PT_GETREGS == mach+1 and
17259        PT_GETFPREGS == mach+3.  */
17260     default:
17261       switch (e_type)
17262         {
17263         case NT_NETBSDCORE_FIRSTMACH + 1:
17264           return _("PT_GETREGS (reg structure)");
17265         case NT_NETBSDCORE_FIRSTMACH + 3:
17266           return _("PT_GETFPREGS (fpreg structure)");
17267         default:
17268           break;
17269         }
17270     }
17271
17272   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17273             e_type - NT_NETBSDCORE_FIRSTMACH);
17274   return buff;
17275 }
17276
17277 static const char *
17278 get_stapsdt_note_type (unsigned e_type)
17279 {
17280   static char buff[64];
17281
17282   switch (e_type)
17283     {
17284     case NT_STAPSDT:
17285       return _("NT_STAPSDT (SystemTap probe descriptors)");
17286
17287     default:
17288       break;
17289     }
17290
17291   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17292   return buff;
17293 }
17294
17295 static bfd_boolean
17296 print_stapsdt_note (Elf_Internal_Note *pnote)
17297 {
17298   int addr_size = is_32bit_elf ? 4 : 8;
17299   char *data = pnote->descdata;
17300   char *data_end = pnote->descdata + pnote->descsz;
17301   bfd_vma pc, base_addr, semaphore;
17302   char *provider, *probe, *arg_fmt;
17303
17304   pc = byte_get ((unsigned char *) data, addr_size);
17305   data += addr_size;
17306   base_addr = byte_get ((unsigned char *) data, addr_size);
17307   data += addr_size;
17308   semaphore = byte_get ((unsigned char *) data, addr_size);
17309   data += addr_size;
17310
17311   provider = data;
17312   data += strlen (data) + 1;
17313   probe = data;
17314   data += strlen (data) + 1;
17315   arg_fmt = data;
17316   data += strlen (data) + 1;
17317
17318   printf (_("    Provider: %s\n"), provider);
17319   printf (_("    Name: %s\n"), probe);
17320   printf (_("    Location: "));
17321   print_vma (pc, FULL_HEX);
17322   printf (_(", Base: "));
17323   print_vma (base_addr, FULL_HEX);
17324   printf (_(", Semaphore: "));
17325   print_vma (semaphore, FULL_HEX);
17326   printf ("\n");
17327   printf (_("    Arguments: %s\n"), arg_fmt);
17328
17329   return data == data_end;
17330 }
17331
17332 static const char *
17333 get_ia64_vms_note_type (unsigned e_type)
17334 {
17335   static char buff[64];
17336
17337   switch (e_type)
17338     {
17339     case NT_VMS_MHD:
17340       return _("NT_VMS_MHD (module header)");
17341     case NT_VMS_LNM:
17342       return _("NT_VMS_LNM (language name)");
17343     case NT_VMS_SRC:
17344       return _("NT_VMS_SRC (source files)");
17345     case NT_VMS_TITLE:
17346       return "NT_VMS_TITLE";
17347     case NT_VMS_EIDC:
17348       return _("NT_VMS_EIDC (consistency check)");
17349     case NT_VMS_FPMODE:
17350       return _("NT_VMS_FPMODE (FP mode)");
17351     case NT_VMS_LINKTIME:
17352       return "NT_VMS_LINKTIME";
17353     case NT_VMS_IMGNAM:
17354       return _("NT_VMS_IMGNAM (image name)");
17355     case NT_VMS_IMGID:
17356       return _("NT_VMS_IMGID (image id)");
17357     case NT_VMS_LINKID:
17358       return _("NT_VMS_LINKID (link id)");
17359     case NT_VMS_IMGBID:
17360       return _("NT_VMS_IMGBID (build id)");
17361     case NT_VMS_GSTNAM:
17362       return _("NT_VMS_GSTNAM (sym table name)");
17363     case NT_VMS_ORIG_DYN:
17364       return "NT_VMS_ORIG_DYN";
17365     case NT_VMS_PATCHTIME:
17366       return "NT_VMS_PATCHTIME";
17367     default:
17368       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17369       return buff;
17370     }
17371 }
17372
17373 static bfd_boolean
17374 print_ia64_vms_note (Elf_Internal_Note * pnote)
17375 {
17376   switch (pnote->type)
17377     {
17378     case NT_VMS_MHD:
17379       if (pnote->descsz > 36)
17380         {
17381           size_t l = strlen (pnote->descdata + 34);
17382           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17383           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17384           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17385           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17386         }
17387       else
17388         printf (_("    Invalid size\n"));
17389       break;
17390     case NT_VMS_LNM:
17391       printf (_("   Language: %s\n"), pnote->descdata);
17392       break;
17393 #ifdef BFD64
17394     case NT_VMS_FPMODE:
17395       printf (_("   Floating Point mode: "));
17396       printf ("0x%016" BFD_VMA_FMT "x\n",
17397               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17398       break;
17399     case NT_VMS_LINKTIME:
17400       printf (_("   Link time: "));
17401       print_vms_time
17402         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17403       printf ("\n");
17404       break;
17405     case NT_VMS_PATCHTIME:
17406       printf (_("   Patch time: "));
17407       print_vms_time
17408         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17409       printf ("\n");
17410       break;
17411     case NT_VMS_ORIG_DYN:
17412       printf (_("   Major id: %u,  minor id: %u\n"),
17413               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17414               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17415       printf (_("   Last modified  : "));
17416       print_vms_time
17417         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17418       printf (_("\n   Link flags  : "));
17419       printf ("0x%016" BFD_VMA_FMT "x\n",
17420               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17421       printf (_("   Header flags: 0x%08x\n"),
17422               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17423       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17424       break;
17425 #endif
17426     case NT_VMS_IMGNAM:
17427       printf (_("    Image name: %s\n"), pnote->descdata);
17428       break;
17429     case NT_VMS_GSTNAM:
17430       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17431       break;
17432     case NT_VMS_IMGID:
17433       printf (_("    Image id: %s\n"), pnote->descdata);
17434       break;
17435     case NT_VMS_LINKID:
17436       printf (_("    Linker id: %s\n"), pnote->descdata);
17437       break;
17438     default:
17439       return FALSE;
17440     }
17441   return TRUE;
17442 }
17443
17444 /* Find the symbol associated with a build attribute that is attached
17445    to address OFFSET.  If PNAME is non-NULL then store the name of
17446    the symbol (if found) in the provided pointer,  Returns NULL if a
17447    symbol could not be found.  */
17448
17449 static Elf_Internal_Sym *
17450 get_symbol_for_build_attribute (Filedata *       filedata,
17451                                 unsigned long    offset,
17452                                 bfd_boolean      is_open_attr,
17453                                 const char **    pname)
17454 {
17455   static Filedata *         saved_filedata = NULL;
17456   static char *             strtab;
17457   static unsigned long      strtablen;
17458   static Elf_Internal_Sym * symtab;
17459   static unsigned long      nsyms;
17460   Elf_Internal_Sym *        saved_sym = NULL;
17461   Elf_Internal_Sym *        sym;
17462
17463   if (filedata->section_headers != NULL
17464       && (saved_filedata == NULL || filedata != saved_filedata))
17465     {
17466       Elf_Internal_Shdr * symsec;
17467
17468       /* Load the symbol and string sections.  */
17469       for (symsec = filedata->section_headers;
17470            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17471            symsec ++)
17472         {
17473           if (symsec->sh_type == SHT_SYMTAB)
17474             {
17475               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17476
17477               if (symsec->sh_link < filedata->file_header.e_shnum)
17478                 {
17479                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17480
17481                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17482                                               1, strtab_sec->sh_size,
17483                                               _("string table"));
17484                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17485                 }
17486             }
17487         }
17488       saved_filedata = filedata;
17489     }
17490
17491   if (symtab == NULL || strtab == NULL)
17492     return NULL;
17493
17494   /* Find a symbol whose value matches offset.  */
17495   for (sym = symtab; sym < symtab + nsyms; sym ++)
17496     if (sym->st_value == offset)
17497       {
17498         if (sym->st_name >= strtablen)
17499           /* Huh ?  This should not happen.  */
17500           continue;
17501
17502         if (strtab[sym->st_name] == 0)
17503           continue;
17504
17505         if (is_open_attr)
17506           {
17507             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17508                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17509                FUNC symbols entirely.  */
17510             switch (ELF_ST_TYPE (sym->st_info))
17511               {
17512               case STT_OBJECT:
17513               case STT_FILE:
17514                 saved_sym = sym;
17515                 if (sym->st_size)
17516                   {
17517                     /* If the symbol has a size associated
17518                        with it then we can stop searching.  */
17519                     sym = symtab + nsyms;
17520                   }
17521                 continue;
17522
17523               case STT_FUNC:
17524                 /* Ignore function symbols.  */
17525                 continue;
17526
17527               default:
17528                 break;
17529               }
17530
17531             switch (ELF_ST_BIND (sym->st_info))
17532               {
17533               case STB_GLOBAL:
17534                 if (saved_sym == NULL
17535                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17536                   saved_sym = sym;
17537                 break;
17538
17539               case STB_LOCAL:
17540                 if (saved_sym == NULL)
17541                   saved_sym = sym;
17542                 break;
17543
17544               default:
17545                 break;
17546               }
17547           }
17548         else
17549           {
17550             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17551               continue;
17552
17553             saved_sym = sym;
17554             break;
17555           }
17556       }
17557
17558   if (saved_sym && pname)
17559     * pname = strtab + saved_sym->st_name;
17560
17561   return saved_sym;
17562 }
17563
17564 static bfd_boolean
17565 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
17566                                        Filedata *           filedata)
17567 {
17568   static unsigned long  global_offset = 0;
17569   static unsigned long  global_end = 0;
17570   static unsigned long  func_offset = 0;
17571   static unsigned long  func_end = 0;
17572
17573   Elf_Internal_Sym *    sym;
17574   const char *          name;
17575   unsigned long         start;
17576   unsigned long         end;
17577   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17578
17579   switch (pnote->descsz)
17580     {
17581     case 0:
17582       /* A zero-length description means that the range of
17583          the previous note of the same type should be used.  */
17584       if (is_open_attr)
17585         {
17586           if (global_end > global_offset)
17587             printf (_("    Applies to region from %#lx to %#lx\n"),
17588                     global_offset, global_end);
17589           else
17590             printf (_("    Applies to region from %#lx\n"), global_offset);
17591         }
17592       else
17593         {
17594           if (func_end > func_offset)
17595             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
17596           else
17597             printf (_("    Applies to region from %#lx\n"), func_offset);
17598         }
17599       return TRUE;
17600
17601     case 4:
17602       start = byte_get ((unsigned char *) pnote->descdata, 4);
17603       end = 0;
17604       break;
17605
17606     case 8:
17607       if (is_32bit_elf)
17608         {
17609           /* FIXME: We should check that version 3+ notes are being used here...  */
17610           start = byte_get ((unsigned char *) pnote->descdata, 4);
17611           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17612         }
17613       else
17614         {
17615           start = byte_get ((unsigned char *) pnote->descdata, 8);
17616           end = 0;
17617         }
17618       break;
17619
17620     case 16:
17621       start = byte_get ((unsigned char *) pnote->descdata, 8);
17622       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
17623       break;
17624
17625     default:
17626       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17627       printf (_("    <invalid descsz>"));
17628       return FALSE;
17629     }
17630
17631   name = NULL;
17632   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
17633
17634   if (end == 0 && sym != NULL && sym->st_size > 0)
17635     end = start + sym->st_size;
17636
17637   if (is_open_attr)
17638     {
17639       /* FIXME: Need to properly allow for section alignment.  16 is just the alignment used on x86_64.  */
17640       if (global_end > 0 && start > BFD_ALIGN (global_end, 16))
17641         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17642               global_end + 1, start - 1);
17643
17644       printf (_("    Applies to region from %#lx"), start);
17645       global_offset = start;
17646
17647       if (end)
17648         {
17649           printf (_(" to %#lx"), end);
17650           global_end = end;
17651         }
17652     }
17653   else
17654     {
17655       printf (_("    Applies to region from %#lx"), start);
17656       func_offset = start;
17657
17658       if (end)
17659         {
17660           printf (_(" to %#lx"), end);
17661           func_end = end;
17662         }
17663     }
17664
17665   if (sym && name)
17666     printf (_(" (%s)"), name);
17667
17668   printf ("\n");
17669   return TRUE;
17670 }
17671
17672 static bfd_boolean
17673 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17674 {
17675   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17676   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17677   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17678   char         name_type;
17679   char         name_attribute;
17680   const char * expected_types;
17681   const char * name = pnote->namedata;
17682   const char * text;
17683   signed int   left;
17684
17685   if (name == NULL || pnote->namesz < 2)
17686     {
17687       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17688       print_symbol (-20, _("  <corrupt name>"));
17689       return FALSE;
17690     }
17691
17692   if (do_wide)
17693     left = 28;
17694   else
17695     left = 20;
17696
17697   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17698   if (name[0] == 'G' && name[1] == 'A')
17699     {
17700       if (pnote->namesz < 4)
17701         {
17702           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17703           print_symbol (-20, _("  <corrupt name>"));
17704           return FALSE;
17705         }
17706
17707       printf ("GA");
17708       name += 2;
17709       left -= 2;
17710     }
17711
17712   switch ((name_type = * name))
17713     {
17714     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17715     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17716     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17717     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17718       printf ("%c", * name);
17719       left --;
17720       break;
17721     default:
17722       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17723       print_symbol (-20, _("<unknown name type>"));
17724       return FALSE;
17725     }
17726
17727   ++ name;
17728   text = NULL;
17729
17730   switch ((name_attribute = * name))
17731     {
17732     case GNU_BUILD_ATTRIBUTE_VERSION:
17733       text = _("<version>");
17734       expected_types = string_expected;
17735       ++ name;
17736       break;
17737     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17738       text = _("<stack prot>");
17739       expected_types = "!+*";
17740       ++ name;
17741       break;
17742     case GNU_BUILD_ATTRIBUTE_RELRO:
17743       text = _("<relro>");
17744       expected_types = bool_expected;
17745       ++ name;
17746       break;
17747     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17748       text = _("<stack size>");
17749       expected_types = number_expected;
17750       ++ name;
17751       break;
17752     case GNU_BUILD_ATTRIBUTE_TOOL:
17753       text = _("<tool>");
17754       expected_types = string_expected;
17755       ++ name;
17756       break;
17757     case GNU_BUILD_ATTRIBUTE_ABI:
17758       text = _("<ABI>");
17759       expected_types = "$*";
17760       ++ name;
17761       break;
17762     case GNU_BUILD_ATTRIBUTE_PIC:
17763       text = _("<PIC>");
17764       expected_types = number_expected;
17765       ++ name;
17766       break;
17767     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17768       text = _("<short enum>");
17769       expected_types = bool_expected;
17770       ++ name;
17771       break;
17772     default:
17773       if (ISPRINT (* name))
17774         {
17775           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17776
17777           if (len > left && ! do_wide)
17778             len = left;
17779           printf ("%.*s:", len, name);
17780           left -= len;
17781           name += len;
17782         }
17783       else
17784         {
17785           static char tmpbuf [128];
17786
17787           error (_("unrecognised byte in name field: %d\n"), * name);
17788           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17789           text = tmpbuf;
17790           name ++;
17791         }
17792       expected_types = "*$!+";
17793       break;
17794     }
17795
17796   if (text)
17797     left -= printf ("%s", text);
17798
17799   if (strchr (expected_types, name_type) == NULL)
17800     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17801
17802   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17803     {
17804       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17805              (unsigned long) pnote->namesz,
17806              (long) (name - pnote->namedata));
17807       return FALSE;
17808     }
17809
17810   if (left < 1 && ! do_wide)
17811     return TRUE;
17812
17813   switch (name_type)
17814     {
17815     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17816       {
17817         unsigned int        bytes;
17818         unsigned long long  val = 0;
17819         unsigned int        shift = 0;
17820         char *              decoded = NULL;
17821
17822         bytes = pnote->namesz - (name - pnote->namedata);
17823         if (bytes > 0)
17824           /* The -1 is because the name field is always 0 terminated, and we
17825              want to be able to ensure that the shift in the while loop below
17826              will not overflow.  */
17827           -- bytes;
17828
17829         if (bytes > sizeof (val))
17830           {
17831             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17832                    bytes);
17833             bytes = sizeof (val);
17834           }
17835         /* We do not bother to warn if bytes == 0 as this can
17836            happen with some early versions of the gcc plugin.  */
17837
17838         while (bytes --)
17839           {
17840             unsigned long byte = (* name ++) & 0xff;
17841
17842             val |= byte << shift;
17843             shift += 8;
17844           }
17845
17846         switch (name_attribute)
17847           {
17848           case GNU_BUILD_ATTRIBUTE_PIC:
17849             switch (val)
17850               {
17851               case 0: decoded = "static"; break;
17852               case 1: decoded = "pic"; break;
17853               case 2: decoded = "PIC"; break;
17854               case 3: decoded = "pie"; break;
17855               case 4: decoded = "PIE"; break;
17856               default: break;
17857               }
17858             break;
17859           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17860             switch (val)
17861               {
17862                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17863               case 0: decoded = "off"; break;
17864               case 1: decoded = "on"; break;
17865               case 2: decoded = "all"; break;
17866               case 3: decoded = "strong"; break;
17867               case 4: decoded = "explicit"; break;
17868               default: break;
17869               }
17870             break;
17871           default:
17872             break;
17873           }
17874
17875         if (decoded != NULL)
17876           {
17877             print_symbol (-left, decoded);
17878             left = 0;
17879           }
17880         else if (val == 0)
17881           {
17882             printf ("0x0");
17883             left -= 3;
17884           }
17885         else
17886           {
17887             if (do_wide)
17888               left -= printf ("0x%llx", val);
17889             else
17890               left -= printf ("0x%-.*llx", left, val);
17891           }
17892       }
17893       break;
17894     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17895       left -= print_symbol (- left, name);
17896       break;
17897     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17898       left -= print_symbol (- left, "true");
17899       break;
17900     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17901       left -= print_symbol (- left, "false");
17902       break;
17903     }
17904
17905   if (do_wide && left > 0)
17906     printf ("%-*s", left, " ");
17907
17908   return TRUE;
17909 }
17910
17911 /* Note that by the ELF standard, the name field is already null byte
17912    terminated, and namesz includes the terminating null byte.
17913    I.E. the value of namesz for the name "FSF" is 4.
17914
17915    If the value of namesz is zero, there is no name present.  */
17916
17917 static bfd_boolean
17918 process_note (Elf_Internal_Note *  pnote,
17919               Filedata *           filedata)
17920 {
17921   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17922   const char * nt;
17923
17924   if (pnote->namesz == 0)
17925     /* If there is no note name, then use the default set of
17926        note type strings.  */
17927     nt = get_note_type (filedata, pnote->type);
17928
17929   else if (const_strneq (pnote->namedata, "GNU"))
17930     /* GNU-specific object file notes.  */
17931     nt = get_gnu_elf_note_type (pnote->type);
17932
17933   else if (const_strneq (pnote->namedata, "FreeBSD"))
17934     /* FreeBSD-specific core file notes.  */
17935     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
17936
17937   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17938     /* NetBSD-specific core file notes.  */
17939     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
17940
17941   else if (const_strneq (pnote->namedata, "NetBSD"))
17942     /* NetBSD-specific core file notes.  */
17943     return process_netbsd_elf_note (pnote);
17944
17945   else if (strneq (pnote->namedata, "SPU/", 4))
17946     {
17947       /* SPU-specific core file notes.  */
17948       nt = pnote->namedata + 4;
17949       name = "SPU";
17950     }
17951
17952   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17953     /* VMS/ia64-specific file notes.  */
17954     nt = get_ia64_vms_note_type (pnote->type);
17955
17956   else if (const_strneq (pnote->namedata, "stapsdt"))
17957     nt = get_stapsdt_note_type (pnote->type);
17958
17959   else
17960     /* Don't recognize this note name; just use the default set of
17961        note type strings.  */
17962     nt = get_note_type (filedata, pnote->type);
17963
17964   printf ("  ");
17965
17966   if (((const_strneq (pnote->namedata, "GA")
17967         && strchr ("*$!+", pnote->namedata[2]) != NULL)
17968        || strchr ("*$!+", pnote->namedata[0]) != NULL)
17969       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17970           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17971     print_gnu_build_attribute_name (pnote);
17972   else
17973     print_symbol (-20, name);
17974
17975   if (do_wide)
17976     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17977   else
17978     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17979
17980   if (const_strneq (pnote->namedata, "IPF/VMS"))
17981     return print_ia64_vms_note (pnote);
17982   else if (const_strneq (pnote->namedata, "GNU"))
17983     return print_gnu_note (filedata, pnote);
17984   else if (const_strneq (pnote->namedata, "stapsdt"))
17985     return print_stapsdt_note (pnote);
17986   else if (const_strneq (pnote->namedata, "CORE"))
17987     return print_core_note (pnote);
17988   else if (((const_strneq (pnote->namedata, "GA")
17989              && strchr ("*$!+", pnote->namedata[2]) != NULL)
17990             || strchr ("*$!+", pnote->namedata[0]) != NULL)
17991            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17992                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17993     return print_gnu_build_attribute_description (pnote, filedata);
17994
17995   if (pnote->descsz)
17996     {
17997       unsigned long i;
17998
17999       printf (_("   description data: "));
18000       for (i = 0; i < pnote->descsz; i++)
18001         printf ("%02x ", pnote->descdata[i]);
18002       if (!do_wide)
18003         printf ("\n");
18004     }
18005
18006   if (do_wide)
18007     printf ("\n");
18008
18009   return TRUE;
18010 }
18011
18012 static bfd_boolean
18013 process_notes_at (Filedata *           filedata,
18014                   Elf_Internal_Shdr *  section,
18015                   bfd_vma              offset,
18016                   bfd_vma              length,
18017                   bfd_vma              align)
18018 {
18019   Elf_External_Note * pnotes;
18020   Elf_External_Note * external;
18021   char *              end;
18022   bfd_boolean         res = TRUE;
18023
18024   if (length <= 0)
18025     return FALSE;
18026
18027   if (section)
18028     {
18029       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18030       if (pnotes)
18031         {
18032           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18033             return FALSE;
18034         }
18035     }
18036   else
18037     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18038                                              _("notes"));
18039
18040   if (pnotes == NULL)
18041     return FALSE;
18042
18043   external = pnotes;
18044
18045   if (section)
18046     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18047   else
18048     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18049             (unsigned long) offset, (unsigned long) length);
18050
18051   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18052      specifies that notes should be aligned to 4 bytes in 32-bit
18053      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18054      we also support 4 byte alignment in 64-bit objects.  If section
18055      alignment is less than 4, we treate alignment as 4 bytes.   */
18056   if (align < 4)
18057     align = 4;
18058   else if (align != 4 && align != 8)
18059     {
18060       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18061             (long) align);
18062       return FALSE;
18063     }
18064
18065   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18066
18067   end = (char *) pnotes + length;
18068   while ((char *) external < end)
18069     {
18070       Elf_Internal_Note inote;
18071       size_t min_notesz;
18072       char * next;
18073       char * temp = NULL;
18074       size_t data_remaining = end - (char *) external;
18075
18076       if (!is_ia64_vms (filedata))
18077         {
18078           /* PR binutils/15191
18079              Make sure that there is enough data to read.  */
18080           min_notesz = offsetof (Elf_External_Note, name);
18081           if (data_remaining < min_notesz)
18082             {
18083               warn (ngettext ("Corrupt note: only %ld byte remains, "
18084                               "not enough for a full note\n",
18085                               "Corrupt note: only %ld bytes remain, "
18086                               "not enough for a full note\n",
18087                               data_remaining),
18088                     (long) data_remaining);
18089               break;
18090             }
18091           data_remaining -= min_notesz;
18092
18093           inote.type     = BYTE_GET (external->type);
18094           inote.namesz   = BYTE_GET (external->namesz);
18095           inote.namedata = external->name;
18096           inote.descsz   = BYTE_GET (external->descsz);
18097           inote.descdata = ((char *) external
18098                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18099           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18100           next = ((char *) external
18101                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18102         }
18103       else
18104         {
18105           Elf64_External_VMS_Note *vms_external;
18106
18107           /* PR binutils/15191
18108              Make sure that there is enough data to read.  */
18109           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18110           if (data_remaining < min_notesz)
18111             {
18112               warn (ngettext ("Corrupt note: only %ld byte remains, "
18113                               "not enough for a full note\n",
18114                               "Corrupt note: only %ld bytes remain, "
18115                               "not enough for a full note\n",
18116                               data_remaining),
18117                     (long) data_remaining);
18118               break;
18119             }
18120           data_remaining -= min_notesz;
18121
18122           vms_external = (Elf64_External_VMS_Note *) external;
18123           inote.type     = BYTE_GET (vms_external->type);
18124           inote.namesz   = BYTE_GET (vms_external->namesz);
18125           inote.namedata = vms_external->name;
18126           inote.descsz   = BYTE_GET (vms_external->descsz);
18127           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18128           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18129           next = inote.descdata + align_power (inote.descsz, 3);
18130         }
18131
18132       /* PR 17531: file: 3443835e.  */
18133       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18134       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18135           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18136           || (size_t) (next - inote.descdata) < inote.descsz
18137           || ((size_t) (next - inote.descdata)
18138               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18139         {
18140           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18141                 (unsigned long) ((char *) external - (char *) pnotes));
18142           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18143                 inote.type, inote.namesz, inote.descsz, (int) align);
18144           break;
18145         }
18146
18147       external = (Elf_External_Note *) next;
18148
18149       /* Verify that name is null terminated.  It appears that at least
18150          one version of Linux (RedHat 6.0) generates corefiles that don't
18151          comply with the ELF spec by failing to include the null byte in
18152          namesz.  */
18153       if (inote.namedata[inote.namesz - 1] != '\0')
18154         {
18155           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18156             {
18157               temp = (char *) malloc (inote.namesz + 1);
18158               if (temp == NULL)
18159                 {
18160                   error (_("Out of memory allocating space for inote name\n"));
18161                   res = FALSE;
18162                   break;
18163                 }
18164
18165               memcpy (temp, inote.namedata, inote.namesz);
18166               inote.namedata = temp;
18167             }
18168           inote.namedata[inote.namesz] = 0;
18169         }
18170
18171       if (! process_note (& inote, filedata))
18172         res = FALSE;
18173
18174       if (temp != NULL)
18175         {
18176           free (temp);
18177           temp = NULL;
18178         }
18179     }
18180
18181   free (pnotes);
18182
18183   return res;
18184 }
18185
18186 static bfd_boolean
18187 process_corefile_note_segments (Filedata * filedata)
18188 {
18189   Elf_Internal_Phdr * segment;
18190   unsigned int i;
18191   bfd_boolean res = TRUE;
18192
18193   if (! get_program_headers (filedata))
18194     return TRUE;
18195
18196   for (i = 0, segment = filedata->program_headers;
18197        i < filedata->file_header.e_phnum;
18198        i++, segment++)
18199     {
18200       if (segment->p_type == PT_NOTE)
18201         if (! process_notes_at (filedata, NULL,
18202                                 (bfd_vma) segment->p_offset,
18203                                 (bfd_vma) segment->p_filesz,
18204                                 (bfd_vma) segment->p_align))
18205           res = FALSE;
18206     }
18207
18208   return res;
18209 }
18210
18211 static bfd_boolean
18212 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18213 {
18214   Elf_External_Note * pnotes;
18215   Elf_External_Note * external;
18216   char * end;
18217   bfd_boolean res = TRUE;
18218
18219   if (length <= 0)
18220     return FALSE;
18221
18222   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18223                                            _("v850 notes"));
18224   if (pnotes == NULL)
18225     return FALSE;
18226
18227   external = pnotes;
18228   end = (char*) pnotes + length;
18229
18230   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18231           (unsigned long) offset, (unsigned long) length);
18232
18233   while ((char *) external + sizeof (Elf_External_Note) < end)
18234     {
18235       Elf_External_Note * next;
18236       Elf_Internal_Note inote;
18237
18238       inote.type     = BYTE_GET (external->type);
18239       inote.namesz   = BYTE_GET (external->namesz);
18240       inote.namedata = external->name;
18241       inote.descsz   = BYTE_GET (external->descsz);
18242       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18243       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18244
18245       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18246         {
18247           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18248           inote.descdata = inote.namedata;
18249           inote.namesz   = 0;
18250         }
18251
18252       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18253
18254       if (   ((char *) next > end)
18255           || ((char *) next <  (char *) pnotes))
18256         {
18257           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18258                 (unsigned long) ((char *) external - (char *) pnotes));
18259           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18260                 inote.type, inote.namesz, inote.descsz);
18261           break;
18262         }
18263
18264       external = next;
18265
18266       /* Prevent out-of-bounds indexing.  */
18267       if (   inote.namedata + inote.namesz > end
18268           || inote.namedata + inote.namesz < inote.namedata)
18269         {
18270           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18271                 (unsigned long) ((char *) external - (char *) pnotes));
18272           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18273                 inote.type, inote.namesz, inote.descsz);
18274           break;
18275         }
18276
18277       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18278
18279       if (! print_v850_note (& inote))
18280         {
18281           res = FALSE;
18282           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18283                   inote.namesz, inote.descsz);
18284         }
18285     }
18286
18287   free (pnotes);
18288
18289   return res;
18290 }
18291
18292 static bfd_boolean
18293 process_note_sections (Filedata * filedata)
18294 {
18295   Elf_Internal_Shdr * section;
18296   unsigned long i;
18297   unsigned int n = 0;
18298   bfd_boolean res = TRUE;
18299
18300   for (i = 0, section = filedata->section_headers;
18301        i < filedata->file_header.e_shnum && section != NULL;
18302        i++, section++)
18303     {
18304       if (section->sh_type == SHT_NOTE)
18305         {
18306           if (! process_notes_at (filedata, section,
18307                                   (bfd_vma) section->sh_offset,
18308                                   (bfd_vma) section->sh_size,
18309                                   (bfd_vma) section->sh_addralign))
18310             res = FALSE;
18311           n++;
18312         }
18313
18314       if ((   filedata->file_header.e_machine == EM_V800
18315            || filedata->file_header.e_machine == EM_V850
18316            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18317           && section->sh_type == SHT_RENESAS_INFO)
18318         {
18319           if (! process_v850_notes (filedata,
18320                                     (bfd_vma) section->sh_offset,
18321                                     (bfd_vma) section->sh_size))
18322             res = FALSE;
18323           n++;
18324         }
18325     }
18326
18327   if (n == 0)
18328     /* Try processing NOTE segments instead.  */
18329     return process_corefile_note_segments (filedata);
18330
18331   return res;
18332 }
18333
18334 static bfd_boolean
18335 process_notes (Filedata * filedata)
18336 {
18337   /* If we have not been asked to display the notes then do nothing.  */
18338   if (! do_notes)
18339     return TRUE;
18340
18341   if (filedata->file_header.e_type != ET_CORE)
18342     return process_note_sections (filedata);
18343
18344   /* No program headers means no NOTE segment.  */
18345   if (filedata->file_header.e_phnum > 0)
18346     return process_corefile_note_segments (filedata);
18347
18348   printf (_("No note segments present in the core file.\n"));
18349   return TRUE;
18350 }
18351
18352 static unsigned char *
18353 display_public_gnu_attributes (unsigned char * start,
18354                                const unsigned char * const end)
18355 {
18356   printf (_("  Unknown GNU attribute: %s\n"), start);
18357
18358   start += strnlen ((char *) start, end - start);
18359   display_raw_attribute (start, end);
18360
18361   return (unsigned char *) end;
18362 }
18363
18364 static unsigned char *
18365 display_generic_attribute (unsigned char * start,
18366                            unsigned int tag,
18367                            const unsigned char * const end)
18368 {
18369   if (tag == 0)
18370     return (unsigned char *) end;
18371
18372   return display_tag_value (tag, start, end);
18373 }
18374
18375 static bfd_boolean
18376 process_arch_specific (Filedata * filedata)
18377 {
18378   if (! do_arch)
18379     return TRUE;
18380
18381   switch (filedata->file_header.e_machine)
18382     {
18383     case EM_ARC:
18384     case EM_ARC_COMPACT:
18385     case EM_ARC_COMPACT2:
18386       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18387                                  display_arc_attribute,
18388                                  display_generic_attribute);
18389     case EM_ARM:
18390       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18391                                  display_arm_attribute,
18392                                  display_generic_attribute);
18393
18394     case EM_MIPS:
18395     case EM_MIPS_RS3_LE:
18396       return process_mips_specific (filedata);
18397
18398     case EM_MSP430:
18399      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18400                                 display_msp430x_attribute,
18401                                 display_generic_attribute);
18402
18403     case EM_NDS32:
18404       return process_nds32_specific (filedata);
18405
18406     case EM_PPC:
18407     case EM_PPC64:
18408       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18409                                  display_power_gnu_attribute);
18410
18411     case EM_S390:
18412     case EM_S390_OLD:
18413       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18414                                  display_s390_gnu_attribute);
18415
18416     case EM_SPARC:
18417     case EM_SPARC32PLUS:
18418     case EM_SPARCV9:
18419       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18420                                  display_sparc_gnu_attribute);
18421
18422     case EM_TI_C6000:
18423       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18424                                  display_tic6x_attribute,
18425                                  display_generic_attribute);
18426
18427     default:
18428       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18429                                  display_public_gnu_attributes,
18430                                  display_generic_attribute);
18431     }
18432 }
18433
18434 static bfd_boolean
18435 get_file_header (Filedata * filedata)
18436 {
18437   /* Read in the identity array.  */
18438   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18439     return FALSE;
18440
18441   /* Determine how to read the rest of the header.  */
18442   switch (filedata->file_header.e_ident[EI_DATA])
18443     {
18444     default:
18445     case ELFDATANONE:
18446     case ELFDATA2LSB:
18447       byte_get = byte_get_little_endian;
18448       byte_put = byte_put_little_endian;
18449       break;
18450     case ELFDATA2MSB:
18451       byte_get = byte_get_big_endian;
18452       byte_put = byte_put_big_endian;
18453       break;
18454     }
18455
18456   /* For now we only support 32 bit and 64 bit ELF files.  */
18457   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18458
18459   /* Read in the rest of the header.  */
18460   if (is_32bit_elf)
18461     {
18462       Elf32_External_Ehdr ehdr32;
18463
18464       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18465         return FALSE;
18466
18467       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18468       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18469       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18470       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18471       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18472       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18473       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18474       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18475       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18476       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18477       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18478       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18479       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18480     }
18481   else
18482     {
18483       Elf64_External_Ehdr ehdr64;
18484
18485       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18486          we will not be able to cope with the 64bit data found in
18487          64 ELF files.  Detect this now and abort before we start
18488          overwriting things.  */
18489       if (sizeof (bfd_vma) < 8)
18490         {
18491           error (_("This instance of readelf has been built without support for a\n\
18492 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18493           return FALSE;
18494         }
18495
18496       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18497         return FALSE;
18498
18499       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18500       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18501       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18502       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18503       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18504       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18505       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18506       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18507       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18508       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18509       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18510       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18511       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18512     }
18513
18514   if (filedata->file_header.e_shoff)
18515     {
18516       /* There may be some extensions in the first section header.  Don't
18517          bomb if we can't read it.  */
18518       if (is_32bit_elf)
18519         get_32bit_section_headers (filedata, TRUE);
18520       else
18521         get_64bit_section_headers (filedata, TRUE);
18522     }
18523
18524   return TRUE;
18525 }
18526
18527 static void
18528 close_file (Filedata * filedata)
18529 {
18530   if (filedata)
18531     {
18532       if (filedata->handle)
18533         fclose (filedata->handle);
18534       free (filedata);
18535     }
18536 }
18537
18538 void
18539 close_debug_file (void * data)
18540 {
18541   close_file ((Filedata *) data);
18542 }
18543
18544 static Filedata *
18545 open_file (const char * pathname)
18546 {
18547   struct stat  statbuf;
18548   Filedata *   filedata = NULL;
18549
18550   if (stat (pathname, & statbuf) < 0
18551       || ! S_ISREG (statbuf.st_mode))
18552     goto fail;
18553
18554   filedata = calloc (1, sizeof * filedata);
18555   if (filedata == NULL)
18556     goto fail;
18557
18558   filedata->handle = fopen (pathname, "rb");
18559   if (filedata->handle == NULL)
18560     goto fail;
18561
18562   filedata->file_size = (bfd_size_type) statbuf.st_size;
18563   filedata->file_name = pathname;
18564
18565   if (! get_file_header (filedata))
18566     goto fail;
18567
18568   if (filedata->file_header.e_shoff)
18569     {
18570       bfd_boolean res;
18571
18572       /* Read the section headers again, this time for real.  */
18573       if (is_32bit_elf)
18574         res = get_32bit_section_headers (filedata, FALSE);
18575       else
18576         res = get_64bit_section_headers (filedata, FALSE);
18577
18578       if (!res)
18579         goto fail;
18580     }
18581
18582   return filedata;
18583
18584  fail:
18585   if (filedata)
18586     {
18587       if (filedata->handle)
18588         fclose (filedata->handle);
18589       free (filedata);
18590     }
18591   return NULL;
18592 }
18593
18594 void *
18595 open_debug_file (const char * pathname)
18596 {
18597   return open_file (pathname);
18598 }
18599
18600 /* Process one ELF object file according to the command line options.
18601    This file may actually be stored in an archive.  The file is
18602    positioned at the start of the ELF object.  Returns TRUE if no
18603    problems were encountered, FALSE otherwise.  */
18604
18605 static bfd_boolean
18606 process_object (Filedata * filedata)
18607 {
18608   Filedata * separates;
18609   unsigned int i;
18610   bfd_boolean res = TRUE;
18611
18612   if (! get_file_header (filedata))
18613     {
18614       error (_("%s: Failed to read file header\n"), filedata->file_name);
18615       return FALSE;
18616     }
18617
18618   /* Initialise per file variables.  */
18619   for (i = ARRAY_SIZE (version_info); i--;)
18620     version_info[i] = 0;
18621
18622   for (i = ARRAY_SIZE (dynamic_info); i--;)
18623     dynamic_info[i] = 0;
18624   dynamic_info_DT_GNU_HASH = 0;
18625
18626   /* Process the file.  */
18627   if (show_name)
18628     printf (_("\nFile: %s\n"), filedata->file_name);
18629
18630   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18631      Note we do this even if cmdline_dump_sects is empty because we
18632      must make sure that the dump_sets array is zeroed out before each
18633      object file is processed.  */
18634   if (filedata->num_dump_sects > cmdline.num_dump_sects)
18635     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
18636
18637   if (cmdline.num_dump_sects > 0)
18638     {
18639       if (filedata->num_dump_sects == 0)
18640         /* A sneaky way of allocating the dump_sects array.  */
18641         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
18642
18643       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
18644       memcpy (filedata->dump_sects, cmdline.dump_sects,
18645               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
18646     }
18647
18648   if (! process_file_header (filedata))
18649     return FALSE;
18650
18651   if (! process_section_headers (filedata))
18652     {
18653       /* Without loaded section headers we cannot process lots of things.  */
18654       do_unwind = do_version = do_dump = do_arch = FALSE;
18655
18656       if (! do_using_dynamic)
18657         do_syms = do_dyn_syms = do_reloc = FALSE;
18658     }
18659
18660   if (! process_section_groups (filedata))
18661     /* Without loaded section groups we cannot process unwind.  */
18662     do_unwind = FALSE;
18663
18664   if (process_program_headers (filedata))
18665     process_dynamic_section (filedata);
18666   else
18667     res = FALSE;
18668
18669   if (! process_relocs (filedata))
18670     res = FALSE;
18671
18672   if (! process_unwind (filedata))
18673     res = FALSE;
18674
18675   if (! process_symbol_table (filedata))
18676     res = FALSE;
18677
18678   if (! process_syminfo (filedata))
18679     res = FALSE;
18680
18681   if (! process_version_sections (filedata))
18682     res = FALSE;
18683
18684   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
18685     separates = load_separate_debug_file (filedata, filedata->file_name);
18686   else
18687     separates = NULL;
18688
18689   if (! process_section_contents (filedata))
18690     res = FALSE;
18691
18692   if (separates)
18693     {
18694       if (! process_section_headers (separates))
18695         res = FALSE;
18696       else if (! process_section_contents (separates))
18697         res = FALSE;
18698     }
18699
18700   if (! process_notes (filedata))
18701     res = FALSE;
18702
18703   if (! process_gnu_liblist (filedata))
18704     res = FALSE;
18705
18706   if (! process_arch_specific (filedata))
18707     res = FALSE;
18708
18709   free (filedata->program_headers);
18710   filedata->program_headers = NULL;
18711
18712   free (filedata->section_headers);
18713   filedata->section_headers = NULL;
18714
18715   free (filedata->string_table);
18716   filedata->string_table = NULL;
18717   filedata->string_table_length = 0;
18718
18719   if (dynamic_strings)
18720     {
18721       free (dynamic_strings);
18722       dynamic_strings = NULL;
18723       dynamic_strings_length = 0;
18724     }
18725
18726   if (dynamic_symbols)
18727     {
18728       free (dynamic_symbols);
18729       dynamic_symbols = NULL;
18730       num_dynamic_syms = 0;
18731     }
18732
18733   if (dynamic_syminfo)
18734     {
18735       free (dynamic_syminfo);
18736       dynamic_syminfo = NULL;
18737     }
18738
18739   if (dynamic_section)
18740     {
18741       free (dynamic_section);
18742       dynamic_section = NULL;
18743     }
18744
18745   if (section_headers_groups)
18746     {
18747       free (section_headers_groups);
18748       section_headers_groups = NULL;
18749     }
18750
18751   if (section_groups)
18752     {
18753       struct group_list * g;
18754       struct group_list * next;
18755
18756       for (i = 0; i < group_count; i++)
18757         {
18758           for (g = section_groups [i].root; g != NULL; g = next)
18759             {
18760               next = g->next;
18761               free (g);
18762             }
18763         }
18764
18765       free (section_groups);
18766       section_groups = NULL;
18767     }
18768
18769   free_debug_memory ();
18770
18771   return res;
18772 }
18773
18774 /* Process an ELF archive.
18775    On entry the file is positioned just after the ARMAG string.
18776    Returns TRUE upon success, FALSE otherwise.  */
18777
18778 static bfd_boolean
18779 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
18780 {
18781   struct archive_info arch;
18782   struct archive_info nested_arch;
18783   size_t got;
18784   bfd_boolean ret = TRUE;
18785
18786   show_name = TRUE;
18787
18788   /* The ARCH structure is used to hold information about this archive.  */
18789   arch.file_name = NULL;
18790   arch.file = NULL;
18791   arch.index_array = NULL;
18792   arch.sym_table = NULL;
18793   arch.longnames = NULL;
18794
18795   /* The NESTED_ARCH structure is used as a single-item cache of information
18796      about a nested archive (when members of a thin archive reside within
18797      another regular archive file).  */
18798   nested_arch.file_name = NULL;
18799   nested_arch.file = NULL;
18800   nested_arch.index_array = NULL;
18801   nested_arch.sym_table = NULL;
18802   nested_arch.longnames = NULL;
18803
18804   if (setup_archive (&arch, filedata->file_name, filedata->handle,
18805                      is_thin_archive, do_archive_index) != 0)
18806     {
18807       ret = FALSE;
18808       goto out;
18809     }
18810
18811   if (do_archive_index)
18812     {
18813       if (arch.sym_table == NULL)
18814         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
18815       else
18816         {
18817           unsigned long i, l;
18818           unsigned long current_pos;
18819
18820           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18821                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
18822
18823           current_pos = ftell (filedata->handle);
18824
18825           for (i = l = 0; i < arch.index_num; i++)
18826             {
18827               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18828                 {
18829                   char * member_name;
18830
18831                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18832
18833                   if (member_name != NULL)
18834                     {
18835                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18836
18837                       if (qualified_name != NULL)
18838                         {
18839                           printf (_("Contents of binary %s at offset "), qualified_name);
18840                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18841                           putchar ('\n');
18842                           free (qualified_name);
18843                         }
18844                     }
18845                 }
18846
18847               if (l >= arch.sym_size)
18848                 {
18849                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18850                          filedata->file_name);
18851                   ret = FALSE;
18852                   break;
18853                 }
18854               /* PR 17531: file: 0b6630b2.  */
18855               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18856               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18857             }
18858
18859           if (arch.uses_64bit_indicies)
18860             l = (l + 7) & ~ 7;
18861           else
18862             l += l & 1;
18863
18864           if (l < arch.sym_size)
18865             {
18866               error (ngettext ("%s: %ld byte remains in the symbol table, "
18867                                "but without corresponding entries in "
18868                                "the index table\n",
18869                                "%s: %ld bytes remain in the symbol table, "
18870                                "but without corresponding entries in "
18871                                "the index table\n",
18872                                arch.sym_size - l),
18873                      filedata->file_name, arch.sym_size - l);
18874               ret = FALSE;
18875             }
18876
18877           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
18878             {
18879               error (_("%s: failed to seek back to start of object files in the archive\n"),
18880                      filedata->file_name);
18881               ret = FALSE;
18882               goto out;
18883             }
18884         }
18885
18886       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18887           && !do_segments && !do_header && !do_dump && !do_version
18888           && !do_histogram && !do_debugging && !do_arch && !do_notes
18889           && !do_section_groups && !do_dyn_syms)
18890         {
18891           ret = TRUE; /* Archive index only.  */
18892           goto out;
18893         }
18894     }
18895
18896   while (1)
18897     {
18898       char * name;
18899       size_t namelen;
18900       char * qualified_name;
18901
18902       /* Read the next archive header.  */
18903       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
18904         {
18905           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
18906           return FALSE;
18907         }
18908       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
18909       if (got != sizeof arch.arhdr)
18910         {
18911           if (got == 0)
18912             break;
18913           error (_("%s: failed to read archive header\n"), filedata->file_name);
18914           ret = FALSE;
18915           break;
18916         }
18917       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18918         {
18919           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18920           ret = FALSE;
18921           break;
18922         }
18923
18924       arch.next_arhdr_offset += sizeof arch.arhdr;
18925
18926       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18927       if (archive_file_size & 01)
18928         ++archive_file_size;
18929
18930       name = get_archive_member_name (&arch, &nested_arch);
18931       if (name == NULL)
18932         {
18933           error (_("%s: bad archive file name\n"), filedata->file_name);
18934           ret = FALSE;
18935           break;
18936         }
18937       namelen = strlen (name);
18938
18939       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18940       if (qualified_name == NULL)
18941         {
18942           error (_("%s: bad archive file name\n"), filedata->file_name);
18943           ret = FALSE;
18944           break;
18945         }
18946
18947       if (is_thin_archive && arch.nested_member_origin == 0)
18948         {
18949           /* This is a proxy for an external member of a thin archive.  */
18950           Filedata * member_filedata;
18951           char * member_file_name = adjust_relative_path
18952             (filedata->file_name, name, namelen);
18953
18954           if (member_file_name == NULL)
18955             {
18956               ret = FALSE;
18957               break;
18958             }
18959
18960           member_filedata = open_file (member_file_name);
18961           if (member_filedata == NULL)
18962             {
18963               error (_("Input file '%s' is not readable.\n"), member_file_name);
18964               free (member_file_name);
18965               ret = FALSE;
18966               break;
18967             }
18968
18969           archive_file_offset = arch.nested_member_origin;
18970           member_filedata->file_name = qualified_name;
18971
18972           if (! process_object (member_filedata))
18973             ret = FALSE;
18974
18975           close_file (member_filedata);
18976           free (member_file_name);
18977         }
18978       else if (is_thin_archive)
18979         {
18980           Filedata thin_filedata;
18981
18982           memset (&thin_filedata, 0, sizeof (thin_filedata));
18983
18984           /* PR 15140: Allow for corrupt thin archives.  */
18985           if (nested_arch.file == NULL)
18986             {
18987               error (_("%s: contains corrupt thin archive: %s\n"),
18988                      filedata->file_name, name);
18989               ret = FALSE;
18990               break;
18991             }
18992
18993           /* This is a proxy for a member of a nested archive.  */
18994           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18995
18996           /* The nested archive file will have been opened and setup by
18997              get_archive_member_name.  */
18998           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18999             {
19000               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19001               ret = FALSE;
19002               break;
19003             }
19004
19005           thin_filedata.handle = nested_arch.file;
19006           thin_filedata.file_name = qualified_name;
19007
19008           if (! process_object (& thin_filedata))
19009             ret = FALSE;
19010         }
19011       else
19012         {
19013           archive_file_offset = arch.next_arhdr_offset;
19014           arch.next_arhdr_offset += archive_file_size;
19015
19016           filedata->file_name = qualified_name;
19017           if (! process_object (filedata))
19018             ret = FALSE;
19019         }
19020
19021       if (filedata->dump_sects != NULL)
19022         {
19023           free (filedata->dump_sects);
19024           filedata->dump_sects = NULL;
19025           filedata->num_dump_sects = 0;
19026         }
19027
19028       free (qualified_name);
19029     }
19030
19031  out:
19032   if (nested_arch.file != NULL)
19033     fclose (nested_arch.file);
19034   release_archive (&nested_arch);
19035   release_archive (&arch);
19036
19037   return ret;
19038 }
19039
19040 static bfd_boolean
19041 process_file (char * file_name)
19042 {
19043   Filedata * filedata = NULL;
19044   struct stat statbuf;
19045   char armag[SARMAG];
19046   bfd_boolean ret = TRUE;
19047
19048   if (stat (file_name, &statbuf) < 0)
19049     {
19050       if (errno == ENOENT)
19051         error (_("'%s': No such file\n"), file_name);
19052       else
19053         error (_("Could not locate '%s'.  System error message: %s\n"),
19054                file_name, strerror (errno));
19055       return FALSE;
19056     }
19057
19058   if (! S_ISREG (statbuf.st_mode))
19059     {
19060       error (_("'%s' is not an ordinary file\n"), file_name);
19061       return FALSE;
19062     }
19063
19064   filedata = calloc (1, sizeof * filedata);
19065   if (filedata == NULL)
19066     {
19067       error (_("Out of memory allocating file data structure\n"));
19068       return FALSE;
19069     }
19070
19071   filedata->file_name = file_name;
19072   filedata->handle = fopen (file_name, "rb");
19073   if (filedata->handle == NULL)
19074     {
19075       error (_("Input file '%s' is not readable.\n"), file_name);
19076       free (filedata);
19077       return FALSE;
19078     }
19079
19080   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19081     {
19082       error (_("%s: Failed to read file's magic number\n"), file_name);
19083       fclose (filedata->handle);
19084       free (filedata);
19085       return FALSE;
19086     }
19087
19088   filedata->file_size = (bfd_size_type) statbuf.st_size;
19089
19090   if (memcmp (armag, ARMAG, SARMAG) == 0)
19091     {
19092       if (! process_archive (filedata, FALSE))
19093         ret = FALSE;
19094     }
19095   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19096     {
19097       if ( ! process_archive (filedata, TRUE))
19098         ret = FALSE;
19099     }
19100   else
19101     {
19102       if (do_archive_index)
19103         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19104                file_name);
19105
19106       rewind (filedata->handle);
19107       archive_file_size = archive_file_offset = 0;
19108
19109       if (! process_object (filedata))
19110         ret = FALSE;
19111     }
19112
19113   fclose (filedata->handle);
19114   free (filedata);
19115
19116   return ret;
19117 }
19118
19119 #ifdef SUPPORT_DISASSEMBLY
19120 /* Needed by the i386 disassembler.  For extra credit, someone could
19121    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19122    symbols.  */
19123
19124 void
19125 print_address (unsigned int addr, FILE * outfile)
19126 {
19127   fprintf (outfile,"0x%8.8x", addr);
19128 }
19129
19130 /* Needed by the i386 disassembler.  */
19131
19132 void
19133 db_task_printsym (unsigned int addr)
19134 {
19135   print_address (addr, stderr);
19136 }
19137 #endif
19138
19139 int
19140 main (int argc, char ** argv)
19141 {
19142   int err;
19143
19144 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19145   setlocale (LC_MESSAGES, "");
19146 #endif
19147 #if defined (HAVE_SETLOCALE)
19148   setlocale (LC_CTYPE, "");
19149 #endif
19150   bindtextdomain (PACKAGE, LOCALEDIR);
19151   textdomain (PACKAGE);
19152
19153   expandargv (&argc, &argv);
19154
19155   cmdline.file_name = "<cmdline>";
19156   parse_args (& cmdline, argc, argv);
19157
19158   if (optind < (argc - 1))
19159     show_name = TRUE;
19160   else if (optind >= argc)
19161     {
19162       warn (_("Nothing to do.\n"));
19163       usage (stderr);
19164     }
19165
19166   err = FALSE;
19167   while (optind < argc)
19168     if (! process_file (argv[optind++]))
19169       err = TRUE;
19170
19171   if (cmdline.dump_sects != NULL)
19172     free (cmdline.dump_sects);
19173
19174   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19175 }