binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2017 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   assert (filedata->section_headers != NULL);
 659
 660   for (i = 0; i < filedata->file_header.e_shnum; i++)
 661     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 662       return filedata->section_headers + i;
 663
 664   return NULL;
 665 }
 666
 667 /* Return a pointer to a section containing ADDR, or NULL if no such
 668    section exists.  */
 669
 670 static Elf_Internal_Shdr *
 671 find_section_by_address (Filedata * filedata, bfd_vma addr)
 672 {
 673   unsigned int i;
 674
 675   for (i = 0; i < filedata->file_header.e_shnum; i++)
 676     {
 677       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 678
 679       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 680         return sec;
 681     }
 682
 683   return NULL;
 684 }
 685
 686 static Elf_Internal_Shdr *
 687 find_section_by_type (Filedata * filedata, unsigned int type)
 688 {
 689   unsigned int i;
 690
 691   for (i = 0; i < filedata->file_header.e_shnum; i++)
 692     {
 693       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 694
 695       if (sec->sh_type == type)
 696         return sec;
 697     }
 698
 699   return NULL;
 700 }
 701
 702 /* Return a pointer to section NAME, or NULL if no such section exists,
 703    restricted to the list of sections given in SET.  */
 704
 705 static Elf_Internal_Shdr *
 706 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 707 {
 708   unsigned int i;
 709
 710   if (set != NULL)
 711     {
 712       while ((i = *set++) > 0)
 713         {
 714           /* See PR 21156 for a reproducer.  */
 715           if (i >= filedata->file_header.e_shnum)
 716             continue; /* FIXME: Should we issue an error message ?  */
 717
 718           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 719             return filedata->section_headers + i;
 720         }
 721     }
 722
 723   return find_section (filedata, name);
 724 }
 725
 726 /* Read an unsigned LEB128 encoded value from DATA.
 727    Set *LENGTH_RETURN to the number of bytes read.  */
 728
 729 static inline unsigned long
 730 read_uleb128 (unsigned char * data,
 731               unsigned int * length_return,
 732               const unsigned char * const end)
 733 {
 734   return read_leb128 (data, length_return, FALSE, end);
 735 }
 736
 737 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 738    This OS has so many departures from the ELF standard that we test it at
 739    many places.  */
 740
 741 static inline bfd_boolean
 742 is_ia64_vms (Filedata * filedata)
 743 {
 744   return filedata->file_header.e_machine == EM_IA_64
 745     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 746 }
 747
 748 /* Guess the relocation size commonly used by the specific machines.  */
 749
 750 static bfd_boolean
 751 guess_is_rela (unsigned int e_machine)
 752 {
 753   switch (e_machine)
 754     {
 755       /* Targets that use REL relocations.  */
 756     case EM_386:
 757     case EM_IAMCU:
 758     case EM_960:
 759     case EM_ARM:
 760     case EM_D10V:
 761     case EM_CYGNUS_D10V:
 762     case EM_DLX:
 763     case EM_MIPS:
 764     case EM_MIPS_RS3_LE:
 765     case EM_CYGNUS_M32R:
 766     case EM_SCORE:
 767     case EM_XGATE:
 768       return FALSE;
 769
 770       /* Targets that use RELA relocations.  */
 771     case EM_68K:
 772     case EM_860:
 773     case EM_AARCH64:
 774     case EM_ADAPTEVA_EPIPHANY:
 775     case EM_ALPHA:
 776     case EM_ALTERA_NIOS2:
 777     case EM_ARC:
 778     case EM_ARC_COMPACT:
 779     case EM_ARC_COMPACT2:
 780     case EM_AVR:
 781     case EM_AVR_OLD:
 782     case EM_BLACKFIN:
 783     case EM_CR16:
 784     case EM_CRIS:
 785     case EM_CRX:
 786     case EM_D30V:
 787     case EM_CYGNUS_D30V:
 788     case EM_FR30:
 789     case EM_FT32:
 790     case EM_CYGNUS_FR30:
 791     case EM_CYGNUS_FRV:
 792     case EM_H8S:
 793     case EM_H8_300:
 794     case EM_H8_300H:
 795     case EM_IA_64:
 796     case EM_IP2K:
 797     case EM_IP2K_OLD:
 798     case EM_IQ2000:
 799     case EM_LATTICEMICO32:
 800     case EM_M32C_OLD:
 801     case EM_M32C:
 802     case EM_M32R:
 803     case EM_MCORE:
 804     case EM_CYGNUS_MEP:
 805     case EM_METAG:
 806     case EM_MMIX:
 807     case EM_MN10200:
 808     case EM_CYGNUS_MN10200:
 809     case EM_MN10300:
 810     case EM_CYGNUS_MN10300:
 811     case EM_MOXIE:
 812     case EM_MSP430:
 813     case EM_MSP430_OLD:
 814     case EM_MT:
 815     case EM_NDS32:
 816     case EM_NIOS32:
 817     case EM_OR1K:
 818     case EM_PPC64:
 819     case EM_PPC:
 820     case EM_TI_PRU:
 821     case EM_RISCV:
 822     case EM_RL78:
 823     case EM_RX:
 824     case EM_S390:
 825     case EM_S390_OLD:
 826     case EM_SH:
 827     case EM_SPARC:
 828     case EM_SPARC32PLUS:
 829     case EM_SPARCV9:
 830     case EM_SPU:
 831     case EM_TI_C6000:
 832     case EM_TILEGX:
 833     case EM_TILEPRO:
 834     case EM_V800:
 835     case EM_V850:
 836     case EM_CYGNUS_V850:
 837     case EM_VAX:
 838     case EM_VISIUM:
 839     case EM_X86_64:
 840     case EM_L1OM:
 841     case EM_K1OM:
 842     case EM_XSTORMY16:
 843     case EM_XTENSA:
 844     case EM_XTENSA_OLD:
 845     case EM_MICROBLAZE:
 846     case EM_MICROBLAZE_OLD:
 847     case EM_WEBASSEMBLY:
 848       return TRUE;
 849
 850     case EM_68HC05:
 851     case EM_68HC08:
 852     case EM_68HC11:
 853     case EM_68HC16:
 854     case EM_FX66:
 855     case EM_ME16:
 856     case EM_MMA:
 857     case EM_NCPU:
 858     case EM_NDR1:
 859     case EM_PCP:
 860     case EM_ST100:
 861     case EM_ST19:
 862     case EM_ST7:
 863     case EM_ST9PLUS:
 864     case EM_STARCORE:
 865     case EM_SVX:
 866     case EM_TINYJ:
 867     default:
 868       warn (_("Don't know about relocations on this machine architecture\n"));
 869       return FALSE;
 870     }
 871 }
 872
 873 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 874    Returns TRUE upon success, FALSE otherwise.  If successful then a
 875    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 876    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 877    responsibility to free the allocated buffer.  */
 878
 879 static bfd_boolean
 880 slurp_rela_relocs (Filedata *            filedata,
 881                    unsigned long         rel_offset,
 882                    unsigned long         rel_size,
 883                    Elf_Internal_Rela **  relasp,
 884                    unsigned long *       nrelasp)
 885 {
 886   Elf_Internal_Rela * relas;
 887   size_t nrelas;
 888   unsigned int i;
 889
 890   if (is_32bit_elf)
 891     {
 892       Elf32_External_Rela * erelas;
 893
 894       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 895                                                  rel_size, _("32-bit relocation data"));
 896       if (!erelas)
 897         return FALSE;
 898
 899       nrelas = rel_size / sizeof (Elf32_External_Rela);
 900
 901       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 902                                              sizeof (Elf_Internal_Rela));
 903
 904       if (relas == NULL)
 905         {
 906           free (erelas);
 907           error (_("out of memory parsing relocs\n"));
 908           return FALSE;
 909         }
 910
 911       for (i = 0; i < nrelas; i++)
 912         {
 913           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 914           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 915           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 916         }
 917
 918       free (erelas);
 919     }
 920   else
 921     {
 922       Elf64_External_Rela * erelas;
 923
 924       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 925                                                  rel_size, _("64-bit relocation data"));
 926       if (!erelas)
 927         return FALSE;
 928
 929       nrelas = rel_size / sizeof (Elf64_External_Rela);
 930
 931       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 932                                              sizeof (Elf_Internal_Rela));
 933
 934       if (relas == NULL)
 935         {
 936           free (erelas);
 937           error (_("out of memory parsing relocs\n"));
 938           return FALSE;
 939         }
 940
 941       for (i = 0; i < nrelas; i++)
 942         {
 943           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 944           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 945           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 946
 947           /* The #ifdef BFD64 below is to prevent a compile time
 948              warning.  We know that if we do not have a 64 bit data
 949              type that we will never execute this code anyway.  */
 950 #ifdef BFD64
 951           if (filedata->file_header.e_machine == EM_MIPS
 952               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 953             {
 954               /* In little-endian objects, r_info isn't really a
 955                  64-bit little-endian value: it has a 32-bit
 956                  little-endian symbol index followed by four
 957                  individual byte fields.  Reorder INFO
 958                  accordingly.  */
 959               bfd_vma inf = relas[i].r_info;
 960               inf = (((inf & 0xffffffff) << 32)
 961                       | ((inf >> 56) & 0xff)
 962                       | ((inf >> 40) & 0xff00)
 963                       | ((inf >> 24) & 0xff0000)
 964                       | ((inf >> 8) & 0xff000000));
 965               relas[i].r_info = inf;
 966             }
 967 #endif /* BFD64 */
 968         }
 969
 970       free (erelas);
 971     }
 972
 973   *relasp = relas;
 974   *nrelasp = nrelas;
 975   return TRUE;
 976 }
 977
 978 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 979    Returns TRUE upon success, FALSE otherwise.  If successful then a
 980    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 981    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 982    responsibility to free the allocated buffer.  */
 983
 984 static bfd_boolean
 985 slurp_rel_relocs (Filedata *            filedata,
 986                   unsigned long         rel_offset,
 987                   unsigned long         rel_size,
 988                   Elf_Internal_Rela **  relsp,
 989                   unsigned long *       nrelsp)
 990 {
 991   Elf_Internal_Rela * rels;
 992   size_t nrels;
 993   unsigned int i;
 994
 995   if (is_32bit_elf)
 996     {
 997       Elf32_External_Rel * erels;
 998
 999       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1000                                                rel_size, _("32-bit relocation data"));
1001       if (!erels)
1002         return FALSE;
1003
1004       nrels = rel_size / sizeof (Elf32_External_Rel);
1005
1006       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1007
1008       if (rels == NULL)
1009         {
1010           free (erels);
1011           error (_("out of memory parsing relocs\n"));
1012           return FALSE;
1013         }
1014
1015       for (i = 0; i < nrels; i++)
1016         {
1017           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1018           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1019           rels[i].r_addend = 0;
1020         }
1021
1022       free (erels);
1023     }
1024   else
1025     {
1026       Elf64_External_Rel * erels;
1027
1028       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1029                                                rel_size, _("64-bit relocation data"));
1030       if (!erels)
1031         return FALSE;
1032
1033       nrels = rel_size / sizeof (Elf64_External_Rel);
1034
1035       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1036
1037       if (rels == NULL)
1038         {
1039           free (erels);
1040           error (_("out of memory parsing relocs\n"));
1041           return FALSE;
1042         }
1043
1044       for (i = 0; i < nrels; i++)
1045         {
1046           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1047           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1048           rels[i].r_addend = 0;
1049
1050           /* The #ifdef BFD64 below is to prevent a compile time
1051              warning.  We know that if we do not have a 64 bit data
1052              type that we will never execute this code anyway.  */
1053 #ifdef BFD64
1054           if (filedata->file_header.e_machine == EM_MIPS
1055               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1056             {
1057               /* In little-endian objects, r_info isn't really a
1058                  64-bit little-endian value: it has a 32-bit
1059                  little-endian symbol index followed by four
1060                  individual byte fields.  Reorder INFO
1061                  accordingly.  */
1062               bfd_vma inf = rels[i].r_info;
1063               inf = (((inf & 0xffffffff) << 32)
1064                      | ((inf >> 56) & 0xff)
1065                      | ((inf >> 40) & 0xff00)
1066                      | ((inf >> 24) & 0xff0000)
1067                      | ((inf >> 8) & 0xff000000));
1068               rels[i].r_info = inf;
1069             }
1070 #endif /* BFD64 */
1071         }
1072
1073       free (erels);
1074     }
1075
1076   *relsp = rels;
1077   *nrelsp = nrels;
1078   return TRUE;
1079 }
1080
1081 /* Returns the reloc type extracted from the reloc info field.  */
1082
1083 static unsigned int
1084 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1085 {
1086   if (is_32bit_elf)
1087     return ELF32_R_TYPE (reloc_info);
1088
1089   switch (filedata->file_header.e_machine)
1090     {
1091     case EM_MIPS:
1092       /* Note: We assume that reloc_info has already been adjusted for us.  */
1093       return ELF64_MIPS_R_TYPE (reloc_info);
1094
1095     case EM_SPARCV9:
1096       return ELF64_R_TYPE_ID (reloc_info);
1097
1098     default:
1099       return ELF64_R_TYPE (reloc_info);
1100     }
1101 }
1102
1103 /* Return the symbol index extracted from the reloc info field.  */
1104
1105 static bfd_vma
1106 get_reloc_symindex (bfd_vma reloc_info)
1107 {
1108   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1109 }
1110
1111 static inline bfd_boolean
1112 uses_msp430x_relocs (Filedata * filedata)
1113 {
1114   return
1115     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1116     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1117     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1118         /* TI compiler uses ELFOSABI_NONE.  */
1119         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1120 }
1121
1122 /* Display the contents of the relocation data found at the specified
1123    offset.  */
1124
1125 static bfd_boolean
1126 dump_relocations (Filedata *          filedata,
1127                   unsigned long       rel_offset,
1128                   unsigned long       rel_size,
1129                   Elf_Internal_Sym *  symtab,
1130                   unsigned long       nsyms,
1131                   char *              strtab,
1132                   unsigned long       strtablen,
1133                   int                 is_rela,
1134                   bfd_boolean         is_dynsym)
1135 {
1136   unsigned long i;
1137   Elf_Internal_Rela * rels;
1138   bfd_boolean res = TRUE;
1139
1140   if (is_rela == UNKNOWN)
1141     is_rela = guess_is_rela (filedata->file_header.e_machine);
1142
1143   if (is_rela)
1144     {
1145       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1146         return FALSE;
1147     }
1148   else
1149     {
1150       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1151         return FALSE;
1152     }
1153
1154   if (is_32bit_elf)
1155     {
1156       if (is_rela)
1157         {
1158           if (do_wide)
1159             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1160           else
1161             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1162         }
1163       else
1164         {
1165           if (do_wide)
1166             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1167           else
1168             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1169         }
1170     }
1171   else
1172     {
1173       if (is_rela)
1174         {
1175           if (do_wide)
1176             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1177           else
1178             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1179         }
1180       else
1181         {
1182           if (do_wide)
1183             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1184           else
1185             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1186         }
1187     }
1188
1189   for (i = 0; i < rel_size; i++)
1190     {
1191       const char * rtype;
1192       bfd_vma offset;
1193       bfd_vma inf;
1194       bfd_vma symtab_index;
1195       bfd_vma type;
1196
1197       offset = rels[i].r_offset;
1198       inf    = rels[i].r_info;
1199
1200       type = get_reloc_type (filedata, inf);
1201       symtab_index = get_reloc_symindex  (inf);
1202
1203       if (is_32bit_elf)
1204         {
1205           printf ("%8.8lx  %8.8lx ",
1206                   (unsigned long) offset & 0xffffffff,
1207                   (unsigned long) inf & 0xffffffff);
1208         }
1209       else
1210         {
1211 #if BFD_HOST_64BIT_LONG
1212           printf (do_wide
1213                   ? "%16.16lx  %16.16lx "
1214                   : "%12.12lx  %12.12lx ",
1215                   offset, inf);
1216 #elif BFD_HOST_64BIT_LONG_LONG
1217 #ifndef __MSVCRT__
1218           printf (do_wide
1219                   ? "%16.16llx  %16.16llx "
1220                   : "%12.12llx  %12.12llx ",
1221                   offset, inf);
1222 #else
1223           printf (do_wide
1224                   ? "%16.16I64x  %16.16I64x "
1225                   : "%12.12I64x  %12.12I64x ",
1226                   offset, inf);
1227 #endif
1228 #else
1229           printf (do_wide
1230                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1231                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1232                   _bfd_int64_high (offset),
1233                   _bfd_int64_low (offset),
1234                   _bfd_int64_high (inf),
1235                   _bfd_int64_low (inf));
1236 #endif
1237         }
1238
1239       switch (filedata->file_header.e_machine)
1240         {
1241         default:
1242           rtype = NULL;
1243           break;
1244
1245         case EM_AARCH64:
1246           rtype = elf_aarch64_reloc_type (type);
1247           break;
1248
1249         case EM_M32R:
1250         case EM_CYGNUS_M32R:
1251           rtype = elf_m32r_reloc_type (type);
1252           break;
1253
1254         case EM_386:
1255         case EM_IAMCU:
1256           rtype = elf_i386_reloc_type (type);
1257           break;
1258
1259         case EM_68HC11:
1260         case EM_68HC12:
1261           rtype = elf_m68hc11_reloc_type (type);
1262           break;
1263
1264         case EM_68K:
1265           rtype = elf_m68k_reloc_type (type);
1266           break;
1267
1268         case EM_960:
1269           rtype = elf_i960_reloc_type (type);
1270           break;
1271
1272         case EM_AVR:
1273         case EM_AVR_OLD:
1274           rtype = elf_avr_reloc_type (type);
1275           break;
1276
1277         case EM_OLD_SPARCV9:
1278         case EM_SPARC32PLUS:
1279         case EM_SPARCV9:
1280         case EM_SPARC:
1281           rtype = elf_sparc_reloc_type (type);
1282           break;
1283
1284         case EM_SPU:
1285           rtype = elf_spu_reloc_type (type);
1286           break;
1287
1288         case EM_V800:
1289           rtype = v800_reloc_type (type);
1290           break;
1291         case EM_V850:
1292         case EM_CYGNUS_V850:
1293           rtype = v850_reloc_type (type);
1294           break;
1295
1296         case EM_D10V:
1297         case EM_CYGNUS_D10V:
1298           rtype = elf_d10v_reloc_type (type);
1299           break;
1300
1301         case EM_D30V:
1302         case EM_CYGNUS_D30V:
1303           rtype = elf_d30v_reloc_type (type);
1304           break;
1305
1306         case EM_DLX:
1307           rtype = elf_dlx_reloc_type (type);
1308           break;
1309
1310         case EM_SH:
1311           rtype = elf_sh_reloc_type (type);
1312           break;
1313
1314         case EM_MN10300:
1315         case EM_CYGNUS_MN10300:
1316           rtype = elf_mn10300_reloc_type (type);
1317           break;
1318
1319         case EM_MN10200:
1320         case EM_CYGNUS_MN10200:
1321           rtype = elf_mn10200_reloc_type (type);
1322           break;
1323
1324         case EM_FR30:
1325         case EM_CYGNUS_FR30:
1326           rtype = elf_fr30_reloc_type (type);
1327           break;
1328
1329         case EM_CYGNUS_FRV:
1330           rtype = elf_frv_reloc_type (type);
1331           break;
1332
1333         case EM_FT32:
1334           rtype = elf_ft32_reloc_type (type);
1335           break;
1336
1337         case EM_MCORE:
1338           rtype = elf_mcore_reloc_type (type);
1339           break;
1340
1341         case EM_MMIX:
1342           rtype = elf_mmix_reloc_type (type);
1343           break;
1344
1345         case EM_MOXIE:
1346           rtype = elf_moxie_reloc_type (type);
1347           break;
1348
1349         case EM_MSP430:
1350           if (uses_msp430x_relocs (filedata))
1351             {
1352               rtype = elf_msp430x_reloc_type (type);
1353               break;
1354             }
1355           /* Fall through.  */
1356         case EM_MSP430_OLD:
1357           rtype = elf_msp430_reloc_type (type);
1358           break;
1359
1360         case EM_NDS32:
1361           rtype = elf_nds32_reloc_type (type);
1362           break;
1363
1364         case EM_PPC:
1365           rtype = elf_ppc_reloc_type (type);
1366           break;
1367
1368         case EM_PPC64:
1369           rtype = elf_ppc64_reloc_type (type);
1370           break;
1371
1372         case EM_MIPS:
1373         case EM_MIPS_RS3_LE:
1374           rtype = elf_mips_reloc_type (type);
1375           break;
1376
1377         case EM_RISCV:
1378           rtype = elf_riscv_reloc_type (type);
1379           break;
1380
1381         case EM_ALPHA:
1382           rtype = elf_alpha_reloc_type (type);
1383           break;
1384
1385         case EM_ARM:
1386           rtype = elf_arm_reloc_type (type);
1387           break;
1388
1389         case EM_ARC:
1390         case EM_ARC_COMPACT:
1391         case EM_ARC_COMPACT2:
1392           rtype = elf_arc_reloc_type (type);
1393           break;
1394
1395         case EM_PARISC:
1396           rtype = elf_hppa_reloc_type (type);
1397           break;
1398
1399         case EM_H8_300:
1400         case EM_H8_300H:
1401         case EM_H8S:
1402           rtype = elf_h8_reloc_type (type);
1403           break;
1404
1405         case EM_OR1K:
1406           rtype = elf_or1k_reloc_type (type);
1407           break;
1408
1409         case EM_PJ:
1410         case EM_PJ_OLD:
1411           rtype = elf_pj_reloc_type (type);
1412           break;
1413         case EM_IA_64:
1414           rtype = elf_ia64_reloc_type (type);
1415           break;
1416
1417         case EM_CRIS:
1418           rtype = elf_cris_reloc_type (type);
1419           break;
1420
1421         case EM_860:
1422           rtype = elf_i860_reloc_type (type);
1423           break;
1424
1425         case EM_X86_64:
1426         case EM_L1OM:
1427         case EM_K1OM:
1428           rtype = elf_x86_64_reloc_type (type);
1429           break;
1430
1431         case EM_S370:
1432           rtype = i370_reloc_type (type);
1433           break;
1434
1435         case EM_S390_OLD:
1436         case EM_S390:
1437           rtype = elf_s390_reloc_type (type);
1438           break;
1439
1440         case EM_SCORE:
1441           rtype = elf_score_reloc_type (type);
1442           break;
1443
1444         case EM_XSTORMY16:
1445           rtype = elf_xstormy16_reloc_type (type);
1446           break;
1447
1448         case EM_CRX:
1449           rtype = elf_crx_reloc_type (type);
1450           break;
1451
1452         case EM_VAX:
1453           rtype = elf_vax_reloc_type (type);
1454           break;
1455
1456         case EM_VISIUM:
1457           rtype = elf_visium_reloc_type (type);
1458           break;
1459
1460         case EM_ADAPTEVA_EPIPHANY:
1461           rtype = elf_epiphany_reloc_type (type);
1462           break;
1463
1464         case EM_IP2K:
1465         case EM_IP2K_OLD:
1466           rtype = elf_ip2k_reloc_type (type);
1467           break;
1468
1469         case EM_IQ2000:
1470           rtype = elf_iq2000_reloc_type (type);
1471           break;
1472
1473         case EM_XTENSA_OLD:
1474         case EM_XTENSA:
1475           rtype = elf_xtensa_reloc_type (type);
1476           break;
1477
1478         case EM_LATTICEMICO32:
1479           rtype = elf_lm32_reloc_type (type);
1480           break;
1481
1482         case EM_M32C_OLD:
1483         case EM_M32C:
1484           rtype = elf_m32c_reloc_type (type);
1485           break;
1486
1487         case EM_MT:
1488           rtype = elf_mt_reloc_type (type);
1489           break;
1490
1491         case EM_BLACKFIN:
1492           rtype = elf_bfin_reloc_type (type);
1493           break;
1494
1495         case EM_CYGNUS_MEP:
1496           rtype = elf_mep_reloc_type (type);
1497           break;
1498
1499         case EM_CR16:
1500           rtype = elf_cr16_reloc_type (type);
1501           break;
1502
1503         case EM_MICROBLAZE:
1504         case EM_MICROBLAZE_OLD:
1505           rtype = elf_microblaze_reloc_type (type);
1506           break;
1507
1508         case EM_RL78:
1509           rtype = elf_rl78_reloc_type (type);
1510           break;
1511
1512         case EM_RX:
1513           rtype = elf_rx_reloc_type (type);
1514           break;
1515
1516         case EM_METAG:
1517           rtype = elf_metag_reloc_type (type);
1518           break;
1519
1520         case EM_XC16X:
1521         case EM_C166:
1522           rtype = elf_xc16x_reloc_type (type);
1523           break;
1524
1525         case EM_TI_C6000:
1526           rtype = elf_tic6x_reloc_type (type);
1527           break;
1528
1529         case EM_TILEGX:
1530           rtype = elf_tilegx_reloc_type (type);
1531           break;
1532
1533         case EM_TILEPRO:
1534           rtype = elf_tilepro_reloc_type (type);
1535           break;
1536
1537         case EM_WEBASSEMBLY:
1538           rtype = elf_wasm32_reloc_type (type);
1539           break;
1540
1541         case EM_XGATE:
1542           rtype = elf_xgate_reloc_type (type);
1543           break;
1544
1545         case EM_ALTERA_NIOS2:
1546           rtype = elf_nios2_reloc_type (type);
1547           break;
1548
1549         case EM_TI_PRU:
1550           rtype = elf_pru_reloc_type (type);
1551           break;
1552         }
1553
1554       if (rtype == NULL)
1555         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1556       else
1557         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1558
1559       if (filedata->file_header.e_machine == EM_ALPHA
1560           && rtype != NULL
1561           && streq (rtype, "R_ALPHA_LITUSE")
1562           && is_rela)
1563         {
1564           switch (rels[i].r_addend)
1565             {
1566             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1567             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1568             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1569             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1570             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1571             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1572             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1573             default: rtype = NULL;
1574             }
1575
1576           if (rtype)
1577             printf (" (%s)", rtype);
1578           else
1579             {
1580               putchar (' ');
1581               printf (_("<unknown addend: %lx>"),
1582                       (unsigned long) rels[i].r_addend);
1583               res = FALSE;
1584             }
1585         }
1586       else if (symtab_index)
1587         {
1588           if (symtab == NULL || symtab_index >= nsyms)
1589             {
1590               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1591               res = FALSE;
1592             }
1593           else
1594             {
1595               Elf_Internal_Sym * psym;
1596               const char * version_string;
1597               enum versioned_symbol_info sym_info;
1598               unsigned short vna_other;
1599
1600               psym = symtab + symtab_index;
1601
1602               version_string
1603                 = get_symbol_version_string (filedata, is_dynsym,
1604                                              strtab, strtablen,
1605                                              symtab_index,
1606                                              psym,
1607                                              &sym_info,
1608                                              &vna_other);
1609
1610               printf (" ");
1611
1612               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1613                 {
1614                   const char * name;
1615                   unsigned int len;
1616                   unsigned int width = is_32bit_elf ? 8 : 14;
1617
1618                   /* Relocations against GNU_IFUNC symbols do not use the value
1619                      of the symbol as the address to relocate against.  Instead
1620                      they invoke the function named by the symbol and use its
1621                      result as the address for relocation.
1622
1623                      To indicate this to the user, do not display the value of
1624                      the symbol in the "Symbols's Value" field.  Instead show
1625                      its name followed by () as a hint that the symbol is
1626                      invoked.  */
1627
1628                   if (strtab == NULL
1629                       || psym->st_name == 0
1630                       || psym->st_name >= strtablen)
1631                     name = "??";
1632                   else
1633                     name = strtab + psym->st_name;
1634
1635                   len = print_symbol (width, name);
1636                   if (version_string)
1637                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1638                             version_string);
1639                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1640                 }
1641               else
1642                 {
1643                   print_vma (psym->st_value, LONG_HEX);
1644
1645                   printf (is_32bit_elf ? "   " : " ");
1646                 }
1647
1648               if (psym->st_name == 0)
1649                 {
1650                   const char * sec_name = "<null>";
1651                   char name_buf[40];
1652
1653                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1654                     {
1655                       if (psym->st_shndx < filedata->file_header.e_shnum)
1656                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1657                       else if (psym->st_shndx == SHN_ABS)
1658                         sec_name = "ABS";
1659                       else if (psym->st_shndx == SHN_COMMON)
1660                         sec_name = "COMMON";
1661                       else if ((filedata->file_header.e_machine == EM_MIPS
1662                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1663                                || (filedata->file_header.e_machine == EM_TI_C6000
1664                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1665                         sec_name = "SCOMMON";
1666                       else if (filedata->file_header.e_machine == EM_MIPS
1667                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1668                         sec_name = "SUNDEF";
1669                       else if ((filedata->file_header.e_machine == EM_X86_64
1670                                 || filedata->file_header.e_machine == EM_L1OM
1671                                 || filedata->file_header.e_machine == EM_K1OM)
1672                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1673                         sec_name = "LARGE_COMMON";
1674                       else if (filedata->file_header.e_machine == EM_IA_64
1675                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1676                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1677                         sec_name = "ANSI_COM";
1678                       else if (is_ia64_vms (filedata)
1679                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1680                         sec_name = "VMS_SYMVEC";
1681                       else
1682                         {
1683                           sprintf (name_buf, "<section 0x%x>",
1684                                    (unsigned int) psym->st_shndx);
1685                           sec_name = name_buf;
1686                         }
1687                     }
1688                   print_symbol (22, sec_name);
1689                 }
1690               else if (strtab == NULL)
1691                 printf (_("<string table index: %3ld>"), psym->st_name);
1692               else if (psym->st_name >= strtablen)
1693                 {
1694                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1695                   res = FALSE;
1696                 }
1697               else
1698                 {
1699                   print_symbol (22, strtab + psym->st_name);
1700                   if (version_string)
1701                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1702                             version_string);
1703                 }
1704
1705               if (is_rela)
1706                 {
1707                   bfd_vma off = rels[i].r_addend;
1708
1709                   if ((bfd_signed_vma) off < 0)
1710                     printf (" - %" BFD_VMA_FMT "x", - off);
1711                   else
1712                     printf (" + %" BFD_VMA_FMT "x", off);
1713                 }
1714             }
1715         }
1716       else if (is_rela)
1717         {
1718           bfd_vma off = rels[i].r_addend;
1719
1720           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1721           if ((bfd_signed_vma) off < 0)
1722             printf ("-%" BFD_VMA_FMT "x", - off);
1723           else
1724             printf ("%" BFD_VMA_FMT "x", off);
1725         }
1726
1727       if (filedata->file_header.e_machine == EM_SPARCV9
1728           && rtype != NULL
1729           && streq (rtype, "R_SPARC_OLO10"))
1730         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1731
1732       putchar ('\n');
1733
1734 #ifdef BFD64
1735       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1736         {
1737           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1738           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1739           const char * rtype2 = elf_mips_reloc_type (type2);
1740           const char * rtype3 = elf_mips_reloc_type (type3);
1741
1742           printf ("                    Type2: ");
1743
1744           if (rtype2 == NULL)
1745             printf (_("unrecognized: %-7lx"),
1746                     (unsigned long) type2 & 0xffffffff);
1747           else
1748             printf ("%-17.17s", rtype2);
1749
1750           printf ("\n                    Type3: ");
1751
1752           if (rtype3 == NULL)
1753             printf (_("unrecognized: %-7lx"),
1754                     (unsigned long) type3 & 0xffffffff);
1755           else
1756             printf ("%-17.17s", rtype3);
1757
1758           putchar ('\n');
1759         }
1760 #endif /* BFD64 */
1761     }
1762
1763   free (rels);
1764
1765   return res;
1766 }
1767
1768 static const char *
1769 get_mips_dynamic_type (unsigned long type)
1770 {
1771   switch (type)
1772     {
1773     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1774     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1775     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1776     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1777     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1778     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1779     case DT_MIPS_MSYM: return "MIPS_MSYM";
1780     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1781     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1782     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1783     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1784     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1785     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1786     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1787     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1788     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1789     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1790     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1791     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1792     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1793     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1794     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1795     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1796     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1797     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1798     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1799     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1800     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1801     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1802     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1803     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1804     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1805     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1806     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1807     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1808     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1809     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1810     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1811     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1812     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1813     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1814     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1815     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1816     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1817     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1818     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1819     default:
1820       return NULL;
1821     }
1822 }
1823
1824 static const char *
1825 get_sparc64_dynamic_type (unsigned long type)
1826 {
1827   switch (type)
1828     {
1829     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1830     default:
1831       return NULL;
1832     }
1833 }
1834
1835 static const char *
1836 get_ppc_dynamic_type (unsigned long type)
1837 {
1838   switch (type)
1839     {
1840     case DT_PPC_GOT:    return "PPC_GOT";
1841     case DT_PPC_OPT:    return "PPC_OPT";
1842     default:
1843       return NULL;
1844     }
1845 }
1846
1847 static const char *
1848 get_ppc64_dynamic_type (unsigned long type)
1849 {
1850   switch (type)
1851     {
1852     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1853     case DT_PPC64_OPD:    return "PPC64_OPD";
1854     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1855     case DT_PPC64_OPT:    return "PPC64_OPT";
1856     default:
1857       return NULL;
1858     }
1859 }
1860
1861 static const char *
1862 get_parisc_dynamic_type (unsigned long type)
1863 {
1864   switch (type)
1865     {
1866     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1867     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1868     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1869     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1870     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1871     case DT_HP_PREINIT:         return "HP_PREINIT";
1872     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1873     case DT_HP_NEEDED:          return "HP_NEEDED";
1874     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1875     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1876     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1877     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1878     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1879     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1880     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1881     case DT_HP_FILTERED:        return "HP_FILTERED";
1882     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1883     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1884     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1885     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1886     case DT_PLT:                return "PLT";
1887     case DT_PLT_SIZE:           return "PLT_SIZE";
1888     case DT_DLT:                return "DLT";
1889     case DT_DLT_SIZE:           return "DLT_SIZE";
1890     default:
1891       return NULL;
1892     }
1893 }
1894
1895 static const char *
1896 get_ia64_dynamic_type (unsigned long type)
1897 {
1898   switch (type)
1899     {
1900     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1901     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1902     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1903     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1904     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1905     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1906     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1907     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1908     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1909     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1910     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1911     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1912     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1913     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1914     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1915     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1916     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1917     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1918     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1919     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1920     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1921     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1922     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1923     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1924     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1925     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1926     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1927     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1928     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1929     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1930     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1931     default:
1932       return NULL;
1933     }
1934 }
1935
1936 static const char *
1937 get_solaris_section_type (unsigned long type)
1938 {
1939   switch (type)
1940     {
1941     case 0x6fffffee: return "SUNW_ancillary";
1942     case 0x6fffffef: return "SUNW_capchain";
1943     case 0x6ffffff0: return "SUNW_capinfo";
1944     case 0x6ffffff1: return "SUNW_symsort";
1945     case 0x6ffffff2: return "SUNW_tlssort";
1946     case 0x6ffffff3: return "SUNW_LDYNSYM";
1947     case 0x6ffffff4: return "SUNW_dof";
1948     case 0x6ffffff5: return "SUNW_cap";
1949     case 0x6ffffff6: return "SUNW_SIGNATURE";
1950     case 0x6ffffff7: return "SUNW_ANNOTATE";
1951     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1952     case 0x6ffffff9: return "SUNW_DEBUG";
1953     case 0x6ffffffa: return "SUNW_move";
1954     case 0x6ffffffb: return "SUNW_COMDAT";
1955     case 0x6ffffffc: return "SUNW_syminfo";
1956     case 0x6ffffffd: return "SUNW_verdef";
1957     case 0x6ffffffe: return "SUNW_verneed";
1958     case 0x6fffffff: return "SUNW_versym";
1959     case 0x70000000: return "SPARC_GOTDATA";
1960     default: return NULL;
1961     }
1962 }
1963
1964 static const char *
1965 get_alpha_dynamic_type (unsigned long type)
1966 {
1967   switch (type)
1968     {
1969     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1970     default: return NULL;
1971     }
1972 }
1973
1974 static const char *
1975 get_score_dynamic_type (unsigned long type)
1976 {
1977   switch (type)
1978     {
1979     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1980     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
1981     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
1982     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
1983     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
1984     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
1985     default:                    return NULL;
1986     }
1987 }
1988
1989 static const char *
1990 get_tic6x_dynamic_type (unsigned long type)
1991 {
1992   switch (type)
1993     {
1994     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1995     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1996     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
1997     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
1998     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
1999     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2000     default:                   return NULL;
2001     }
2002 }
2003
2004 static const char *
2005 get_nios2_dynamic_type (unsigned long type)
2006 {
2007   switch (type)
2008     {
2009     case DT_NIOS2_GP: return "NIOS2_GP";
2010     default:          return NULL;
2011     }
2012 }
2013
2014 static const char *
2015 get_solaris_dynamic_type (unsigned long type)
2016 {
2017   switch (type)
2018     {
2019     case 0x6000000d: return "SUNW_AUXILIARY";
2020     case 0x6000000e: return "SUNW_RTLDINF";
2021     case 0x6000000f: return "SUNW_FILTER";
2022     case 0x60000010: return "SUNW_CAP";
2023     case 0x60000011: return "SUNW_SYMTAB";
2024     case 0x60000012: return "SUNW_SYMSZ";
2025     case 0x60000013: return "SUNW_SORTENT";
2026     case 0x60000014: return "SUNW_SYMSORT";
2027     case 0x60000015: return "SUNW_SYMSORTSZ";
2028     case 0x60000016: return "SUNW_TLSSORT";
2029     case 0x60000017: return "SUNW_TLSSORTSZ";
2030     case 0x60000018: return "SUNW_CAPINFO";
2031     case 0x60000019: return "SUNW_STRPAD";
2032     case 0x6000001a: return "SUNW_CAPCHAIN";
2033     case 0x6000001b: return "SUNW_LDMACH";
2034     case 0x6000001d: return "SUNW_CAPCHAINENT";
2035     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2036     case 0x60000021: return "SUNW_PARENT";
2037     case 0x60000023: return "SUNW_ASLR";
2038     case 0x60000025: return "SUNW_RELAX";
2039     case 0x60000029: return "SUNW_NXHEAP";
2040     case 0x6000002b: return "SUNW_NXSTACK";
2041
2042     case 0x70000001: return "SPARC_REGISTER";
2043     case 0x7ffffffd: return "AUXILIARY";
2044     case 0x7ffffffe: return "USED";
2045     case 0x7fffffff: return "FILTER";
2046
2047     default: return NULL;
2048     }
2049 }
2050
2051 static const char *
2052 get_dynamic_type (Filedata * filedata, unsigned long type)
2053 {
2054   static char buff[64];
2055
2056   switch (type)
2057     {
2058     case DT_NULL:       return "NULL";
2059     case DT_NEEDED:     return "NEEDED";
2060     case DT_PLTRELSZ:   return "PLTRELSZ";
2061     case DT_PLTGOT:     return "PLTGOT";
2062     case DT_HASH:       return "HASH";
2063     case DT_STRTAB:     return "STRTAB";
2064     case DT_SYMTAB:     return "SYMTAB";
2065     case DT_RELA:       return "RELA";
2066     case DT_RELASZ:     return "RELASZ";
2067     case DT_RELAENT:    return "RELAENT";
2068     case DT_STRSZ:      return "STRSZ";
2069     case DT_SYMENT:     return "SYMENT";
2070     case DT_INIT:       return "INIT";
2071     case DT_FINI:       return "FINI";
2072     case DT_SONAME:     return "SONAME";
2073     case DT_RPATH:      return "RPATH";
2074     case DT_SYMBOLIC:   return "SYMBOLIC";
2075     case DT_REL:        return "REL";
2076     case DT_RELSZ:      return "RELSZ";
2077     case DT_RELENT:     return "RELENT";
2078     case DT_PLTREL:     return "PLTREL";
2079     case DT_DEBUG:      return "DEBUG";
2080     case DT_TEXTREL:    return "TEXTREL";
2081     case DT_JMPREL:     return "JMPREL";
2082     case DT_BIND_NOW:   return "BIND_NOW";
2083     case DT_INIT_ARRAY: return "INIT_ARRAY";
2084     case DT_FINI_ARRAY: return "FINI_ARRAY";
2085     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2086     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2087     case DT_RUNPATH:    return "RUNPATH";
2088     case DT_FLAGS:      return "FLAGS";
2089
2090     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2091     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2092     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2093
2094     case DT_CHECKSUM:   return "CHECKSUM";
2095     case DT_PLTPADSZ:   return "PLTPADSZ";
2096     case DT_MOVEENT:    return "MOVEENT";
2097     case DT_MOVESZ:     return "MOVESZ";
2098     case DT_FEATURE:    return "FEATURE";
2099     case DT_POSFLAG_1:  return "POSFLAG_1";
2100     case DT_SYMINSZ:    return "SYMINSZ";
2101     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2102
2103     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2104     case DT_CONFIG:     return "CONFIG";
2105     case DT_DEPAUDIT:   return "DEPAUDIT";
2106     case DT_AUDIT:      return "AUDIT";
2107     case DT_PLTPAD:     return "PLTPAD";
2108     case DT_MOVETAB:    return "MOVETAB";
2109     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2110
2111     case DT_VERSYM:     return "VERSYM";
2112
2113     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2114     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2115     case DT_RELACOUNT:  return "RELACOUNT";
2116     case DT_RELCOUNT:   return "RELCOUNT";
2117     case DT_FLAGS_1:    return "FLAGS_1";
2118     case DT_VERDEF:     return "VERDEF";
2119     case DT_VERDEFNUM:  return "VERDEFNUM";
2120     case DT_VERNEED:    return "VERNEED";
2121     case DT_VERNEEDNUM: return "VERNEEDNUM";
2122
2123     case DT_AUXILIARY:  return "AUXILIARY";
2124     case DT_USED:       return "USED";
2125     case DT_FILTER:     return "FILTER";
2126
2127     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2128     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2129     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2130     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2131     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2132     case DT_GNU_HASH:   return "GNU_HASH";
2133
2134     default:
2135       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2136         {
2137           const char * result;
2138
2139           switch (filedata->file_header.e_machine)
2140             {
2141             case EM_MIPS:
2142             case EM_MIPS_RS3_LE:
2143               result = get_mips_dynamic_type (type);
2144               break;
2145             case EM_SPARCV9:
2146               result = get_sparc64_dynamic_type (type);
2147               break;
2148             case EM_PPC:
2149               result = get_ppc_dynamic_type (type);
2150               break;
2151             case EM_PPC64:
2152               result = get_ppc64_dynamic_type (type);
2153               break;
2154             case EM_IA_64:
2155               result = get_ia64_dynamic_type (type);
2156               break;
2157             case EM_ALPHA:
2158               result = get_alpha_dynamic_type (type);
2159               break;
2160             case EM_SCORE:
2161               result = get_score_dynamic_type (type);
2162               break;
2163             case EM_TI_C6000:
2164               result = get_tic6x_dynamic_type (type);
2165               break;
2166             case EM_ALTERA_NIOS2:
2167               result = get_nios2_dynamic_type (type);
2168               break;
2169             default:
2170               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2171                 result = get_solaris_dynamic_type (type);
2172               else
2173                 result = NULL;
2174               break;
2175             }
2176
2177           if (result != NULL)
2178             return result;
2179
2180           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2181         }
2182       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2183                || (filedata->file_header.e_machine == EM_PARISC
2184                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2185         {
2186           const char * result;
2187
2188           switch (filedata->file_header.e_machine)
2189             {
2190             case EM_PARISC:
2191               result = get_parisc_dynamic_type (type);
2192               break;
2193             case EM_IA_64:
2194               result = get_ia64_dynamic_type (type);
2195               break;
2196             default:
2197               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2198                 result = get_solaris_dynamic_type (type);
2199               else
2200                 result = NULL;
2201               break;
2202             }
2203
2204           if (result != NULL)
2205             return result;
2206
2207           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2208                     type);
2209         }
2210       else
2211         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2212
2213       return buff;
2214     }
2215 }
2216
2217 static char *
2218 get_file_type (unsigned e_type)
2219 {
2220   static char buff[32];
2221
2222   switch (e_type)
2223     {
2224     case ET_NONE: return _("NONE (None)");
2225     case ET_REL:  return _("REL (Relocatable file)");
2226     case ET_EXEC: return _("EXEC (Executable file)");
2227     case ET_DYN:  return _("DYN (Shared object file)");
2228     case ET_CORE: return _("CORE (Core file)");
2229
2230     default:
2231       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2232         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2233       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2234         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2235       else
2236         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2237       return buff;
2238     }
2239 }
2240
2241 static char *
2242 get_machine_name (unsigned e_machine)
2243 {
2244   static char buff[64]; /* XXX */
2245
2246   switch (e_machine)
2247     {
2248       /* Please keep this switch table sorted by increasing EM_ value.  */
2249       /* 0 */
2250     case EM_NONE:               return _("None");
2251     case EM_M32:                return "WE32100";
2252     case EM_SPARC:              return "Sparc";
2253     case EM_386:                return "Intel 80386";
2254     case EM_68K:                return "MC68000";
2255     case EM_88K:                return "MC88000";
2256     case EM_IAMCU:              return "Intel MCU";
2257     case EM_860:                return "Intel 80860";
2258     case EM_MIPS:               return "MIPS R3000";
2259     case EM_S370:               return "IBM System/370";
2260       /* 10 */
2261     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2262     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2263     case EM_PARISC:             return "HPPA";
2264     case EM_VPP550:             return "Fujitsu VPP500";
2265     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2266     case EM_960:                return "Intel 90860";
2267     case EM_PPC:                return "PowerPC";
2268       /* 20 */
2269     case EM_PPC64:              return "PowerPC64";
2270     case EM_S390_OLD:
2271     case EM_S390:               return "IBM S/390";
2272     case EM_SPU:                return "SPU";
2273       /* 30 */
2274     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2275     case EM_FR20:               return "Fujitsu FR20";
2276     case EM_RH32:               return "TRW RH32";
2277     case EM_MCORE:              return "MCORE";
2278       /* 40 */
2279     case EM_ARM:                return "ARM";
2280     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2281     case EM_SH:                 return "Renesas / SuperH SH";
2282     case EM_SPARCV9:            return "Sparc v9";
2283     case EM_TRICORE:            return "Siemens Tricore";
2284     case EM_ARC:                return "ARC";
2285     case EM_H8_300:             return "Renesas H8/300";
2286     case EM_H8_300H:            return "Renesas H8/300H";
2287     case EM_H8S:                return "Renesas H8S";
2288     case EM_H8_500:             return "Renesas H8/500";
2289       /* 50 */
2290     case EM_IA_64:              return "Intel IA-64";
2291     case EM_MIPS_X:             return "Stanford MIPS-X";
2292     case EM_COLDFIRE:           return "Motorola Coldfire";
2293     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2294     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2295     case EM_PCP:                return "Siemens PCP";
2296     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2297     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2298     case EM_STARCORE:           return "Motorola Star*Core processor";
2299     case EM_ME16:               return "Toyota ME16 processor";
2300       /* 60 */
2301     case EM_ST100:              return "STMicroelectronics ST100 processor";
2302     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2303     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2304     case EM_PDSP:               return "Sony DSP processor";
2305     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2306     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2307     case EM_FX66:               return "Siemens FX66 microcontroller";
2308     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2309     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2310     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2311       /* 70 */
2312     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2313     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2314     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2315     case EM_SVX:                return "Silicon Graphics SVx";
2316     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2317     case EM_VAX:                return "Digital VAX";
2318     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2319     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2320     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2321     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2322       /* 80 */
2323     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2324     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2325     case EM_PRISM:              return "Vitesse Prism";
2326     case EM_AVR_OLD:
2327     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2328     case EM_CYGNUS_FR30:
2329     case EM_FR30:               return "Fujitsu FR30";
2330     case EM_CYGNUS_D10V:
2331     case EM_D10V:               return "d10v";
2332     case EM_CYGNUS_D30V:
2333     case EM_D30V:               return "d30v";
2334     case EM_CYGNUS_V850:
2335     case EM_V850:               return "Renesas V850";
2336     case EM_CYGNUS_M32R:
2337     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2338     case EM_CYGNUS_MN10300:
2339     case EM_MN10300:            return "mn10300";
2340       /* 90 */
2341     case EM_CYGNUS_MN10200:
2342     case EM_MN10200:            return "mn10200";
2343     case EM_PJ:                 return "picoJava";
2344     case EM_OR1K:               return "OpenRISC 1000";
2345     case EM_ARC_COMPACT:        return "ARCompact";
2346     case EM_XTENSA_OLD:
2347     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2348     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2349     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2350     case EM_NS32K:              return "National Semiconductor 32000 series";
2351     case EM_TPC:                return "Tenor Network TPC processor";
2352     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2353       /* 100 */
2354     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2355     case EM_IP2K_OLD:
2356     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2357     case EM_MAX:                return "MAX Processor";
2358     case EM_CR:                 return "National Semiconductor CompactRISC";
2359     case EM_F2MC16:             return "Fujitsu F2MC16";
2360     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2361     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2362     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2363     case EM_SEP:                return "Sharp embedded microprocessor";
2364     case EM_ARCA:               return "Arca RISC microprocessor";
2365       /* 110 */
2366     case EM_UNICORE:            return "Unicore";
2367     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2368     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2369     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2370     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2371     case EM_XGATE:              return "Motorola XGATE embedded processor";
2372     case EM_C166:
2373     case EM_XC16X:              return "Infineon Technologies xc16x";
2374     case EM_M16C:               return "Renesas M16C series microprocessors";
2375     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2376     case EM_CE:                 return "Freescale Communication Engine RISC core";
2377       /* 120 */
2378     case EM_M32C:               return "Renesas M32c";
2379       /* 130 */
2380     case EM_TSK3000:            return "Altium TSK3000 core";
2381     case EM_RS08:               return "Freescale RS08 embedded processor";
2382     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2383     case EM_SCORE:              return "SUNPLUS S+Core";
2384     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2385     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2386     case EM_LATTICEMICO32:      return "Lattice Mico32";
2387     case EM_SE_C17:             return "Seiko Epson C17 family";
2388       /* 140 */
2389     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2390     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2391     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2392     case EM_TI_PRU:             return "TI PRU I/O processor";
2393       /* 160 */
2394     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2395     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2396     case EM_R32C:               return "Renesas R32C series microprocessors";
2397     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2398     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2399     case EM_8051:               return "Intel 8051 and variants";
2400     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2401     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2402     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2403     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2404       /* 170 */
2405     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2406     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2407     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2408     case EM_RX:                 return "Renesas RX";
2409     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2410     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2411     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2412     case EM_CR16:
2413     case EM_MICROBLAZE:
2414     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2415     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2416     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2417       /* 180 */
2418     case EM_L1OM:               return "Intel L1OM";
2419     case EM_K1OM:               return "Intel K1OM";
2420     case EM_INTEL182:           return "Intel (reserved)";
2421     case EM_AARCH64:            return "AArch64";
2422     case EM_ARM184:             return "ARM (reserved)";
2423     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2424     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2425     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2426     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2427       /* 190 */
2428     case EM_CUDA:               return "NVIDIA CUDA architecture";
2429     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2430     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2431     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2432     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2433     case EM_ARC_COMPACT2:       return "ARCv2";
2434     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2435     case EM_RL78:               return "Renesas RL78";
2436     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2437     case EM_78K0R:              return "Renesas 78K0R";
2438       /* 200 */
2439     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2440     case EM_BA1:                return "Beyond BA1 CPU architecture";
2441     case EM_BA2:                return "Beyond BA2 CPU architecture";
2442     case EM_XCORE:              return "XMOS xCORE processor family";
2443     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2444       /* 210 */
2445     case EM_KM32:               return "KM211 KM32 32-bit processor";
2446     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2447     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2448     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2449     case EM_KVARC:              return "KM211 KVARC processor";
2450     case EM_CDP:                return "Paneve CDP architecture family";
2451     case EM_COGE:               return "Cognitive Smart Memory Processor";
2452     case EM_COOL:               return "Bluechip Systems CoolEngine";
2453     case EM_NORC:               return "Nanoradio Optimized RISC";
2454     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2455       /* 220 */
2456     case EM_Z80:                return "Zilog Z80";
2457     case EM_VISIUM:             return "CDS VISIUMcore processor";
2458     case EM_FT32:               return "FTDI Chip FT32";
2459     case EM_MOXIE:              return "Moxie";
2460     case EM_AMDGPU:             return "AMD GPU";
2461     case EM_RISCV:              return "RISC-V";
2462     case EM_LANAI:              return "Lanai 32-bit processor";
2463     case EM_BPF:                return "Linux BPF";
2464
2465       /* Large numbers...  */
2466     case EM_MT:                 return "Morpho Techologies MT processor";
2467     case EM_ALPHA:              return "Alpha";
2468     case EM_WEBASSEMBLY:        return "Web Assembly";
2469     case EM_DLX:                return "OpenDLX";
2470     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2471     case EM_IQ2000:             return "Vitesse IQ2000";
2472     case EM_M32C_OLD:
2473     case EM_NIOS32:             return "Altera Nios";
2474     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2475     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2476     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2477
2478     default:
2479       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2480       return buff;
2481     }
2482 }
2483
2484 static void
2485 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2486 {
2487   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2488      other compilers don't a specific architecture type in the e_flags, and
2489      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2490      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2491      architectures.
2492
2493      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2494      but also sets a specific architecture type in the e_flags field.
2495
2496      However, when decoding the flags we don't worry if we see an
2497      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2498      ARCEM architecture type.  */
2499
2500   switch (e_flags & EF_ARC_MACH_MSK)
2501     {
2502       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2503     case EF_ARC_CPU_ARCV2EM:
2504       strcat (buf, ", ARC EM");
2505       break;
2506     case EF_ARC_CPU_ARCV2HS:
2507       strcat (buf, ", ARC HS");
2508       break;
2509
2510       /* We only expect these to occur for EM_ARC_COMPACT.  */
2511     case E_ARC_MACH_ARC600:
2512       strcat (buf, ", ARC600");
2513       break;
2514     case E_ARC_MACH_ARC601:
2515       strcat (buf, ", ARC601");
2516       break;
2517     case E_ARC_MACH_ARC700:
2518       strcat (buf, ", ARC700");
2519       break;
2520
2521       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2522          new ELF with new architecture being read by an old version of
2523          readelf, or (c) An ELF built with non-GNU compiler that does not
2524          set the architecture in the e_flags.  */
2525     default:
2526       if (e_machine == EM_ARC_COMPACT)
2527         strcat (buf, ", Unknown ARCompact");
2528       else
2529         strcat (buf, ", Unknown ARC");
2530       break;
2531     }
2532
2533   switch (e_flags & EF_ARC_OSABI_MSK)
2534     {
2535     case E_ARC_OSABI_ORIG:
2536       strcat (buf, ", (ABI:legacy)");
2537       break;
2538     case E_ARC_OSABI_V2:
2539       strcat (buf, ", (ABI:v2)");
2540       break;
2541       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2542     case E_ARC_OSABI_V3:
2543       strcat (buf, ", v3 no-legacy-syscalls ABI");
2544       break;
2545     case E_ARC_OSABI_V4:
2546       strcat (buf, ", v4 ABI");
2547       break;
2548     default:
2549       strcat (buf, ", unrecognised ARC OSABI flag");
2550       break;
2551     }
2552 }
2553
2554 static void
2555 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2556 {
2557   unsigned eabi;
2558   bfd_boolean unknown = FALSE;
2559
2560   eabi = EF_ARM_EABI_VERSION (e_flags);
2561   e_flags &= ~ EF_ARM_EABIMASK;
2562
2563   /* Handle "generic" ARM flags.  */
2564   if (e_flags & EF_ARM_RELEXEC)
2565     {
2566       strcat (buf, ", relocatable executable");
2567       e_flags &= ~ EF_ARM_RELEXEC;
2568     }
2569
2570   /* Now handle EABI specific flags.  */
2571   switch (eabi)
2572     {
2573     default:
2574       strcat (buf, ", <unrecognized EABI>");
2575       if (e_flags)
2576         unknown = TRUE;
2577       break;
2578
2579     case EF_ARM_EABI_VER1:
2580       strcat (buf, ", Version1 EABI");
2581       while (e_flags)
2582         {
2583           unsigned flag;
2584
2585           /* Process flags one bit at a time.  */
2586           flag = e_flags & - e_flags;
2587           e_flags &= ~ flag;
2588
2589           switch (flag)
2590             {
2591             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2592               strcat (buf, ", sorted symbol tables");
2593               break;
2594
2595             default:
2596               unknown = TRUE;
2597               break;
2598             }
2599         }
2600       break;
2601
2602     case EF_ARM_EABI_VER2:
2603       strcat (buf, ", Version2 EABI");
2604       while (e_flags)
2605         {
2606           unsigned flag;
2607
2608           /* Process flags one bit at a time.  */
2609           flag = e_flags & - e_flags;
2610           e_flags &= ~ flag;
2611
2612           switch (flag)
2613             {
2614             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2615               strcat (buf, ", sorted symbol tables");
2616               break;
2617
2618             case EF_ARM_DYNSYMSUSESEGIDX:
2619               strcat (buf, ", dynamic symbols use segment index");
2620               break;
2621
2622             case EF_ARM_MAPSYMSFIRST:
2623               strcat (buf, ", mapping symbols precede others");
2624               break;
2625
2626             default:
2627               unknown = TRUE;
2628               break;
2629             }
2630         }
2631       break;
2632
2633     case EF_ARM_EABI_VER3:
2634       strcat (buf, ", Version3 EABI");
2635       break;
2636
2637     case EF_ARM_EABI_VER4:
2638       strcat (buf, ", Version4 EABI");
2639       while (e_flags)
2640         {
2641           unsigned flag;
2642
2643           /* Process flags one bit at a time.  */
2644           flag = e_flags & - e_flags;
2645           e_flags &= ~ flag;
2646
2647           switch (flag)
2648             {
2649             case EF_ARM_BE8:
2650               strcat (buf, ", BE8");
2651               break;
2652
2653             case EF_ARM_LE8:
2654               strcat (buf, ", LE8");
2655               break;
2656
2657             default:
2658               unknown = TRUE;
2659               break;
2660             }
2661         }
2662       break;
2663
2664     case EF_ARM_EABI_VER5:
2665       strcat (buf, ", Version5 EABI");
2666       while (e_flags)
2667         {
2668           unsigned flag;
2669
2670           /* Process flags one bit at a time.  */
2671           flag = e_flags & - e_flags;
2672           e_flags &= ~ flag;
2673
2674           switch (flag)
2675             {
2676             case EF_ARM_BE8:
2677               strcat (buf, ", BE8");
2678               break;
2679
2680             case EF_ARM_LE8:
2681               strcat (buf, ", LE8");
2682               break;
2683
2684             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2685               strcat (buf, ", soft-float ABI");
2686               break;
2687
2688             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2689               strcat (buf, ", hard-float ABI");
2690               break;
2691
2692             default:
2693               unknown = TRUE;
2694               break;
2695             }
2696         }
2697       break;
2698
2699     case EF_ARM_EABI_UNKNOWN:
2700       strcat (buf, ", GNU EABI");
2701       while (e_flags)
2702         {
2703           unsigned flag;
2704
2705           /* Process flags one bit at a time.  */
2706           flag = e_flags & - e_flags;
2707           e_flags &= ~ flag;
2708
2709           switch (flag)
2710             {
2711             case EF_ARM_INTERWORK:
2712               strcat (buf, ", interworking enabled");
2713               break;
2714
2715             case EF_ARM_APCS_26:
2716               strcat (buf, ", uses APCS/26");
2717               break;
2718
2719             case EF_ARM_APCS_FLOAT:
2720               strcat (buf, ", uses APCS/float");
2721               break;
2722
2723             case EF_ARM_PIC:
2724               strcat (buf, ", position independent");
2725               break;
2726
2727             case EF_ARM_ALIGN8:
2728               strcat (buf, ", 8 bit structure alignment");
2729               break;
2730
2731             case EF_ARM_NEW_ABI:
2732               strcat (buf, ", uses new ABI");
2733               break;
2734
2735             case EF_ARM_OLD_ABI:
2736               strcat (buf, ", uses old ABI");
2737               break;
2738
2739             case EF_ARM_SOFT_FLOAT:
2740               strcat (buf, ", software FP");
2741               break;
2742
2743             case EF_ARM_VFP_FLOAT:
2744               strcat (buf, ", VFP");
2745               break;
2746
2747             case EF_ARM_MAVERICK_FLOAT:
2748               strcat (buf, ", Maverick FP");
2749               break;
2750
2751             default:
2752               unknown = TRUE;
2753               break;
2754             }
2755         }
2756     }
2757
2758   if (unknown)
2759     strcat (buf,_(", <unknown>"));
2760 }
2761
2762 static void
2763 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2764 {
2765   --size; /* Leave space for null terminator.  */
2766
2767   switch (e_flags & EF_AVR_MACH)
2768     {
2769     case E_AVR_MACH_AVR1:
2770       strncat (buf, ", avr:1", size);
2771       break;
2772     case E_AVR_MACH_AVR2:
2773       strncat (buf, ", avr:2", size);
2774       break;
2775     case E_AVR_MACH_AVR25:
2776       strncat (buf, ", avr:25", size);
2777       break;
2778     case E_AVR_MACH_AVR3:
2779       strncat (buf, ", avr:3", size);
2780       break;
2781     case E_AVR_MACH_AVR31:
2782       strncat (buf, ", avr:31", size);
2783       break;
2784     case E_AVR_MACH_AVR35:
2785       strncat (buf, ", avr:35", size);
2786       break;
2787     case E_AVR_MACH_AVR4:
2788       strncat (buf, ", avr:4", size);
2789       break;
2790     case E_AVR_MACH_AVR5:
2791       strncat (buf, ", avr:5", size);
2792       break;
2793     case E_AVR_MACH_AVR51:
2794       strncat (buf, ", avr:51", size);
2795       break;
2796     case E_AVR_MACH_AVR6:
2797       strncat (buf, ", avr:6", size);
2798       break;
2799     case E_AVR_MACH_AVRTINY:
2800       strncat (buf, ", avr:100", size);
2801       break;
2802     case E_AVR_MACH_XMEGA1:
2803       strncat (buf, ", avr:101", size);
2804       break;
2805     case E_AVR_MACH_XMEGA2:
2806       strncat (buf, ", avr:102", size);
2807       break;
2808     case E_AVR_MACH_XMEGA3:
2809       strncat (buf, ", avr:103", size);
2810       break;
2811     case E_AVR_MACH_XMEGA4:
2812       strncat (buf, ", avr:104", size);
2813       break;
2814     case E_AVR_MACH_XMEGA5:
2815       strncat (buf, ", avr:105", size);
2816       break;
2817     case E_AVR_MACH_XMEGA6:
2818       strncat (buf, ", avr:106", size);
2819       break;
2820     case E_AVR_MACH_XMEGA7:
2821       strncat (buf, ", avr:107", size);
2822       break;
2823     default:
2824       strncat (buf, ", avr:<unknown>", size);
2825       break;
2826     }
2827
2828   size -= strlen (buf);
2829   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2830     strncat (buf, ", link-relax", size);
2831 }
2832
2833 static void
2834 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2835 {
2836   unsigned abi;
2837   unsigned arch;
2838   unsigned config;
2839   unsigned version;
2840   bfd_boolean has_fpu = FALSE;
2841   unsigned int r = 0;
2842
2843   static const char *ABI_STRINGS[] =
2844   {
2845     "ABI v0", /* use r5 as return register; only used in N1213HC */
2846     "ABI v1", /* use r0 as return register */
2847     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2848     "ABI v2fp", /* for FPU */
2849     "AABI",
2850     "ABI2 FP+"
2851   };
2852   static const char *VER_STRINGS[] =
2853   {
2854     "Andes ELF V1.3 or older",
2855     "Andes ELF V1.3.1",
2856     "Andes ELF V1.4"
2857   };
2858   static const char *ARCH_STRINGS[] =
2859   {
2860     "",
2861     "Andes Star v1.0",
2862     "Andes Star v2.0",
2863     "Andes Star v3.0",
2864     "Andes Star v3.0m"
2865   };
2866
2867   abi = EF_NDS_ABI & e_flags;
2868   arch = EF_NDS_ARCH & e_flags;
2869   config = EF_NDS_INST & e_flags;
2870   version = EF_NDS32_ELF_VERSION & e_flags;
2871
2872   memset (buf, 0, size);
2873
2874   switch (abi)
2875     {
2876     case E_NDS_ABI_V0:
2877     case E_NDS_ABI_V1:
2878     case E_NDS_ABI_V2:
2879     case E_NDS_ABI_V2FP:
2880     case E_NDS_ABI_AABI:
2881     case E_NDS_ABI_V2FP_PLUS:
2882       /* In case there are holes in the array.  */
2883       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2884       break;
2885
2886     default:
2887       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2888       break;
2889     }
2890
2891   switch (version)
2892     {
2893     case E_NDS32_ELF_VER_1_2:
2894     case E_NDS32_ELF_VER_1_3:
2895     case E_NDS32_ELF_VER_1_4:
2896       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2897       break;
2898
2899     default:
2900       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2901       break;
2902     }
2903
2904   if (E_NDS_ABI_V0 == abi)
2905     {
2906       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2907       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2908       if (arch == E_NDS_ARCH_STAR_V1_0)
2909         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2910       return;
2911     }
2912
2913   switch (arch)
2914     {
2915     case E_NDS_ARCH_STAR_V1_0:
2916     case E_NDS_ARCH_STAR_V2_0:
2917     case E_NDS_ARCH_STAR_V3_0:
2918     case E_NDS_ARCH_STAR_V3_M:
2919       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2920       break;
2921
2922     default:
2923       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2924       /* ARCH version determines how the e_flags are interpreted.
2925          If it is unknown, we cannot proceed.  */
2926       return;
2927     }
2928
2929   /* Newer ABI; Now handle architecture specific flags.  */
2930   if (arch == E_NDS_ARCH_STAR_V1_0)
2931     {
2932       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2933         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2934
2935       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2936         r += snprintf (buf + r, size -r, ", MAC");
2937
2938       if (config & E_NDS32_HAS_DIV_INST)
2939         r += snprintf (buf + r, size -r, ", DIV");
2940
2941       if (config & E_NDS32_HAS_16BIT_INST)
2942         r += snprintf (buf + r, size -r, ", 16b");
2943     }
2944   else
2945     {
2946       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2947         {
2948           if (version <= E_NDS32_ELF_VER_1_3)
2949             r += snprintf (buf + r, size -r, ", [B8]");
2950           else
2951             r += snprintf (buf + r, size -r, ", EX9");
2952         }
2953
2954       if (config & E_NDS32_HAS_MAC_DX_INST)
2955         r += snprintf (buf + r, size -r, ", MAC_DX");
2956
2957       if (config & E_NDS32_HAS_DIV_DX_INST)
2958         r += snprintf (buf + r, size -r, ", DIV_DX");
2959
2960       if (config & E_NDS32_HAS_16BIT_INST)
2961         {
2962           if (version <= E_NDS32_ELF_VER_1_3)
2963             r += snprintf (buf + r, size -r, ", 16b");
2964           else
2965             r += snprintf (buf + r, size -r, ", IFC");
2966         }
2967     }
2968
2969   if (config & E_NDS32_HAS_EXT_INST)
2970     r += snprintf (buf + r, size -r, ", PERF1");
2971
2972   if (config & E_NDS32_HAS_EXT2_INST)
2973     r += snprintf (buf + r, size -r, ", PERF2");
2974
2975   if (config & E_NDS32_HAS_FPU_INST)
2976     {
2977       has_fpu = TRUE;
2978       r += snprintf (buf + r, size -r, ", FPU_SP");
2979     }
2980
2981   if (config & E_NDS32_HAS_FPU_DP_INST)
2982     {
2983       has_fpu = TRUE;
2984       r += snprintf (buf + r, size -r, ", FPU_DP");
2985     }
2986
2987   if (config & E_NDS32_HAS_FPU_MAC_INST)
2988     {
2989       has_fpu = TRUE;
2990       r += snprintf (buf + r, size -r, ", FPU_MAC");
2991     }
2992
2993   if (has_fpu)
2994     {
2995       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2996         {
2997         case E_NDS32_FPU_REG_8SP_4DP:
2998           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2999           break;
3000         case E_NDS32_FPU_REG_16SP_8DP:
3001           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3002           break;
3003         case E_NDS32_FPU_REG_32SP_16DP:
3004           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3005           break;
3006         case E_NDS32_FPU_REG_32SP_32DP:
3007           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3008           break;
3009         }
3010     }
3011
3012   if (config & E_NDS32_HAS_AUDIO_INST)
3013     r += snprintf (buf + r, size -r, ", AUDIO");
3014
3015   if (config & E_NDS32_HAS_STRING_INST)
3016     r += snprintf (buf + r, size -r, ", STR");
3017
3018   if (config & E_NDS32_HAS_REDUCED_REGS)
3019     r += snprintf (buf + r, size -r, ", 16REG");
3020
3021   if (config & E_NDS32_HAS_VIDEO_INST)
3022     {
3023       if (version <= E_NDS32_ELF_VER_1_3)
3024         r += snprintf (buf + r, size -r, ", VIDEO");
3025       else
3026         r += snprintf (buf + r, size -r, ", SATURATION");
3027     }
3028
3029   if (config & E_NDS32_HAS_ENCRIPT_INST)
3030     r += snprintf (buf + r, size -r, ", ENCRP");
3031
3032   if (config & E_NDS32_HAS_L2C_INST)
3033     r += snprintf (buf + r, size -r, ", L2C");
3034 }
3035
3036 static char *
3037 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3038 {
3039   static char buf[1024];
3040
3041   buf[0] = '\0';
3042
3043   if (e_flags)
3044     {
3045       switch (e_machine)
3046         {
3047         default:
3048           break;
3049
3050         case EM_ARC_COMPACT2:
3051         case EM_ARC_COMPACT:
3052           decode_ARC_machine_flags (e_flags, e_machine, buf);
3053           break;
3054
3055         case EM_ARM:
3056           decode_ARM_machine_flags (e_flags, buf);
3057           break;
3058
3059         case EM_AVR:
3060           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3061           break;
3062
3063         case EM_BLACKFIN:
3064           if (e_flags & EF_BFIN_PIC)
3065             strcat (buf, ", PIC");
3066
3067           if (e_flags & EF_BFIN_FDPIC)
3068             strcat (buf, ", FDPIC");
3069
3070           if (e_flags & EF_BFIN_CODE_IN_L1)
3071             strcat (buf, ", code in L1");
3072
3073           if (e_flags & EF_BFIN_DATA_IN_L1)
3074             strcat (buf, ", data in L1");
3075
3076           break;
3077
3078         case EM_CYGNUS_FRV:
3079           switch (e_flags & EF_FRV_CPU_MASK)
3080             {
3081             case EF_FRV_CPU_GENERIC:
3082               break;
3083
3084             default:
3085               strcat (buf, ", fr???");
3086               break;
3087
3088             case EF_FRV_CPU_FR300:
3089               strcat (buf, ", fr300");
3090               break;
3091
3092             case EF_FRV_CPU_FR400:
3093               strcat (buf, ", fr400");
3094               break;
3095             case EF_FRV_CPU_FR405:
3096               strcat (buf, ", fr405");
3097               break;
3098
3099             case EF_FRV_CPU_FR450:
3100               strcat (buf, ", fr450");
3101               break;
3102
3103             case EF_FRV_CPU_FR500:
3104               strcat (buf, ", fr500");
3105               break;
3106             case EF_FRV_CPU_FR550:
3107               strcat (buf, ", fr550");
3108               break;
3109
3110             case EF_FRV_CPU_SIMPLE:
3111               strcat (buf, ", simple");
3112               break;
3113             case EF_FRV_CPU_TOMCAT:
3114               strcat (buf, ", tomcat");
3115               break;
3116             }
3117           break;
3118
3119         case EM_68K:
3120           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3121             strcat (buf, ", m68000");
3122           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3123             strcat (buf, ", cpu32");
3124           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3125             strcat (buf, ", fido_a");
3126           else
3127             {
3128               char const * isa = _("unknown");
3129               char const * mac = _("unknown mac");
3130               char const * additional = NULL;
3131
3132               switch (e_flags & EF_M68K_CF_ISA_MASK)
3133                 {
3134                 case EF_M68K_CF_ISA_A_NODIV:
3135                   isa = "A";
3136                   additional = ", nodiv";
3137                   break;
3138                 case EF_M68K_CF_ISA_A:
3139                   isa = "A";
3140                   break;
3141                 case EF_M68K_CF_ISA_A_PLUS:
3142                   isa = "A+";
3143                   break;
3144                 case EF_M68K_CF_ISA_B_NOUSP:
3145                   isa = "B";
3146                   additional = ", nousp";
3147                   break;
3148                 case EF_M68K_CF_ISA_B:
3149                   isa = "B";
3150                   break;
3151                 case EF_M68K_CF_ISA_C:
3152                   isa = "C";
3153                   break;
3154                 case EF_M68K_CF_ISA_C_NODIV:
3155                   isa = "C";
3156                   additional = ", nodiv";
3157                   break;
3158                 }
3159               strcat (buf, ", cf, isa ");
3160               strcat (buf, isa);
3161               if (additional)
3162                 strcat (buf, additional);
3163               if (e_flags & EF_M68K_CF_FLOAT)
3164                 strcat (buf, ", float");
3165               switch (e_flags & EF_M68K_CF_MAC_MASK)
3166                 {
3167                 case 0:
3168                   mac = NULL;
3169                   break;
3170                 case EF_M68K_CF_MAC:
3171                   mac = "mac";
3172                   break;
3173                 case EF_M68K_CF_EMAC:
3174                   mac = "emac";
3175                   break;
3176                 case EF_M68K_CF_EMAC_B:
3177                   mac = "emac_b";
3178                   break;
3179                 }
3180               if (mac)
3181                 {
3182                   strcat (buf, ", ");
3183                   strcat (buf, mac);
3184                 }
3185             }
3186           break;
3187
3188         case EM_CYGNUS_MEP:
3189           switch (e_flags & EF_MEP_CPU_MASK)
3190             {
3191             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3192             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3193             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3194             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3195             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3196             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3197             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3198             }
3199
3200           switch (e_flags & EF_MEP_COP_MASK)
3201             {
3202             case EF_MEP_COP_NONE: break;
3203             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3204             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3205             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3206             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3207             default: strcat (buf, _("<unknown MeP copro type>")); break;
3208             }
3209
3210           if (e_flags & EF_MEP_LIBRARY)
3211             strcat (buf, ", Built for Library");
3212
3213           if (e_flags & EF_MEP_INDEX_MASK)
3214             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3215                      e_flags & EF_MEP_INDEX_MASK);
3216
3217           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3218             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3219                      e_flags & ~ EF_MEP_ALL_FLAGS);
3220           break;
3221
3222         case EM_PPC:
3223           if (e_flags & EF_PPC_EMB)
3224             strcat (buf, ", emb");
3225
3226           if (e_flags & EF_PPC_RELOCATABLE)
3227             strcat (buf, _(", relocatable"));
3228
3229           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3230             strcat (buf, _(", relocatable-lib"));
3231           break;
3232
3233         case EM_PPC64:
3234           if (e_flags & EF_PPC64_ABI)
3235             {
3236               char abi[] = ", abiv0";
3237
3238               abi[6] += e_flags & EF_PPC64_ABI;
3239               strcat (buf, abi);
3240             }
3241           break;
3242
3243         case EM_V800:
3244           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3245             strcat (buf, ", RH850 ABI");
3246
3247           if (e_flags & EF_V800_850E3)
3248             strcat (buf, ", V3 architecture");
3249
3250           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3251             strcat (buf, ", FPU not used");
3252
3253           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3254             strcat (buf, ", regmode: COMMON");
3255
3256           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3257             strcat (buf, ", r4 not used");
3258
3259           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3260             strcat (buf, ", r30 not used");
3261
3262           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3263             strcat (buf, ", r5 not used");
3264
3265           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3266             strcat (buf, ", r2 not used");
3267
3268           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3269             {
3270               switch (e_flags & - e_flags)
3271                 {
3272                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3273                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3274                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3275                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3276                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3277                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3278                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3279                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3280                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3281                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3282                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3283                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3284                 default: break;
3285                 }
3286             }
3287           break;
3288
3289         case EM_V850:
3290         case EM_CYGNUS_V850:
3291           switch (e_flags & EF_V850_ARCH)
3292             {
3293             case E_V850E3V5_ARCH:
3294               strcat (buf, ", v850e3v5");
3295               break;
3296             case E_V850E2V3_ARCH:
3297               strcat (buf, ", v850e2v3");
3298               break;
3299             case E_V850E2_ARCH:
3300               strcat (buf, ", v850e2");
3301               break;
3302             case E_V850E1_ARCH:
3303               strcat (buf, ", v850e1");
3304               break;
3305             case E_V850E_ARCH:
3306               strcat (buf, ", v850e");
3307               break;
3308             case E_V850_ARCH:
3309               strcat (buf, ", v850");
3310               break;
3311             default:
3312               strcat (buf, _(", unknown v850 architecture variant"));
3313               break;
3314             }
3315           break;
3316
3317         case EM_M32R:
3318         case EM_CYGNUS_M32R:
3319           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3320             strcat (buf, ", m32r");
3321           break;
3322
3323         case EM_MIPS:
3324         case EM_MIPS_RS3_LE:
3325           if (e_flags & EF_MIPS_NOREORDER)
3326             strcat (buf, ", noreorder");
3327
3328           if (e_flags & EF_MIPS_PIC)
3329             strcat (buf, ", pic");
3330
3331           if (e_flags & EF_MIPS_CPIC)
3332             strcat (buf, ", cpic");
3333
3334           if (e_flags & EF_MIPS_UCODE)
3335             strcat (buf, ", ugen_reserved");
3336
3337           if (e_flags & EF_MIPS_ABI2)
3338             strcat (buf, ", abi2");
3339
3340           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3341             strcat (buf, ", odk first");
3342
3343           if (e_flags & EF_MIPS_32BITMODE)
3344             strcat (buf, ", 32bitmode");
3345
3346           if (e_flags & EF_MIPS_NAN2008)
3347             strcat (buf, ", nan2008");
3348
3349           if (e_flags & EF_MIPS_FP64)
3350             strcat (buf, ", fp64");
3351
3352           switch ((e_flags & EF_MIPS_MACH))
3353             {
3354             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3355             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3356             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3357             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3358             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3359             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3360             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3361             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3362             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3363             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3364             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3365             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3366             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3367             case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3368             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3369             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3370             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3371             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3372             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3373             case 0:
3374             /* We simply ignore the field in this case to avoid confusion:
3375                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3376                extension.  */
3377               break;
3378             default: strcat (buf, _(", unknown CPU")); break;
3379             }
3380
3381           switch ((e_flags & EF_MIPS_ABI))
3382             {
3383             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3384             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3385             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3386             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3387             case 0:
3388             /* We simply ignore the field in this case to avoid confusion:
3389                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3390                This means it is likely to be an o32 file, but not for
3391                sure.  */
3392               break;
3393             default: strcat (buf, _(", unknown ABI")); break;
3394             }
3395
3396           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3397             strcat (buf, ", mdmx");
3398
3399           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3400             strcat (buf, ", mips16");
3401
3402           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3403             strcat (buf, ", micromips");
3404
3405           switch ((e_flags & EF_MIPS_ARCH))
3406             {
3407             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3408             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3409             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3410             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3411             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3412             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3413             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3414             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3415             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3416             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3417             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3418             default: strcat (buf, _(", unknown ISA")); break;
3419             }
3420           break;
3421
3422         case EM_NDS32:
3423           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3424           break;
3425
3426         case EM_RISCV:
3427           if (e_flags & EF_RISCV_RVC)
3428             strcat (buf, ", RVC");
3429
3430           switch (e_flags & EF_RISCV_FLOAT_ABI)
3431             {
3432             case EF_RISCV_FLOAT_ABI_SOFT:
3433               strcat (buf, ", soft-float ABI");
3434               break;
3435
3436             case EF_RISCV_FLOAT_ABI_SINGLE:
3437               strcat (buf, ", single-float ABI");
3438               break;
3439
3440             case EF_RISCV_FLOAT_ABI_DOUBLE:
3441               strcat (buf, ", double-float ABI");
3442               break;
3443
3444             case EF_RISCV_FLOAT_ABI_QUAD:
3445               strcat (buf, ", quad-float ABI");
3446               break;
3447             }
3448           break;
3449
3450         case EM_SH:
3451           switch ((e_flags & EF_SH_MACH_MASK))
3452             {
3453             case EF_SH1: strcat (buf, ", sh1"); break;
3454             case EF_SH2: strcat (buf, ", sh2"); break;
3455             case EF_SH3: strcat (buf, ", sh3"); break;
3456             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3457             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3458             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3459             case EF_SH3E: strcat (buf, ", sh3e"); break;
3460             case EF_SH4: strcat (buf, ", sh4"); break;
3461             case EF_SH5: strcat (buf, ", sh5"); break;
3462             case EF_SH2E: strcat (buf, ", sh2e"); break;
3463             case EF_SH4A: strcat (buf, ", sh4a"); break;
3464             case EF_SH2A: strcat (buf, ", sh2a"); break;
3465             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3466             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3467             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3468             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3469             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3470             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3471             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3472             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3473             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3474             default: strcat (buf, _(", unknown ISA")); break;
3475             }
3476
3477           if (e_flags & EF_SH_PIC)
3478             strcat (buf, ", pic");
3479
3480           if (e_flags & EF_SH_FDPIC)
3481             strcat (buf, ", fdpic");
3482           break;
3483
3484         case EM_OR1K:
3485           if (e_flags & EF_OR1K_NODELAY)
3486             strcat (buf, ", no delay");
3487           break;
3488
3489         case EM_SPARCV9:
3490           if (e_flags & EF_SPARC_32PLUS)
3491             strcat (buf, ", v8+");
3492
3493           if (e_flags & EF_SPARC_SUN_US1)
3494             strcat (buf, ", ultrasparcI");
3495
3496           if (e_flags & EF_SPARC_SUN_US3)
3497             strcat (buf, ", ultrasparcIII");
3498
3499           if (e_flags & EF_SPARC_HAL_R1)
3500             strcat (buf, ", halr1");
3501
3502           if (e_flags & EF_SPARC_LEDATA)
3503             strcat (buf, ", ledata");
3504
3505           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3506             strcat (buf, ", tso");
3507
3508           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3509             strcat (buf, ", pso");
3510
3511           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3512             strcat (buf, ", rmo");
3513           break;
3514
3515         case EM_PARISC:
3516           switch (e_flags & EF_PARISC_ARCH)
3517             {
3518             case EFA_PARISC_1_0:
3519               strcpy (buf, ", PA-RISC 1.0");
3520               break;
3521             case EFA_PARISC_1_1:
3522               strcpy (buf, ", PA-RISC 1.1");
3523               break;
3524             case EFA_PARISC_2_0:
3525               strcpy (buf, ", PA-RISC 2.0");
3526               break;
3527             default:
3528               break;
3529             }
3530           if (e_flags & EF_PARISC_TRAPNIL)
3531             strcat (buf, ", trapnil");
3532           if (e_flags & EF_PARISC_EXT)
3533             strcat (buf, ", ext");
3534           if (e_flags & EF_PARISC_LSB)
3535             strcat (buf, ", lsb");
3536           if (e_flags & EF_PARISC_WIDE)
3537             strcat (buf, ", wide");
3538           if (e_flags & EF_PARISC_NO_KABP)
3539             strcat (buf, ", no kabp");
3540           if (e_flags & EF_PARISC_LAZYSWAP)
3541             strcat (buf, ", lazyswap");
3542           break;
3543
3544         case EM_PJ:
3545         case EM_PJ_OLD:
3546           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3547             strcat (buf, ", new calling convention");
3548
3549           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3550             strcat (buf, ", gnu calling convention");
3551           break;
3552
3553         case EM_IA_64:
3554           if ((e_flags & EF_IA_64_ABI64))
3555             strcat (buf, ", 64-bit");
3556           else
3557             strcat (buf, ", 32-bit");
3558           if ((e_flags & EF_IA_64_REDUCEDFP))
3559             strcat (buf, ", reduced fp model");
3560           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3561             strcat (buf, ", no function descriptors, constant gp");
3562           else if ((e_flags & EF_IA_64_CONS_GP))
3563             strcat (buf, ", constant gp");
3564           if ((e_flags & EF_IA_64_ABSOLUTE))
3565             strcat (buf, ", absolute");
3566           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3567             {
3568               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3569                 strcat (buf, ", vms_linkages");
3570               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3571                 {
3572                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3573                   break;
3574                 case EF_IA_64_VMS_COMCOD_WARNING:
3575                   strcat (buf, ", warning");
3576                   break;
3577                 case EF_IA_64_VMS_COMCOD_ERROR:
3578                   strcat (buf, ", error");
3579                   break;
3580                 case EF_IA_64_VMS_COMCOD_ABORT:
3581                   strcat (buf, ", abort");
3582                   break;
3583                 default:
3584                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3585                         e_flags & EF_IA_64_VMS_COMCOD);
3586                   strcat (buf, ", <unknown>");
3587                 }
3588             }
3589           break;
3590
3591         case EM_VAX:
3592           if ((e_flags & EF_VAX_NONPIC))
3593             strcat (buf, ", non-PIC");
3594           if ((e_flags & EF_VAX_DFLOAT))
3595             strcat (buf, ", D-Float");
3596           if ((e_flags & EF_VAX_GFLOAT))
3597             strcat (buf, ", G-Float");
3598           break;
3599
3600         case EM_VISIUM:
3601           if (e_flags & EF_VISIUM_ARCH_MCM)
3602             strcat (buf, ", mcm");
3603           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3604             strcat (buf, ", mcm24");
3605           if (e_flags & EF_VISIUM_ARCH_GR6)
3606             strcat (buf, ", gr6");
3607           break;
3608
3609         case EM_RL78:
3610           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3611             {
3612             case E_FLAG_RL78_ANY_CPU: break;
3613             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3614             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3615             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3616             }
3617           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3618             strcat (buf, ", 64-bit doubles");
3619           break;
3620
3621         case EM_RX:
3622           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3623             strcat (buf, ", 64-bit doubles");
3624           if (e_flags & E_FLAG_RX_DSP)
3625             strcat (buf, ", dsp");
3626           if (e_flags & E_FLAG_RX_PID)
3627             strcat (buf, ", pid");
3628           if (e_flags & E_FLAG_RX_ABI)
3629             strcat (buf, ", RX ABI");
3630           if (e_flags & E_FLAG_RX_SINSNS_SET)
3631             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3632                     ? ", uses String instructions" : ", bans String instructions");
3633           if (e_flags & E_FLAG_RX_V2)
3634             strcat (buf, ", V2");
3635           break;
3636
3637         case EM_S390:
3638           if (e_flags & EF_S390_HIGH_GPRS)
3639             strcat (buf, ", highgprs");
3640           break;
3641
3642         case EM_TI_C6000:
3643           if ((e_flags & EF_C6000_REL))
3644             strcat (buf, ", relocatable module");
3645           break;
3646
3647         case EM_MSP430:
3648           strcat (buf, _(": architecture variant: "));
3649           switch (e_flags & EF_MSP430_MACH)
3650             {
3651             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3652             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3653             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3654             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3655             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3656             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3657             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3658             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3659             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3660             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3661             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3662             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3663             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3664             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3665             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3666             default:
3667               strcat (buf, _(": unknown")); break;
3668             }
3669
3670           if (e_flags & ~ EF_MSP430_MACH)
3671             strcat (buf, _(": unknown extra flag bits also present"));
3672         }
3673     }
3674
3675   return buf;
3676 }
3677
3678 static const char *
3679 get_osabi_name (Filedata * filedata, unsigned int osabi)
3680 {
3681   static char buff[32];
3682
3683   switch (osabi)
3684     {
3685     case ELFOSABI_NONE:         return "UNIX - System V";
3686     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3687     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3688     case ELFOSABI_GNU:          return "UNIX - GNU";
3689     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3690     case ELFOSABI_AIX:          return "UNIX - AIX";
3691     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3692     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3693     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3694     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3695     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3696     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3697     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3698     case ELFOSABI_AROS:         return "AROS";
3699     case ELFOSABI_FENIXOS:      return "FenixOS";
3700     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3701     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3702     default:
3703       if (osabi >= 64)
3704         switch (filedata->file_header.e_machine)
3705           {
3706           case EM_ARM:
3707             switch (osabi)
3708               {
3709               case ELFOSABI_ARM:        return "ARM";
3710               default:
3711                 break;
3712               }
3713             break;
3714
3715           case EM_MSP430:
3716           case EM_MSP430_OLD:
3717           case EM_VISIUM:
3718             switch (osabi)
3719               {
3720               case ELFOSABI_STANDALONE: return _("Standalone App");
3721               default:
3722                 break;
3723               }
3724             break;
3725
3726           case EM_TI_C6000:
3727             switch (osabi)
3728               {
3729               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3730               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3731               default:
3732                 break;
3733               }
3734             break;
3735
3736           default:
3737             break;
3738           }
3739       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3740       return buff;
3741     }
3742 }
3743
3744 static const char *
3745 get_aarch64_segment_type (unsigned long type)
3746 {
3747   switch (type)
3748     {
3749     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3750     default:                  return NULL;
3751     }
3752 }
3753
3754 static const char *
3755 get_arm_segment_type (unsigned long type)
3756 {
3757   switch (type)
3758     {
3759     case PT_ARM_EXIDX: return "EXIDX";
3760     default:           return NULL;
3761     }
3762 }
3763
3764 static const char *
3765 get_s390_segment_type (unsigned long type)
3766 {
3767   switch (type)
3768     {
3769     case PT_S390_PGSTE: return "S390_PGSTE";
3770     default:            return NULL;
3771     }
3772 }
3773
3774 static const char *
3775 get_mips_segment_type (unsigned long type)
3776 {
3777   switch (type)
3778     {
3779     case PT_MIPS_REGINFO:   return "REGINFO";
3780     case PT_MIPS_RTPROC:    return "RTPROC";
3781     case PT_MIPS_OPTIONS:   return "OPTIONS";
3782     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3783     default:                return NULL;
3784     }
3785 }
3786
3787 static const char *
3788 get_parisc_segment_type (unsigned long type)
3789 {
3790   switch (type)
3791     {
3792     case PT_HP_TLS:             return "HP_TLS";
3793     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3794     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3795     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3796     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3797     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3798     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3799     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3800     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3801     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3802     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3803     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3804     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3805     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3806     case PT_HP_STACK:           return "HP_STACK";
3807     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3808     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3809     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3810     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3811     default:                    return NULL;
3812     }
3813 }
3814
3815 static const char *
3816 get_ia64_segment_type (unsigned long type)
3817 {
3818   switch (type)
3819     {
3820     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3821     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3822     case PT_HP_TLS:             return "HP_TLS";
3823     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3824     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3825     case PT_IA_64_HP_STACK:     return "HP_STACK";
3826     default:                    return NULL;
3827     }
3828 }
3829
3830 static const char *
3831 get_tic6x_segment_type (unsigned long type)
3832 {
3833   switch (type)
3834     {
3835     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3836     default:               return NULL;
3837     }
3838 }
3839
3840 static const char *
3841 get_solaris_segment_type (unsigned long type)
3842 {
3843   switch (type)
3844     {
3845     case 0x6464e550: return "PT_SUNW_UNWIND";
3846     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3847     case 0x6ffffff7: return "PT_LOSUNW";
3848     case 0x6ffffffa: return "PT_SUNWBSS";
3849     case 0x6ffffffb: return "PT_SUNWSTACK";
3850     case 0x6ffffffc: return "PT_SUNWDTRACE";
3851     case 0x6ffffffd: return "PT_SUNWCAP";
3852     case 0x6fffffff: return "PT_HISUNW";
3853     default:         return NULL;
3854     }
3855 }
3856
3857 static const char *
3858 get_segment_type (Filedata * filedata, unsigned long p_type)
3859 {
3860   static char buff[32];
3861
3862   switch (p_type)
3863     {
3864     case PT_NULL:       return "NULL";
3865     case PT_LOAD:       return "LOAD";
3866     case PT_DYNAMIC:    return "DYNAMIC";
3867     case PT_INTERP:     return "INTERP";
3868     case PT_NOTE:       return "NOTE";
3869     case PT_SHLIB:      return "SHLIB";
3870     case PT_PHDR:       return "PHDR";
3871     case PT_TLS:        return "TLS";
3872     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3873     case PT_GNU_STACK:  return "GNU_STACK";
3874     case PT_GNU_RELRO:  return "GNU_RELRO";
3875
3876     default:
3877       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3878         {
3879           sprintf (buff, "GNU_MBIND+%#lx",
3880                    p_type - PT_GNU_MBIND_LO);
3881         }
3882       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3883         {
3884           const char * result;
3885
3886           switch (filedata->file_header.e_machine)
3887             {
3888             case EM_AARCH64:
3889               result = get_aarch64_segment_type (p_type);
3890               break;
3891             case EM_ARM:
3892               result = get_arm_segment_type (p_type);
3893               break;
3894             case EM_MIPS:
3895             case EM_MIPS_RS3_LE:
3896               result = get_mips_segment_type (p_type);
3897               break;
3898             case EM_PARISC:
3899               result = get_parisc_segment_type (p_type);
3900               break;
3901             case EM_IA_64:
3902               result = get_ia64_segment_type (p_type);
3903               break;
3904             case EM_TI_C6000:
3905               result = get_tic6x_segment_type (p_type);
3906               break;
3907             case EM_S390:
3908             case EM_S390_OLD:
3909               result = get_s390_segment_type (p_type);
3910               break;
3911             default:
3912               result = NULL;
3913               break;
3914             }
3915
3916           if (result != NULL)
3917             return result;
3918
3919           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3920         }
3921       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3922         {
3923           const char * result;
3924
3925           switch (filedata->file_header.e_machine)
3926             {
3927             case EM_PARISC:
3928               result = get_parisc_segment_type (p_type);
3929               break;
3930             case EM_IA_64:
3931               result = get_ia64_segment_type (p_type);
3932               break;
3933             default:
3934               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3935                 result = get_solaris_segment_type (p_type);
3936               else
3937                 result = NULL;
3938               break;
3939             }
3940
3941           if (result != NULL)
3942             return result;
3943
3944           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3945         }
3946       else
3947         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3948
3949       return buff;
3950     }
3951 }
3952
3953 static const char *
3954 get_arc_section_type_name (unsigned int sh_type)
3955 {
3956   switch (sh_type)
3957     {
3958     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
3959     default:
3960       break;
3961     }
3962   return NULL;
3963 }
3964
3965 static const char *
3966 get_mips_section_type_name (unsigned int sh_type)
3967 {
3968   switch (sh_type)
3969     {
3970     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
3971     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
3972     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
3973     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
3974     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
3975     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
3976     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
3977     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
3978     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
3979     case SHT_MIPS_RELD:          return "MIPS_RELD";
3980     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
3981     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
3982     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
3983     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
3984     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
3985     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
3986     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
3987     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
3988     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
3989     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
3990     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
3991     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
3992     case SHT_MIPS_LINE:          return "MIPS_LINE";
3993     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
3994     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
3995     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
3996     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
3997     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
3998     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
3999     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4000     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4001     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4002     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4003     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4004     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4005     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4006     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4007     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4008     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4009     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4010     default:
4011       break;
4012     }
4013   return NULL;
4014 }
4015
4016 static const char *
4017 get_parisc_section_type_name (unsigned int sh_type)
4018 {
4019   switch (sh_type)
4020     {
4021     case SHT_PARISC_EXT:        return "PARISC_EXT";
4022     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4023     case SHT_PARISC_DOC:        return "PARISC_DOC";
4024     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4025     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4026     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4027     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4028     default:                    return NULL;
4029     }
4030 }
4031
4032 static const char *
4033 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4034 {
4035   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4036   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4037     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4038
4039   switch (sh_type)
4040     {
4041     case SHT_IA_64_EXT:                return "IA_64_EXT";
4042     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4043     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4044     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4045     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4046     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4047     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4048     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4049     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4050     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4051     default:
4052       break;
4053     }
4054   return NULL;
4055 }
4056
4057 static const char *
4058 get_x86_64_section_type_name (unsigned int sh_type)
4059 {
4060   switch (sh_type)
4061     {
4062     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4063     default:                    return NULL;
4064     }
4065 }
4066
4067 static const char *
4068 get_aarch64_section_type_name (unsigned int sh_type)
4069 {
4070   switch (sh_type)
4071     {
4072     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4073     default:                     return NULL;
4074     }
4075 }
4076
4077 static const char *
4078 get_arm_section_type_name (unsigned int sh_type)
4079 {
4080   switch (sh_type)
4081     {
4082     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4083     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4084     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4085     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4086     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4087     default:                      return NULL;
4088     }
4089 }
4090
4091 static const char *
4092 get_tic6x_section_type_name (unsigned int sh_type)
4093 {
4094   switch (sh_type)
4095     {
4096     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4097     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4098     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4099     case SHT_TI_ICODE:          return "TI_ICODE";
4100     case SHT_TI_XREF:           return "TI_XREF";
4101     case SHT_TI_HANDLER:        return "TI_HANDLER";
4102     case SHT_TI_INITINFO:       return "TI_INITINFO";
4103     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4104     default:                    return NULL;
4105     }
4106 }
4107
4108 static const char *
4109 get_msp430x_section_type_name (unsigned int sh_type)
4110 {
4111   switch (sh_type)
4112     {
4113     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4114     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4115     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4116     default:                      return NULL;
4117     }
4118 }
4119
4120 static const char *
4121 get_v850_section_type_name (unsigned int sh_type)
4122 {
4123   switch (sh_type)
4124     {
4125     case SHT_V850_SCOMMON:  return "V850 Small Common";
4126     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4127     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4128     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4129     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4130     default:                return NULL;
4131     }
4132 }
4133
4134 static const char *
4135 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4136 {
4137   static char buff[32];
4138   const char * result;
4139
4140   switch (sh_type)
4141     {
4142     case SHT_NULL:              return "NULL";
4143     case SHT_PROGBITS:          return "PROGBITS";
4144     case SHT_SYMTAB:            return "SYMTAB";
4145     case SHT_STRTAB:            return "STRTAB";
4146     case SHT_RELA:              return "RELA";
4147     case SHT_HASH:              return "HASH";
4148     case SHT_DYNAMIC:           return "DYNAMIC";
4149     case SHT_NOTE:              return "NOTE";
4150     case SHT_NOBITS:            return "NOBITS";
4151     case SHT_REL:               return "REL";
4152     case SHT_SHLIB:             return "SHLIB";
4153     case SHT_DYNSYM:            return "DYNSYM";
4154     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4155     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4156     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4157     case SHT_GNU_HASH:          return "GNU_HASH";
4158     case SHT_GROUP:             return "GROUP";
4159     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICIES";
4160     case SHT_GNU_verdef:        return "VERDEF";
4161     case SHT_GNU_verneed:       return "VERNEED";
4162     case SHT_GNU_versym:        return "VERSYM";
4163     case 0x6ffffff0:            return "VERSYM";
4164     case 0x6ffffffc:            return "VERDEF";
4165     case 0x7ffffffd:            return "AUXILIARY";
4166     case 0x7fffffff:            return "FILTER";
4167     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4168
4169     default:
4170       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4171         {
4172           switch (filedata->file_header.e_machine)
4173             {
4174             case EM_ARC:
4175             case EM_ARC_COMPACT:
4176             case EM_ARC_COMPACT2:
4177               result = get_arc_section_type_name (sh_type);
4178               break;
4179             case EM_MIPS:
4180             case EM_MIPS_RS3_LE:
4181               result = get_mips_section_type_name (sh_type);
4182               break;
4183             case EM_PARISC:
4184               result = get_parisc_section_type_name (sh_type);
4185               break;
4186             case EM_IA_64:
4187               result = get_ia64_section_type_name (filedata, sh_type);
4188               break;
4189             case EM_X86_64:
4190             case EM_L1OM:
4191             case EM_K1OM:
4192               result = get_x86_64_section_type_name (sh_type);
4193               break;
4194             case EM_AARCH64:
4195               result = get_aarch64_section_type_name (sh_type);
4196               break;
4197             case EM_ARM:
4198               result = get_arm_section_type_name (sh_type);
4199               break;
4200             case EM_TI_C6000:
4201               result = get_tic6x_section_type_name (sh_type);
4202               break;
4203             case EM_MSP430:
4204               result = get_msp430x_section_type_name (sh_type);
4205               break;
4206             case EM_V800:
4207             case EM_V850:
4208             case EM_CYGNUS_V850:
4209               result = get_v850_section_type_name (sh_type);
4210               break;
4211             default:
4212               result = NULL;
4213               break;
4214             }
4215
4216           if (result != NULL)
4217             return result;
4218
4219           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4220         }
4221       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4222         {
4223           switch (filedata->file_header.e_machine)
4224             {
4225             case EM_IA_64:
4226               result = get_ia64_section_type_name (filedata, sh_type);
4227               break;
4228             default:
4229               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4230                 result = get_solaris_section_type (sh_type);
4231               else
4232                 {
4233                   switch (sh_type)
4234                     {
4235                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4236                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4237                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4238                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4239                     default:
4240                       result = NULL;
4241                       break;
4242                     }
4243                 }
4244               break;
4245             }
4246
4247           if (result != NULL)
4248             return result;
4249
4250           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4251         }
4252       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4253         {
4254           switch (filedata->file_header.e_machine)
4255             {
4256             case EM_V800:
4257             case EM_V850:
4258             case EM_CYGNUS_V850:
4259               result = get_v850_section_type_name (sh_type);
4260               break;
4261             default:
4262               result = NULL;
4263               break;
4264             }
4265
4266           if (result != NULL)
4267             return result;
4268
4269           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4270         }
4271       else
4272         /* This message is probably going to be displayed in a 15
4273            character wide field, so put the hex value first.  */
4274         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4275
4276       return buff;
4277     }
4278 }
4279
4280 #define OPTION_DEBUG_DUMP       512
4281 #define OPTION_DYN_SYMS         513
4282 #define OPTION_DWARF_DEPTH      514
4283 #define OPTION_DWARF_START      515
4284 #define OPTION_DWARF_CHECK      516
4285
4286 static struct option options[] =
4287 {
4288   {"all",              no_argument, 0, 'a'},
4289   {"file-header",      no_argument, 0, 'h'},
4290   {"program-headers",  no_argument, 0, 'l'},
4291   {"headers",          no_argument, 0, 'e'},
4292   {"histogram",        no_argument, 0, 'I'},
4293   {"segments",         no_argument, 0, 'l'},
4294   {"sections",         no_argument, 0, 'S'},
4295   {"section-headers",  no_argument, 0, 'S'},
4296   {"section-groups",   no_argument, 0, 'g'},
4297   {"section-details",  no_argument, 0, 't'},
4298   {"full-section-name",no_argument, 0, 'N'},
4299   {"symbols",          no_argument, 0, 's'},
4300   {"syms",             no_argument, 0, 's'},
4301   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4302   {"relocs",           no_argument, 0, 'r'},
4303   {"notes",            no_argument, 0, 'n'},
4304   {"dynamic",          no_argument, 0, 'd'},
4305   {"arch-specific",    no_argument, 0, 'A'},
4306   {"version-info",     no_argument, 0, 'V'},
4307   {"use-dynamic",      no_argument, 0, 'D'},
4308   {"unwind",           no_argument, 0, 'u'},
4309   {"archive-index",    no_argument, 0, 'c'},
4310   {"hex-dump",         required_argument, 0, 'x'},
4311   {"relocated-dump",   required_argument, 0, 'R'},
4312   {"string-dump",      required_argument, 0, 'p'},
4313   {"decompress",       no_argument, 0, 'z'},
4314 #ifdef SUPPORT_DISASSEMBLY
4315   {"instruction-dump", required_argument, 0, 'i'},
4316 #endif
4317   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4318
4319   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4320   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4321   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4322
4323   {"version",          no_argument, 0, 'v'},
4324   {"wide",             no_argument, 0, 'W'},
4325   {"help",             no_argument, 0, 'H'},
4326   {0,                  no_argument, 0, 0}
4327 };
4328
4329 static void
4330 usage (FILE * stream)
4331 {
4332   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4333   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4334   fprintf (stream, _(" Options are:\n\
4335   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4336   -h --file-header       Display the ELF file header\n\
4337   -l --program-headers   Display the program headers\n\
4338      --segments          An alias for --program-headers\n\
4339   -S --section-headers   Display the sections' header\n\
4340      --sections          An alias for --section-headers\n\
4341   -g --section-groups    Display the section groups\n\
4342   -t --section-details   Display the section details\n\
4343   -e --headers           Equivalent to: -h -l -S\n\
4344   -s --syms              Display the symbol table\n\
4345      --symbols           An alias for --syms\n\
4346   --dyn-syms             Display the dynamic symbol table\n\
4347   -n --notes             Display the core notes (if present)\n\
4348   -r --relocs            Display the relocations (if present)\n\
4349   -u --unwind            Display the unwind info (if present)\n\
4350   -d --dynamic           Display the dynamic section (if present)\n\
4351   -V --version-info      Display the version sections (if present)\n\
4352   -A --arch-specific     Display architecture specific information (if any)\n\
4353   -c --archive-index     Display the symbol/file index in an archive\n\
4354   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4355   -x --hex-dump=<number|name>\n\
4356                          Dump the contents of section <number|name> as bytes\n\
4357   -p --string-dump=<number|name>\n\
4358                          Dump the contents of section <number|name> as strings\n\
4359   -R --relocated-dump=<number|name>\n\
4360                          Dump the contents of section <number|name> as relocated bytes\n\
4361   -z --decompress        Decompress section before dumping it\n\
4362   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4363   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4364                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4365                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4366                =addr,=cu_index,=links,=follow-links]\n\
4367                          Display the contents of DWARF debug sections\n"));
4368   fprintf (stream, _("\
4369   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4370   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4371                          or deeper\n"));
4372 #ifdef SUPPORT_DISASSEMBLY
4373   fprintf (stream, _("\
4374   -i --instruction-dump=<number|name>\n\
4375                          Disassemble the contents of section <number|name>\n"));
4376 #endif
4377   fprintf (stream, _("\
4378   -I --histogram         Display histogram of bucket list lengths\n\
4379   -W --wide              Allow output width to exceed 80 characters\n\
4380   @<file>                Read options from <file>\n\
4381   -H --help              Display this information\n\
4382   -v --version           Display the version number of readelf\n"));
4383
4384   if (REPORT_BUGS_TO[0] && stream == stdout)
4385     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4386
4387   exit (stream == stdout ? 0 : 1);
4388 }
4389
4390 /* Record the fact that the user wants the contents of section number
4391    SECTION to be displayed using the method(s) encoded as flags bits
4392    in TYPE.  Note, TYPE can be zero if we are creating the array for
4393    the first time.  */
4394
4395 static void
4396 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4397 {
4398   if (section >= filedata->num_dump_sects)
4399     {
4400       dump_type * new_dump_sects;
4401
4402       new_dump_sects = (dump_type *) calloc (section + 1,
4403                                              sizeof (* new_dump_sects));
4404
4405       if (new_dump_sects == NULL)
4406         error (_("Out of memory allocating dump request table.\n"));
4407       else
4408         {
4409           if (filedata->dump_sects)
4410             {
4411               /* Copy current flag settings.  */
4412               memcpy (new_dump_sects, filedata->dump_sects,
4413                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4414
4415               free (filedata->dump_sects);
4416             }
4417
4418           filedata->dump_sects = new_dump_sects;
4419           filedata->num_dump_sects = section + 1;
4420         }
4421     }
4422
4423   if (filedata->dump_sects)
4424     filedata->dump_sects[section] |= type;
4425 }
4426
4427 /* Request a dump by section name.  */
4428
4429 static void
4430 request_dump_byname (const char * section, dump_type type)
4431 {
4432   struct dump_list_entry * new_request;
4433
4434   new_request = (struct dump_list_entry *)
4435       malloc (sizeof (struct dump_list_entry));
4436   if (!new_request)
4437     error (_("Out of memory allocating dump request table.\n"));
4438
4439   new_request->name = strdup (section);
4440   if (!new_request->name)
4441     error (_("Out of memory allocating dump request table.\n"));
4442
4443   new_request->type = type;
4444
4445   new_request->next = dump_sects_byname;
4446   dump_sects_byname = new_request;
4447 }
4448
4449 static inline void
4450 request_dump (Filedata * filedata, dump_type type)
4451 {
4452   int section;
4453   char * cp;
4454
4455   do_dump++;
4456   section = strtoul (optarg, & cp, 0);
4457
4458   if (! *cp && section >= 0)
4459     request_dump_bynumber (filedata, section, type);
4460   else
4461     request_dump_byname (optarg, type);
4462 }
4463
4464 static void
4465 parse_args (Filedata * filedata, int argc, char ** argv)
4466 {
4467   int c;
4468
4469   if (argc < 2)
4470     usage (stderr);
4471
4472   while ((c = getopt_long
4473           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4474     {
4475       switch (c)
4476         {
4477         case 0:
4478           /* Long options.  */
4479           break;
4480         case 'H':
4481           usage (stdout);
4482           break;
4483
4484         case 'a':
4485           do_syms = TRUE;
4486           do_reloc = TRUE;
4487           do_unwind = TRUE;
4488           do_dynamic = TRUE;
4489           do_header = TRUE;
4490           do_sections = TRUE;
4491           do_section_groups = TRUE;
4492           do_segments = TRUE;
4493           do_version = TRUE;
4494           do_histogram = TRUE;
4495           do_arch = TRUE;
4496           do_notes = TRUE;
4497           break;
4498         case 'g':
4499           do_section_groups = TRUE;
4500           break;
4501         case 't':
4502         case 'N':
4503           do_sections = TRUE;
4504           do_section_details = TRUE;
4505           break;
4506         case 'e':
4507           do_header = TRUE;
4508           do_sections = TRUE;
4509           do_segments = TRUE;
4510           break;
4511         case 'A':
4512           do_arch = TRUE;
4513           break;
4514         case 'D':
4515           do_using_dynamic = TRUE;
4516           break;
4517         case 'r':
4518           do_reloc = TRUE;
4519           break;
4520         case 'u':
4521           do_unwind = TRUE;
4522           break;
4523         case 'h':
4524           do_header = TRUE;
4525           break;
4526         case 'l':
4527           do_segments = TRUE;
4528           break;
4529         case 's':
4530           do_syms = TRUE;
4531           break;
4532         case 'S':
4533           do_sections = TRUE;
4534           break;
4535         case 'd':
4536           do_dynamic = TRUE;
4537           break;
4538         case 'I':
4539           do_histogram = TRUE;
4540           break;
4541         case 'n':
4542           do_notes = TRUE;
4543           break;
4544         case 'c':
4545           do_archive_index = TRUE;
4546           break;
4547         case 'x':
4548           request_dump (filedata, HEX_DUMP);
4549           break;
4550         case 'p':
4551           request_dump (filedata, STRING_DUMP);
4552           break;
4553         case 'R':
4554           request_dump (filedata, RELOC_DUMP);
4555           break;
4556         case 'z':
4557           decompress_dumps = TRUE;
4558           break;
4559         case 'w':
4560           do_dump = TRUE;
4561           if (optarg == 0)
4562             {
4563               do_debugging = TRUE;
4564               dwarf_select_sections_all ();
4565             }
4566           else
4567             {
4568               do_debugging = FALSE;
4569               dwarf_select_sections_by_letters (optarg);
4570             }
4571           break;
4572         case OPTION_DEBUG_DUMP:
4573           do_dump = TRUE;
4574           if (optarg == 0)
4575             do_debugging = TRUE;
4576           else
4577             {
4578               do_debugging = FALSE;
4579               dwarf_select_sections_by_names (optarg);
4580             }
4581           break;
4582         case OPTION_DWARF_DEPTH:
4583           {
4584             char *cp;
4585
4586             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4587           }
4588           break;
4589         case OPTION_DWARF_START:
4590           {
4591             char *cp;
4592
4593             dwarf_start_die = strtoul (optarg, & cp, 0);
4594           }
4595           break;
4596         case OPTION_DWARF_CHECK:
4597           dwarf_check = TRUE;
4598           break;
4599         case OPTION_DYN_SYMS:
4600           do_dyn_syms = TRUE;
4601           break;
4602 #ifdef SUPPORT_DISASSEMBLY
4603         case 'i':
4604           request_dump (filedata, DISASS_DUMP);
4605           break;
4606 #endif
4607         case 'v':
4608           print_version (program_name);
4609           break;
4610         case 'V':
4611           do_version = TRUE;
4612           break;
4613         case 'W':
4614           do_wide = TRUE;
4615           break;
4616         default:
4617           /* xgettext:c-format */
4618           error (_("Invalid option '-%c'\n"), c);
4619           /* Fall through.  */
4620         case '?':
4621           usage (stderr);
4622         }
4623     }
4624
4625   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4626       && !do_segments && !do_header && !do_dump && !do_version
4627       && !do_histogram && !do_debugging && !do_arch && !do_notes
4628       && !do_section_groups && !do_archive_index
4629       && !do_dyn_syms)
4630     usage (stderr);
4631 }
4632
4633 static const char *
4634 get_elf_class (unsigned int elf_class)
4635 {
4636   static char buff[32];
4637
4638   switch (elf_class)
4639     {
4640     case ELFCLASSNONE: return _("none");
4641     case ELFCLASS32:   return "ELF32";
4642     case ELFCLASS64:   return "ELF64";
4643     default:
4644       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4645       return buff;
4646     }
4647 }
4648
4649 static const char *
4650 get_data_encoding (unsigned int encoding)
4651 {
4652   static char buff[32];
4653
4654   switch (encoding)
4655     {
4656     case ELFDATANONE: return _("none");
4657     case ELFDATA2LSB: return _("2's complement, little endian");
4658     case ELFDATA2MSB: return _("2's complement, big endian");
4659     default:
4660       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4661       return buff;
4662     }
4663 }
4664
4665 /* Decode the data held in 'filedata->file_header'.  */
4666
4667 static bfd_boolean
4668 process_file_header (Filedata * filedata)
4669 {
4670   Elf_Internal_Ehdr * header = & filedata->file_header;
4671
4672   if (   header->e_ident[EI_MAG0] != ELFMAG0
4673       || header->e_ident[EI_MAG1] != ELFMAG1
4674       || header->e_ident[EI_MAG2] != ELFMAG2
4675       || header->e_ident[EI_MAG3] != ELFMAG3)
4676     {
4677       error
4678         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4679       return FALSE;
4680     }
4681
4682   init_dwarf_regnames (header->e_machine);
4683
4684   if (do_header)
4685     {
4686       unsigned i;
4687
4688       printf (_("ELF Header:\n"));
4689       printf (_("  Magic:   "));
4690       for (i = 0; i < EI_NIDENT; i++)
4691         printf ("%2.2x ", header->e_ident[i]);
4692       printf ("\n");
4693       printf (_("  Class:                             %s\n"),
4694               get_elf_class (header->e_ident[EI_CLASS]));
4695       printf (_("  Data:                              %s\n"),
4696               get_data_encoding (header->e_ident[EI_DATA]));
4697       printf (_("  Version:                           %d %s\n"),
4698               header->e_ident[EI_VERSION],
4699               (header->e_ident[EI_VERSION] == EV_CURRENT
4700                ? "(current)"
4701                : (header->e_ident[EI_VERSION] != EV_NONE
4702                   ? _("<unknown: %lx>")
4703                   : "")));
4704       printf (_("  OS/ABI:                            %s\n"),
4705               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4706       printf (_("  ABI Version:                       %d\n"),
4707               header->e_ident[EI_ABIVERSION]);
4708       printf (_("  Type:                              %s\n"),
4709               get_file_type (header->e_type));
4710       printf (_("  Machine:                           %s\n"),
4711               get_machine_name (header->e_machine));
4712       printf (_("  Version:                           0x%lx\n"),
4713               (unsigned long) header->e_version);
4714
4715       printf (_("  Entry point address:               "));
4716       print_vma ((bfd_vma) header->e_entry, PREFIX_HEX);
4717       printf (_("\n  Start of program headers:          "));
4718       print_vma ((bfd_vma) header->e_phoff, DEC);
4719       printf (_(" (bytes into file)\n  Start of section headers:          "));
4720       print_vma ((bfd_vma) header->e_shoff, DEC);
4721       printf (_(" (bytes into file)\n"));
4722
4723       printf (_("  Flags:                             0x%lx%s\n"),
4724               (unsigned long) header->e_flags,
4725               get_machine_flags (filedata, header->e_flags, header->e_machine));
4726       printf (_("  Size of this header:               %ld (bytes)\n"),
4727               (long) header->e_ehsize);
4728       printf (_("  Size of program headers:           %ld (bytes)\n"),
4729               (long) header->e_phentsize);
4730       printf (_("  Number of program headers:         %ld"),
4731               (long) header->e_phnum);
4732       if (filedata->section_headers != NULL
4733           && header->e_phnum == PN_XNUM
4734           && filedata->section_headers[0].sh_info != 0)
4735         printf (" (%ld)", (long) filedata->section_headers[0].sh_info);
4736       putc ('\n', stdout);
4737       printf (_("  Size of section headers:           %ld (bytes)\n"),
4738               (long) header->e_shentsize);
4739       printf (_("  Number of section headers:         %ld"),
4740               (long) header->e_shnum);
4741       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4742         printf (" (%ld)", (long) filedata->section_headers[0].sh_size);
4743       putc ('\n', stdout);
4744       printf (_("  Section header string table index: %ld"),
4745               (long) header->e_shstrndx);
4746       if (filedata->section_headers != NULL
4747           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4748         printf (" (%u)", filedata->section_headers[0].sh_link);
4749       else if (header->e_shstrndx != SHN_UNDEF
4750                && header->e_shstrndx >= header->e_shnum)
4751         printf (_(" <corrupt: out of range>"));
4752       putc ('\n', stdout);
4753     }
4754
4755   if (filedata->section_headers != NULL)
4756     {
4757       if (header->e_phnum == PN_XNUM
4758           && filedata->section_headers[0].sh_info != 0)
4759         header->e_phnum = filedata->section_headers[0].sh_info;
4760       if (header->e_shnum == SHN_UNDEF)
4761         header->e_shnum = filedata->section_headers[0].sh_size;
4762       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4763         header->e_shstrndx = filedata->section_headers[0].sh_link;
4764       if (header->e_shstrndx >= header->e_shnum)
4765         header->e_shstrndx = SHN_UNDEF;
4766       free (filedata->section_headers);
4767       filedata->section_headers = NULL;
4768     }
4769
4770   return TRUE;
4771 }
4772
4773 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4774    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4775
4776 static bfd_boolean
4777 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4778 {
4779   Elf32_External_Phdr * phdrs;
4780   Elf32_External_Phdr * external;
4781   Elf_Internal_Phdr *   internal;
4782   unsigned int i;
4783   unsigned int size = filedata->file_header.e_phentsize;
4784   unsigned int num  = filedata->file_header.e_phnum;
4785
4786   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4787   if (size == 0 || num == 0)
4788     return FALSE;
4789   if (size < sizeof * phdrs)
4790     {
4791       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4792       return FALSE;
4793     }
4794   if (size > sizeof * phdrs)
4795     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4796
4797   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4798                                             size, num, _("program headers"));
4799   if (phdrs == NULL)
4800     return FALSE;
4801
4802   for (i = 0, internal = pheaders, external = phdrs;
4803        i < filedata->file_header.e_phnum;
4804        i++, internal++, external++)
4805     {
4806       internal->p_type   = BYTE_GET (external->p_type);
4807       internal->p_offset = BYTE_GET (external->p_offset);
4808       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4809       internal->p_paddr  = BYTE_GET (external->p_paddr);
4810       internal->p_filesz = BYTE_GET (external->p_filesz);
4811       internal->p_memsz  = BYTE_GET (external->p_memsz);
4812       internal->p_flags  = BYTE_GET (external->p_flags);
4813       internal->p_align  = BYTE_GET (external->p_align);
4814     }
4815
4816   free (phdrs);
4817   return TRUE;
4818 }
4819
4820 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4821    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4822
4823 static bfd_boolean
4824 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4825 {
4826   Elf64_External_Phdr * phdrs;
4827   Elf64_External_Phdr * external;
4828   Elf_Internal_Phdr *   internal;
4829   unsigned int i;
4830   unsigned int size = filedata->file_header.e_phentsize;
4831   unsigned int num  = filedata->file_header.e_phnum;
4832
4833   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4834   if (size == 0 || num == 0)
4835     return FALSE;
4836   if (size < sizeof * phdrs)
4837     {
4838       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4839       return FALSE;
4840     }
4841   if (size > sizeof * phdrs)
4842     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4843
4844   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4845                                             size, num, _("program headers"));
4846   if (!phdrs)
4847     return FALSE;
4848
4849   for (i = 0, internal = pheaders, external = phdrs;
4850        i < filedata->file_header.e_phnum;
4851        i++, internal++, external++)
4852     {
4853       internal->p_type   = BYTE_GET (external->p_type);
4854       internal->p_flags  = BYTE_GET (external->p_flags);
4855       internal->p_offset = BYTE_GET (external->p_offset);
4856       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4857       internal->p_paddr  = BYTE_GET (external->p_paddr);
4858       internal->p_filesz = BYTE_GET (external->p_filesz);
4859       internal->p_memsz  = BYTE_GET (external->p_memsz);
4860       internal->p_align  = BYTE_GET (external->p_align);
4861     }
4862
4863   free (phdrs);
4864   return TRUE;
4865 }
4866
4867 /* Returns TRUE if the program headers were read into `program_headers'.  */
4868
4869 static bfd_boolean
4870 get_program_headers (Filedata * filedata)
4871 {
4872   Elf_Internal_Phdr * phdrs;
4873
4874   /* Check cache of prior read.  */
4875   if (filedata->program_headers != NULL)
4876     return TRUE;
4877
4878   /* Be kind to memory checkers by looking for
4879      e_phnum values which we know must be invalid.  */
4880   if (filedata->file_header.e_phnum
4881       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4882       >= filedata->file_size)
4883     {
4884       error (_("Too many program headers - %#x - the file is not that big\n"),
4885              filedata->file_header.e_phnum);
4886       return FALSE;
4887     }
4888
4889   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4890                                          sizeof (Elf_Internal_Phdr));
4891   if (phdrs == NULL)
4892     {
4893       error (_("Out of memory reading %u program headers\n"),
4894              filedata->file_header.e_phnum);
4895       return FALSE;
4896     }
4897
4898   if (is_32bit_elf
4899       ? get_32bit_program_headers (filedata, phdrs)
4900       : get_64bit_program_headers (filedata, phdrs))
4901     {
4902       filedata->program_headers = phdrs;
4903       return TRUE;
4904     }
4905
4906   free (phdrs);
4907   return FALSE;
4908 }
4909
4910 /* Returns TRUE if the program headers were loaded.  */
4911
4912 static bfd_boolean
4913 process_program_headers (Filedata * filedata)
4914 {
4915   Elf_Internal_Phdr * segment;
4916   unsigned int i;
4917   Elf_Internal_Phdr * previous_load = NULL;
4918
4919   if (filedata->file_header.e_phnum == 0)
4920     {
4921       /* PR binutils/12467.  */
4922       if (filedata->file_header.e_phoff != 0)
4923         {
4924           warn (_("possibly corrupt ELF header - it has a non-zero program"
4925                   " header offset, but no program headers\n"));
4926           return FALSE;
4927         }
4928       else if (do_segments)
4929         printf (_("\nThere are no program headers in this file.\n"));
4930       return TRUE;
4931     }
4932
4933   if (do_segments && !do_header)
4934     {
4935       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
4936       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
4937       printf (ngettext ("There is %d program header, starting at offset %s\n",
4938                         "There are %d program headers, starting at offset %s\n",
4939                         filedata->file_header.e_phnum),
4940               filedata->file_header.e_phnum,
4941               bfd_vmatoa ("u", filedata->file_header.e_phoff));
4942     }
4943
4944   if (! get_program_headers (filedata))
4945     return TRUE;
4946
4947   if (do_segments)
4948     {
4949       if (filedata->file_header.e_phnum > 1)
4950         printf (_("\nProgram Headers:\n"));
4951       else
4952         printf (_("\nProgram Headers:\n"));
4953
4954       if (is_32bit_elf)
4955         printf
4956           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
4957       else if (do_wide)
4958         printf
4959           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
4960       else
4961         {
4962           printf
4963             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
4964           printf
4965             (_("                 FileSiz            MemSiz              Flags  Align\n"));
4966         }
4967     }
4968
4969   dynamic_addr = 0;
4970   dynamic_size = 0;
4971
4972   for (i = 0, segment = filedata->program_headers;
4973        i < filedata->file_header.e_phnum;
4974        i++, segment++)
4975     {
4976       if (do_segments)
4977         {
4978           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
4979
4980           if (is_32bit_elf)
4981             {
4982               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4983               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4984               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4985               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4986               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4987               printf ("%c%c%c ",
4988                       (segment->p_flags & PF_R ? 'R' : ' '),
4989                       (segment->p_flags & PF_W ? 'W' : ' '),
4990                       (segment->p_flags & PF_X ? 'E' : ' '));
4991               printf ("%#lx", (unsigned long) segment->p_align);
4992             }
4993           else if (do_wide)
4994             {
4995               if ((unsigned long) segment->p_offset == segment->p_offset)
4996                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4997               else
4998                 {
4999                   print_vma (segment->p_offset, FULL_HEX);
5000                   putchar (' ');
5001                 }
5002
5003               print_vma (segment->p_vaddr, FULL_HEX);
5004               putchar (' ');
5005               print_vma (segment->p_paddr, FULL_HEX);
5006               putchar (' ');
5007
5008               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5009                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5010               else
5011                 {
5012                   print_vma (segment->p_filesz, FULL_HEX);
5013                   putchar (' ');
5014                 }
5015
5016               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5017                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5018               else
5019                 {
5020                   print_vma (segment->p_memsz, FULL_HEX);
5021                 }
5022
5023               printf (" %c%c%c ",
5024                       (segment->p_flags & PF_R ? 'R' : ' '),
5025                       (segment->p_flags & PF_W ? 'W' : ' '),
5026                       (segment->p_flags & PF_X ? 'E' : ' '));
5027
5028               if ((unsigned long) segment->p_align == segment->p_align)
5029                 printf ("%#lx", (unsigned long) segment->p_align);
5030               else
5031                 {
5032                   print_vma (segment->p_align, PREFIX_HEX);
5033                 }
5034             }
5035           else
5036             {
5037               print_vma (segment->p_offset, FULL_HEX);
5038               putchar (' ');
5039               print_vma (segment->p_vaddr, FULL_HEX);
5040               putchar (' ');
5041               print_vma (segment->p_paddr, FULL_HEX);
5042               printf ("\n                 ");
5043               print_vma (segment->p_filesz, FULL_HEX);
5044               putchar (' ');
5045               print_vma (segment->p_memsz, FULL_HEX);
5046               printf ("  %c%c%c    ",
5047                       (segment->p_flags & PF_R ? 'R' : ' '),
5048                       (segment->p_flags & PF_W ? 'W' : ' '),
5049                       (segment->p_flags & PF_X ? 'E' : ' '));
5050               print_vma (segment->p_align, PREFIX_HEX);
5051             }
5052
5053           putc ('\n', stdout);
5054         }
5055
5056       switch (segment->p_type)
5057         {
5058         case PT_LOAD:
5059 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5060          required by the ELF standard, several programs, including the Linux
5061          kernel, make use of non-ordered segments.  */
5062           if (previous_load
5063               && previous_load->p_vaddr > segment->p_vaddr)
5064             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5065 #endif
5066           if (segment->p_memsz < segment->p_filesz)
5067             error (_("the segment's file size is larger than its memory size\n"));
5068           previous_load = segment;
5069           break;
5070
5071         case PT_PHDR:
5072           /* PR 20815 - Verify that the program header is loaded into memory.  */
5073           if (i > 0 && previous_load != NULL)
5074             error (_("the PHDR segment must occur before any LOAD segment\n"));
5075           if (filedata->file_header.e_machine != EM_PARISC)
5076             {
5077               unsigned int j;
5078
5079               for (j = 1; j < filedata->file_header.e_phnum; j++)
5080                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5081                     && (filedata->program_headers[j].p_vaddr
5082                         + filedata->program_headers[j].p_memsz)
5083                     >= (segment->p_vaddr + segment->p_filesz))
5084                   break;
5085               if (j == filedata->file_header.e_phnum)
5086                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5087             }
5088           break;
5089
5090         case PT_DYNAMIC:
5091           if (dynamic_addr)
5092             error (_("more than one dynamic segment\n"));
5093
5094           /* By default, assume that the .dynamic section is the first
5095              section in the DYNAMIC segment.  */
5096           dynamic_addr = segment->p_offset;
5097           dynamic_size = segment->p_filesz;
5098
5099           /* Try to locate the .dynamic section. If there is
5100              a section header table, we can easily locate it.  */
5101           if (filedata->section_headers != NULL)
5102             {
5103               Elf_Internal_Shdr * sec;
5104
5105               sec = find_section (filedata, ".dynamic");
5106               if (sec == NULL || sec->sh_size == 0)
5107                 {
5108                   /* A corresponding .dynamic section is expected, but on
5109                      IA-64/OpenVMS it is OK for it to be missing.  */
5110                   if (!is_ia64_vms (filedata))
5111                     error (_("no .dynamic section in the dynamic segment\n"));
5112                   break;
5113                 }
5114
5115               if (sec->sh_type == SHT_NOBITS)
5116                 {
5117                   dynamic_size = 0;
5118                   break;
5119                 }
5120
5121               dynamic_addr = sec->sh_offset;
5122               dynamic_size = sec->sh_size;
5123
5124               if (dynamic_addr < segment->p_offset
5125                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5126                 warn (_("the .dynamic section is not contained"
5127                         " within the dynamic segment\n"));
5128               else if (dynamic_addr > segment->p_offset)
5129                 warn (_("the .dynamic section is not the first section"
5130                         " in the dynamic segment.\n"));
5131             }
5132
5133           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5134              segment.  Check this after matching against the section headers
5135              so we don't warn on debuginfo file (which have NOBITS .dynamic
5136              sections).  */
5137           if (dynamic_addr + dynamic_size >= filedata->file_size)
5138             {
5139               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5140               dynamic_addr = dynamic_size = 0;
5141             }
5142           break;
5143
5144         case PT_INTERP:
5145           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5146                      SEEK_SET))
5147             error (_("Unable to find program interpreter name\n"));
5148           else
5149             {
5150               char fmt [32];
5151               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5152
5153               if (ret >= (int) sizeof (fmt) || ret < 0)
5154                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5155
5156               program_interpreter[0] = 0;
5157               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5158                 error (_("Unable to read program interpreter name\n"));
5159
5160               if (do_segments)
5161                 printf (_("      [Requesting program interpreter: %s]\n"),
5162                     program_interpreter);
5163             }
5164           break;
5165         }
5166     }
5167
5168   if (do_segments
5169       && filedata->section_headers != NULL
5170       && filedata->string_table != NULL)
5171     {
5172       printf (_("\n Section to Segment mapping:\n"));
5173       printf (_("  Segment Sections...\n"));
5174
5175       for (i = 0; i < filedata->file_header.e_phnum; i++)
5176         {
5177           unsigned int j;
5178           Elf_Internal_Shdr * section;
5179
5180           segment = filedata->program_headers + i;
5181           section = filedata->section_headers + 1;
5182
5183           printf ("   %2.2d     ", i);
5184
5185           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5186             {
5187               if (!ELF_TBSS_SPECIAL (section, segment)
5188                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5189                 printf ("%s ", printable_section_name (filedata, section));
5190             }
5191
5192           putc ('\n',stdout);
5193         }
5194     }
5195
5196   return TRUE;
5197 }
5198
5199
5200 /* Find the file offset corresponding to VMA by using the program headers.  */
5201
5202 static long
5203 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5204 {
5205   Elf_Internal_Phdr * seg;
5206
5207   if (! get_program_headers (filedata))
5208     {
5209       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5210       return (long) vma;
5211     }
5212
5213   for (seg = filedata->program_headers;
5214        seg < filedata->program_headers + filedata->file_header.e_phnum;
5215        ++seg)
5216     {
5217       if (seg->p_type != PT_LOAD)
5218         continue;
5219
5220       if (vma >= (seg->p_vaddr & -seg->p_align)
5221           && vma + size <= seg->p_vaddr + seg->p_filesz)
5222         return vma - seg->p_vaddr + seg->p_offset;
5223     }
5224
5225   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5226         (unsigned long) vma);
5227   return (long) vma;
5228 }
5229
5230
5231 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5232    If PROBE is true, this is just a probe and we do not generate any error
5233    messages if the load fails.  */
5234
5235 static bfd_boolean
5236 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5237 {
5238   Elf32_External_Shdr * shdrs;
5239   Elf_Internal_Shdr *   internal;
5240   unsigned int          i;
5241   unsigned int          size = filedata->file_header.e_shentsize;
5242   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5243
5244   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5245   if (size == 0 || num == 0)
5246     return FALSE;
5247   if (size < sizeof * shdrs)
5248     {
5249       if (! probe)
5250         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5251       return FALSE;
5252     }
5253   if (!probe && size > sizeof * shdrs)
5254     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5255
5256   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5257                                             size, num,
5258                                             probe ? NULL : _("section headers"));
5259   if (shdrs == NULL)
5260     return FALSE;
5261
5262   free (filedata->section_headers);
5263   filedata->section_headers = (Elf_Internal_Shdr *)
5264     cmalloc (num, sizeof (Elf_Internal_Shdr));
5265   if (filedata->section_headers == NULL)
5266     {
5267       if (!probe)
5268         error (_("Out of memory reading %u section headers\n"), num);
5269       return FALSE;
5270     }
5271
5272   for (i = 0, internal = filedata->section_headers;
5273        i < num;
5274        i++, internal++)
5275     {
5276       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5277       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5278       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5279       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5280       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5281       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5282       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5283       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5284       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5285       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5286       if (!probe && internal->sh_link > num)
5287         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5288       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5289         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5290     }
5291
5292   free (shdrs);
5293   return TRUE;
5294 }
5295
5296 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5297
5298 static bfd_boolean
5299 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5300 {
5301   Elf64_External_Shdr *  shdrs;
5302   Elf_Internal_Shdr *    internal;
5303   unsigned int           i;
5304   unsigned int           size = filedata->file_header.e_shentsize;
5305   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5306
5307   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5308   if (size == 0 || num == 0)
5309     return FALSE;
5310
5311   if (size < sizeof * shdrs)
5312     {
5313       if (! probe)
5314         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5315       return FALSE;
5316     }
5317
5318   if (! probe && size > sizeof * shdrs)
5319     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5320
5321   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5322                                             filedata->file_header.e_shoff,
5323                                             size, num,
5324                                             probe ? NULL : _("section headers"));
5325   if (shdrs == NULL)
5326     return FALSE;
5327
5328   free (filedata->section_headers);
5329   filedata->section_headers = (Elf_Internal_Shdr *)
5330     cmalloc (num, sizeof (Elf_Internal_Shdr));
5331   if (filedata->section_headers == NULL)
5332     {
5333       if (! probe)
5334         error (_("Out of memory reading %u section headers\n"), num);
5335       return FALSE;
5336     }
5337
5338   for (i = 0, internal = filedata->section_headers;
5339        i < num;
5340        i++, internal++)
5341     {
5342       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5343       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5344       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5345       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5346       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5347       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5348       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5349       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5350       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5351       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5352       if (!probe && internal->sh_link > num)
5353         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5354       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5355         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5356     }
5357
5358   free (shdrs);
5359   return TRUE;
5360 }
5361
5362 static Elf_Internal_Sym *
5363 get_32bit_elf_symbols (Filedata *           filedata,
5364                        Elf_Internal_Shdr *  section,
5365                        unsigned long *      num_syms_return)
5366 {
5367   unsigned long number = 0;
5368   Elf32_External_Sym * esyms = NULL;
5369   Elf_External_Sym_Shndx * shndx = NULL;
5370   Elf_Internal_Sym * isyms = NULL;
5371   Elf_Internal_Sym * psym;
5372   unsigned int j;
5373
5374   if (section->sh_size == 0)
5375     {
5376       if (num_syms_return != NULL)
5377         * num_syms_return = 0;
5378       return NULL;
5379     }
5380
5381   /* Run some sanity checks first.  */
5382   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5383     {
5384       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5385              printable_section_name (filedata, section),
5386              (unsigned long) section->sh_entsize);
5387       goto exit_point;
5388     }
5389
5390   if (section->sh_size > filedata->file_size)
5391     {
5392       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5393              printable_section_name (filedata, section),
5394              (unsigned long) section->sh_size);
5395       goto exit_point;
5396     }
5397
5398   number = section->sh_size / section->sh_entsize;
5399
5400   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5401     {
5402       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5403              (unsigned long) section->sh_size,
5404              printable_section_name (filedata, section),
5405              (unsigned long) section->sh_entsize);
5406       goto exit_point;
5407     }
5408
5409   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5410                                            section->sh_size, _("symbols"));
5411   if (esyms == NULL)
5412     goto exit_point;
5413
5414   {
5415     elf_section_list * entry;
5416
5417     shndx = NULL;
5418     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5419       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5420         {
5421           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5422                                                        entry->hdr->sh_offset,
5423                                                        1, entry->hdr->sh_size,
5424                                                        _("symbol table section indicies"));
5425           if (shndx == NULL)
5426             goto exit_point;
5427           /* PR17531: file: heap-buffer-overflow */
5428           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5429             {
5430               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5431                      printable_section_name (filedata, entry->hdr),
5432                      (unsigned long) entry->hdr->sh_size,
5433                      (unsigned long) section->sh_size);
5434               goto exit_point;
5435             }
5436         }
5437   }
5438
5439   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5440
5441   if (isyms == NULL)
5442     {
5443       error (_("Out of memory reading %lu symbols\n"),
5444              (unsigned long) number);
5445       goto exit_point;
5446     }
5447
5448   for (j = 0, psym = isyms; j < number; j++, psym++)
5449     {
5450       psym->st_name  = BYTE_GET (esyms[j].st_name);
5451       psym->st_value = BYTE_GET (esyms[j].st_value);
5452       psym->st_size  = BYTE_GET (esyms[j].st_size);
5453       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5454       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5455         psym->st_shndx
5456           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5457       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5458         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5459       psym->st_info  = BYTE_GET (esyms[j].st_info);
5460       psym->st_other = BYTE_GET (esyms[j].st_other);
5461     }
5462
5463  exit_point:
5464   if (shndx != NULL)
5465     free (shndx);
5466   if (esyms != NULL)
5467     free (esyms);
5468
5469   if (num_syms_return != NULL)
5470     * num_syms_return = isyms == NULL ? 0 : number;
5471
5472   return isyms;
5473 }
5474
5475 static Elf_Internal_Sym *
5476 get_64bit_elf_symbols (Filedata *           filedata,
5477                        Elf_Internal_Shdr *  section,
5478                        unsigned long *      num_syms_return)
5479 {
5480   unsigned long number = 0;
5481   Elf64_External_Sym * esyms = NULL;
5482   Elf_External_Sym_Shndx * shndx = NULL;
5483   Elf_Internal_Sym * isyms = NULL;
5484   Elf_Internal_Sym * psym;
5485   unsigned int j;
5486
5487   if (section->sh_size == 0)
5488     {
5489       if (num_syms_return != NULL)
5490         * num_syms_return = 0;
5491       return NULL;
5492     }
5493
5494   /* Run some sanity checks first.  */
5495   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5496     {
5497       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5498              printable_section_name (filedata, section),
5499              (unsigned long) section->sh_entsize);
5500       goto exit_point;
5501     }
5502
5503   if (section->sh_size > filedata->file_size)
5504     {
5505       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5506              printable_section_name (filedata, section),
5507              (unsigned long) section->sh_size);
5508       goto exit_point;
5509     }
5510
5511   number = section->sh_size / section->sh_entsize;
5512
5513   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5514     {
5515       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5516              (unsigned long) section->sh_size,
5517              printable_section_name (filedata, section),
5518              (unsigned long) section->sh_entsize);
5519       goto exit_point;
5520     }
5521
5522   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5523                                            section->sh_size, _("symbols"));
5524   if (!esyms)
5525     goto exit_point;
5526
5527   {
5528     elf_section_list * entry;
5529
5530     shndx = NULL;
5531     for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5532       if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
5533         {
5534           shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5535                                                        entry->hdr->sh_offset,
5536                                                        1, entry->hdr->sh_size,
5537                                                        _("symbol table section indicies"));
5538           if (shndx == NULL)
5539             goto exit_point;
5540           /* PR17531: file: heap-buffer-overflow */
5541           else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5542             {
5543               error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5544                      printable_section_name (filedata, entry->hdr),
5545                      (unsigned long) entry->hdr->sh_size,
5546                      (unsigned long) section->sh_size);
5547               goto exit_point;
5548             }
5549         }
5550   }
5551
5552   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5553
5554   if (isyms == NULL)
5555     {
5556       error (_("Out of memory reading %lu symbols\n"),
5557              (unsigned long) number);
5558       goto exit_point;
5559     }
5560
5561   for (j = 0, psym = isyms; j < number; j++, psym++)
5562     {
5563       psym->st_name  = BYTE_GET (esyms[j].st_name);
5564       psym->st_info  = BYTE_GET (esyms[j].st_info);
5565       psym->st_other = BYTE_GET (esyms[j].st_other);
5566       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5567
5568       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5569         psym->st_shndx
5570           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5571       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5572         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5573
5574       psym->st_value = BYTE_GET (esyms[j].st_value);
5575       psym->st_size  = BYTE_GET (esyms[j].st_size);
5576     }
5577
5578  exit_point:
5579   if (shndx != NULL)
5580     free (shndx);
5581   if (esyms != NULL)
5582     free (esyms);
5583
5584   if (num_syms_return != NULL)
5585     * num_syms_return = isyms == NULL ? 0 : number;
5586
5587   return isyms;
5588 }
5589
5590 static const char *
5591 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5592 {
5593   static char buff[1024];
5594   char * p = buff;
5595   unsigned int field_size = is_32bit_elf ? 8 : 16;
5596   signed int sindex;
5597   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5598   bfd_vma os_flags = 0;
5599   bfd_vma proc_flags = 0;
5600   bfd_vma unknown_flags = 0;
5601   static const struct
5602     {
5603       const char * str;
5604       unsigned int len;
5605     }
5606   flags [] =
5607     {
5608       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5609       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5610       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5611       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5612       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5613       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5614       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5615       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5616       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5617       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5618       /* IA-64 specific.  */
5619       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5620       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5621       /* IA-64 OpenVMS specific.  */
5622       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5623       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5624       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5625       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5626       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5627       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5628       /* Generic.  */
5629       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5630       /* SPARC specific.  */
5631       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5632       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5633       /* ARM specific.  */
5634       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5635       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5636       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5637       /* GNU specific.  */
5638       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5639       /* VLE specific.  */
5640       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5641     };
5642
5643   if (do_section_details)
5644     {
5645       sprintf (buff, "[%*.*lx]: ",
5646                field_size, field_size, (unsigned long) sh_flags);
5647       p += field_size + 4;
5648     }
5649
5650   while (sh_flags)
5651     {
5652       bfd_vma flag;
5653
5654       flag = sh_flags & - sh_flags;
5655       sh_flags &= ~ flag;
5656
5657       if (do_section_details)
5658         {
5659           switch (flag)
5660             {
5661             case SHF_WRITE:             sindex = 0; break;
5662             case SHF_ALLOC:             sindex = 1; break;
5663             case SHF_EXECINSTR:         sindex = 2; break;
5664             case SHF_MERGE:             sindex = 3; break;
5665             case SHF_STRINGS:           sindex = 4; break;
5666             case SHF_INFO_LINK:         sindex = 5; break;
5667             case SHF_LINK_ORDER:        sindex = 6; break;
5668             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5669             case SHF_GROUP:             sindex = 8; break;
5670             case SHF_TLS:               sindex = 9; break;
5671             case SHF_EXCLUDE:           sindex = 18; break;
5672             case SHF_COMPRESSED:        sindex = 20; break;
5673             case SHF_GNU_MBIND:         sindex = 24; break;
5674
5675             default:
5676               sindex = -1;
5677               switch (filedata->file_header.e_machine)
5678                 {
5679                 case EM_IA_64:
5680                   if (flag == SHF_IA_64_SHORT)
5681                     sindex = 10;
5682                   else if (flag == SHF_IA_64_NORECOV)
5683                     sindex = 11;
5684 #ifdef BFD64
5685                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5686                     switch (flag)
5687                       {
5688                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5689                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5690                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5691                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5692                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5693                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5694                       default:                        break;
5695                       }
5696 #endif
5697                   break;
5698
5699                 case EM_386:
5700                 case EM_IAMCU:
5701                 case EM_X86_64:
5702                 case EM_L1OM:
5703                 case EM_K1OM:
5704                 case EM_OLD_SPARCV9:
5705                 case EM_SPARC32PLUS:
5706                 case EM_SPARCV9:
5707                 case EM_SPARC:
5708                   if (flag == SHF_ORDERED)
5709                     sindex = 19;
5710                   break;
5711
5712                 case EM_ARM:
5713                   switch (flag)
5714                     {
5715                     case SHF_ENTRYSECT: sindex = 21; break;
5716                     case SHF_ARM_PURECODE: sindex = 22; break;
5717                     case SHF_COMDEF: sindex = 23; break;
5718                     default: break;
5719                     }
5720                   break;
5721                 case EM_PPC:
5722                   if (flag == SHF_PPC_VLE)
5723                     sindex = 25;
5724                   break;
5725
5726                 default:
5727                   break;
5728                 }
5729             }
5730
5731           if (sindex != -1)
5732             {
5733               if (p != buff + field_size + 4)
5734                 {
5735                   if (size < (10 + 2))
5736                     {
5737                       warn (_("Internal error: not enough buffer room for section flag info"));
5738                       return _("<unknown>");
5739                     }
5740                   size -= 2;
5741                   *p++ = ',';
5742                   *p++ = ' ';
5743                 }
5744
5745               size -= flags [sindex].len;
5746               p = stpcpy (p, flags [sindex].str);
5747             }
5748           else if (flag & SHF_MASKOS)
5749             os_flags |= flag;
5750           else if (flag & SHF_MASKPROC)
5751             proc_flags |= flag;
5752           else
5753             unknown_flags |= flag;
5754         }
5755       else
5756         {
5757           switch (flag)
5758             {
5759             case SHF_WRITE:             *p = 'W'; break;
5760             case SHF_ALLOC:             *p = 'A'; break;
5761             case SHF_EXECINSTR:         *p = 'X'; break;
5762             case SHF_MERGE:             *p = 'M'; break;
5763             case SHF_STRINGS:           *p = 'S'; break;
5764             case SHF_INFO_LINK:         *p = 'I'; break;
5765             case SHF_LINK_ORDER:        *p = 'L'; break;
5766             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5767             case SHF_GROUP:             *p = 'G'; break;
5768             case SHF_TLS:               *p = 'T'; break;
5769             case SHF_EXCLUDE:           *p = 'E'; break;
5770             case SHF_COMPRESSED:        *p = 'C'; break;
5771             case SHF_GNU_MBIND:         *p = 'D'; break;
5772
5773             default:
5774               if ((filedata->file_header.e_machine == EM_X86_64
5775                    || filedata->file_header.e_machine == EM_L1OM
5776                    || filedata->file_header.e_machine == EM_K1OM)
5777                   && flag == SHF_X86_64_LARGE)
5778                 *p = 'l';
5779               else if (filedata->file_header.e_machine == EM_ARM
5780                        && flag == SHF_ARM_PURECODE)
5781                   *p = 'y';
5782               else if (filedata->file_header.e_machine == EM_PPC
5783                        && flag == SHF_PPC_VLE)
5784                   *p = 'v';
5785               else if (flag & SHF_MASKOS)
5786                 {
5787                   *p = 'o';
5788                   sh_flags &= ~ SHF_MASKOS;
5789                 }
5790               else if (flag & SHF_MASKPROC)
5791                 {
5792                   *p = 'p';
5793                   sh_flags &= ~ SHF_MASKPROC;
5794                 }
5795               else
5796                 *p = 'x';
5797               break;
5798             }
5799           p++;
5800         }
5801     }
5802
5803   if (do_section_details)
5804     {
5805       if (os_flags)
5806         {
5807           size -= 5 + field_size;
5808           if (p != buff + field_size + 4)
5809             {
5810               if (size < (2 + 1))
5811                 {
5812                   warn (_("Internal error: not enough buffer room for section flag info"));
5813                   return _("<unknown>");
5814                 }
5815               size -= 2;
5816               *p++ = ',';
5817               *p++ = ' ';
5818             }
5819           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5820                    (unsigned long) os_flags);
5821           p += 5 + field_size;
5822         }
5823       if (proc_flags)
5824         {
5825           size -= 7 + field_size;
5826           if (p != buff + field_size + 4)
5827             {
5828               if (size < (2 + 1))
5829                 {
5830                   warn (_("Internal error: not enough buffer room for section flag info"));
5831                   return _("<unknown>");
5832                 }
5833               size -= 2;
5834               *p++ = ',';
5835               *p++ = ' ';
5836             }
5837           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5838                    (unsigned long) proc_flags);
5839           p += 7 + field_size;
5840         }
5841       if (unknown_flags)
5842         {
5843           size -= 10 + field_size;
5844           if (p != buff + field_size + 4)
5845             {
5846               if (size < (2 + 1))
5847                 {
5848                   warn (_("Internal error: not enough buffer room for section flag info"));
5849                   return _("<unknown>");
5850                 }
5851               size -= 2;
5852               *p++ = ',';
5853               *p++ = ' ';
5854             }
5855           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5856                    (unsigned long) unknown_flags);
5857           p += 10 + field_size;
5858         }
5859     }
5860
5861   *p = '\0';
5862   return buff;
5863 }
5864
5865 static unsigned int
5866 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5867 {
5868   if (is_32bit_elf)
5869     {
5870       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5871
5872       if (size < sizeof (* echdr))
5873         {
5874           error (_("Compressed section is too small even for a compression header\n"));
5875           return 0;
5876         }
5877
5878       chdr->ch_type = BYTE_GET (echdr->ch_type);
5879       chdr->ch_size = BYTE_GET (echdr->ch_size);
5880       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5881       return sizeof (*echdr);
5882     }
5883   else
5884     {
5885       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5886
5887       if (size < sizeof (* echdr))
5888         {
5889           error (_("Compressed section is too small even for a compression header\n"));
5890           return 0;
5891         }
5892
5893       chdr->ch_type = BYTE_GET (echdr->ch_type);
5894       chdr->ch_size = BYTE_GET (echdr->ch_size);
5895       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5896       return sizeof (*echdr);
5897     }
5898 }
5899
5900 static bfd_boolean
5901 process_section_headers (Filedata * filedata)
5902 {
5903   Elf_Internal_Shdr * section;
5904   unsigned int i;
5905
5906   filedata->section_headers = NULL;
5907
5908   if (filedata->file_header.e_shnum == 0)
5909     {
5910       /* PR binutils/12467.  */
5911       if (filedata->file_header.e_shoff != 0)
5912         {
5913           warn (_("possibly corrupt ELF file header - it has a non-zero"
5914                   " section header offset, but no section headers\n"));
5915           return FALSE;
5916         }
5917       else if (do_sections)
5918         printf (_("\nThere are no sections in this file.\n"));
5919
5920       return TRUE;
5921     }
5922
5923   if (do_sections && !do_header)
5924     printf (ngettext ("There is %d section header, "
5925                       "starting at offset 0x%lx:\n",
5926                       "There are %d section headers, "
5927                       "starting at offset 0x%lx:\n",
5928                       filedata->file_header.e_shnum),
5929             filedata->file_header.e_shnum,
5930             (unsigned long) filedata->file_header.e_shoff);
5931
5932   if (is_32bit_elf)
5933     {
5934       if (! get_32bit_section_headers (filedata, FALSE))
5935         return FALSE;
5936     }
5937   else
5938     {
5939       if (! get_64bit_section_headers (filedata, FALSE))
5940         return FALSE;
5941     }
5942
5943   /* Read in the string table, so that we have names to display.  */
5944   if (filedata->file_header.e_shstrndx != SHN_UNDEF
5945        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
5946     {
5947       section = filedata->section_headers + filedata->file_header.e_shstrndx;
5948
5949       if (section->sh_size != 0)
5950         {
5951           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
5952                                                       1, section->sh_size,
5953                                                       _("string table"));
5954
5955           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
5956         }
5957     }
5958
5959   /* Scan the sections for the dynamic symbol table
5960      and dynamic string table and debug sections.  */
5961   dynamic_symbols = NULL;
5962   dynamic_strings = NULL;
5963   dynamic_syminfo = NULL;
5964   symtab_shndx_list = NULL;
5965
5966   eh_addr_size = is_32bit_elf ? 4 : 8;
5967   switch (filedata->file_header.e_machine)
5968     {
5969     case EM_MIPS:
5970     case EM_MIPS_RS3_LE:
5971       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5972          FDE addresses.  However, the ABI also has a semi-official ILP32
5973          variant for which the normal FDE address size rules apply.
5974
5975          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5976          section, where XX is the size of longs in bits.  Unfortunately,
5977          earlier compilers provided no way of distinguishing ILP32 objects
5978          from LP64 objects, so if there's any doubt, we should assume that
5979          the official LP64 form is being used.  */
5980       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5981           && find_section (filedata, ".gcc_compiled_long32") == NULL)
5982         eh_addr_size = 8;
5983       break;
5984
5985     case EM_H8_300:
5986     case EM_H8_300H:
5987       switch (filedata->file_header.e_flags & EF_H8_MACH)
5988         {
5989         case E_H8_MACH_H8300:
5990         case E_H8_MACH_H8300HN:
5991         case E_H8_MACH_H8300SN:
5992         case E_H8_MACH_H8300SXN:
5993           eh_addr_size = 2;
5994           break;
5995         case E_H8_MACH_H8300H:
5996         case E_H8_MACH_H8300S:
5997         case E_H8_MACH_H8300SX:
5998           eh_addr_size = 4;
5999           break;
6000         }
6001       break;
6002
6003     case EM_M32C_OLD:
6004     case EM_M32C:
6005       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6006         {
6007         case EF_M32C_CPU_M16C:
6008           eh_addr_size = 2;
6009           break;
6010         }
6011       break;
6012     }
6013
6014 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6015   do                                                                    \
6016     {                                                                   \
6017       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6018       if (section->sh_entsize != expected_entsize)                      \
6019         {                                                               \
6020           char buf[40];                                                 \
6021           sprintf_vma (buf, section->sh_entsize);                       \
6022           /* Note: coded this way so that there is a single string for  \
6023              translation.  */ \
6024           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6025           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6026                    (unsigned) expected_entsize);                        \
6027           section->sh_entsize = expected_entsize;                       \
6028         }                                                               \
6029     }                                                                   \
6030   while (0)
6031
6032 #define CHECK_ENTSIZE(section, i, type)                                 \
6033   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6034                         sizeof (Elf64_External_##type))
6035
6036   for (i = 0, section = filedata->section_headers;
6037        i < filedata->file_header.e_shnum;
6038        i++, section++)
6039     {
6040       char * name = SECTION_NAME (section);
6041
6042       if (section->sh_type == SHT_DYNSYM)
6043         {
6044           if (dynamic_symbols != NULL)
6045             {
6046               error (_("File contains multiple dynamic symbol tables\n"));
6047               continue;
6048             }
6049
6050           CHECK_ENTSIZE (section, i, Sym);
6051           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6052         }
6053       else if (section->sh_type == SHT_STRTAB
6054                && streq (name, ".dynstr"))
6055         {
6056           if (dynamic_strings != NULL)
6057             {
6058               error (_("File contains multiple dynamic string tables\n"));
6059               continue;
6060             }
6061
6062           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6063                                                1, section->sh_size,
6064                                                _("dynamic strings"));
6065           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6066         }
6067       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6068         {
6069           elf_section_list * entry = xmalloc (sizeof * entry);
6070
6071           entry->hdr = section;
6072           entry->next = symtab_shndx_list;
6073           symtab_shndx_list = entry;
6074         }
6075       else if (section->sh_type == SHT_SYMTAB)
6076         CHECK_ENTSIZE (section, i, Sym);
6077       else if (section->sh_type == SHT_GROUP)
6078         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6079       else if (section->sh_type == SHT_REL)
6080         CHECK_ENTSIZE (section, i, Rel);
6081       else if (section->sh_type == SHT_RELA)
6082         CHECK_ENTSIZE (section, i, Rela);
6083       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6084                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6085                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6086                 || do_debug_str || do_debug_loc || do_debug_ranges
6087                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6088                && (const_strneq (name, ".debug_")
6089                    || const_strneq (name, ".zdebug_")))
6090         {
6091           if (name[1] == 'z')
6092             name += sizeof (".zdebug_") - 1;
6093           else
6094             name += sizeof (".debug_") - 1;
6095
6096           if (do_debugging
6097               || (do_debug_info     && const_strneq (name, "info"))
6098               || (do_debug_info     && const_strneq (name, "types"))
6099               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6100               || (do_debug_lines    && strcmp (name, "line") == 0)
6101               || (do_debug_lines    && const_strneq (name, "line."))
6102               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6103               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6104               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6105               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6106               || (do_debug_aranges  && const_strneq (name, "aranges"))
6107               || (do_debug_ranges   && const_strneq (name, "ranges"))
6108               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6109               || (do_debug_frames   && const_strneq (name, "frame"))
6110               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6111               || (do_debug_macinfo  && const_strneq (name, "macro"))
6112               || (do_debug_str      && const_strneq (name, "str"))
6113               || (do_debug_loc      && const_strneq (name, "loc"))
6114               || (do_debug_loc      && const_strneq (name, "loclists"))
6115               || (do_debug_addr     && const_strneq (name, "addr"))
6116               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6117               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6118               )
6119             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6120         }
6121       /* Linkonce section to be combined with .debug_info at link time.  */
6122       else if ((do_debugging || do_debug_info)
6123                && const_strneq (name, ".gnu.linkonce.wi."))
6124         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6125       else if (do_debug_frames && streq (name, ".eh_frame"))
6126         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6127       else if (do_gdb_index && (streq (name, ".gdb_index")
6128                                 || streq (name, ".debug_names")))
6129         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6130       /* Trace sections for Itanium VMS.  */
6131       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6132                 || do_trace_aranges)
6133                && const_strneq (name, ".trace_"))
6134         {
6135           name += sizeof (".trace_") - 1;
6136
6137           if (do_debugging
6138               || (do_trace_info     && streq (name, "info"))
6139               || (do_trace_abbrevs  && streq (name, "abbrev"))
6140               || (do_trace_aranges  && streq (name, "aranges"))
6141               )
6142             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6143         }
6144       else if ((do_debugging || do_debug_links)
6145                && (const_strneq (name, ".gnu_debuglink")
6146                    || const_strneq (name, ".gnu_debugaltlink")))
6147         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6148     }
6149
6150   if (! do_sections)
6151     return TRUE;
6152
6153   if (filedata->file_header.e_shnum > 1)
6154     printf (_("\nSection Headers:\n"));
6155   else
6156     printf (_("\nSection Header:\n"));
6157
6158   if (is_32bit_elf)
6159     {
6160       if (do_section_details)
6161         {
6162           printf (_("  [Nr] Name\n"));
6163           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6164         }
6165       else
6166         printf
6167           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6168     }
6169   else if (do_wide)
6170     {
6171       if (do_section_details)
6172         {
6173           printf (_("  [Nr] Name\n"));
6174           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6175         }
6176       else
6177         printf
6178           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6179     }
6180   else
6181     {
6182       if (do_section_details)
6183         {
6184           printf (_("  [Nr] Name\n"));
6185           printf (_("       Type              Address          Offset            Link\n"));
6186           printf (_("       Size              EntSize          Info              Align\n"));
6187         }
6188       else
6189         {
6190           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6191           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6192         }
6193     }
6194
6195   if (do_section_details)
6196     printf (_("       Flags\n"));
6197
6198   for (i = 0, section = filedata->section_headers;
6199        i < filedata->file_header.e_shnum;
6200        i++, section++)
6201     {
6202       /* Run some sanity checks on the section header.  */
6203
6204       /* Check the sh_link field.  */
6205       switch (section->sh_type)
6206         {
6207         case SHT_SYMTAB_SHNDX:
6208         case SHT_GROUP:
6209         case SHT_HASH:
6210         case SHT_GNU_HASH:
6211         case SHT_GNU_versym:
6212         case SHT_REL:
6213         case SHT_RELA:
6214           if (section->sh_link < 1
6215               || section->sh_link >= filedata->file_header.e_shnum
6216               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6217                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6218             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6219                   i, section->sh_link);
6220           break;
6221
6222         case SHT_DYNAMIC:
6223         case SHT_SYMTAB:
6224         case SHT_DYNSYM:
6225         case SHT_GNU_verneed:
6226         case SHT_GNU_verdef:
6227         case SHT_GNU_LIBLIST:
6228           if (section->sh_link < 1
6229               || section->sh_link >= filedata->file_header.e_shnum
6230               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6231             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6232                   i, section->sh_link);
6233           break;
6234
6235         case SHT_INIT_ARRAY:
6236         case SHT_FINI_ARRAY:
6237         case SHT_PREINIT_ARRAY:
6238           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6239             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6240                   i, section->sh_link);
6241           break;
6242
6243         default:
6244           /* FIXME: Add support for target specific section types.  */
6245 #if 0     /* Currently we do not check other section types as there are too
6246              many special cases.  Stab sections for example have a type
6247              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6248              section.  */
6249           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6250             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6251                   i, section->sh_link);
6252 #endif
6253           break;
6254         }
6255
6256       /* Check the sh_info field.  */
6257       switch (section->sh_type)
6258         {
6259         case SHT_REL:
6260         case SHT_RELA:
6261           if (section->sh_info < 1
6262               || section->sh_info >= filedata->file_header.e_shnum
6263               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6264                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6265                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6266                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6267                   /* FIXME: Are other section types valid ?  */
6268                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6269             {
6270               if (section->sh_info == 0
6271                   && (streq (SECTION_NAME (section), ".rel.dyn")
6272                       || streq (SECTION_NAME (section), ".rela.dyn")))
6273                 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6274                    of zero.  The relocations in these sections may apply
6275                    to many different sections.  */
6276                    ;
6277               else
6278                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6279                       i, section->sh_info);
6280             }
6281           break;
6282
6283         case SHT_DYNAMIC:
6284         case SHT_HASH:
6285         case SHT_SYMTAB_SHNDX:
6286         case SHT_INIT_ARRAY:
6287         case SHT_FINI_ARRAY:
6288         case SHT_PREINIT_ARRAY:
6289           if (section->sh_info != 0)
6290             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6291                   i, section->sh_info);
6292           break;
6293
6294         case SHT_GROUP:
6295         case SHT_SYMTAB:
6296         case SHT_DYNSYM:
6297           /* A symbol index - we assume that it is valid.  */
6298           break;
6299
6300         default:
6301           /* FIXME: Add support for target specific section types.  */
6302           if (section->sh_type == SHT_NOBITS)
6303             /* NOBITS section headers with non-zero sh_info fields can be
6304                created when a binary is stripped of everything but its debug
6305                information.  The stripped sections have their headers
6306                preserved but their types set to SHT_NOBITS.  So do not check
6307                this type of section.  */
6308             ;
6309           else if (section->sh_flags & SHF_INFO_LINK)
6310             {
6311               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6312                 warn (_("[%2u]: Expected link to another section in info field"), i);
6313             }
6314           else if (section->sh_type < SHT_LOOS
6315                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6316                    && section->sh_info != 0)
6317             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6318                   i, section->sh_info);
6319           break;
6320         }
6321
6322       /* Check the sh_size field.  */
6323       if (section->sh_size > filedata->file_size
6324           && section->sh_type != SHT_NOBITS
6325           && section->sh_type != SHT_NULL
6326           && section->sh_type < SHT_LOOS)
6327         warn (_("Size of section %u is larger than the entire file!\n"), i);
6328
6329       printf ("  [%2u] ", i);
6330       if (do_section_details)
6331         printf ("%s\n      ", printable_section_name (filedata, section));
6332       else
6333         print_symbol (-17, SECTION_NAME (section));
6334
6335       printf (do_wide ? " %-15s " : " %-15.15s ",
6336               get_section_type_name (filedata, section->sh_type));
6337
6338       if (is_32bit_elf)
6339         {
6340           const char * link_too_big = NULL;
6341
6342           print_vma (section->sh_addr, LONG_HEX);
6343
6344           printf ( " %6.6lx %6.6lx %2.2lx",
6345                    (unsigned long) section->sh_offset,
6346                    (unsigned long) section->sh_size,
6347                    (unsigned long) section->sh_entsize);
6348
6349           if (do_section_details)
6350             fputs ("  ", stdout);
6351           else
6352             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6353
6354           if (section->sh_link >= filedata->file_header.e_shnum)
6355             {
6356               link_too_big = "";
6357               /* The sh_link value is out of range.  Normally this indicates
6358                  an error but it can have special values in Solaris binaries.  */
6359               switch (filedata->file_header.e_machine)
6360                 {
6361                 case EM_386:
6362                 case EM_IAMCU:
6363                 case EM_X86_64:
6364                 case EM_L1OM:
6365                 case EM_K1OM:
6366                 case EM_OLD_SPARCV9:
6367                 case EM_SPARC32PLUS:
6368                 case EM_SPARCV9:
6369                 case EM_SPARC:
6370                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6371                     link_too_big = "BEFORE";
6372                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6373                     link_too_big = "AFTER";
6374                   break;
6375                 default:
6376                   break;
6377                 }
6378             }
6379
6380           if (do_section_details)
6381             {
6382               if (link_too_big != NULL && * link_too_big)
6383                 printf ("<%s> ", link_too_big);
6384               else
6385                 printf ("%2u ", section->sh_link);
6386               printf ("%3u %2lu\n", section->sh_info,
6387                       (unsigned long) section->sh_addralign);
6388             }
6389           else
6390             printf ("%2u %3u %2lu\n",
6391                     section->sh_link,
6392                     section->sh_info,
6393                     (unsigned long) section->sh_addralign);
6394
6395           if (link_too_big && ! * link_too_big)
6396             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6397                   i, section->sh_link);
6398         }
6399       else if (do_wide)
6400         {
6401           print_vma (section->sh_addr, LONG_HEX);
6402
6403           if ((long) section->sh_offset == section->sh_offset)
6404             printf (" %6.6lx", (unsigned long) section->sh_offset);
6405           else
6406             {
6407               putchar (' ');
6408               print_vma (section->sh_offset, LONG_HEX);
6409             }
6410
6411           if ((unsigned long) section->sh_size == section->sh_size)
6412             printf (" %6.6lx", (unsigned long) section->sh_size);
6413           else
6414             {
6415               putchar (' ');
6416               print_vma (section->sh_size, LONG_HEX);
6417             }
6418
6419           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6420             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6421           else
6422             {
6423               putchar (' ');
6424               print_vma (section->sh_entsize, LONG_HEX);
6425             }
6426
6427           if (do_section_details)
6428             fputs ("  ", stdout);
6429           else
6430             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6431
6432           printf ("%2u %3u ", section->sh_link, section->sh_info);
6433
6434           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6435             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6436           else
6437             {
6438               print_vma (section->sh_addralign, DEC);
6439               putchar ('\n');
6440             }
6441         }
6442       else if (do_section_details)
6443         {
6444           printf ("       %-15.15s  ",
6445                   get_section_type_name (filedata, section->sh_type));
6446           print_vma (section->sh_addr, LONG_HEX);
6447           if ((long) section->sh_offset == section->sh_offset)
6448             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6449           else
6450             {
6451               printf ("  ");
6452               print_vma (section->sh_offset, LONG_HEX);
6453             }
6454           printf ("  %u\n       ", section->sh_link);
6455           print_vma (section->sh_size, LONG_HEX);
6456           putchar (' ');
6457           print_vma (section->sh_entsize, LONG_HEX);
6458
6459           printf ("  %-16u  %lu\n",
6460                   section->sh_info,
6461                   (unsigned long) section->sh_addralign);
6462         }
6463       else
6464         {
6465           putchar (' ');
6466           print_vma (section->sh_addr, LONG_HEX);
6467           if ((long) section->sh_offset == section->sh_offset)
6468             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6469           else
6470             {
6471               printf ("  ");
6472               print_vma (section->sh_offset, LONG_HEX);
6473             }
6474           printf ("\n       ");
6475           print_vma (section->sh_size, LONG_HEX);
6476           printf ("  ");
6477           print_vma (section->sh_entsize, LONG_HEX);
6478
6479           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6480
6481           printf ("     %2u   %3u     %lu\n",
6482                   section->sh_link,
6483                   section->sh_info,
6484                   (unsigned long) section->sh_addralign);
6485         }
6486
6487       if (do_section_details)
6488         {
6489           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6490           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6491             {
6492               /* Minimum section size is 12 bytes for 32-bit compression
6493                  header + 12 bytes for compressed data header.  */
6494               unsigned char buf[24];
6495
6496               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6497               if (get_data (&buf, filedata, section->sh_offset, 1,
6498                             sizeof (buf), _("compression header")))
6499                 {
6500                   Elf_Internal_Chdr chdr;
6501
6502                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6503
6504                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6505                     printf ("       ZLIB, ");
6506                   else
6507                     printf (_("       [<unknown>: 0x%x], "),
6508                             chdr.ch_type);
6509                   print_vma (chdr.ch_size, LONG_HEX);
6510                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6511                 }
6512             }
6513         }
6514     }
6515
6516   if (!do_section_details)
6517     {
6518       /* The ordering of the letters shown here matches the ordering of the
6519          corresponding SHF_xxx values, and hence the order in which these
6520          letters will be displayed to the user.  */
6521       printf (_("Key to Flags:\n\
6522   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6523   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6524   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6525       if (filedata->file_header.e_machine == EM_X86_64
6526           || filedata->file_header.e_machine == EM_L1OM
6527           || filedata->file_header.e_machine == EM_K1OM)
6528         printf (_("l (large), "));
6529       else if (filedata->file_header.e_machine == EM_ARM)
6530         printf (_("y (purecode), "));
6531       else if (filedata->file_header.e_machine == EM_PPC)
6532         printf (_("v (VLE), "));
6533       printf ("p (processor specific)\n");
6534     }
6535
6536   return TRUE;
6537 }
6538
6539 static const char *
6540 get_group_flags (unsigned int flags)
6541 {
6542   static char buff[128];
6543
6544   if (flags == 0)
6545     return "";
6546   else if (flags == GRP_COMDAT)
6547     return "COMDAT ";
6548
6549   snprintf (buff, 14, _("[0x%x: "), flags);
6550
6551   flags &= ~ GRP_COMDAT;
6552   if (flags & GRP_MASKOS)
6553     {
6554       strcat (buff, "<OS specific>");
6555       flags &= ~ GRP_MASKOS;
6556     }
6557
6558   if (flags & GRP_MASKPROC)
6559     {
6560       strcat (buff, "<PROC specific>");
6561       flags &= ~ GRP_MASKPROC;
6562     }
6563
6564   if (flags)
6565     strcat (buff, "<unknown>");
6566
6567   strcat (buff, "]");
6568   return buff;
6569 }
6570
6571 static bfd_boolean
6572 process_section_groups (Filedata * filedata)
6573 {
6574   Elf_Internal_Shdr * section;
6575   unsigned int i;
6576   struct group * group;
6577   Elf_Internal_Shdr * symtab_sec;
6578   Elf_Internal_Shdr * strtab_sec;
6579   Elf_Internal_Sym * symtab;
6580   unsigned long num_syms;
6581   char * strtab;
6582   size_t strtab_size;
6583
6584   /* Don't process section groups unless needed.  */
6585   if (!do_unwind && !do_section_groups)
6586     return TRUE;
6587
6588   if (filedata->file_header.e_shnum == 0)
6589     {
6590       if (do_section_groups)
6591         printf (_("\nThere are no sections to group in this file.\n"));
6592
6593       return TRUE;
6594     }
6595
6596   if (filedata->section_headers == NULL)
6597     {
6598       error (_("Section headers are not available!\n"));
6599       /* PR 13622: This can happen with a corrupt ELF header.  */
6600       return FALSE;
6601     }
6602
6603   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6604                                                      sizeof (struct group *));
6605
6606   if (section_headers_groups == NULL)
6607     {
6608       error (_("Out of memory reading %u section group headers\n"),
6609              filedata->file_header.e_shnum);
6610       return FALSE;
6611     }
6612
6613   /* Scan the sections for the group section.  */
6614   group_count = 0;
6615   for (i = 0, section = filedata->section_headers;
6616        i < filedata->file_header.e_shnum;
6617        i++, section++)
6618     if (section->sh_type == SHT_GROUP)
6619       group_count++;
6620
6621   if (group_count == 0)
6622     {
6623       if (do_section_groups)
6624         printf (_("\nThere are no section groups in this file.\n"));
6625
6626       return TRUE;
6627     }
6628
6629   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6630
6631   if (section_groups == NULL)
6632     {
6633       error (_("Out of memory reading %lu groups\n"),
6634              (unsigned long) group_count);
6635       return FALSE;
6636     }
6637
6638   symtab_sec = NULL;
6639   strtab_sec = NULL;
6640   symtab = NULL;
6641   num_syms = 0;
6642   strtab = NULL;
6643   strtab_size = 0;
6644   for (i = 0, section = filedata->section_headers, group = section_groups;
6645        i < filedata->file_header.e_shnum;
6646        i++, section++)
6647     {
6648       if (section->sh_type == SHT_GROUP)
6649         {
6650           const char * name = printable_section_name (filedata, section);
6651           const char * group_name;
6652           unsigned char * start;
6653           unsigned char * indices;
6654           unsigned int entry, j, size;
6655           Elf_Internal_Shdr * sec;
6656           Elf_Internal_Sym * sym;
6657
6658           /* Get the symbol table.  */
6659           if (section->sh_link >= filedata->file_header.e_shnum
6660               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6661                   != SHT_SYMTAB))
6662             {
6663               error (_("Bad sh_link in group section `%s'\n"), name);
6664               continue;
6665             }
6666
6667           if (symtab_sec != sec)
6668             {
6669               symtab_sec = sec;
6670               if (symtab)
6671                 free (symtab);
6672               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6673             }
6674
6675           if (symtab == NULL)
6676             {
6677               error (_("Corrupt header in group section `%s'\n"), name);
6678               continue;
6679             }
6680
6681           if (section->sh_info >= num_syms)
6682             {
6683               error (_("Bad sh_info in group section `%s'\n"), name);
6684               continue;
6685             }
6686
6687           sym = symtab + section->sh_info;
6688
6689           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6690             {
6691               if (sym->st_shndx == 0
6692                   || sym->st_shndx >= filedata->file_header.e_shnum)
6693                 {
6694                   error (_("Bad sh_info in group section `%s'\n"), name);
6695                   continue;
6696                 }
6697
6698               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6699               strtab_sec = NULL;
6700               if (strtab)
6701                 free (strtab);
6702               strtab = NULL;
6703               strtab_size = 0;
6704             }
6705           else
6706             {
6707               /* Get the string table.  */
6708               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6709                 {
6710                   strtab_sec = NULL;
6711                   if (strtab)
6712                     free (strtab);
6713                   strtab = NULL;
6714                   strtab_size = 0;
6715                 }
6716               else if (strtab_sec
6717                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6718                 {
6719                   strtab_sec = sec;
6720                   if (strtab)
6721                     free (strtab);
6722
6723                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6724                                               1, strtab_sec->sh_size,
6725                                               _("string table"));
6726                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6727                 }
6728               group_name = sym->st_name < strtab_size
6729                 ? strtab + sym->st_name : _("<corrupt>");
6730             }
6731
6732           /* PR 17531: file: loop.  */
6733           if (section->sh_entsize > section->sh_size)
6734             {
6735               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6736                      printable_section_name (filedata, section),
6737                      (unsigned long) section->sh_entsize,
6738                      (unsigned long) section->sh_size);
6739               break;
6740             }
6741
6742           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6743                                               1, section->sh_size,
6744                                               _("section data"));
6745           if (start == NULL)
6746             continue;
6747
6748           indices = start;
6749           size = (section->sh_size / section->sh_entsize) - 1;
6750           entry = byte_get (indices, 4);
6751           indices += 4;
6752
6753           if (do_section_groups)
6754             {
6755               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6756                       get_group_flags (entry), i, name, group_name, size);
6757
6758               printf (_("   [Index]    Name\n"));
6759             }
6760
6761           group->group_index = i;
6762
6763           for (j = 0; j < size; j++)
6764             {
6765               struct group_list * g;
6766
6767               entry = byte_get (indices, 4);
6768               indices += 4;
6769
6770               if (entry >= filedata->file_header.e_shnum)
6771                 {
6772                   static unsigned num_group_errors = 0;
6773
6774                   if (num_group_errors ++ < 10)
6775                     {
6776                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6777                              entry, i, filedata->file_header.e_shnum - 1);
6778                       if (num_group_errors == 10)
6779                         warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6780                     }
6781                   continue;
6782                 }
6783
6784               if (section_headers_groups [entry] != NULL)
6785                 {
6786                   if (entry)
6787                     {
6788                       static unsigned num_errs = 0;
6789
6790                       if (num_errs ++ < 10)
6791                         {
6792                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6793                                  entry, i,
6794                                  section_headers_groups [entry]->group_index);
6795                           if (num_errs == 10)
6796                             warn (_("Further error messages about already contained group sections suppressed\n"));
6797                         }
6798                       continue;
6799                     }
6800                   else
6801                     {
6802                       /* Intel C/C++ compiler may put section 0 in a
6803                          section group.  We just warn it the first time
6804                          and ignore it afterwards.  */
6805                       static bfd_boolean warned = FALSE;
6806                       if (!warned)
6807                         {
6808                           error (_("section 0 in group section [%5u]\n"),
6809                                  section_headers_groups [entry]->group_index);
6810                           warned = TRUE;
6811                         }
6812                     }
6813                 }
6814
6815               section_headers_groups [entry] = group;
6816
6817               if (do_section_groups)
6818                 {
6819                   sec = filedata->section_headers + entry;
6820                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6821                 }
6822
6823               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6824               g->section_index = entry;
6825               g->next = group->root;
6826               group->root = g;
6827             }
6828
6829           if (start)
6830             free (start);
6831
6832           group++;
6833         }
6834     }
6835
6836   if (symtab)
6837     free (symtab);
6838   if (strtab)
6839     free (strtab);
6840   return TRUE;
6841 }
6842
6843 /* Data used to display dynamic fixups.  */
6844
6845 struct ia64_vms_dynfixup
6846 {
6847   bfd_vma needed_ident;         /* Library ident number.  */
6848   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6849   bfd_vma fixup_needed;         /* Index of the library.  */
6850   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6851   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6852 };
6853
6854 /* Data used to display dynamic relocations.  */
6855
6856 struct ia64_vms_dynimgrela
6857 {
6858   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6859   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6860 };
6861
6862 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6863    library).  */
6864
6865 static bfd_boolean
6866 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6867                               struct ia64_vms_dynfixup *  fixup,
6868                               const char *                strtab,
6869                               unsigned int                strtab_sz)
6870 {
6871   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6872   long i;
6873   const char * lib_name;
6874
6875   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6876                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6877                    _("dynamic section image fixups"));
6878   if (!imfs)
6879     return FALSE;
6880
6881   if (fixup->needed < strtab_sz)
6882     lib_name = strtab + fixup->needed;
6883   else
6884     {
6885       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6886             (unsigned long) fixup->needed);
6887       lib_name = "???";
6888     }
6889   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6890           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6891   printf
6892     (_("Seg Offset           Type                             SymVec DataType\n"));
6893
6894   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6895     {
6896       unsigned int type;
6897       const char *rtype;
6898
6899       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6900       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6901       type = BYTE_GET (imfs [i].type);
6902       rtype = elf_ia64_reloc_type (type);
6903       if (rtype == NULL)
6904         printf (" 0x%08x                       ", type);
6905       else
6906         printf (" %-32s ", rtype);
6907       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6908       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6909     }
6910
6911   free (imfs);
6912   return TRUE;
6913 }
6914
6915 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
6916
6917 static bfd_boolean
6918 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
6919 {
6920   Elf64_External_VMS_IMAGE_RELA *imrs;
6921   long i;
6922
6923   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
6924                    1, imgrela->img_rela_cnt * sizeof (*imrs),
6925                    _("dynamic section image relocations"));
6926   if (!imrs)
6927     return FALSE;
6928
6929   printf (_("\nImage relocs\n"));
6930   printf
6931     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
6932
6933   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6934     {
6935       unsigned int type;
6936       const char *rtype;
6937
6938       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6939       printf ("%08" BFD_VMA_FMT "x ",
6940               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6941       type = BYTE_GET (imrs [i].type);
6942       rtype = elf_ia64_reloc_type (type);
6943       if (rtype == NULL)
6944         printf ("0x%08x                      ", type);
6945       else
6946         printf ("%-31s ", rtype);
6947       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6948       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6949       printf ("%08" BFD_VMA_FMT "x\n",
6950               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6951     }
6952
6953   free (imrs);
6954   return TRUE;
6955 }
6956
6957 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
6958
6959 static bfd_boolean
6960 process_ia64_vms_dynamic_relocs (Filedata * filedata)
6961 {
6962   struct ia64_vms_dynfixup fixup;
6963   struct ia64_vms_dynimgrela imgrela;
6964   Elf_Internal_Dyn *entry;
6965   bfd_vma strtab_off = 0;
6966   bfd_vma strtab_sz = 0;
6967   char *strtab = NULL;
6968   bfd_boolean res = TRUE;
6969
6970   memset (&fixup, 0, sizeof (fixup));
6971   memset (&imgrela, 0, sizeof (imgrela));
6972
6973   /* Note: the order of the entries is specified by the OpenVMS specs.  */
6974   for (entry = dynamic_section;
6975        entry < dynamic_section + dynamic_nent;
6976        entry++)
6977     {
6978       switch (entry->d_tag)
6979         {
6980         case DT_IA_64_VMS_STRTAB_OFFSET:
6981           strtab_off = entry->d_un.d_val;
6982           break;
6983         case DT_STRSZ:
6984           strtab_sz = entry->d_un.d_val;
6985           if (strtab == NULL)
6986             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
6987                                1, strtab_sz, _("dynamic string section"));
6988           break;
6989
6990         case DT_IA_64_VMS_NEEDED_IDENT:
6991           fixup.needed_ident = entry->d_un.d_val;
6992           break;
6993         case DT_NEEDED:
6994           fixup.needed = entry->d_un.d_val;
6995           break;
6996         case DT_IA_64_VMS_FIXUP_NEEDED:
6997           fixup.fixup_needed = entry->d_un.d_val;
6998           break;
6999         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7000           fixup.fixup_rela_cnt = entry->d_un.d_val;
7001           break;
7002         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7003           fixup.fixup_rela_off = entry->d_un.d_val;
7004           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7005             res = FALSE;
7006           break;
7007         case DT_IA_64_VMS_IMG_RELA_CNT:
7008           imgrela.img_rela_cnt = entry->d_un.d_val;
7009           break;
7010         case DT_IA_64_VMS_IMG_RELA_OFF:
7011           imgrela.img_rela_off = entry->d_un.d_val;
7012           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7013             res = FALSE;
7014           break;
7015
7016         default:
7017           break;
7018         }
7019     }
7020
7021   if (strtab != NULL)
7022     free (strtab);
7023
7024   return res;
7025 }
7026
7027 static struct
7028 {
7029   const char * name;
7030   int reloc;
7031   int size;
7032   int rela;
7033 }
7034   dynamic_relocations [] =
7035 {
7036   { "REL", DT_REL, DT_RELSZ, FALSE },
7037   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7038   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7039 };
7040
7041 /* Process the reloc section.  */
7042
7043 static bfd_boolean
7044 process_relocs (Filedata * filedata)
7045 {
7046   unsigned long rel_size;
7047   unsigned long rel_offset;
7048
7049   if (!do_reloc)
7050     return TRUE;
7051
7052   if (do_using_dynamic)
7053     {
7054       int          is_rela;
7055       const char * name;
7056       bfd_boolean  has_dynamic_reloc;
7057       unsigned int i;
7058
7059       has_dynamic_reloc = FALSE;
7060
7061       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7062         {
7063           is_rela = dynamic_relocations [i].rela;
7064           name = dynamic_relocations [i].name;
7065           rel_size = dynamic_info [dynamic_relocations [i].size];
7066           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7067
7068           if (rel_size)
7069             has_dynamic_reloc = TRUE;
7070
7071           if (is_rela == UNKNOWN)
7072             {
7073               if (dynamic_relocations [i].reloc == DT_JMPREL)
7074                 switch (dynamic_info[DT_PLTREL])
7075                   {
7076                   case DT_REL:
7077                     is_rela = FALSE;
7078                     break;
7079                   case DT_RELA:
7080                     is_rela = TRUE;
7081                     break;
7082                   }
7083             }
7084
7085           if (rel_size)
7086             {
7087               printf
7088                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7089                  name, rel_offset, rel_size);
7090
7091               dump_relocations (filedata,
7092                                 offset_from_vma (filedata, rel_offset, rel_size),
7093                                 rel_size,
7094                                 dynamic_symbols, num_dynamic_syms,
7095                                 dynamic_strings, dynamic_strings_length,
7096                                 is_rela, TRUE /* is_dynamic */);
7097             }
7098         }
7099
7100       if (is_ia64_vms (filedata))
7101         if (process_ia64_vms_dynamic_relocs (filedata))
7102           has_dynamic_reloc = TRUE;
7103
7104       if (! has_dynamic_reloc)
7105         printf (_("\nThere are no dynamic relocations in this file.\n"));
7106     }
7107   else
7108     {
7109       Elf_Internal_Shdr * section;
7110       unsigned long i;
7111       bfd_boolean found = FALSE;
7112
7113       for (i = 0, section = filedata->section_headers;
7114            i < filedata->file_header.e_shnum;
7115            i++, section++)
7116         {
7117           if (   section->sh_type != SHT_RELA
7118               && section->sh_type != SHT_REL)
7119             continue;
7120
7121           rel_offset = section->sh_offset;
7122           rel_size   = section->sh_size;
7123
7124           if (rel_size)
7125             {
7126               Elf_Internal_Shdr * strsec;
7127               int is_rela;
7128               unsigned long num_rela;
7129
7130               printf (_("\nRelocation section "));
7131
7132               if (filedata->string_table == NULL)
7133                 printf ("%d", section->sh_name);
7134               else
7135                 printf ("'%s'", printable_section_name (filedata, section));
7136
7137               num_rela = rel_size / section->sh_entsize;
7138               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7139                                 " at offset 0x%lx contains %lu entries:\n",
7140                                 num_rela),
7141                       rel_offset, num_rela);
7142
7143               is_rela = section->sh_type == SHT_RELA;
7144
7145               if (section->sh_link != 0
7146                   && section->sh_link < filedata->file_header.e_shnum)
7147                 {
7148                   Elf_Internal_Shdr * symsec;
7149                   Elf_Internal_Sym *  symtab;
7150                   unsigned long nsyms;
7151                   unsigned long strtablen = 0;
7152                   char * strtab = NULL;
7153
7154                   symsec = filedata->section_headers + section->sh_link;
7155                   if (symsec->sh_type != SHT_SYMTAB
7156                       && symsec->sh_type != SHT_DYNSYM)
7157                     continue;
7158
7159                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7160
7161                   if (symtab == NULL)
7162                     continue;
7163
7164                   if (symsec->sh_link != 0
7165                       && symsec->sh_link < filedata->file_header.e_shnum)
7166                     {
7167                       strsec = filedata->section_headers + symsec->sh_link;
7168
7169                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7170                                                   1, strsec->sh_size,
7171                                                   _("string table"));
7172                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7173                     }
7174
7175                   dump_relocations (filedata, rel_offset, rel_size,
7176                                     symtab, nsyms, strtab, strtablen,
7177                                     is_rela,
7178                                     symsec->sh_type == SHT_DYNSYM);
7179                   if (strtab)
7180                     free (strtab);
7181                   free (symtab);
7182                 }
7183               else
7184                 dump_relocations (filedata, rel_offset, rel_size,
7185                                   NULL, 0, NULL, 0, is_rela,
7186                                   FALSE /* is_dynamic */);
7187
7188               found = TRUE;
7189             }
7190         }
7191
7192       if (! found)
7193         {
7194           /* Users sometimes forget the -D option, so try to be helpful.  */
7195           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7196             {
7197               if (dynamic_info [dynamic_relocations [i].size])
7198                 {
7199                   printf (_("\nThere are no static relocations in this file."));
7200                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7201
7202                   break;
7203                 }
7204             }
7205           if (i == ARRAY_SIZE (dynamic_relocations))
7206             printf (_("\nThere are no relocations in this file.\n"));
7207         }
7208     }
7209
7210   return TRUE;
7211 }
7212
7213 /* An absolute address consists of a section and an offset.  If the
7214    section is NULL, the offset itself is the address, otherwise, the
7215    address equals to LOAD_ADDRESS(section) + offset.  */
7216
7217 struct absaddr
7218 {
7219   unsigned short section;
7220   bfd_vma offset;
7221 };
7222
7223 #define ABSADDR(a) \
7224   ((a).section \
7225    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7226    : (a).offset)
7227
7228 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7229    name, if found, and the offset from the symbol to ADDR.  */
7230
7231 static void
7232 find_symbol_for_address (Filedata *          filedata,
7233                          Elf_Internal_Sym *  symtab,
7234                          unsigned long       nsyms,
7235                          const char *        strtab,
7236                          unsigned long       strtab_size,
7237                          struct absaddr      addr,
7238                          const char **       symname,
7239                          bfd_vma *           offset)
7240 {
7241   bfd_vma dist = 0x100000;
7242   Elf_Internal_Sym * sym;
7243   Elf_Internal_Sym * beg;
7244   Elf_Internal_Sym * end;
7245   Elf_Internal_Sym * best = NULL;
7246
7247   REMOVE_ARCH_BITS (addr.offset);
7248   beg = symtab;
7249   end = symtab + nsyms;
7250
7251   while (beg < end)
7252     {
7253       bfd_vma value;
7254
7255       sym = beg + (end - beg) / 2;
7256
7257       value = sym->st_value;
7258       REMOVE_ARCH_BITS (value);
7259
7260       if (sym->st_name != 0
7261           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7262           && addr.offset >= value
7263           && addr.offset - value < dist)
7264         {
7265           best = sym;
7266           dist = addr.offset - value;
7267           if (!dist)
7268             break;
7269         }
7270
7271       if (addr.offset < value)
7272         end = sym;
7273       else
7274         beg = sym + 1;
7275     }
7276
7277   if (best)
7278     {
7279       *symname = (best->st_name >= strtab_size
7280                   ? _("<corrupt>") : strtab + best->st_name);
7281       *offset = dist;
7282       return;
7283     }
7284
7285   *symname = NULL;
7286   *offset = addr.offset;
7287 }
7288
7289 static /* signed */ int
7290 symcmp (const void *p, const void *q)
7291 {
7292   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7293   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7294
7295   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7296 }
7297
7298 /* Process the unwind section.  */
7299
7300 #include "unwind-ia64.h"
7301
7302 struct ia64_unw_table_entry
7303 {
7304   struct absaddr start;
7305   struct absaddr end;
7306   struct absaddr info;
7307 };
7308
7309 struct ia64_unw_aux_info
7310 {
7311   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7312   unsigned long                 table_len;      /* Length of unwind table.  */
7313   unsigned char *               info;           /* Unwind info.  */
7314   unsigned long                 info_size;      /* Size of unwind info.  */
7315   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7316   bfd_vma                       seg_base;       /* Starting address of segment.  */
7317   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7318   unsigned long                 nsyms;          /* Number of symbols.  */
7319   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7320   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7321   char *                        strtab;         /* The string table.  */
7322   unsigned long                 strtab_size;    /* Size of string table.  */
7323 };
7324
7325 static bfd_boolean
7326 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7327 {
7328   struct ia64_unw_table_entry * tp;
7329   unsigned long j, nfuns;
7330   int in_body;
7331   bfd_boolean res = TRUE;
7332
7333   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7334   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7335     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7336       aux->funtab[nfuns++] = aux->symtab[j];
7337   aux->nfuns = nfuns;
7338   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7339
7340   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7341     {
7342       bfd_vma stamp;
7343       bfd_vma offset;
7344       const unsigned char * dp;
7345       const unsigned char * head;
7346       const unsigned char * end;
7347       const char * procname;
7348
7349       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7350                                aux->strtab_size, tp->start, &procname, &offset);
7351
7352       fputs ("\n<", stdout);
7353
7354       if (procname)
7355         {
7356           fputs (procname, stdout);
7357
7358           if (offset)
7359             printf ("+%lx", (unsigned long) offset);
7360         }
7361
7362       fputs (">: [", stdout);
7363       print_vma (tp->start.offset, PREFIX_HEX);
7364       fputc ('-', stdout);
7365       print_vma (tp->end.offset, PREFIX_HEX);
7366       printf ("], info at +0x%lx\n",
7367               (unsigned long) (tp->info.offset - aux->seg_base));
7368
7369       /* PR 17531: file: 86232b32.  */
7370       if (aux->info == NULL)
7371         continue;
7372
7373       /* PR 17531: file: 0997b4d1.  */
7374       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7375         {
7376           warn (_("Invalid offset %lx in table entry %ld\n"),
7377                 (long) tp->info.offset, (long) (tp - aux->table));
7378           res = FALSE;
7379           continue;
7380         }
7381
7382       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7383       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7384
7385       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7386               (unsigned) UNW_VER (stamp),
7387               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7388               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7389               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7390               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7391
7392       if (UNW_VER (stamp) != 1)
7393         {
7394           printf (_("\tUnknown version.\n"));
7395           continue;
7396         }
7397
7398       in_body = 0;
7399       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7400       /* PR 17531: file: 16ceda89.  */
7401       if (end > aux->info + aux->info_size)
7402         end = aux->info + aux->info_size;
7403       for (dp = head + 8; dp < end;)
7404         dp = unw_decode (dp, in_body, & in_body, end);
7405     }
7406
7407   free (aux->funtab);
7408
7409   return res;
7410 }
7411
7412 static bfd_boolean
7413 slurp_ia64_unwind_table (Filedata *                  filedata,
7414                          struct ia64_unw_aux_info *  aux,
7415                          Elf_Internal_Shdr *         sec)
7416 {
7417   unsigned long size, nrelas, i;
7418   Elf_Internal_Phdr * seg;
7419   struct ia64_unw_table_entry * tep;
7420   Elf_Internal_Shdr * relsec;
7421   Elf_Internal_Rela * rela;
7422   Elf_Internal_Rela * rp;
7423   unsigned char * table;
7424   unsigned char * tp;
7425   Elf_Internal_Sym * sym;
7426   const char * relname;
7427
7428   aux->table_len = 0;
7429
7430   /* First, find the starting address of the segment that includes
7431      this section: */
7432
7433   if (filedata->file_header.e_phnum)
7434     {
7435       if (! get_program_headers (filedata))
7436           return FALSE;
7437
7438       for (seg = filedata->program_headers;
7439            seg < filedata->program_headers + filedata->file_header.e_phnum;
7440            ++seg)
7441         {
7442           if (seg->p_type != PT_LOAD)
7443             continue;
7444
7445           if (sec->sh_addr >= seg->p_vaddr
7446               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7447             {
7448               aux->seg_base = seg->p_vaddr;
7449               break;
7450             }
7451         }
7452     }
7453
7454   /* Second, build the unwind table from the contents of the unwind section:  */
7455   size = sec->sh_size;
7456   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7457                                       _("unwind table"));
7458   if (!table)
7459     return FALSE;
7460
7461   aux->table_len = size / (3 * eh_addr_size);
7462   aux->table = (struct ia64_unw_table_entry *)
7463     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7464   tep = aux->table;
7465
7466   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7467     {
7468       tep->start.section = SHN_UNDEF;
7469       tep->end.section   = SHN_UNDEF;
7470       tep->info.section  = SHN_UNDEF;
7471       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7472       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7473       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7474       tep->start.offset += aux->seg_base;
7475       tep->end.offset   += aux->seg_base;
7476       tep->info.offset  += aux->seg_base;
7477     }
7478   free (table);
7479
7480   /* Third, apply any relocations to the unwind table:  */
7481   for (relsec = filedata->section_headers;
7482        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7483        ++relsec)
7484     {
7485       if (relsec->sh_type != SHT_RELA
7486           || relsec->sh_info >= filedata->file_header.e_shnum
7487           || filedata->section_headers + relsec->sh_info != sec)
7488         continue;
7489
7490       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7491                               & rela, & nrelas))
7492         {
7493           free (aux->table);
7494           aux->table = NULL;
7495           aux->table_len = 0;
7496           return FALSE;
7497         }
7498
7499       for (rp = rela; rp < rela + nrelas; ++rp)
7500         {
7501           relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7502           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7503
7504           /* PR 17531: file: 9fa67536.  */
7505           if (relname == NULL)
7506             {
7507               warn (_("Skipping unknown relocation type: %u\n"),
7508                     get_reloc_type (filedata, rp->r_info));
7509               continue;
7510             }
7511
7512           if (! const_strneq (relname, "R_IA64_SEGREL"))
7513             {
7514               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7515               continue;
7516             }
7517
7518           i = rp->r_offset / (3 * eh_addr_size);
7519
7520           /* PR 17531: file: 5bc8d9bf.  */
7521           if (i >= aux->table_len)
7522             {
7523               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7524               continue;
7525             }
7526
7527           switch (rp->r_offset / eh_addr_size % 3)
7528             {
7529             case 0:
7530               aux->table[i].start.section = sym->st_shndx;
7531               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7532               break;
7533             case 1:
7534               aux->table[i].end.section   = sym->st_shndx;
7535               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7536               break;
7537             case 2:
7538               aux->table[i].info.section  = sym->st_shndx;
7539               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7540               break;
7541             default:
7542               break;
7543             }
7544         }
7545
7546       free (rela);
7547     }
7548
7549   return TRUE;
7550 }
7551
7552 static bfd_boolean
7553 ia64_process_unwind (Filedata * filedata)
7554 {
7555   Elf_Internal_Shdr * sec;
7556   Elf_Internal_Shdr * unwsec = NULL;
7557   Elf_Internal_Shdr * strsec;
7558   unsigned long i, unwcount = 0, unwstart = 0;
7559   struct ia64_unw_aux_info aux;
7560   bfd_boolean res = TRUE;
7561
7562   memset (& aux, 0, sizeof (aux));
7563
7564   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7565     {
7566       if (sec->sh_type == SHT_SYMTAB
7567           && sec->sh_link < filedata->file_header.e_shnum)
7568         {
7569           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7570
7571           strsec = filedata->section_headers + sec->sh_link;
7572           if (aux.strtab != NULL)
7573             {
7574               error (_("Multiple auxillary string tables encountered\n"));
7575               free (aux.strtab);
7576               res = FALSE;
7577             }
7578           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7579                                           1, strsec->sh_size,
7580                                           _("string table"));
7581           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7582         }
7583       else if (sec->sh_type == SHT_IA_64_UNWIND)
7584         unwcount++;
7585     }
7586
7587   if (!unwcount)
7588     printf (_("\nThere are no unwind sections in this file.\n"));
7589
7590   while (unwcount-- > 0)
7591     {
7592       char * suffix;
7593       size_t len, len2;
7594
7595       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7596            i < filedata->file_header.e_shnum; ++i, ++sec)
7597         if (sec->sh_type == SHT_IA_64_UNWIND)
7598           {
7599             unwsec = sec;
7600             break;
7601           }
7602       /* We have already counted the number of SHT_IA64_UNWIND
7603          sections so the loop above should never fail.  */
7604       assert (unwsec != NULL);
7605
7606       unwstart = i + 1;
7607       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7608
7609       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7610         {
7611           /* We need to find which section group it is in.  */
7612           struct group_list * g;
7613
7614           if (section_headers_groups == NULL
7615               || section_headers_groups [i] == NULL)
7616             i = filedata->file_header.e_shnum;
7617           else
7618             {
7619               g = section_headers_groups [i]->root;
7620
7621               for (; g != NULL; g = g->next)
7622                 {
7623                   sec = filedata->section_headers + g->section_index;
7624
7625                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7626                     break;
7627                 }
7628
7629               if (g == NULL)
7630                 i = filedata->file_header.e_shnum;
7631             }
7632         }
7633       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7634         {
7635           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7636           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7637           suffix = SECTION_NAME (unwsec) + len;
7638           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7639                ++i, ++sec)
7640             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7641                 && streq (SECTION_NAME (sec) + len2, suffix))
7642               break;
7643         }
7644       else
7645         {
7646           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7647              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7648           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7649           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7650           suffix = "";
7651           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7652             suffix = SECTION_NAME (unwsec) + len;
7653           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7654                ++i, ++sec)
7655             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7656                 && streq (SECTION_NAME (sec) + len2, suffix))
7657               break;
7658         }
7659
7660       if (i == filedata->file_header.e_shnum)
7661         {
7662           printf (_("\nCould not find unwind info section for "));
7663
7664           if (filedata->string_table == NULL)
7665             printf ("%d", unwsec->sh_name);
7666           else
7667             printf ("'%s'", printable_section_name (filedata, unwsec));
7668         }
7669       else
7670         {
7671           aux.info_addr = sec->sh_addr;
7672           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7673                                                  sec->sh_size,
7674                                                  _("unwind info"));
7675           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7676
7677           printf (_("\nUnwind section "));
7678
7679           if (filedata->string_table == NULL)
7680             printf ("%d", unwsec->sh_name);
7681           else
7682             printf ("'%s'", printable_section_name (filedata, unwsec));
7683
7684           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7685                   (unsigned long) unwsec->sh_offset,
7686                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7687
7688           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7689               && aux.table_len > 0)
7690             dump_ia64_unwind (filedata, & aux);
7691
7692           if (aux.table)
7693             free ((char *) aux.table);
7694           if (aux.info)
7695             free ((char *) aux.info);
7696           aux.table = NULL;
7697           aux.info = NULL;
7698         }
7699     }
7700
7701   if (aux.symtab)
7702     free (aux.symtab);
7703   if (aux.strtab)
7704     free ((char *) aux.strtab);
7705
7706   return res;
7707 }
7708
7709 struct hppa_unw_table_entry
7710 {
7711   struct absaddr start;
7712   struct absaddr end;
7713   unsigned int Cannot_unwind:1;                 /* 0 */
7714   unsigned int Millicode:1;                     /* 1 */
7715   unsigned int Millicode_save_sr0:1;            /* 2 */
7716   unsigned int Region_description:2;            /* 3..4 */
7717   unsigned int reserved1:1;                     /* 5 */
7718   unsigned int Entry_SR:1;                      /* 6 */
7719   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7720   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7721   unsigned int Args_stored:1;                   /* 16 */
7722   unsigned int Variable_Frame:1;                /* 17 */
7723   unsigned int Separate_Package_Body:1;         /* 18 */
7724   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7725   unsigned int Stack_Overflow_Check:1;          /* 20 */
7726   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7727   unsigned int Ada_Region:1;                    /* 22 */
7728   unsigned int cxx_info:1;                      /* 23 */
7729   unsigned int cxx_try_catch:1;                 /* 24 */
7730   unsigned int sched_entry_seq:1;               /* 25 */
7731   unsigned int reserved2:1;                     /* 26 */
7732   unsigned int Save_SP:1;                       /* 27 */
7733   unsigned int Save_RP:1;                       /* 28 */
7734   unsigned int Save_MRP_in_frame:1;             /* 29 */
7735   unsigned int extn_ptr_defined:1;              /* 30 */
7736   unsigned int Cleanup_defined:1;               /* 31 */
7737
7738   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7739   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7740   unsigned int Large_frame:1;                   /* 2 */
7741   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7742   unsigned int reserved4:1;                     /* 4 */
7743   unsigned int Total_frame_size:27;             /* 5..31 */
7744 };
7745
7746 struct hppa_unw_aux_info
7747 {
7748   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7749   unsigned long                  table_len;     /* Length of unwind table.  */
7750   bfd_vma                        seg_base;      /* Starting address of segment.  */
7751   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7752   unsigned long                  nsyms;         /* Number of symbols.  */
7753   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7754   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7755   char *                         strtab;        /* The string table.  */
7756   unsigned long                  strtab_size;   /* Size of string table.  */
7757 };
7758
7759 static bfd_boolean
7760 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7761 {
7762   struct hppa_unw_table_entry * tp;
7763   unsigned long j, nfuns;
7764   bfd_boolean res = TRUE;
7765
7766   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7767   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7768     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7769       aux->funtab[nfuns++] = aux->symtab[j];
7770   aux->nfuns = nfuns;
7771   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7772
7773   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7774     {
7775       bfd_vma offset;
7776       const char * procname;
7777
7778       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7779                                aux->strtab_size, tp->start, &procname,
7780                                &offset);
7781
7782       fputs ("\n<", stdout);
7783
7784       if (procname)
7785         {
7786           fputs (procname, stdout);
7787
7788           if (offset)
7789             printf ("+%lx", (unsigned long) offset);
7790         }
7791
7792       fputs (">: [", stdout);
7793       print_vma (tp->start.offset, PREFIX_HEX);
7794       fputc ('-', stdout);
7795       print_vma (tp->end.offset, PREFIX_HEX);
7796       printf ("]\n\t");
7797
7798 #define PF(_m) if (tp->_m) printf (#_m " ");
7799 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7800       PF(Cannot_unwind);
7801       PF(Millicode);
7802       PF(Millicode_save_sr0);
7803       /* PV(Region_description);  */
7804       PF(Entry_SR);
7805       PV(Entry_FR);
7806       PV(Entry_GR);
7807       PF(Args_stored);
7808       PF(Variable_Frame);
7809       PF(Separate_Package_Body);
7810       PF(Frame_Extension_Millicode);
7811       PF(Stack_Overflow_Check);
7812       PF(Two_Instruction_SP_Increment);
7813       PF(Ada_Region);
7814       PF(cxx_info);
7815       PF(cxx_try_catch);
7816       PF(sched_entry_seq);
7817       PF(Save_SP);
7818       PF(Save_RP);
7819       PF(Save_MRP_in_frame);
7820       PF(extn_ptr_defined);
7821       PF(Cleanup_defined);
7822       PF(MPE_XL_interrupt_marker);
7823       PF(HP_UX_interrupt_marker);
7824       PF(Large_frame);
7825       PF(Pseudo_SP_Set);
7826       PV(Total_frame_size);
7827 #undef PF
7828 #undef PV
7829     }
7830
7831   printf ("\n");
7832
7833   free (aux->funtab);
7834
7835   return res;
7836 }
7837
7838 static bfd_boolean
7839 slurp_hppa_unwind_table (Filedata *                  filedata,
7840                          struct hppa_unw_aux_info *  aux,
7841                          Elf_Internal_Shdr *         sec)
7842 {
7843   unsigned long size, unw_ent_size, nentries, nrelas, i;
7844   Elf_Internal_Phdr * seg;
7845   struct hppa_unw_table_entry * tep;
7846   Elf_Internal_Shdr * relsec;
7847   Elf_Internal_Rela * rela;
7848   Elf_Internal_Rela * rp;
7849   unsigned char * table;
7850   unsigned char * tp;
7851   Elf_Internal_Sym * sym;
7852   const char * relname;
7853
7854   /* First, find the starting address of the segment that includes
7855      this section.  */
7856   if (filedata->file_header.e_phnum)
7857     {
7858       if (! get_program_headers (filedata))
7859         return FALSE;
7860
7861       for (seg = filedata->program_headers;
7862            seg < filedata->program_headers + filedata->file_header.e_phnum;
7863            ++seg)
7864         {
7865           if (seg->p_type != PT_LOAD)
7866             continue;
7867
7868           if (sec->sh_addr >= seg->p_vaddr
7869               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7870             {
7871               aux->seg_base = seg->p_vaddr;
7872               break;
7873             }
7874         }
7875     }
7876
7877   /* Second, build the unwind table from the contents of the unwind
7878      section.  */
7879   size = sec->sh_size;
7880   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7881                                       _("unwind table"));
7882   if (!table)
7883     return FALSE;
7884
7885   unw_ent_size = 16;
7886   nentries = size / unw_ent_size;
7887   size = unw_ent_size * nentries;
7888
7889   tep = aux->table = (struct hppa_unw_table_entry *)
7890       xcmalloc (nentries, sizeof (aux->table[0]));
7891
7892   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7893     {
7894       unsigned int tmp1, tmp2;
7895
7896       tep->start.section = SHN_UNDEF;
7897       tep->end.section   = SHN_UNDEF;
7898
7899       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7900       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7901       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7902       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7903
7904       tep->start.offset += aux->seg_base;
7905       tep->end.offset   += aux->seg_base;
7906
7907       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7908       tep->Millicode = (tmp1 >> 30) & 0x1;
7909       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7910       tep->Region_description = (tmp1 >> 27) & 0x3;
7911       tep->reserved1 = (tmp1 >> 26) & 0x1;
7912       tep->Entry_SR = (tmp1 >> 25) & 0x1;
7913       tep->Entry_FR = (tmp1 >> 21) & 0xf;
7914       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7915       tep->Args_stored = (tmp1 >> 15) & 0x1;
7916       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7917       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7918       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7919       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7920       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7921       tep->Ada_Region = (tmp1 >> 9) & 0x1;
7922       tep->cxx_info = (tmp1 >> 8) & 0x1;
7923       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7924       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7925       tep->reserved2 = (tmp1 >> 5) & 0x1;
7926       tep->Save_SP = (tmp1 >> 4) & 0x1;
7927       tep->Save_RP = (tmp1 >> 3) & 0x1;
7928       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7929       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7930       tep->Cleanup_defined = tmp1 & 0x1;
7931
7932       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7933       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7934       tep->Large_frame = (tmp2 >> 29) & 0x1;
7935       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7936       tep->reserved4 = (tmp2 >> 27) & 0x1;
7937       tep->Total_frame_size = tmp2 & 0x7ffffff;
7938     }
7939   free (table);
7940
7941   /* Third, apply any relocations to the unwind table.  */
7942   for (relsec = filedata->section_headers;
7943        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7944        ++relsec)
7945     {
7946       if (relsec->sh_type != SHT_RELA
7947           || relsec->sh_info >= filedata->file_header.e_shnum
7948           || filedata->section_headers + relsec->sh_info != sec)
7949         continue;
7950
7951       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7952                               & rela, & nrelas))
7953         return FALSE;
7954
7955       for (rp = rela; rp < rela + nrelas; ++rp)
7956         {
7957           relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
7958           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7959
7960           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
7961           if (! const_strneq (relname, "R_PARISC_SEGREL"))
7962             {
7963               warn (_("Skipping unexpected relocation type %s\n"), relname);
7964               continue;
7965             }
7966
7967           i = rp->r_offset / unw_ent_size;
7968
7969           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7970             {
7971             case 0:
7972               aux->table[i].start.section = sym->st_shndx;
7973               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
7974               break;
7975             case 1:
7976               aux->table[i].end.section   = sym->st_shndx;
7977               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
7978               break;
7979             default:
7980               break;
7981             }
7982         }
7983
7984       free (rela);
7985     }
7986
7987   aux->table_len = nentries;
7988
7989   return TRUE;
7990 }
7991
7992 static bfd_boolean
7993 hppa_process_unwind (Filedata * filedata)
7994 {
7995   struct hppa_unw_aux_info aux;
7996   Elf_Internal_Shdr * unwsec = NULL;
7997   Elf_Internal_Shdr * strsec;
7998   Elf_Internal_Shdr * sec;
7999   unsigned long i;
8000   bfd_boolean res = TRUE;
8001
8002   if (filedata->string_table == NULL)
8003     return FALSE;
8004
8005   memset (& aux, 0, sizeof (aux));
8006
8007   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8008     {
8009       if (sec->sh_type == SHT_SYMTAB
8010           && sec->sh_link < filedata->file_header.e_shnum)
8011         {
8012           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8013
8014           strsec = filedata->section_headers + sec->sh_link;
8015           if (aux.strtab != NULL)
8016             {
8017               error (_("Multiple auxillary string tables encountered\n"));
8018               free (aux.strtab);
8019               res = FALSE;
8020             }
8021           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8022                                           1, strsec->sh_size,
8023                                           _("string table"));
8024           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8025         }
8026       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8027         unwsec = sec;
8028     }
8029
8030   if (!unwsec)
8031     printf (_("\nThere are no unwind sections in this file.\n"));
8032
8033   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8034     {
8035       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8036         {
8037           unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8038
8039           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8040                             "contains %lu entry:\n",
8041                             "\nUnwind section '%s' at offset 0x%lx "
8042                             "contains %lu entries:\n",
8043                             num_unwind),
8044                   printable_section_name (filedata, sec),
8045                   (unsigned long) sec->sh_offset,
8046                   num_unwind);
8047
8048           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8049             res = FALSE;
8050
8051           if (aux.table_len > 0)
8052             {
8053               if (! dump_hppa_unwind (filedata, &aux))
8054                 res = FALSE;
8055             }
8056
8057           if (aux.table)
8058             free ((char *) aux.table);
8059           aux.table = NULL;
8060         }
8061     }
8062
8063   if (aux.symtab)
8064     free (aux.symtab);
8065   if (aux.strtab)
8066     free ((char *) aux.strtab);
8067
8068   return res;
8069 }
8070
8071 struct arm_section
8072 {
8073   unsigned char *      data;            /* The unwind data.  */
8074   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8075   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8076   unsigned long        nrelas;          /* The number of relocations.  */
8077   unsigned int         rel_type;        /* REL or RELA ?  */
8078   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8079 };
8080
8081 struct arm_unw_aux_info
8082 {
8083   Filedata *          filedata;         /* The file containing the unwind sections.  */
8084   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8085   unsigned long       nsyms;            /* Number of symbols.  */
8086   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8087   unsigned long       nfuns;            /* Number of these symbols.  */
8088   char *              strtab;           /* The file's string table.  */
8089   unsigned long       strtab_size;      /* Size of string table.  */
8090 };
8091
8092 static const char *
8093 arm_print_vma_and_name (Filedata *                 filedata,
8094                         struct arm_unw_aux_info *  aux,
8095                         bfd_vma                    fn,
8096                         struct absaddr             addr)
8097 {
8098   const char *procname;
8099   bfd_vma sym_offset;
8100
8101   if (addr.section == SHN_UNDEF)
8102     addr.offset = fn;
8103
8104   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8105                            aux->strtab_size, addr, &procname,
8106                            &sym_offset);
8107
8108   print_vma (fn, PREFIX_HEX);
8109
8110   if (procname)
8111     {
8112       fputs (" <", stdout);
8113       fputs (procname, stdout);
8114
8115       if (sym_offset)
8116         printf ("+0x%lx", (unsigned long) sym_offset);
8117       fputc ('>', stdout);
8118     }
8119
8120   return procname;
8121 }
8122
8123 static void
8124 arm_free_section (struct arm_section *arm_sec)
8125 {
8126   if (arm_sec->data != NULL)
8127     free (arm_sec->data);
8128
8129   if (arm_sec->rela != NULL)
8130     free (arm_sec->rela);
8131 }
8132
8133 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8134       cached section and install SEC instead.
8135    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8136       and return its valued in * WORDP, relocating if necessary.
8137    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8138       relocation's offset in ADDR.
8139    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8140       into the string table of the symbol associated with the reloc.  If no
8141       reloc was applied store -1 there.
8142    5) Return TRUE upon success, FALSE otherwise.  */
8143
8144 static bfd_boolean
8145 get_unwind_section_word (Filedata *                 filedata,
8146                          struct arm_unw_aux_info *  aux,
8147                          struct arm_section *       arm_sec,
8148                          Elf_Internal_Shdr *        sec,
8149                          bfd_vma                    word_offset,
8150                          unsigned int *             wordp,
8151                          struct absaddr *           addr,
8152                          bfd_vma *                  sym_name)
8153 {
8154   Elf_Internal_Rela *rp;
8155   Elf_Internal_Sym *sym;
8156   const char * relname;
8157   unsigned int word;
8158   bfd_boolean wrapped;
8159
8160   if (sec == NULL || arm_sec == NULL)
8161     return FALSE;
8162
8163   addr->section = SHN_UNDEF;
8164   addr->offset = 0;
8165
8166   if (sym_name != NULL)
8167     *sym_name = (bfd_vma) -1;
8168
8169   /* If necessary, update the section cache.  */
8170   if (sec != arm_sec->sec)
8171     {
8172       Elf_Internal_Shdr *relsec;
8173
8174       arm_free_section (arm_sec);
8175
8176       arm_sec->sec = sec;
8177       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8178                                 sec->sh_size, _("unwind data"));
8179       arm_sec->rela = NULL;
8180       arm_sec->nrelas = 0;
8181
8182       for (relsec = filedata->section_headers;
8183            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8184            ++relsec)
8185         {
8186           if (relsec->sh_info >= filedata->file_header.e_shnum
8187               || filedata->section_headers + relsec->sh_info != sec
8188               /* PR 15745: Check the section type as well.  */
8189               || (relsec->sh_type != SHT_REL
8190                   && relsec->sh_type != SHT_RELA))
8191             continue;
8192
8193           arm_sec->rel_type = relsec->sh_type;
8194           if (relsec->sh_type == SHT_REL)
8195             {
8196               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8197                                      relsec->sh_size,
8198                                      & arm_sec->rela, & arm_sec->nrelas))
8199                 return FALSE;
8200             }
8201           else /* relsec->sh_type == SHT_RELA */
8202             {
8203               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8204                                       relsec->sh_size,
8205                                       & arm_sec->rela, & arm_sec->nrelas))
8206                 return FALSE;
8207             }
8208           break;
8209         }
8210
8211       arm_sec->next_rela = arm_sec->rela;
8212     }
8213
8214   /* If there is no unwind data we can do nothing.  */
8215   if (arm_sec->data == NULL)
8216     return FALSE;
8217
8218   /* If the offset is invalid then fail.  */
8219   if (/* PR 21343 *//* PR 18879 */
8220       sec->sh_size < 4
8221       || word_offset > (sec->sh_size - 4)
8222       || ((bfd_signed_vma) word_offset) < 0)
8223     return FALSE;
8224
8225   /* Get the word at the required offset.  */
8226   word = byte_get (arm_sec->data + word_offset, 4);
8227
8228   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8229   if (arm_sec->rela == NULL)
8230     {
8231       * wordp = word;
8232       return TRUE;
8233     }
8234
8235   /* Look through the relocs to find the one that applies to the provided offset.  */
8236   wrapped = FALSE;
8237   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8238     {
8239       bfd_vma prelval, offset;
8240
8241       if (rp->r_offset > word_offset && !wrapped)
8242         {
8243           rp = arm_sec->rela;
8244           wrapped = TRUE;
8245         }
8246       if (rp->r_offset > word_offset)
8247         break;
8248
8249       if (rp->r_offset & 3)
8250         {
8251           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8252                 (unsigned long) rp->r_offset);
8253           continue;
8254         }
8255
8256       if (rp->r_offset < word_offset)
8257         continue;
8258
8259       /* PR 17531: file: 027-161405-0.004  */
8260       if (aux->symtab == NULL)
8261         continue;
8262
8263       if (arm_sec->rel_type == SHT_REL)
8264         {
8265           offset = word & 0x7fffffff;
8266           if (offset & 0x40000000)
8267             offset |= ~ (bfd_vma) 0x7fffffff;
8268         }
8269       else if (arm_sec->rel_type == SHT_RELA)
8270         offset = rp->r_addend;
8271       else
8272         {
8273           error (_("Unknown section relocation type %d encountered\n"),
8274                  arm_sec->rel_type);
8275           break;
8276         }
8277
8278       /* PR 17531 file: 027-1241568-0.004.  */
8279       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8280         {
8281           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8282                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8283           break;
8284         }
8285
8286       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8287       offset += sym->st_value;
8288       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8289
8290       /* Check that we are processing the expected reloc type.  */
8291       if (filedata->file_header.e_machine == EM_ARM)
8292         {
8293           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8294           if (relname == NULL)
8295             {
8296               warn (_("Skipping unknown ARM relocation type: %d\n"),
8297                     (int) ELF32_R_TYPE (rp->r_info));
8298               continue;
8299             }
8300
8301           if (streq (relname, "R_ARM_NONE"))
8302               continue;
8303
8304           if (! streq (relname, "R_ARM_PREL31"))
8305             {
8306               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8307               continue;
8308             }
8309         }
8310       else if (filedata->file_header.e_machine == EM_TI_C6000)
8311         {
8312           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8313           if (relname == NULL)
8314             {
8315               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8316                     (int) ELF32_R_TYPE (rp->r_info));
8317               continue;
8318             }
8319
8320           if (streq (relname, "R_C6000_NONE"))
8321             continue;
8322
8323           if (! streq (relname, "R_C6000_PREL31"))
8324             {
8325               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8326               continue;
8327             }
8328
8329           prelval >>= 1;
8330         }
8331       else
8332         {
8333           /* This function currently only supports ARM and TI unwinders.  */
8334           warn (_("Only TI and ARM unwinders are currently supported\n"));
8335           break;
8336         }
8337
8338       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8339       addr->section = sym->st_shndx;
8340       addr->offset = offset;
8341
8342       if (sym_name)
8343         * sym_name = sym->st_name;
8344       break;
8345     }
8346
8347   *wordp = word;
8348   arm_sec->next_rela = rp;
8349
8350   return TRUE;
8351 }
8352
8353 static const char *tic6x_unwind_regnames[16] =
8354 {
8355   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8356   "A14", "A13", "A12", "A11", "A10",
8357   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8358 };
8359
8360 static void
8361 decode_tic6x_unwind_regmask (unsigned int mask)
8362 {
8363   int i;
8364
8365   for (i = 12; mask; mask >>= 1, i--)
8366     {
8367       if (mask & 1)
8368         {
8369           fputs (tic6x_unwind_regnames[i], stdout);
8370           if (mask > 1)
8371             fputs (", ", stdout);
8372         }
8373     }
8374 }
8375
8376 #define ADVANCE                                                 \
8377   if (remaining == 0 && more_words)                             \
8378     {                                                           \
8379       data_offset += 4;                                         \
8380       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8381                                      data_offset, & word, & addr, NULL))        \
8382         return FALSE;                                           \
8383       remaining = 4;                                            \
8384       more_words--;                                             \
8385     }                                                           \
8386
8387 #define GET_OP(OP)                      \
8388   ADVANCE;                              \
8389   if (remaining)                        \
8390     {                                   \
8391       remaining--;                      \
8392       (OP) = word >> 24;                \
8393       word <<= 8;                       \
8394     }                                   \
8395   else                                  \
8396     {                                   \
8397       printf (_("[Truncated opcode]\n"));       \
8398       return FALSE;                     \
8399     }                                   \
8400   printf ("0x%02x ", OP)
8401
8402 static bfd_boolean
8403 decode_arm_unwind_bytecode (Filedata *                 filedata,
8404                             struct arm_unw_aux_info *  aux,
8405                             unsigned int               word,
8406                             unsigned int               remaining,
8407                             unsigned int               more_words,
8408                             bfd_vma                    data_offset,
8409                             Elf_Internal_Shdr *        data_sec,
8410                             struct arm_section *       data_arm_sec)
8411 {
8412   struct absaddr addr;
8413   bfd_boolean res = TRUE;
8414
8415   /* Decode the unwinding instructions.  */
8416   while (1)
8417     {
8418       unsigned int op, op2;
8419
8420       ADVANCE;
8421       if (remaining == 0)
8422         break;
8423       remaining--;
8424       op = word >> 24;
8425       word <<= 8;
8426
8427       printf ("  0x%02x ", op);
8428
8429       if ((op & 0xc0) == 0x00)
8430         {
8431           int offset = ((op & 0x3f) << 2) + 4;
8432
8433           printf ("     vsp = vsp + %d", offset);
8434         }
8435       else if ((op & 0xc0) == 0x40)
8436         {
8437           int offset = ((op & 0x3f) << 2) + 4;
8438
8439           printf ("     vsp = vsp - %d", offset);
8440         }
8441       else if ((op & 0xf0) == 0x80)
8442         {
8443           GET_OP (op2);
8444           if (op == 0x80 && op2 == 0)
8445             printf (_("Refuse to unwind"));
8446           else
8447             {
8448               unsigned int mask = ((op & 0x0f) << 8) | op2;
8449               bfd_boolean first = TRUE;
8450               int i;
8451
8452               printf ("pop {");
8453               for (i = 0; i < 12; i++)
8454                 if (mask & (1 << i))
8455                   {
8456                     if (first)
8457                       first = FALSE;
8458                     else
8459                       printf (", ");
8460                     printf ("r%d", 4 + i);
8461                   }
8462               printf ("}");
8463             }
8464         }
8465       else if ((op & 0xf0) == 0x90)
8466         {
8467           if (op == 0x9d || op == 0x9f)
8468             printf (_("     [Reserved]"));
8469           else
8470             printf ("     vsp = r%d", op & 0x0f);
8471         }
8472       else if ((op & 0xf0) == 0xa0)
8473         {
8474           int end = 4 + (op & 0x07);
8475           bfd_boolean first = TRUE;
8476           int i;
8477
8478           printf ("     pop {");
8479           for (i = 4; i <= end; i++)
8480             {
8481               if (first)
8482                 first = FALSE;
8483               else
8484                 printf (", ");
8485               printf ("r%d", i);
8486             }
8487           if (op & 0x08)
8488             {
8489               if (!first)
8490                 printf (", ");
8491               printf ("r14");
8492             }
8493           printf ("}");
8494         }
8495       else if (op == 0xb0)
8496         printf (_("     finish"));
8497       else if (op == 0xb1)
8498         {
8499           GET_OP (op2);
8500           if (op2 == 0 || (op2 & 0xf0) != 0)
8501             printf (_("[Spare]"));
8502           else
8503             {
8504               unsigned int mask = op2 & 0x0f;
8505               bfd_boolean first = TRUE;
8506               int i;
8507
8508               printf ("pop {");
8509               for (i = 0; i < 12; i++)
8510                 if (mask & (1 << i))
8511                   {
8512                     if (first)
8513                       first = FALSE;
8514                     else
8515                       printf (", ");
8516                     printf ("r%d", i);
8517                   }
8518               printf ("}");
8519             }
8520         }
8521       else if (op == 0xb2)
8522         {
8523           unsigned char buf[9];
8524           unsigned int i, len;
8525           unsigned long offset;
8526
8527           for (i = 0; i < sizeof (buf); i++)
8528             {
8529               GET_OP (buf[i]);
8530               if ((buf[i] & 0x80) == 0)
8531                 break;
8532             }
8533           if (i == sizeof (buf))
8534             {
8535               error (_("corrupt change to vsp"));
8536               res = FALSE;
8537             }
8538           else
8539             {
8540               offset = read_uleb128 (buf, &len, buf + i + 1);
8541               assert (len == i + 1);
8542               offset = offset * 4 + 0x204;
8543               printf ("vsp = vsp + %ld", offset);
8544             }
8545         }
8546       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8547         {
8548           unsigned int first, last;
8549
8550           GET_OP (op2);
8551           first = op2 >> 4;
8552           last = op2 & 0x0f;
8553           if (op == 0xc8)
8554             first = first + 16;
8555           printf ("pop {D%d", first);
8556           if (last)
8557             printf ("-D%d", first + last);
8558           printf ("}");
8559         }
8560       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8561         {
8562           unsigned int count = op & 0x07;
8563
8564           printf ("pop {D8");
8565           if (count)
8566             printf ("-D%d", 8 + count);
8567           printf ("}");
8568         }
8569       else if (op >= 0xc0 && op <= 0xc5)
8570         {
8571           unsigned int count = op & 0x07;
8572
8573           printf ("     pop {wR10");
8574           if (count)
8575             printf ("-wR%d", 10 + count);
8576           printf ("}");
8577         }
8578       else if (op == 0xc6)
8579         {
8580           unsigned int first, last;
8581
8582           GET_OP (op2);
8583           first = op2 >> 4;
8584           last = op2 & 0x0f;
8585           printf ("pop {wR%d", first);
8586           if (last)
8587             printf ("-wR%d", first + last);
8588           printf ("}");
8589         }
8590       else if (op == 0xc7)
8591         {
8592           GET_OP (op2);
8593           if (op2 == 0 || (op2 & 0xf0) != 0)
8594             printf (_("[Spare]"));
8595           else
8596             {
8597               unsigned int mask = op2 & 0x0f;
8598               bfd_boolean first = TRUE;
8599               int i;
8600
8601               printf ("pop {");
8602               for (i = 0; i < 4; i++)
8603                 if (mask & (1 << i))
8604                   {
8605                     if (first)
8606                       first = FALSE;
8607                     else
8608                       printf (", ");
8609                     printf ("wCGR%d", i);
8610                   }
8611               printf ("}");
8612             }
8613         }
8614       else
8615         {
8616           printf (_("     [unsupported opcode]"));
8617           res = FALSE;
8618         }
8619
8620       printf ("\n");
8621     }
8622
8623   return res;
8624 }
8625
8626 static bfd_boolean
8627 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8628                               struct arm_unw_aux_info *  aux,
8629                               unsigned int               word,
8630                               unsigned int               remaining,
8631                               unsigned int               more_words,
8632                               bfd_vma                    data_offset,
8633                               Elf_Internal_Shdr *        data_sec,
8634                               struct arm_section *       data_arm_sec)
8635 {
8636   struct absaddr addr;
8637
8638   /* Decode the unwinding instructions.  */
8639   while (1)
8640     {
8641       unsigned int op, op2;
8642
8643       ADVANCE;
8644       if (remaining == 0)
8645         break;
8646       remaining--;
8647       op = word >> 24;
8648       word <<= 8;
8649
8650       printf ("  0x%02x ", op);
8651
8652       if ((op & 0xc0) == 0x00)
8653         {
8654           int offset = ((op & 0x3f) << 3) + 8;
8655           printf ("     sp = sp + %d", offset);
8656         }
8657       else if ((op & 0xc0) == 0x80)
8658         {
8659           GET_OP (op2);
8660           if (op == 0x80 && op2 == 0)
8661             printf (_("Refuse to unwind"));
8662           else
8663             {
8664               unsigned int mask = ((op & 0x1f) << 8) | op2;
8665               if (op & 0x20)
8666                 printf ("pop compact {");
8667               else
8668                 printf ("pop {");
8669
8670               decode_tic6x_unwind_regmask (mask);
8671               printf("}");
8672             }
8673         }
8674       else if ((op & 0xf0) == 0xc0)
8675         {
8676           unsigned int reg;
8677           unsigned int nregs;
8678           unsigned int i;
8679           const char *name;
8680           struct
8681           {
8682             unsigned int offset;
8683             unsigned int reg;
8684           } regpos[16];
8685
8686           /* Scan entire instruction first so that GET_OP output is not
8687              interleaved with disassembly.  */
8688           nregs = 0;
8689           for (i = 0; nregs < (op & 0xf); i++)
8690             {
8691               GET_OP (op2);
8692               reg = op2 >> 4;
8693               if (reg != 0xf)
8694                 {
8695                   regpos[nregs].offset = i * 2;
8696                   regpos[nregs].reg = reg;
8697                   nregs++;
8698                 }
8699
8700               reg = op2 & 0xf;
8701               if (reg != 0xf)
8702                 {
8703                   regpos[nregs].offset = i * 2 + 1;
8704                   regpos[nregs].reg = reg;
8705                   nregs++;
8706                 }
8707             }
8708
8709           printf (_("pop frame {"));
8710           reg = nregs - 1;
8711           for (i = i * 2; i > 0; i--)
8712             {
8713               if (regpos[reg].offset == i - 1)
8714                 {
8715                   name = tic6x_unwind_regnames[regpos[reg].reg];
8716                   if (reg > 0)
8717                     reg--;
8718                 }
8719               else
8720                 name = _("[pad]");
8721
8722               fputs (name, stdout);
8723               if (i > 1)
8724                 printf (", ");
8725             }
8726
8727           printf ("}");
8728         }
8729       else if (op == 0xd0)
8730         printf ("     MOV FP, SP");
8731       else if (op == 0xd1)
8732         printf ("     __c6xabi_pop_rts");
8733       else if (op == 0xd2)
8734         {
8735           unsigned char buf[9];
8736           unsigned int i, len;
8737           unsigned long offset;
8738
8739           for (i = 0; i < sizeof (buf); i++)
8740             {
8741               GET_OP (buf[i]);
8742               if ((buf[i] & 0x80) == 0)
8743                 break;
8744             }
8745           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8746           if (i == sizeof (buf))
8747             {
8748               warn (_("Corrupt stack pointer adjustment detected\n"));
8749               return FALSE;
8750             }
8751
8752           offset = read_uleb128 (buf, &len, buf + i + 1);
8753           assert (len == i + 1);
8754           offset = offset * 8 + 0x408;
8755           printf (_("sp = sp + %ld"), offset);
8756         }
8757       else if ((op & 0xf0) == 0xe0)
8758         {
8759           if ((op & 0x0f) == 7)
8760             printf ("     RETURN");
8761           else
8762             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8763         }
8764       else
8765         {
8766           printf (_("     [unsupported opcode]"));
8767         }
8768       putchar ('\n');
8769     }
8770
8771   return TRUE;
8772 }
8773
8774 static bfd_vma
8775 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8776 {
8777   bfd_vma offset;
8778
8779   offset = word & 0x7fffffff;
8780   if (offset & 0x40000000)
8781     offset |= ~ (bfd_vma) 0x7fffffff;
8782
8783   if (filedata->file_header.e_machine == EM_TI_C6000)
8784     offset <<= 1;
8785
8786   return offset + where;
8787 }
8788
8789 static bfd_boolean
8790 decode_arm_unwind (Filedata *                 filedata,
8791                    struct arm_unw_aux_info *  aux,
8792                    unsigned int               word,
8793                    unsigned int               remaining,
8794                    bfd_vma                    data_offset,
8795                    Elf_Internal_Shdr *        data_sec,
8796                    struct arm_section *       data_arm_sec)
8797 {
8798   int per_index;
8799   unsigned int more_words = 0;
8800   struct absaddr addr;
8801   bfd_vma sym_name = (bfd_vma) -1;
8802   bfd_boolean res = TRUE;
8803
8804   if (remaining == 0)
8805     {
8806       /* Fetch the first word.
8807          Note - when decoding an object file the address extracted
8808          here will always be 0.  So we also pass in the sym_name
8809          parameter so that we can find the symbol associated with
8810          the personality routine.  */
8811       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8812                                      & word, & addr, & sym_name))
8813         return FALSE;
8814
8815       remaining = 4;
8816     }
8817
8818   if ((word & 0x80000000) == 0)
8819     {
8820       /* Expand prel31 for personality routine.  */
8821       bfd_vma fn;
8822       const char *procname;
8823
8824       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8825       printf (_("  Personality routine: "));
8826       if (fn == 0
8827           && addr.section == SHN_UNDEF && addr.offset == 0
8828           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8829         {
8830           procname = aux->strtab + sym_name;
8831           print_vma (fn, PREFIX_HEX);
8832           if (procname)
8833             {
8834               fputs (" <", stdout);
8835               fputs (procname, stdout);
8836               fputc ('>', stdout);
8837             }
8838         }
8839       else
8840         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8841       fputc ('\n', stdout);
8842
8843       /* The GCC personality routines use the standard compact
8844          encoding, starting with one byte giving the number of
8845          words.  */
8846       if (procname != NULL
8847           && (const_strneq (procname, "__gcc_personality_v0")
8848               || const_strneq (procname, "__gxx_personality_v0")
8849               || const_strneq (procname, "__gcj_personality_v0")
8850               || const_strneq (procname, "__gnu_objc_personality_v0")))
8851         {
8852           remaining = 0;
8853           more_words = 1;
8854           ADVANCE;
8855           if (!remaining)
8856             {
8857               printf (_("  [Truncated data]\n"));
8858               return FALSE;
8859             }
8860           more_words = word >> 24;
8861           word <<= 8;
8862           remaining--;
8863           per_index = -1;
8864         }
8865       else
8866         return TRUE;
8867     }
8868   else
8869     {
8870       /* ARM EHABI Section 6.3:
8871
8872          An exception-handling table entry for the compact model looks like:
8873
8874            31 30-28 27-24 23-0
8875            -- ----- ----- ----
8876             1   0   index Data for personalityRoutine[index]    */
8877
8878       if (filedata->file_header.e_machine == EM_ARM
8879           && (word & 0x70000000))
8880         {
8881           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8882           res = FALSE;
8883         }
8884
8885       per_index = (word >> 24) & 0x7f;
8886       printf (_("  Compact model index: %d\n"), per_index);
8887       if (per_index == 0)
8888         {
8889           more_words = 0;
8890           word <<= 8;
8891           remaining--;
8892         }
8893       else if (per_index < 3)
8894         {
8895           more_words = (word >> 16) & 0xff;
8896           word <<= 16;
8897           remaining -= 2;
8898         }
8899     }
8900
8901   switch (filedata->file_header.e_machine)
8902     {
8903     case EM_ARM:
8904       if (per_index < 3)
8905         {
8906           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
8907                                             data_offset, data_sec, data_arm_sec))
8908             res = FALSE;
8909         }
8910       else
8911         {
8912           warn (_("Unknown ARM compact model index encountered\n"));
8913           printf (_("  [reserved]\n"));
8914           res = FALSE;
8915         }
8916       break;
8917
8918     case EM_TI_C6000:
8919       if (per_index < 3)
8920         {
8921           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
8922                                               data_offset, data_sec, data_arm_sec))
8923             res = FALSE;
8924         }
8925       else if (per_index < 5)
8926         {
8927           if (((word >> 17) & 0x7f) == 0x7f)
8928             printf (_("  Restore stack from frame pointer\n"));
8929           else
8930             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
8931           printf (_("  Registers restored: "));
8932           if (per_index == 4)
8933             printf (" (compact) ");
8934           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8935           putchar ('\n');
8936           printf (_("  Return register: %s\n"),
8937                   tic6x_unwind_regnames[word & 0xf]);
8938         }
8939       else
8940         printf (_("  [reserved (%d)]\n"), per_index);
8941       break;
8942
8943     default:
8944       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8945              filedata->file_header.e_machine);
8946       res = FALSE;
8947     }
8948
8949   /* Decode the descriptors.  Not implemented.  */
8950
8951   return res;
8952 }
8953
8954 static bfd_boolean
8955 dump_arm_unwind (Filedata *                 filedata,
8956                  struct arm_unw_aux_info *  aux,
8957                  Elf_Internal_Shdr *        exidx_sec)
8958 {
8959   struct arm_section exidx_arm_sec, extab_arm_sec;
8960   unsigned int i, exidx_len;
8961   unsigned long j, nfuns;
8962   bfd_boolean res = TRUE;
8963
8964   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8965   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8966   exidx_len = exidx_sec->sh_size / 8;
8967
8968   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8969   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8970     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8971       aux->funtab[nfuns++] = aux->symtab[j];
8972   aux->nfuns = nfuns;
8973   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8974
8975   for (i = 0; i < exidx_len; i++)
8976     {
8977       unsigned int exidx_fn, exidx_entry;
8978       struct absaddr fn_addr, entry_addr;
8979       bfd_vma fn;
8980
8981       fputc ('\n', stdout);
8982
8983       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
8984                                      8 * i, & exidx_fn, & fn_addr, NULL)
8985           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
8986                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
8987         {
8988           free (aux->funtab);
8989           arm_free_section (& exidx_arm_sec);
8990           arm_free_section (& extab_arm_sec);
8991           return FALSE;
8992         }
8993
8994       /* ARM EHABI, Section 5:
8995          An index table entry consists of 2 words.
8996          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
8997       if (exidx_fn & 0x80000000)
8998         {
8999           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9000           res = FALSE;
9001         }
9002
9003       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9004
9005       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9006       fputs (": ", stdout);
9007
9008       if (exidx_entry == 1)
9009         {
9010           print_vma (exidx_entry, PREFIX_HEX);
9011           fputs (" [cantunwind]\n", stdout);
9012         }
9013       else if (exidx_entry & 0x80000000)
9014         {
9015           print_vma (exidx_entry, PREFIX_HEX);
9016           fputc ('\n', stdout);
9017           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9018         }
9019       else
9020         {
9021           bfd_vma table, table_offset = 0;
9022           Elf_Internal_Shdr *table_sec;
9023
9024           fputs ("@", stdout);
9025           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9026           print_vma (table, PREFIX_HEX);
9027           printf ("\n");
9028
9029           /* Locate the matching .ARM.extab.  */
9030           if (entry_addr.section != SHN_UNDEF
9031               && entry_addr.section < filedata->file_header.e_shnum)
9032             {
9033               table_sec = filedata->section_headers + entry_addr.section;
9034               table_offset = entry_addr.offset;
9035               /* PR 18879 */
9036               if (table_offset > table_sec->sh_size
9037                   || ((bfd_signed_vma) table_offset) < 0)
9038                 {
9039                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9040                         (unsigned long) table_offset,
9041                         printable_section_name (filedata, table_sec));
9042                   res = FALSE;
9043                   continue;
9044                 }
9045             }
9046           else
9047             {
9048               table_sec = find_section_by_address (filedata, table);
9049               if (table_sec != NULL)
9050                 table_offset = table - table_sec->sh_addr;
9051             }
9052
9053           if (table_sec == NULL)
9054             {
9055               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9056                     (unsigned long) table);
9057               res = FALSE;
9058               continue;
9059             }
9060
9061           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9062                                    &extab_arm_sec))
9063             res = FALSE;
9064         }
9065     }
9066
9067   printf ("\n");
9068
9069   free (aux->funtab);
9070   arm_free_section (&exidx_arm_sec);
9071   arm_free_section (&extab_arm_sec);
9072
9073   return res;
9074 }
9075
9076 /* Used for both ARM and C6X unwinding tables.  */
9077
9078 static bfd_boolean
9079 arm_process_unwind (Filedata * filedata)
9080 {
9081   struct arm_unw_aux_info aux;
9082   Elf_Internal_Shdr *unwsec = NULL;
9083   Elf_Internal_Shdr *strsec;
9084   Elf_Internal_Shdr *sec;
9085   unsigned long i;
9086   unsigned int sec_type;
9087   bfd_boolean res = TRUE;
9088
9089   switch (filedata->file_header.e_machine)
9090     {
9091     case EM_ARM:
9092       sec_type = SHT_ARM_EXIDX;
9093       break;
9094
9095     case EM_TI_C6000:
9096       sec_type = SHT_C6000_UNWIND;
9097       break;
9098
9099     default:
9100       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9101              filedata->file_header.e_machine);
9102       return FALSE;
9103     }
9104
9105   if (filedata->string_table == NULL)
9106     return FALSE;
9107
9108   memset (& aux, 0, sizeof (aux));
9109   aux.filedata = filedata;
9110
9111   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9112     {
9113       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9114         {
9115           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9116
9117           strsec = filedata->section_headers + sec->sh_link;
9118
9119           /* PR binutils/17531 file: 011-12666-0.004.  */
9120           if (aux.strtab != NULL)
9121             {
9122               error (_("Multiple string tables found in file.\n"));
9123               free (aux.strtab);
9124               res = FALSE;
9125             }
9126           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9127                                  1, strsec->sh_size, _("string table"));
9128           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9129         }
9130       else if (sec->sh_type == sec_type)
9131         unwsec = sec;
9132     }
9133
9134   if (unwsec == NULL)
9135     printf (_("\nThere are no unwind sections in this file.\n"));
9136   else
9137     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9138       {
9139         if (sec->sh_type == sec_type)
9140           {
9141             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9142             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9143                               "contains %lu entry:\n",
9144                               "\nUnwind section '%s' at offset 0x%lx "
9145                               "contains %lu entries:\n",
9146                               num_unwind),
9147                     printable_section_name (filedata, sec),
9148                     (unsigned long) sec->sh_offset,
9149                     num_unwind);
9150
9151             if (! dump_arm_unwind (filedata, &aux, sec))
9152               res = FALSE;
9153           }
9154       }
9155
9156   if (aux.symtab)
9157     free (aux.symtab);
9158   if (aux.strtab)
9159     free ((char *) aux.strtab);
9160
9161   return res;
9162 }
9163
9164 static bfd_boolean
9165 process_unwind (Filedata * filedata)
9166 {
9167   struct unwind_handler
9168   {
9169     unsigned int machtype;
9170     bfd_boolean (* handler)(Filedata *);
9171   } handlers[] =
9172   {
9173     { EM_ARM, arm_process_unwind },
9174     { EM_IA_64, ia64_process_unwind },
9175     { EM_PARISC, hppa_process_unwind },
9176     { EM_TI_C6000, arm_process_unwind },
9177     { 0, NULL }
9178   };
9179   int i;
9180
9181   if (!do_unwind)
9182     return TRUE;
9183
9184   for (i = 0; handlers[i].handler != NULL; i++)
9185     if (filedata->file_header.e_machine == handlers[i].machtype)
9186       return handlers[i].handler (filedata);
9187
9188   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9189           get_machine_name (filedata->file_header.e_machine));
9190   return TRUE;
9191 }
9192
9193 static void
9194 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9195 {
9196   switch (entry->d_tag)
9197     {
9198     case DT_MIPS_FLAGS:
9199       if (entry->d_un.d_val == 0)
9200         printf (_("NONE"));
9201       else
9202         {
9203           static const char * opts[] =
9204           {
9205             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9206             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9207             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9208             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9209             "RLD_ORDER_SAFE"
9210           };
9211           unsigned int cnt;
9212           bfd_boolean first = TRUE;
9213
9214           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9215             if (entry->d_un.d_val & (1 << cnt))
9216               {
9217                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9218                 first = FALSE;
9219               }
9220         }
9221       break;
9222
9223     case DT_MIPS_IVERSION:
9224       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9225         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9226       else
9227         {
9228           char buf[40];
9229           sprintf_vma (buf, entry->d_un.d_ptr);
9230           /* Note: coded this way so that there is a single string for translation.  */
9231           printf (_("<corrupt: %s>"), buf);
9232         }
9233       break;
9234
9235     case DT_MIPS_TIME_STAMP:
9236       {
9237         char timebuf[128];
9238         struct tm * tmp;
9239         time_t atime = entry->d_un.d_val;
9240
9241         tmp = gmtime (&atime);
9242         /* PR 17531: file: 6accc532.  */
9243         if (tmp == NULL)
9244           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9245         else
9246           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9247                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9248                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9249         printf (_("Time Stamp: %s"), timebuf);
9250       }
9251       break;
9252
9253     case DT_MIPS_RLD_VERSION:
9254     case DT_MIPS_LOCAL_GOTNO:
9255     case DT_MIPS_CONFLICTNO:
9256     case DT_MIPS_LIBLISTNO:
9257     case DT_MIPS_SYMTABNO:
9258     case DT_MIPS_UNREFEXTNO:
9259     case DT_MIPS_HIPAGENO:
9260     case DT_MIPS_DELTA_CLASS_NO:
9261     case DT_MIPS_DELTA_INSTANCE_NO:
9262     case DT_MIPS_DELTA_RELOC_NO:
9263     case DT_MIPS_DELTA_SYM_NO:
9264     case DT_MIPS_DELTA_CLASSSYM_NO:
9265     case DT_MIPS_COMPACT_SIZE:
9266       print_vma (entry->d_un.d_val, DEC);
9267       break;
9268
9269     default:
9270       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9271     }
9272     putchar ('\n');
9273 }
9274
9275 static void
9276 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9277 {
9278   switch (entry->d_tag)
9279     {
9280     case DT_HP_DLD_FLAGS:
9281       {
9282         static struct
9283         {
9284           long int bit;
9285           const char * str;
9286         }
9287         flags[] =
9288         {
9289           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9290           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9291           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9292           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9293           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9294           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9295           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9296           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9297           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9298           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9299           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9300           { DT_HP_GST, "HP_GST" },
9301           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9302           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9303           { DT_HP_NODELETE, "HP_NODELETE" },
9304           { DT_HP_GROUP, "HP_GROUP" },
9305           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9306         };
9307         bfd_boolean first = TRUE;
9308         size_t cnt;
9309         bfd_vma val = entry->d_un.d_val;
9310
9311         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9312           if (val & flags[cnt].bit)
9313             {
9314               if (! first)
9315                 putchar (' ');
9316               fputs (flags[cnt].str, stdout);
9317               first = FALSE;
9318               val ^= flags[cnt].bit;
9319             }
9320
9321         if (val != 0 || first)
9322           {
9323             if (! first)
9324               putchar (' ');
9325             print_vma (val, HEX);
9326           }
9327       }
9328       break;
9329
9330     default:
9331       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9332       break;
9333     }
9334   putchar ('\n');
9335 }
9336
9337 #ifdef BFD64
9338
9339 /* VMS vs Unix time offset and factor.  */
9340
9341 #define VMS_EPOCH_OFFSET 35067168000000000LL
9342 #define VMS_GRANULARITY_FACTOR 10000000
9343
9344 /* Display a VMS time in a human readable format.  */
9345
9346 static void
9347 print_vms_time (bfd_int64_t vmstime)
9348 {
9349   struct tm *tm;
9350   time_t unxtime;
9351
9352   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9353   tm = gmtime (&unxtime);
9354   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9355           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9356           tm->tm_hour, tm->tm_min, tm->tm_sec);
9357 }
9358 #endif /* BFD64 */
9359
9360 static void
9361 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9362 {
9363   switch (entry->d_tag)
9364     {
9365     case DT_IA_64_PLT_RESERVE:
9366       /* First 3 slots reserved.  */
9367       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9368       printf (" -- ");
9369       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9370       break;
9371
9372     case DT_IA_64_VMS_LINKTIME:
9373 #ifdef BFD64
9374       print_vms_time (entry->d_un.d_val);
9375 #endif
9376       break;
9377
9378     case DT_IA_64_VMS_LNKFLAGS:
9379       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9380       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9381         printf (" CALL_DEBUG");
9382       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9383         printf (" NOP0BUFS");
9384       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9385         printf (" P0IMAGE");
9386       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9387         printf (" MKTHREADS");
9388       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9389         printf (" UPCALLS");
9390       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9391         printf (" IMGSTA");
9392       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9393         printf (" INITIALIZE");
9394       if (entry->d_un.d_val & VMS_LF_MAIN)
9395         printf (" MAIN");
9396       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9397         printf (" EXE_INIT");
9398       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9399         printf (" TBK_IN_IMG");
9400       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9401         printf (" DBG_IN_IMG");
9402       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9403         printf (" TBK_IN_DSF");
9404       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9405         printf (" DBG_IN_DSF");
9406       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9407         printf (" SIGNATURES");
9408       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9409         printf (" REL_SEG_OFF");
9410       break;
9411
9412     default:
9413       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9414       break;
9415     }
9416   putchar ('\n');
9417 }
9418
9419 static bfd_boolean
9420 get_32bit_dynamic_section (Filedata * filedata)
9421 {
9422   Elf32_External_Dyn * edyn;
9423   Elf32_External_Dyn * ext;
9424   Elf_Internal_Dyn * entry;
9425
9426   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9427                                           dynamic_size, _("dynamic section"));
9428   if (!edyn)
9429     return FALSE;
9430
9431   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9432      might not have the luxury of section headers.  Look for the DT_NULL
9433      terminator to determine the number of entries.  */
9434   for (ext = edyn, dynamic_nent = 0;
9435        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9436        ext++)
9437     {
9438       dynamic_nent++;
9439       if (BYTE_GET (ext->d_tag) == DT_NULL)
9440         break;
9441     }
9442
9443   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9444                                                   sizeof (* entry));
9445   if (dynamic_section == NULL)
9446     {
9447       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9448              (unsigned long) dynamic_nent);
9449       free (edyn);
9450       return FALSE;
9451     }
9452
9453   for (ext = edyn, entry = dynamic_section;
9454        entry < dynamic_section + dynamic_nent;
9455        ext++, entry++)
9456     {
9457       entry->d_tag      = BYTE_GET (ext->d_tag);
9458       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9459     }
9460
9461   free (edyn);
9462
9463   return TRUE;
9464 }
9465
9466 static bfd_boolean
9467 get_64bit_dynamic_section (Filedata * filedata)
9468 {
9469   Elf64_External_Dyn * edyn;
9470   Elf64_External_Dyn * ext;
9471   Elf_Internal_Dyn * entry;
9472
9473   /* Read in the data.  */
9474   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9475                                           dynamic_size, _("dynamic section"));
9476   if (!edyn)
9477     return FALSE;
9478
9479   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9480      might not have the luxury of section headers.  Look for the DT_NULL
9481      terminator to determine the number of entries.  */
9482   for (ext = edyn, dynamic_nent = 0;
9483        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9484        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9485        ext++)
9486     {
9487       dynamic_nent++;
9488       if (BYTE_GET (ext->d_tag) == DT_NULL)
9489         break;
9490     }
9491
9492   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9493                                                   sizeof (* entry));
9494   if (dynamic_section == NULL)
9495     {
9496       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9497              (unsigned long) dynamic_nent);
9498       free (edyn);
9499       return FALSE;
9500     }
9501
9502   /* Convert from external to internal formats.  */
9503   for (ext = edyn, entry = dynamic_section;
9504        entry < dynamic_section + dynamic_nent;
9505        ext++, entry++)
9506     {
9507       entry->d_tag      = BYTE_GET (ext->d_tag);
9508       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9509     }
9510
9511   free (edyn);
9512
9513   return TRUE;
9514 }
9515
9516 static void
9517 print_dynamic_flags (bfd_vma flags)
9518 {
9519   bfd_boolean first = TRUE;
9520
9521   while (flags)
9522     {
9523       bfd_vma flag;
9524
9525       flag = flags & - flags;
9526       flags &= ~ flag;
9527
9528       if (first)
9529         first = FALSE;
9530       else
9531         putc (' ', stdout);
9532
9533       switch (flag)
9534         {
9535         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9536         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9537         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9538         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9539         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9540         default:                fputs (_("unknown"), stdout); break;
9541         }
9542     }
9543   puts ("");
9544 }
9545
9546 /* Parse and display the contents of the dynamic section.  */
9547
9548 static bfd_boolean
9549 process_dynamic_section (Filedata * filedata)
9550 {
9551   Elf_Internal_Dyn * entry;
9552
9553   if (dynamic_size == 0)
9554     {
9555       if (do_dynamic)
9556         printf (_("\nThere is no dynamic section in this file.\n"));
9557
9558       return TRUE;
9559     }
9560
9561   if (is_32bit_elf)
9562     {
9563       if (! get_32bit_dynamic_section (filedata))
9564         return FALSE;
9565     }
9566   else
9567     {
9568       if (! get_64bit_dynamic_section (filedata))
9569         return FALSE;
9570     }
9571
9572   /* Find the appropriate symbol table.  */
9573   if (dynamic_symbols == NULL)
9574     {
9575       for (entry = dynamic_section;
9576            entry < dynamic_section + dynamic_nent;
9577            ++entry)
9578         {
9579           Elf_Internal_Shdr section;
9580
9581           if (entry->d_tag != DT_SYMTAB)
9582             continue;
9583
9584           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9585
9586           /* Since we do not know how big the symbol table is,
9587              we default to reading in the entire file (!) and
9588              processing that.  This is overkill, I know, but it
9589              should work.  */
9590           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9591           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9592             {
9593               /* See PR 21379 for a reproducer.  */
9594               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9595               return FALSE;
9596             }
9597
9598           if (archive_file_offset != 0)
9599             section.sh_size = archive_file_size - section.sh_offset;
9600           else
9601             section.sh_size = filedata->file_size - section.sh_offset;
9602
9603           if (is_32bit_elf)
9604             section.sh_entsize = sizeof (Elf32_External_Sym);
9605           else
9606             section.sh_entsize = sizeof (Elf64_External_Sym);
9607           section.sh_name = filedata->string_table_length;
9608
9609           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9610           if (num_dynamic_syms < 1)
9611             {
9612               error (_("Unable to determine the number of symbols to load\n"));
9613               continue;
9614             }
9615         }
9616     }
9617
9618   /* Similarly find a string table.  */
9619   if (dynamic_strings == NULL)
9620     {
9621       for (entry = dynamic_section;
9622            entry < dynamic_section + dynamic_nent;
9623            ++entry)
9624         {
9625           unsigned long offset;
9626           long str_tab_len;
9627
9628           if (entry->d_tag != DT_STRTAB)
9629             continue;
9630
9631           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9632
9633           /* Since we do not know how big the string table is,
9634              we default to reading in the entire file (!) and
9635              processing that.  This is overkill, I know, but it
9636              should work.  */
9637
9638           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9639
9640           if (archive_file_offset != 0)
9641             str_tab_len = archive_file_size - offset;
9642           else
9643             str_tab_len = filedata->file_size;
9644
9645           if (str_tab_len < 1)
9646             {
9647               error
9648                 (_("Unable to determine the length of the dynamic string table\n"));
9649               continue;
9650             }
9651
9652           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9653                                                str_tab_len,
9654                                                _("dynamic string table"));
9655           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9656           break;
9657         }
9658     }
9659
9660   /* And find the syminfo section if available.  */
9661   if (dynamic_syminfo == NULL)
9662     {
9663       unsigned long syminsz = 0;
9664
9665       for (entry = dynamic_section;
9666            entry < dynamic_section + dynamic_nent;
9667            ++entry)
9668         {
9669           if (entry->d_tag == DT_SYMINENT)
9670             {
9671               /* Note: these braces are necessary to avoid a syntax
9672                  error from the SunOS4 C compiler.  */
9673               /* PR binutils/17531: A corrupt file can trigger this test.
9674                  So do not use an assert, instead generate an error message.  */
9675               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9676                 error (_("Bad value (%d) for SYMINENT entry\n"),
9677                        (int) entry->d_un.d_val);
9678             }
9679           else if (entry->d_tag == DT_SYMINSZ)
9680             syminsz = entry->d_un.d_val;
9681           else if (entry->d_tag == DT_SYMINFO)
9682             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9683                                                       syminsz);
9684         }
9685
9686       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9687         {
9688           Elf_External_Syminfo * extsyminfo;
9689           Elf_External_Syminfo * extsym;
9690           Elf_Internal_Syminfo * syminfo;
9691
9692           /* There is a syminfo section.  Read the data.  */
9693           extsyminfo = (Elf_External_Syminfo *)
9694               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9695                         _("symbol information"));
9696           if (!extsyminfo)
9697             return FALSE;
9698
9699           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9700           if (dynamic_syminfo == NULL)
9701             {
9702               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9703                      (unsigned long) syminsz);
9704               return FALSE;
9705             }
9706
9707           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9708           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9709                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9710                ++syminfo, ++extsym)
9711             {
9712               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9713               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9714             }
9715
9716           free (extsyminfo);
9717         }
9718     }
9719
9720   if (do_dynamic && dynamic_addr)
9721     printf (ngettext ("\nDynamic section at offset 0x%lx "
9722                       "contains %lu entry:\n",
9723                       "\nDynamic section at offset 0x%lx "
9724                       "contains %lu entries:\n",
9725                       dynamic_nent),
9726             dynamic_addr, (unsigned long) dynamic_nent);
9727   if (do_dynamic)
9728     printf (_("  Tag        Type                         Name/Value\n"));
9729
9730   for (entry = dynamic_section;
9731        entry < dynamic_section + dynamic_nent;
9732        entry++)
9733     {
9734       if (do_dynamic)
9735         {
9736           const char * dtype;
9737
9738           putchar (' ');
9739           print_vma (entry->d_tag, FULL_HEX);
9740           dtype = get_dynamic_type (filedata, entry->d_tag);
9741           printf (" (%s)%*s", dtype,
9742                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9743         }
9744
9745       switch (entry->d_tag)
9746         {
9747         case DT_FLAGS:
9748           if (do_dynamic)
9749             print_dynamic_flags (entry->d_un.d_val);
9750           break;
9751
9752         case DT_AUXILIARY:
9753         case DT_FILTER:
9754         case DT_CONFIG:
9755         case DT_DEPAUDIT:
9756         case DT_AUDIT:
9757           if (do_dynamic)
9758             {
9759               switch (entry->d_tag)
9760                 {
9761                 case DT_AUXILIARY:
9762                   printf (_("Auxiliary library"));
9763                   break;
9764
9765                 case DT_FILTER:
9766                   printf (_("Filter library"));
9767                   break;
9768
9769                 case DT_CONFIG:
9770                   printf (_("Configuration file"));
9771                   break;
9772
9773                 case DT_DEPAUDIT:
9774                   printf (_("Dependency audit library"));
9775                   break;
9776
9777                 case DT_AUDIT:
9778                   printf (_("Audit library"));
9779                   break;
9780                 }
9781
9782               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9783                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9784               else
9785                 {
9786                   printf (": ");
9787                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9788                   putchar ('\n');
9789                 }
9790             }
9791           break;
9792
9793         case DT_FEATURE:
9794           if (do_dynamic)
9795             {
9796               printf (_("Flags:"));
9797
9798               if (entry->d_un.d_val == 0)
9799                 printf (_(" None\n"));
9800               else
9801                 {
9802                   unsigned long int val = entry->d_un.d_val;
9803
9804                   if (val & DTF_1_PARINIT)
9805                     {
9806                       printf (" PARINIT");
9807                       val ^= DTF_1_PARINIT;
9808                     }
9809                   if (val & DTF_1_CONFEXP)
9810                     {
9811                       printf (" CONFEXP");
9812                       val ^= DTF_1_CONFEXP;
9813                     }
9814                   if (val != 0)
9815                     printf (" %lx", val);
9816                   puts ("");
9817                 }
9818             }
9819           break;
9820
9821         case DT_POSFLAG_1:
9822           if (do_dynamic)
9823             {
9824               printf (_("Flags:"));
9825
9826               if (entry->d_un.d_val == 0)
9827                 printf (_(" None\n"));
9828               else
9829                 {
9830                   unsigned long int val = entry->d_un.d_val;
9831
9832                   if (val & DF_P1_LAZYLOAD)
9833                     {
9834                       printf (" LAZYLOAD");
9835                       val ^= DF_P1_LAZYLOAD;
9836                     }
9837                   if (val & DF_P1_GROUPPERM)
9838                     {
9839                       printf (" GROUPPERM");
9840                       val ^= DF_P1_GROUPPERM;
9841                     }
9842                   if (val != 0)
9843                     printf (" %lx", val);
9844                   puts ("");
9845                 }
9846             }
9847           break;
9848
9849         case DT_FLAGS_1:
9850           if (do_dynamic)
9851             {
9852               printf (_("Flags:"));
9853               if (entry->d_un.d_val == 0)
9854                 printf (_(" None\n"));
9855               else
9856                 {
9857                   unsigned long int val = entry->d_un.d_val;
9858
9859                   if (val & DF_1_NOW)
9860                     {
9861                       printf (" NOW");
9862                       val ^= DF_1_NOW;
9863                     }
9864                   if (val & DF_1_GLOBAL)
9865                     {
9866                       printf (" GLOBAL");
9867                       val ^= DF_1_GLOBAL;
9868                     }
9869                   if (val & DF_1_GROUP)
9870                     {
9871                       printf (" GROUP");
9872                       val ^= DF_1_GROUP;
9873                     }
9874                   if (val & DF_1_NODELETE)
9875                     {
9876                       printf (" NODELETE");
9877                       val ^= DF_1_NODELETE;
9878                     }
9879                   if (val & DF_1_LOADFLTR)
9880                     {
9881                       printf (" LOADFLTR");
9882                       val ^= DF_1_LOADFLTR;
9883                     }
9884                   if (val & DF_1_INITFIRST)
9885                     {
9886                       printf (" INITFIRST");
9887                       val ^= DF_1_INITFIRST;
9888                     }
9889                   if (val & DF_1_NOOPEN)
9890                     {
9891                       printf (" NOOPEN");
9892                       val ^= DF_1_NOOPEN;
9893                     }
9894                   if (val & DF_1_ORIGIN)
9895                     {
9896                       printf (" ORIGIN");
9897                       val ^= DF_1_ORIGIN;
9898                     }
9899                   if (val & DF_1_DIRECT)
9900                     {
9901                       printf (" DIRECT");
9902                       val ^= DF_1_DIRECT;
9903                     }
9904                   if (val & DF_1_TRANS)
9905                     {
9906                       printf (" TRANS");
9907                       val ^= DF_1_TRANS;
9908                     }
9909                   if (val & DF_1_INTERPOSE)
9910                     {
9911                       printf (" INTERPOSE");
9912                       val ^= DF_1_INTERPOSE;
9913                     }
9914                   if (val & DF_1_NODEFLIB)
9915                     {
9916                       printf (" NODEFLIB");
9917                       val ^= DF_1_NODEFLIB;
9918                     }
9919                   if (val & DF_1_NODUMP)
9920                     {
9921                       printf (" NODUMP");
9922                       val ^= DF_1_NODUMP;
9923                     }
9924                   if (val & DF_1_CONFALT)
9925                     {
9926                       printf (" CONFALT");
9927                       val ^= DF_1_CONFALT;
9928                     }
9929                   if (val & DF_1_ENDFILTEE)
9930                     {
9931                       printf (" ENDFILTEE");
9932                       val ^= DF_1_ENDFILTEE;
9933                     }
9934                   if (val & DF_1_DISPRELDNE)
9935                     {
9936                       printf (" DISPRELDNE");
9937                       val ^= DF_1_DISPRELDNE;
9938                     }
9939                   if (val & DF_1_DISPRELPND)
9940                     {
9941                       printf (" DISPRELPND");
9942                       val ^= DF_1_DISPRELPND;
9943                     }
9944                   if (val & DF_1_NODIRECT)
9945                     {
9946                       printf (" NODIRECT");
9947                       val ^= DF_1_NODIRECT;
9948                     }
9949                   if (val & DF_1_IGNMULDEF)
9950                     {
9951                       printf (" IGNMULDEF");
9952                       val ^= DF_1_IGNMULDEF;
9953                     }
9954                   if (val & DF_1_NOKSYMS)
9955                     {
9956                       printf (" NOKSYMS");
9957                       val ^= DF_1_NOKSYMS;
9958                     }
9959                   if (val & DF_1_NOHDR)
9960                     {
9961                       printf (" NOHDR");
9962                       val ^= DF_1_NOHDR;
9963                     }
9964                   if (val & DF_1_EDITED)
9965                     {
9966                       printf (" EDITED");
9967                       val ^= DF_1_EDITED;
9968                     }
9969                   if (val & DF_1_NORELOC)
9970                     {
9971                       printf (" NORELOC");
9972                       val ^= DF_1_NORELOC;
9973                     }
9974                   if (val & DF_1_SYMINTPOSE)
9975                     {
9976                       printf (" SYMINTPOSE");
9977                       val ^= DF_1_SYMINTPOSE;
9978                     }
9979                   if (val & DF_1_GLOBAUDIT)
9980                     {
9981                       printf (" GLOBAUDIT");
9982                       val ^= DF_1_GLOBAUDIT;
9983                     }
9984                   if (val & DF_1_SINGLETON)
9985                     {
9986                       printf (" SINGLETON");
9987                       val ^= DF_1_SINGLETON;
9988                     }
9989                   if (val & DF_1_STUB)
9990                     {
9991                       printf (" STUB");
9992                       val ^= DF_1_STUB;
9993                     }
9994                   if (val & DF_1_PIE)
9995                     {
9996                       printf (" PIE");
9997                       val ^= DF_1_PIE;
9998                     }
9999                   if (val != 0)
10000                     printf (" %lx", val);
10001                   puts ("");
10002                 }
10003             }
10004           break;
10005
10006         case DT_PLTREL:
10007           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10008           if (do_dynamic)
10009             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10010           break;
10011
10012         case DT_NULL    :
10013         case DT_NEEDED  :
10014         case DT_PLTGOT  :
10015         case DT_HASH    :
10016         case DT_STRTAB  :
10017         case DT_SYMTAB  :
10018         case DT_RELA    :
10019         case DT_INIT    :
10020         case DT_FINI    :
10021         case DT_SONAME  :
10022         case DT_RPATH   :
10023         case DT_SYMBOLIC:
10024         case DT_REL     :
10025         case DT_DEBUG   :
10026         case DT_TEXTREL :
10027         case DT_JMPREL  :
10028         case DT_RUNPATH :
10029           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10030
10031           if (do_dynamic)
10032             {
10033               char * name;
10034
10035               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10036                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10037               else
10038                 name = NULL;
10039
10040               if (name)
10041                 {
10042                   switch (entry->d_tag)
10043                     {
10044                     case DT_NEEDED:
10045                       printf (_("Shared library: [%s]"), name);
10046
10047                       if (streq (name, program_interpreter))
10048                         printf (_(" program interpreter"));
10049                       break;
10050
10051                     case DT_SONAME:
10052                       printf (_("Library soname: [%s]"), name);
10053                       break;
10054
10055                     case DT_RPATH:
10056                       printf (_("Library rpath: [%s]"), name);
10057                       break;
10058
10059                     case DT_RUNPATH:
10060                       printf (_("Library runpath: [%s]"), name);
10061                       break;
10062
10063                     default:
10064                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10065                       break;
10066                     }
10067                 }
10068               else
10069                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10070
10071               putchar ('\n');
10072             }
10073           break;
10074
10075         case DT_PLTRELSZ:
10076         case DT_RELASZ  :
10077         case DT_STRSZ   :
10078         case DT_RELSZ   :
10079         case DT_RELAENT :
10080         case DT_SYMENT  :
10081         case DT_RELENT  :
10082           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10083           /* Fall through.  */
10084         case DT_PLTPADSZ:
10085         case DT_MOVEENT :
10086         case DT_MOVESZ  :
10087         case DT_INIT_ARRAYSZ:
10088         case DT_FINI_ARRAYSZ:
10089         case DT_GNU_CONFLICTSZ:
10090         case DT_GNU_LIBLISTSZ:
10091           if (do_dynamic)
10092             {
10093               print_vma (entry->d_un.d_val, UNSIGNED);
10094               printf (_(" (bytes)\n"));
10095             }
10096           break;
10097
10098         case DT_VERDEFNUM:
10099         case DT_VERNEEDNUM:
10100         case DT_RELACOUNT:
10101         case DT_RELCOUNT:
10102           if (do_dynamic)
10103             {
10104               print_vma (entry->d_un.d_val, UNSIGNED);
10105               putchar ('\n');
10106             }
10107           break;
10108
10109         case DT_SYMINSZ:
10110         case DT_SYMINENT:
10111         case DT_SYMINFO:
10112         case DT_USED:
10113         case DT_INIT_ARRAY:
10114         case DT_FINI_ARRAY:
10115           if (do_dynamic)
10116             {
10117               if (entry->d_tag == DT_USED
10118                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10119                 {
10120                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10121
10122                   if (*name)
10123                     {
10124                       printf (_("Not needed object: [%s]\n"), name);
10125                       break;
10126                     }
10127                 }
10128
10129               print_vma (entry->d_un.d_val, PREFIX_HEX);
10130               putchar ('\n');
10131             }
10132           break;
10133
10134         case DT_BIND_NOW:
10135           /* The value of this entry is ignored.  */
10136           if (do_dynamic)
10137             putchar ('\n');
10138           break;
10139
10140         case DT_GNU_PRELINKED:
10141           if (do_dynamic)
10142             {
10143               struct tm * tmp;
10144               time_t atime = entry->d_un.d_val;
10145
10146               tmp = gmtime (&atime);
10147               /* PR 17533 file: 041-1244816-0.004.  */
10148               if (tmp == NULL)
10149                 printf (_("<corrupt time val: %lx"),
10150                         (unsigned long) atime);
10151               else
10152                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10153                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10154                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10155
10156             }
10157           break;
10158
10159         case DT_GNU_HASH:
10160           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10161           if (do_dynamic)
10162             {
10163               print_vma (entry->d_un.d_val, PREFIX_HEX);
10164               putchar ('\n');
10165             }
10166           break;
10167
10168         default:
10169           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10170             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10171               entry->d_un.d_val;
10172
10173           if (do_dynamic)
10174             {
10175               switch (filedata->file_header.e_machine)
10176                 {
10177                 case EM_MIPS:
10178                 case EM_MIPS_RS3_LE:
10179                   dynamic_section_mips_val (entry);
10180                   break;
10181                 case EM_PARISC:
10182                   dynamic_section_parisc_val (entry);
10183                   break;
10184                 case EM_IA_64:
10185                   dynamic_section_ia64_val (entry);
10186                   break;
10187                 default:
10188                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10189                   putchar ('\n');
10190                 }
10191             }
10192           break;
10193         }
10194     }
10195
10196   return TRUE;
10197 }
10198
10199 static char *
10200 get_ver_flags (unsigned int flags)
10201 {
10202   static char buff[32];
10203
10204   buff[0] = 0;
10205
10206   if (flags == 0)
10207     return _("none");
10208
10209   if (flags & VER_FLG_BASE)
10210     strcat (buff, "BASE");
10211
10212   if (flags & VER_FLG_WEAK)
10213     {
10214       if (flags & VER_FLG_BASE)
10215         strcat (buff, " | ");
10216
10217       strcat (buff, "WEAK");
10218     }
10219
10220   if (flags & VER_FLG_INFO)
10221     {
10222       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10223         strcat (buff, " | ");
10224
10225       strcat (buff, "INFO");
10226     }
10227
10228   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10229     {
10230       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10231         strcat (buff, " | ");
10232
10233       strcat (buff, _("<unknown>"));
10234     }
10235
10236   return buff;
10237 }
10238
10239 /* Display the contents of the version sections.  */
10240
10241 static bfd_boolean
10242 process_version_sections (Filedata * filedata)
10243 {
10244   Elf_Internal_Shdr * section;
10245   unsigned i;
10246   bfd_boolean found = FALSE;
10247
10248   if (! do_version)
10249     return TRUE;
10250
10251   for (i = 0, section = filedata->section_headers;
10252        i < filedata->file_header.e_shnum;
10253        i++, section++)
10254     {
10255       switch (section->sh_type)
10256         {
10257         case SHT_GNU_verdef:
10258           {
10259             Elf_External_Verdef * edefs;
10260             unsigned long idx;
10261             unsigned long cnt;
10262             char * endbuf;
10263
10264             found = TRUE;
10265
10266             printf (ngettext ("\nVersion definition section '%s' "
10267                               "contains %u entry:\n",
10268                               "\nVersion definition section '%s' "
10269                               "contains %u entries:\n",
10270                               section->sh_info),
10271                     printable_section_name (filedata, section),
10272                     section->sh_info);
10273
10274             printf (_("  Addr: 0x"));
10275             printf_vma (section->sh_addr);
10276             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10277                     (unsigned long) section->sh_offset, section->sh_link,
10278                     printable_section_name_from_index (filedata, section->sh_link));
10279
10280             edefs = (Elf_External_Verdef *)
10281                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10282                           _("version definition section"));
10283             if (!edefs)
10284               break;
10285             endbuf = (char *) edefs + section->sh_size;
10286
10287             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10288               {
10289                 char * vstart;
10290                 Elf_External_Verdef * edef;
10291                 Elf_Internal_Verdef ent;
10292                 Elf_External_Verdaux * eaux;
10293                 Elf_Internal_Verdaux aux;
10294                 unsigned long isum;
10295                 int j;
10296
10297                 vstart = ((char *) edefs) + idx;
10298                 if (vstart + sizeof (*edef) > endbuf)
10299                   break;
10300
10301                 edef = (Elf_External_Verdef *) vstart;
10302
10303                 ent.vd_version = BYTE_GET (edef->vd_version);
10304                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10305                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10306                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10307                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10308                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10309                 ent.vd_next    = BYTE_GET (edef->vd_next);
10310
10311                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10312                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10313
10314                 printf (_("  Index: %d  Cnt: %d  "),
10315                         ent.vd_ndx, ent.vd_cnt);
10316
10317                 /* Check for overflow.  */
10318                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10319                   break;
10320
10321                 vstart += ent.vd_aux;
10322
10323                 if (vstart + sizeof (*eaux) > endbuf)
10324                   break;
10325                 eaux = (Elf_External_Verdaux *) vstart;
10326
10327                 aux.vda_name = BYTE_GET (eaux->vda_name);
10328                 aux.vda_next = BYTE_GET (eaux->vda_next);
10329
10330                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10331                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10332                 else
10333                   printf (_("Name index: %ld\n"), aux.vda_name);
10334
10335                 isum = idx + ent.vd_aux;
10336
10337                 for (j = 1; j < ent.vd_cnt; j++)
10338                   {
10339                     if (aux.vda_next < sizeof (*eaux)
10340                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10341                       {
10342                         warn (_("Invalid vda_next field of %lx\n"),
10343                               aux.vda_next);
10344                         j = ent.vd_cnt;
10345                         break;
10346                       }
10347                     /* Check for overflow.  */
10348                     if (aux.vda_next > (size_t) (endbuf - vstart))
10349                       break;
10350
10351                     isum   += aux.vda_next;
10352                     vstart += aux.vda_next;
10353
10354                     if (vstart + sizeof (*eaux) > endbuf)
10355                       break;
10356                     eaux = (Elf_External_Verdaux *) vstart;
10357
10358                     aux.vda_name = BYTE_GET (eaux->vda_name);
10359                     aux.vda_next = BYTE_GET (eaux->vda_next);
10360
10361                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10362                       printf (_("  %#06lx: Parent %d: %s\n"),
10363                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10364                     else
10365                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10366                               isum, j, aux.vda_name);
10367                   }
10368
10369                 if (j < ent.vd_cnt)
10370                   printf (_("  Version def aux past end of section\n"));
10371
10372                 /* PR 17531:
10373                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10374                 if (ent.vd_next < sizeof (*edef)
10375                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10376                   {
10377                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10378                     cnt = section->sh_info;
10379                     break;
10380                   }
10381                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10382                   break;
10383
10384                 idx += ent.vd_next;
10385               }
10386
10387             if (cnt < section->sh_info)
10388               printf (_("  Version definition past end of section\n"));
10389
10390             free (edefs);
10391           }
10392           break;
10393
10394         case SHT_GNU_verneed:
10395           {
10396             Elf_External_Verneed * eneed;
10397             unsigned long idx;
10398             unsigned long cnt;
10399             char * endbuf;
10400
10401             found = TRUE;
10402
10403             printf (ngettext ("\nVersion needs section '%s' "
10404                               "contains %u entry:\n",
10405                               "\nVersion needs section '%s' "
10406                               "contains %u entries:\n",
10407                               section->sh_info),
10408                     printable_section_name (filedata, section), section->sh_info);
10409
10410             printf (_(" Addr: 0x"));
10411             printf_vma (section->sh_addr);
10412             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10413                     (unsigned long) section->sh_offset, section->sh_link,
10414                     printable_section_name_from_index (filedata, section->sh_link));
10415
10416             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10417                                                        section->sh_offset, 1,
10418                                                        section->sh_size,
10419                                                        _("Version Needs section"));
10420             if (!eneed)
10421               break;
10422             endbuf = (char *) eneed + section->sh_size;
10423
10424             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10425               {
10426                 Elf_External_Verneed * entry;
10427                 Elf_Internal_Verneed ent;
10428                 unsigned long isum;
10429                 int j;
10430                 char * vstart;
10431
10432                 vstart = ((char *) eneed) + idx;
10433                 if (vstart + sizeof (*entry) > endbuf)
10434                   break;
10435
10436                 entry = (Elf_External_Verneed *) vstart;
10437
10438                 ent.vn_version = BYTE_GET (entry->vn_version);
10439                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10440                 ent.vn_file    = BYTE_GET (entry->vn_file);
10441                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10442                 ent.vn_next    = BYTE_GET (entry->vn_next);
10443
10444                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10445
10446                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10447                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10448                 else
10449                   printf (_("  File: %lx"), ent.vn_file);
10450
10451                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10452
10453                 /* Check for overflow.  */
10454                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10455                   break;
10456                 vstart += ent.vn_aux;
10457
10458                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10459                   {
10460                     Elf_External_Vernaux * eaux;
10461                     Elf_Internal_Vernaux aux;
10462
10463                     if (vstart + sizeof (*eaux) > endbuf)
10464                       break;
10465                     eaux = (Elf_External_Vernaux *) vstart;
10466
10467                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10468                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10469                     aux.vna_other = BYTE_GET (eaux->vna_other);
10470                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10471                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10472
10473                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10474                       printf (_("  %#06lx:   Name: %s"),
10475                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10476                     else
10477                       printf (_("  %#06lx:   Name index: %lx"),
10478                               isum, aux.vna_name);
10479
10480                     printf (_("  Flags: %s  Version: %d\n"),
10481                             get_ver_flags (aux.vna_flags), aux.vna_other);
10482
10483                     if (aux.vna_next < sizeof (*eaux)
10484                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10485                       {
10486                         warn (_("Invalid vna_next field of %lx\n"),
10487                               aux.vna_next);
10488                         j = ent.vn_cnt;
10489                         break;
10490                       }
10491                     /* Check for overflow.  */
10492                     if (aux.vna_next > (size_t) (endbuf - vstart))
10493                       break;
10494                     isum   += aux.vna_next;
10495                     vstart += aux.vna_next;
10496                   }
10497
10498                 if (j < ent.vn_cnt)
10499                   warn (_("Missing Version Needs auxillary information\n"));
10500
10501                 if (ent.vn_next < sizeof (*entry)
10502                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10503                   {
10504                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10505                     cnt = section->sh_info;
10506                     break;
10507                   }
10508                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10509                   break;
10510                 idx += ent.vn_next;
10511               }
10512
10513             if (cnt < section->sh_info)
10514               warn (_("Missing Version Needs information\n"));
10515
10516             free (eneed);
10517           }
10518           break;
10519
10520         case SHT_GNU_versym:
10521           {
10522             Elf_Internal_Shdr * link_section;
10523             size_t total;
10524             unsigned int cnt;
10525             unsigned char * edata;
10526             unsigned short * data;
10527             char * strtab;
10528             Elf_Internal_Sym * symbols;
10529             Elf_Internal_Shdr * string_sec;
10530             unsigned long num_syms;
10531             long off;
10532
10533             if (section->sh_link >= filedata->file_header.e_shnum)
10534               break;
10535
10536             link_section = filedata->section_headers + section->sh_link;
10537             total = section->sh_size / sizeof (Elf_External_Versym);
10538
10539             if (link_section->sh_link >= filedata->file_header.e_shnum)
10540               break;
10541
10542             found = TRUE;
10543
10544             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10545             if (symbols == NULL)
10546               break;
10547
10548             string_sec = filedata->section_headers + link_section->sh_link;
10549
10550             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10551                                         string_sec->sh_size,
10552                                         _("version string table"));
10553             if (!strtab)
10554               {
10555                 free (symbols);
10556                 break;
10557               }
10558
10559             printf (ngettext ("\nVersion symbols section '%s' "
10560                               "contains %lu entry:\n",
10561                               "\nVersion symbols section '%s' "
10562                               "contains %lu entries:\n",
10563                               total),
10564                     printable_section_name (filedata, section), (unsigned long) total);
10565
10566             printf (_(" Addr: "));
10567             printf_vma (section->sh_addr);
10568             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10569                     (unsigned long) section->sh_offset, section->sh_link,
10570                     printable_section_name (filedata, link_section));
10571
10572             off = offset_from_vma (filedata,
10573                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10574                                    total * sizeof (short));
10575             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10576                                                 sizeof (short),
10577                                                 _("version symbol data"));
10578             if (!edata)
10579               {
10580                 free (strtab);
10581                 free (symbols);
10582                 break;
10583               }
10584
10585             data = (short unsigned int *) cmalloc (total, sizeof (short));
10586
10587             for (cnt = total; cnt --;)
10588               data[cnt] = byte_get (edata + cnt * sizeof (short),
10589                                     sizeof (short));
10590
10591             free (edata);
10592
10593             for (cnt = 0; cnt < total; cnt += 4)
10594               {
10595                 int j, nn;
10596                 char *name;
10597                 char *invalid = _("*invalid*");
10598
10599                 printf ("  %03x:", cnt);
10600
10601                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10602                   switch (data[cnt + j])
10603                     {
10604                     case 0:
10605                       fputs (_("   0 (*local*)    "), stdout);
10606                       break;
10607
10608                     case 1:
10609                       fputs (_("   1 (*global*)   "), stdout);
10610                       break;
10611
10612                     default:
10613                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10614                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10615
10616                       /* If this index value is greater than the size of the symbols
10617                          array, break to avoid an out-of-bounds read.  */
10618                       if ((unsigned long)(cnt + j) >= num_syms)
10619                         {
10620                           warn (_("invalid index into symbol array\n"));
10621                           break;
10622                         }
10623
10624                       name = NULL;
10625                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10626                         {
10627                           Elf_Internal_Verneed ivn;
10628                           unsigned long offset;
10629
10630                           offset = offset_from_vma
10631                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10632                              sizeof (Elf_External_Verneed));
10633
10634                           do
10635                             {
10636                               Elf_Internal_Vernaux ivna;
10637                               Elf_External_Verneed evn;
10638                               Elf_External_Vernaux evna;
10639                               unsigned long a_off;
10640
10641                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10642                                             _("version need")) == NULL)
10643                                 break;
10644
10645                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10646                               ivn.vn_next = BYTE_GET (evn.vn_next);
10647
10648                               a_off = offset + ivn.vn_aux;
10649
10650                               do
10651                                 {
10652                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10653                                                 1, _("version need aux (2)")) == NULL)
10654                                     {
10655                                       ivna.vna_next  = 0;
10656                                       ivna.vna_other = 0;
10657                                     }
10658                                   else
10659                                     {
10660                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10661                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10662                                     }
10663
10664                                   a_off += ivna.vna_next;
10665                                 }
10666                               while (ivna.vna_other != data[cnt + j]
10667                                      && ivna.vna_next != 0);
10668
10669                               if (ivna.vna_other == data[cnt + j])
10670                                 {
10671                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10672
10673                                   if (ivna.vna_name >= string_sec->sh_size)
10674                                     name = invalid;
10675                                   else
10676                                     name = strtab + ivna.vna_name;
10677                                   break;
10678                                 }
10679
10680                               offset += ivn.vn_next;
10681                             }
10682                           while (ivn.vn_next);
10683                         }
10684
10685                       if (data[cnt + j] != 0x8001
10686                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10687                         {
10688                           Elf_Internal_Verdef ivd;
10689                           Elf_External_Verdef evd;
10690                           unsigned long offset;
10691
10692                           offset = offset_from_vma
10693                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10694                              sizeof evd);
10695
10696                           do
10697                             {
10698                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10699                                             _("version def")) == NULL)
10700                                 {
10701                                   ivd.vd_next = 0;
10702                                   /* PR 17531: file: 046-1082287-0.004.  */
10703                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10704                                   break;
10705                                 }
10706                               else
10707                                 {
10708                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10709                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10710                                 }
10711
10712                               offset += ivd.vd_next;
10713                             }
10714                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10715                                  && ivd.vd_next != 0);
10716
10717                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10718                             {
10719                               Elf_External_Verdaux evda;
10720                               Elf_Internal_Verdaux ivda;
10721
10722                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10723
10724                               if (get_data (&evda, filedata,
10725                                             offset - ivd.vd_next + ivd.vd_aux,
10726                                             sizeof (evda), 1,
10727                                             _("version def aux")) == NULL)
10728                                 break;
10729
10730                               ivda.vda_name = BYTE_GET (evda.vda_name);
10731
10732                               if (ivda.vda_name >= string_sec->sh_size)
10733                                 name = invalid;
10734                               else if (name != NULL && name != invalid)
10735                                 name = _("*both*");
10736                               else
10737                                 name = strtab + ivda.vda_name;
10738                             }
10739                         }
10740                       if (name != NULL)
10741                         nn += printf ("(%s%-*s",
10742                                       name,
10743                                       12 - (int) strlen (name),
10744                                       ")");
10745
10746                       if (nn < 18)
10747                         printf ("%*c", 18 - nn, ' ');
10748                     }
10749
10750                 putchar ('\n');
10751               }
10752
10753             free (data);
10754             free (strtab);
10755             free (symbols);
10756           }
10757           break;
10758
10759         default:
10760           break;
10761         }
10762     }
10763
10764   if (! found)
10765     printf (_("\nNo version information found in this file.\n"));
10766
10767   return TRUE;
10768 }
10769
10770 static const char *
10771 get_symbol_binding (Filedata * filedata, unsigned int binding)
10772 {
10773   static char buff[32];
10774
10775   switch (binding)
10776     {
10777     case STB_LOCAL:     return "LOCAL";
10778     case STB_GLOBAL:    return "GLOBAL";
10779     case STB_WEAK:      return "WEAK";
10780     default:
10781       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10782         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10783                   binding);
10784       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10785         {
10786           if (binding == STB_GNU_UNIQUE
10787               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10788                   /* GNU is still using the default value 0.  */
10789                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10790             return "UNIQUE";
10791           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10792         }
10793       else
10794         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10795       return buff;
10796     }
10797 }
10798
10799 static const char *
10800 get_symbol_type (Filedata * filedata, unsigned int type)
10801 {
10802   static char buff[32];
10803
10804   switch (type)
10805     {
10806     case STT_NOTYPE:    return "NOTYPE";
10807     case STT_OBJECT:    return "OBJECT";
10808     case STT_FUNC:      return "FUNC";
10809     case STT_SECTION:   return "SECTION";
10810     case STT_FILE:      return "FILE";
10811     case STT_COMMON:    return "COMMON";
10812     case STT_TLS:       return "TLS";
10813     case STT_RELC:      return "RELC";
10814     case STT_SRELC:     return "SRELC";
10815     default:
10816       if (type >= STT_LOPROC && type <= STT_HIPROC)
10817         {
10818           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10819             return "THUMB_FUNC";
10820
10821           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10822             return "REGISTER";
10823
10824           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10825             return "PARISC_MILLI";
10826
10827           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10828         }
10829       else if (type >= STT_LOOS && type <= STT_HIOS)
10830         {
10831           if (filedata->file_header.e_machine == EM_PARISC)
10832             {
10833               if (type == STT_HP_OPAQUE)
10834                 return "HP_OPAQUE";
10835               if (type == STT_HP_STUB)
10836                 return "HP_STUB";
10837             }
10838
10839           if (type == STT_GNU_IFUNC
10840               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10841                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10842                   /* GNU is still using the default value 0.  */
10843                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10844             return "IFUNC";
10845
10846           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10847         }
10848       else
10849         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10850       return buff;
10851     }
10852 }
10853
10854 static const char *
10855 get_symbol_visibility (unsigned int visibility)
10856 {
10857   switch (visibility)
10858     {
10859     case STV_DEFAULT:   return "DEFAULT";
10860     case STV_INTERNAL:  return "INTERNAL";
10861     case STV_HIDDEN:    return "HIDDEN";
10862     case STV_PROTECTED: return "PROTECTED";
10863     default:
10864       error (_("Unrecognized visibility value: %u"), visibility);
10865       return _("<unknown>");
10866     }
10867 }
10868
10869 static const char *
10870 get_solaris_symbol_visibility (unsigned int visibility)
10871 {
10872   switch (visibility)
10873     {
10874     case 4: return "EXPORTED";
10875     case 5: return "SINGLETON";
10876     case 6: return "ELIMINATE";
10877     default: return get_symbol_visibility (visibility);
10878     }
10879 }
10880
10881 static const char *
10882 get_mips_symbol_other (unsigned int other)
10883 {
10884   switch (other)
10885     {
10886     case STO_OPTIONAL:      return "OPTIONAL";
10887     case STO_MIPS_PLT:      return "MIPS PLT";
10888     case STO_MIPS_PIC:      return "MIPS PIC";
10889     case STO_MICROMIPS:     return "MICROMIPS";
10890     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
10891     case STO_MIPS16:        return "MIPS16";
10892     default:                return NULL;
10893     }
10894 }
10895
10896 static const char *
10897 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
10898 {
10899   if (is_ia64_vms (filedata))
10900     {
10901       static char res[32];
10902
10903       res[0] = 0;
10904
10905       /* Function types is for images and .STB files only.  */
10906       switch (filedata->file_header.e_type)
10907         {
10908         case ET_DYN:
10909         case ET_EXEC:
10910           switch (VMS_ST_FUNC_TYPE (other))
10911             {
10912             case VMS_SFT_CODE_ADDR:
10913               strcat (res, " CA");
10914               break;
10915             case VMS_SFT_SYMV_IDX:
10916               strcat (res, " VEC");
10917               break;
10918             case VMS_SFT_FD:
10919               strcat (res, " FD");
10920               break;
10921             case VMS_SFT_RESERVE:
10922               strcat (res, " RSV");
10923               break;
10924             default:
10925               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10926                     VMS_ST_FUNC_TYPE (other));
10927               strcat (res, " <unknown>");
10928               break;
10929             }
10930           break;
10931         default:
10932           break;
10933         }
10934       switch (VMS_ST_LINKAGE (other))
10935         {
10936         case VMS_STL_IGNORE:
10937           strcat (res, " IGN");
10938           break;
10939         case VMS_STL_RESERVE:
10940           strcat (res, " RSV");
10941           break;
10942         case VMS_STL_STD:
10943           strcat (res, " STD");
10944           break;
10945         case VMS_STL_LNK:
10946           strcat (res, " LNK");
10947           break;
10948         default:
10949           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10950                 VMS_ST_LINKAGE (other));
10951           strcat (res, " <unknown>");
10952           break;
10953         }
10954
10955       if (res[0] != 0)
10956         return res + 1;
10957       else
10958         return res;
10959     }
10960   return NULL;
10961 }
10962
10963 static const char *
10964 get_ppc64_symbol_other (unsigned int other)
10965 {
10966   if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10967     {
10968       static char buf[32];
10969       snprintf (buf, sizeof buf, _("<localentry>: %d"),
10970                 PPC64_LOCAL_ENTRY_OFFSET (other));
10971       return buf;
10972     }
10973   return NULL;
10974 }
10975
10976 static const char *
10977 get_symbol_other (Filedata * filedata, unsigned int other)
10978 {
10979   const char * result = NULL;
10980   static char buff [32];
10981
10982   if (other == 0)
10983     return "";
10984
10985   switch (filedata->file_header.e_machine)
10986     {
10987     case EM_MIPS:
10988       result = get_mips_symbol_other (other);
10989       break;
10990     case EM_IA_64:
10991       result = get_ia64_symbol_other (filedata, other);
10992       break;
10993     case EM_PPC64:
10994       result = get_ppc64_symbol_other (other);
10995       break;
10996     default:
10997       result = NULL;
10998       break;
10999     }
11000
11001   if (result)
11002     return result;
11003
11004   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11005   return buff;
11006 }
11007
11008 static const char *
11009 get_symbol_index_type (Filedata * filedata, unsigned int type)
11010 {
11011   static char buff[32];
11012
11013   switch (type)
11014     {
11015     case SHN_UNDEF:     return "UND";
11016     case SHN_ABS:       return "ABS";
11017     case SHN_COMMON:    return "COM";
11018     default:
11019       if (type == SHN_IA_64_ANSI_COMMON
11020           && filedata->file_header.e_machine == EM_IA_64
11021           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11022         return "ANSI_COM";
11023       else if ((filedata->file_header.e_machine == EM_X86_64
11024                 || filedata->file_header.e_machine == EM_L1OM
11025                 || filedata->file_header.e_machine == EM_K1OM)
11026                && type == SHN_X86_64_LCOMMON)
11027         return "LARGE_COM";
11028       else if ((type == SHN_MIPS_SCOMMON
11029                 && filedata->file_header.e_machine == EM_MIPS)
11030                || (type == SHN_TIC6X_SCOMMON
11031                    && filedata->file_header.e_machine == EM_TI_C6000))
11032         return "SCOM";
11033       else if (type == SHN_MIPS_SUNDEFINED
11034                && filedata->file_header.e_machine == EM_MIPS)
11035         return "SUND";
11036       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11037         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11038       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11039         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11040       else if (type >= SHN_LORESERVE)
11041         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11042       else if (type >= filedata->file_header.e_shnum)
11043         sprintf (buff, _("bad section index[%3d]"), type);
11044       else
11045         sprintf (buff, "%3d", type);
11046       break;
11047     }
11048
11049   return buff;
11050 }
11051
11052 static bfd_vma *
11053 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11054 {
11055   unsigned char * e_data;
11056   bfd_vma * i_data;
11057
11058   /* If the size_t type is smaller than the bfd_size_type, eg because
11059      you are building a 32-bit tool on a 64-bit host, then make sure
11060      that when (number) is cast to (size_t) no information is lost.  */
11061   if (sizeof (size_t) < sizeof (bfd_size_type)
11062       && (bfd_size_type) ((size_t) number) != number)
11063     {
11064       error (_("Size truncation prevents reading %s elements of size %u\n"),
11065              bfd_vmatoa ("u", number), ent_size);
11066       return NULL;
11067     }
11068
11069   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11070      attempting to allocate memory when the read is bound to fail.  */
11071   if (ent_size * number > filedata->file_size)
11072     {
11073       error (_("Invalid number of dynamic entries: %s\n"),
11074              bfd_vmatoa ("u", number));
11075       return NULL;
11076     }
11077
11078   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11079   if (e_data == NULL)
11080     {
11081       error (_("Out of memory reading %s dynamic entries\n"),
11082              bfd_vmatoa ("u", number));
11083       return NULL;
11084     }
11085
11086   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11087     {
11088       error (_("Unable to read in %s bytes of dynamic data\n"),
11089              bfd_vmatoa ("u", number * ent_size));
11090       free (e_data);
11091       return NULL;
11092     }
11093
11094   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11095   if (i_data == NULL)
11096     {
11097       error (_("Out of memory allocating space for %s dynamic entries\n"),
11098              bfd_vmatoa ("u", number));
11099       free (e_data);
11100       return NULL;
11101     }
11102
11103   while (number--)
11104     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11105
11106   free (e_data);
11107
11108   return i_data;
11109 }
11110
11111 static void
11112 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11113 {
11114   Elf_Internal_Sym * psym;
11115   int n;
11116
11117   n = print_vma (si, DEC_5);
11118   if (n < 5)
11119     fputs (&"     "[n], stdout);
11120   printf (" %3lu: ", hn);
11121
11122   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11123     {
11124       printf (_("<No info available for dynamic symbol number %lu>\n"),
11125               (unsigned long) si);
11126       return;
11127     }
11128
11129   psym = dynamic_symbols + si;
11130   print_vma (psym->st_value, LONG_HEX);
11131   putchar (' ');
11132   print_vma (psym->st_size, DEC_5);
11133
11134   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11135   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11136
11137   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11138     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11139   else
11140     {
11141       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11142
11143       printf (" %-7s",  get_symbol_visibility (vis));
11144       /* Check to see if any other bits in the st_other field are set.
11145          Note - displaying this information disrupts the layout of the
11146          table being generated, but for the moment this case is very
11147          rare.  */
11148       if (psym->st_other ^ vis)
11149         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11150     }
11151
11152   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11153   if (VALID_DYNAMIC_NAME (psym->st_name))
11154     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11155   else
11156     printf (_(" <corrupt: %14ld>"), psym->st_name);
11157   putchar ('\n');
11158 }
11159
11160 static const char *
11161 get_symbol_version_string (Filedata *                   filedata,
11162                            bfd_boolean                  is_dynsym,
11163                            const char *                 strtab,
11164                            unsigned long int            strtab_size,
11165                            unsigned int                 si,
11166                            Elf_Internal_Sym *           psym,
11167                            enum versioned_symbol_info * sym_info,
11168                            unsigned short *             vna_other)
11169 {
11170   unsigned char data[2];
11171   unsigned short vers_data;
11172   unsigned long offset;
11173
11174   if (!is_dynsym
11175       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11176     return NULL;
11177
11178   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11179                             sizeof data + si * sizeof (vers_data));
11180
11181   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11182                 sizeof (data), 1, _("version data")) == NULL)
11183     return NULL;
11184
11185   vers_data = byte_get (data, 2);
11186
11187   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
11188     return NULL;
11189
11190   /* Usually we'd only see verdef for defined symbols, and verneed for
11191      undefined symbols.  However, symbols defined by the linker in
11192      .dynbss for variables copied from a shared library in order to
11193      avoid text relocations are defined yet have verneed.  We could
11194      use a heuristic to detect the special case, for example, check
11195      for verneed first on symbols defined in SHT_NOBITS sections, but
11196      it is simpler and more reliable to just look for both verdef and
11197      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11198
11199   if (psym->st_shndx != SHN_UNDEF
11200       && vers_data != 0x8001
11201       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11202     {
11203       Elf_Internal_Verdef ivd;
11204       Elf_Internal_Verdaux ivda;
11205       Elf_External_Verdaux evda;
11206       unsigned long off;
11207
11208       off = offset_from_vma (filedata,
11209                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11210                              sizeof (Elf_External_Verdef));
11211
11212       do
11213         {
11214           Elf_External_Verdef evd;
11215
11216           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11217                         _("version def")) == NULL)
11218             {
11219               ivd.vd_ndx = 0;
11220               ivd.vd_aux = 0;
11221               ivd.vd_next = 0;
11222             }
11223           else
11224             {
11225               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11226               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11227               ivd.vd_next = BYTE_GET (evd.vd_next);
11228             }
11229
11230           off += ivd.vd_next;
11231         }
11232       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11233
11234       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11235         {
11236           off -= ivd.vd_next;
11237           off += ivd.vd_aux;
11238
11239           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11240                         _("version def aux")) != NULL)
11241             {
11242               ivda.vda_name = BYTE_GET (evda.vda_name);
11243
11244               if (psym->st_name != ivda.vda_name)
11245                 {
11246                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11247                                ? symbol_hidden : symbol_public);
11248                   return (ivda.vda_name < strtab_size
11249                           ? strtab + ivda.vda_name : _("<corrupt>"));
11250                 }
11251             }
11252         }
11253     }
11254
11255   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11256     {
11257       Elf_External_Verneed evn;
11258       Elf_Internal_Verneed ivn;
11259       Elf_Internal_Vernaux ivna;
11260
11261       offset = offset_from_vma (filedata,
11262                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11263                                 sizeof evn);
11264       do
11265         {
11266           unsigned long vna_off;
11267
11268           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11269                         _("version need")) == NULL)
11270             {
11271               ivna.vna_next = 0;
11272               ivna.vna_other = 0;
11273               ivna.vna_name = 0;
11274               break;
11275             }
11276
11277           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11278           ivn.vn_next = BYTE_GET (evn.vn_next);
11279
11280           vna_off = offset + ivn.vn_aux;
11281
11282           do
11283             {
11284               Elf_External_Vernaux evna;
11285
11286               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11287                             _("version need aux (3)")) == NULL)
11288                 {
11289                   ivna.vna_next = 0;
11290                   ivna.vna_other = 0;
11291                   ivna.vna_name = 0;
11292                 }
11293               else
11294                 {
11295                   ivna.vna_other = BYTE_GET (evna.vna_other);
11296                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11297                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11298                 }
11299
11300               vna_off += ivna.vna_next;
11301             }
11302           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11303
11304           if (ivna.vna_other == vers_data)
11305             break;
11306
11307           offset += ivn.vn_next;
11308         }
11309       while (ivn.vn_next != 0);
11310
11311       if (ivna.vna_other == vers_data)
11312         {
11313           *sym_info = symbol_undefined;
11314           *vna_other = ivna.vna_other;
11315           return (ivna.vna_name < strtab_size
11316                   ? strtab + ivna.vna_name : _("<corrupt>"));
11317         }
11318     }
11319   return NULL;
11320 }
11321
11322 /* Dump the symbol table.  */
11323 static bfd_boolean
11324 process_symbol_table (Filedata * filedata)
11325 {
11326   Elf_Internal_Shdr * section;
11327   bfd_size_type nbuckets = 0;
11328   bfd_size_type nchains = 0;
11329   bfd_vma * buckets = NULL;
11330   bfd_vma * chains = NULL;
11331   bfd_vma ngnubuckets = 0;
11332   bfd_vma * gnubuckets = NULL;
11333   bfd_vma * gnuchains = NULL;
11334   bfd_vma gnusymidx = 0;
11335   bfd_size_type ngnuchains = 0;
11336
11337   if (!do_syms && !do_dyn_syms && !do_histogram)
11338     return TRUE;
11339
11340   if (dynamic_info[DT_HASH]
11341       && (do_histogram
11342           || (do_using_dynamic
11343               && !do_dyn_syms
11344               && dynamic_strings != NULL)))
11345     {
11346       unsigned char nb[8];
11347       unsigned char nc[8];
11348       unsigned int hash_ent_size = 4;
11349
11350       if ((filedata->file_header.e_machine == EM_ALPHA
11351            || filedata->file_header.e_machine == EM_S390
11352            || filedata->file_header.e_machine == EM_S390_OLD)
11353           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11354         hash_ent_size = 8;
11355
11356       if (fseek (filedata->handle,
11357                  (archive_file_offset
11358                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11359                                      sizeof nb + sizeof nc)),
11360                  SEEK_SET))
11361         {
11362           error (_("Unable to seek to start of dynamic information\n"));
11363           goto no_hash;
11364         }
11365
11366       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11367         {
11368           error (_("Failed to read in number of buckets\n"));
11369           goto no_hash;
11370         }
11371
11372       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11373         {
11374           error (_("Failed to read in number of chains\n"));
11375           goto no_hash;
11376         }
11377
11378       nbuckets = byte_get (nb, hash_ent_size);
11379       nchains  = byte_get (nc, hash_ent_size);
11380
11381       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11382       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11383
11384     no_hash:
11385       if (buckets == NULL || chains == NULL)
11386         {
11387           if (do_using_dynamic)
11388             return FALSE;
11389           free (buckets);
11390           free (chains);
11391           buckets = NULL;
11392           chains = NULL;
11393           nbuckets = 0;
11394           nchains = 0;
11395         }
11396     }
11397
11398   if (dynamic_info_DT_GNU_HASH
11399       && (do_histogram
11400           || (do_using_dynamic
11401               && !do_dyn_syms
11402               && dynamic_strings != NULL)))
11403     {
11404       unsigned char nb[16];
11405       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11406       bfd_vma buckets_vma;
11407
11408       if (fseek (filedata->handle,
11409                  (archive_file_offset
11410                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11411                                      sizeof nb)),
11412                  SEEK_SET))
11413         {
11414           error (_("Unable to seek to start of dynamic information\n"));
11415           goto no_gnu_hash;
11416         }
11417
11418       if (fread (nb, 16, 1, filedata->handle) != 1)
11419         {
11420           error (_("Failed to read in number of buckets\n"));
11421           goto no_gnu_hash;
11422         }
11423
11424       ngnubuckets = byte_get (nb, 4);
11425       gnusymidx = byte_get (nb + 4, 4);
11426       bitmaskwords = byte_get (nb + 8, 4);
11427       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11428       if (is_32bit_elf)
11429         buckets_vma += bitmaskwords * 4;
11430       else
11431         buckets_vma += bitmaskwords * 8;
11432
11433       if (fseek (filedata->handle,
11434                  (archive_file_offset
11435                   + offset_from_vma (filedata, buckets_vma, 4)),
11436                  SEEK_SET))
11437         {
11438           error (_("Unable to seek to start of dynamic information\n"));
11439           goto no_gnu_hash;
11440         }
11441
11442       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11443
11444       if (gnubuckets == NULL)
11445         goto no_gnu_hash;
11446
11447       for (i = 0; i < ngnubuckets; i++)
11448         if (gnubuckets[i] != 0)
11449           {
11450             if (gnubuckets[i] < gnusymidx)
11451               return FALSE;
11452
11453             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11454               maxchain = gnubuckets[i];
11455           }
11456
11457       if (maxchain == 0xffffffff)
11458         goto no_gnu_hash;
11459
11460       maxchain -= gnusymidx;
11461
11462       if (fseek (filedata->handle,
11463                  (archive_file_offset
11464                   + offset_from_vma (filedata, buckets_vma
11465                                            + 4 * (ngnubuckets + maxchain), 4)),
11466                  SEEK_SET))
11467         {
11468           error (_("Unable to seek to start of dynamic information\n"));
11469           goto no_gnu_hash;
11470         }
11471
11472       do
11473         {
11474           if (fread (nb, 4, 1, filedata->handle) != 1)
11475             {
11476               error (_("Failed to determine last chain length\n"));
11477               goto no_gnu_hash;
11478             }
11479
11480           if (maxchain + 1 == 0)
11481             goto no_gnu_hash;
11482
11483           ++maxchain;
11484         }
11485       while ((byte_get (nb, 4) & 1) == 0);
11486
11487       if (fseek (filedata->handle,
11488                  (archive_file_offset
11489                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11490                  SEEK_SET))
11491         {
11492           error (_("Unable to seek to start of dynamic information\n"));
11493           goto no_gnu_hash;
11494         }
11495
11496       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11497       ngnuchains = maxchain;
11498
11499     no_gnu_hash:
11500       if (gnuchains == NULL)
11501         {
11502           free (gnubuckets);
11503           gnubuckets = NULL;
11504           ngnubuckets = 0;
11505           if (do_using_dynamic)
11506             return FALSE;
11507         }
11508     }
11509
11510   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11511       && do_syms
11512       && do_using_dynamic
11513       && dynamic_strings != NULL
11514       && dynamic_symbols != NULL)
11515     {
11516       unsigned long hn;
11517
11518       if (dynamic_info[DT_HASH])
11519         {
11520           bfd_vma si;
11521           char *visited;
11522
11523           printf (_("\nSymbol table for image:\n"));
11524           if (is_32bit_elf)
11525             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11526           else
11527             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11528
11529           visited = xcmalloc (nchains, 1);
11530           memset (visited, 0, nchains);
11531           for (hn = 0; hn < nbuckets; hn++)
11532             {
11533               for (si = buckets[hn]; si > 0; si = chains[si])
11534                 {
11535                   print_dynamic_symbol (filedata, si, hn);
11536                   if (si >= nchains || visited[si])
11537                     {
11538                       error (_("histogram chain is corrupt\n"));
11539                       break;
11540                     }
11541                   visited[si] = 1;
11542                 }
11543             }
11544           free (visited);
11545         }
11546
11547       if (dynamic_info_DT_GNU_HASH)
11548         {
11549           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11550           if (is_32bit_elf)
11551             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11552           else
11553             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11554
11555           for (hn = 0; hn < ngnubuckets; ++hn)
11556             if (gnubuckets[hn] != 0)
11557               {
11558                 bfd_vma si = gnubuckets[hn];
11559                 bfd_vma off = si - gnusymidx;
11560
11561                 do
11562                   {
11563                     print_dynamic_symbol (filedata, si, hn);
11564                     si++;
11565                   }
11566                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11567               }
11568         }
11569     }
11570   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11571            && filedata->section_headers != NULL)
11572     {
11573       unsigned int i;
11574
11575       for (i = 0, section = filedata->section_headers;
11576            i < filedata->file_header.e_shnum;
11577            i++, section++)
11578         {
11579           unsigned int si;
11580           char * strtab = NULL;
11581           unsigned long int strtab_size = 0;
11582           Elf_Internal_Sym * symtab;
11583           Elf_Internal_Sym * psym;
11584           unsigned long num_syms;
11585
11586           if ((section->sh_type != SHT_SYMTAB
11587                && section->sh_type != SHT_DYNSYM)
11588               || (!do_syms
11589                   && section->sh_type == SHT_SYMTAB))
11590             continue;
11591
11592           if (section->sh_entsize == 0)
11593             {
11594               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11595                       printable_section_name (filedata, section));
11596               continue;
11597             }
11598
11599           num_syms = section->sh_size / section->sh_entsize;
11600           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11601                             "\nSymbol table '%s' contains %lu entries:\n",
11602                             num_syms),
11603                   printable_section_name (filedata, section),
11604                   num_syms);
11605
11606           if (is_32bit_elf)
11607             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11608           else
11609             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11610
11611           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11612           if (symtab == NULL)
11613             continue;
11614
11615           if (section->sh_link == filedata->file_header.e_shstrndx)
11616             {
11617               strtab = filedata->string_table;
11618               strtab_size = filedata->string_table_length;
11619             }
11620           else if (section->sh_link < filedata->file_header.e_shnum)
11621             {
11622               Elf_Internal_Shdr * string_sec;
11623
11624               string_sec = filedata->section_headers + section->sh_link;
11625
11626               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11627                                           1, string_sec->sh_size,
11628                                           _("string table"));
11629               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11630             }
11631
11632           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11633             {
11634               const char *version_string;
11635               enum versioned_symbol_info sym_info;
11636               unsigned short vna_other;
11637
11638               printf ("%6d: ", si);
11639               print_vma (psym->st_value, LONG_HEX);
11640               putchar (' ');
11641               print_vma (psym->st_size, DEC_5);
11642               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11643               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11644               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11645                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11646               else
11647                 {
11648                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11649
11650                   printf (" %-7s", get_symbol_visibility (vis));
11651                   /* Check to see if any other bits in the st_other field are set.
11652                      Note - displaying this information disrupts the layout of the
11653                      table being generated, but for the moment this case is very rare.  */
11654                   if (psym->st_other ^ vis)
11655                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11656                 }
11657               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11658               print_symbol (25, psym->st_name < strtab_size
11659                             ? strtab + psym->st_name : _("<corrupt>"));
11660
11661               version_string
11662                 = get_symbol_version_string (filedata,
11663                                              section->sh_type == SHT_DYNSYM,
11664                                              strtab, strtab_size, si,
11665                                              psym, &sym_info, &vna_other);
11666               if (version_string)
11667                 {
11668                   if (sym_info == symbol_undefined)
11669                     printf ("@%s (%d)", version_string, vna_other);
11670                   else
11671                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11672                             version_string);
11673                 }
11674
11675               putchar ('\n');
11676
11677               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11678                   && si >= section->sh_info
11679                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11680                   && filedata->file_header.e_machine != EM_MIPS
11681                   /* Solaris binaries have been found to violate this requirement as
11682                      well.  Not sure if this is a bug or an ABI requirement.  */
11683                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11684                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11685                       si, printable_section_name (filedata, section), section->sh_info);
11686             }
11687
11688           free (symtab);
11689           if (strtab != filedata->string_table)
11690             free (strtab);
11691         }
11692     }
11693   else if (do_syms)
11694     printf
11695       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11696
11697   if (do_histogram && buckets != NULL)
11698     {
11699       unsigned long * lengths;
11700       unsigned long * counts;
11701       unsigned long hn;
11702       bfd_vma si;
11703       unsigned long maxlength = 0;
11704       unsigned long nzero_counts = 0;
11705       unsigned long nsyms = 0;
11706       char *visited;
11707
11708       printf (ngettext ("\nHistogram for bucket list length "
11709                         "(total of %lu bucket):\n",
11710                         "\nHistogram for bucket list length "
11711                         "(total of %lu buckets):\n",
11712                         (unsigned long) nbuckets),
11713               (unsigned long) nbuckets);
11714
11715       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11716       if (lengths == NULL)
11717         {
11718           error (_("Out of memory allocating space for histogram buckets\n"));
11719           return FALSE;
11720         }
11721       visited = xcmalloc (nchains, 1);
11722       memset (visited, 0, nchains);
11723
11724       printf (_(" Length  Number     %% of total  Coverage\n"));
11725       for (hn = 0; hn < nbuckets; ++hn)
11726         {
11727           for (si = buckets[hn]; si > 0; si = chains[si])
11728             {
11729               ++nsyms;
11730               if (maxlength < ++lengths[hn])
11731                 ++maxlength;
11732               if (si >= nchains || visited[si])
11733                 {
11734                   error (_("histogram chain is corrupt\n"));
11735                   break;
11736                 }
11737               visited[si] = 1;
11738             }
11739         }
11740       free (visited);
11741
11742       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11743       if (counts == NULL)
11744         {
11745           free (lengths);
11746           error (_("Out of memory allocating space for histogram counts\n"));
11747           return FALSE;
11748         }
11749
11750       for (hn = 0; hn < nbuckets; ++hn)
11751         ++counts[lengths[hn]];
11752
11753       if (nbuckets > 0)
11754         {
11755           unsigned long i;
11756           printf ("      0  %-10lu (%5.1f%%)\n",
11757                   counts[0], (counts[0] * 100.0) / nbuckets);
11758           for (i = 1; i <= maxlength; ++i)
11759             {
11760               nzero_counts += counts[i] * i;
11761               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11762                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11763                       (nzero_counts * 100.0) / nsyms);
11764             }
11765         }
11766
11767       free (counts);
11768       free (lengths);
11769     }
11770
11771   if (buckets != NULL)
11772     {
11773       free (buckets);
11774       free (chains);
11775     }
11776
11777   if (do_histogram && gnubuckets != NULL)
11778     {
11779       unsigned long * lengths;
11780       unsigned long * counts;
11781       unsigned long hn;
11782       unsigned long maxlength = 0;
11783       unsigned long nzero_counts = 0;
11784       unsigned long nsyms = 0;
11785
11786       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11787                         "(total of %lu bucket):\n",
11788                         "\nHistogram for `.gnu.hash' bucket list length "
11789                         "(total of %lu buckets):\n",
11790                         (unsigned long) ngnubuckets),
11791               (unsigned long) ngnubuckets);
11792
11793       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11794       if (lengths == NULL)
11795         {
11796           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11797           return FALSE;
11798         }
11799
11800       printf (_(" Length  Number     %% of total  Coverage\n"));
11801
11802       for (hn = 0; hn < ngnubuckets; ++hn)
11803         if (gnubuckets[hn] != 0)
11804           {
11805             bfd_vma off, length = 1;
11806
11807             for (off = gnubuckets[hn] - gnusymidx;
11808                  /* PR 17531 file: 010-77222-0.004.  */
11809                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11810                  ++off)
11811               ++length;
11812             lengths[hn] = length;
11813             if (length > maxlength)
11814               maxlength = length;
11815             nsyms += length;
11816           }
11817
11818       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11819       if (counts == NULL)
11820         {
11821           free (lengths);
11822           error (_("Out of memory allocating space for gnu histogram counts\n"));
11823           return FALSE;
11824         }
11825
11826       for (hn = 0; hn < ngnubuckets; ++hn)
11827         ++counts[lengths[hn]];
11828
11829       if (ngnubuckets > 0)
11830         {
11831           unsigned long j;
11832           printf ("      0  %-10lu (%5.1f%%)\n",
11833                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11834           for (j = 1; j <= maxlength; ++j)
11835             {
11836               nzero_counts += counts[j] * j;
11837               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11838                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11839                       (nzero_counts * 100.0) / nsyms);
11840             }
11841         }
11842
11843       free (counts);
11844       free (lengths);
11845       free (gnubuckets);
11846       free (gnuchains);
11847     }
11848
11849   return TRUE;
11850 }
11851
11852 static bfd_boolean
11853 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11854 {
11855   unsigned int i;
11856
11857   if (dynamic_syminfo == NULL
11858       || !do_dynamic)
11859     /* No syminfo, this is ok.  */
11860     return TRUE;
11861
11862   /* There better should be a dynamic symbol section.  */
11863   if (dynamic_symbols == NULL || dynamic_strings == NULL)
11864     return FALSE;
11865
11866   if (dynamic_addr)
11867     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11868                       "contains %d entry:\n",
11869                       "\nDynamic info segment at offset 0x%lx "
11870                       "contains %d entries:\n",
11871                       dynamic_syminfo_nent),
11872             dynamic_syminfo_offset, dynamic_syminfo_nent);
11873
11874   printf (_(" Num: Name                           BoundTo     Flags\n"));
11875   for (i = 0; i < dynamic_syminfo_nent; ++i)
11876     {
11877       unsigned short int flags = dynamic_syminfo[i].si_flags;
11878
11879       printf ("%4d: ", i);
11880       if (i >= num_dynamic_syms)
11881         printf (_("<corrupt index>"));
11882       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11883         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11884       else
11885         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11886       putchar (' ');
11887
11888       switch (dynamic_syminfo[i].si_boundto)
11889         {
11890         case SYMINFO_BT_SELF:
11891           fputs ("SELF       ", stdout);
11892           break;
11893         case SYMINFO_BT_PARENT:
11894           fputs ("PARENT     ", stdout);
11895           break;
11896         default:
11897           if (dynamic_syminfo[i].si_boundto > 0
11898               && dynamic_syminfo[i].si_boundto < dynamic_nent
11899               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11900             {
11901               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11902               putchar (' ' );
11903             }
11904           else
11905             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11906           break;
11907         }
11908
11909       if (flags & SYMINFO_FLG_DIRECT)
11910         printf (" DIRECT");
11911       if (flags & SYMINFO_FLG_PASSTHRU)
11912         printf (" PASSTHRU");
11913       if (flags & SYMINFO_FLG_COPY)
11914         printf (" COPY");
11915       if (flags & SYMINFO_FLG_LAZYLOAD)
11916         printf (" LAZYLOAD");
11917
11918       puts ("");
11919     }
11920
11921   return TRUE;
11922 }
11923
11924 #define IN_RANGE(START,END,ADDR,OFF)            \
11925   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11926
11927 /* Check to see if the given reloc needs to be handled in a target specific
11928    manner.  If so then process the reloc and return TRUE otherwise return
11929    FALSE.
11930
11931    If called with reloc == NULL, then this is a signal that reloc processing
11932    for the current section has finished, and any saved state should be
11933    discarded.  */
11934
11935 static bfd_boolean
11936 target_specific_reloc_handling (Filedata *           filedata,
11937                                 Elf_Internal_Rela *  reloc,
11938                                 unsigned char *      start,
11939                                 unsigned char *      end,
11940                                 Elf_Internal_Sym *   symtab,
11941                                 unsigned long        num_syms)
11942 {
11943   unsigned int reloc_type = 0;
11944   unsigned long sym_index = 0;
11945
11946   if (reloc)
11947     {
11948       reloc_type = get_reloc_type (filedata, reloc->r_info);
11949       sym_index = get_reloc_symindex (reloc->r_info);
11950     }
11951
11952   switch (filedata->file_header.e_machine)
11953     {
11954     case EM_MSP430:
11955     case EM_MSP430_OLD:
11956       {
11957         static Elf_Internal_Sym * saved_sym = NULL;
11958
11959         if (reloc == NULL)
11960           {
11961             saved_sym = NULL;
11962             return TRUE;
11963           }
11964
11965         switch (reloc_type)
11966           {
11967           case 10: /* R_MSP430_SYM_DIFF */
11968             if (uses_msp430x_relocs (filedata))
11969               break;
11970             /* Fall through.  */
11971           case 21: /* R_MSP430X_SYM_DIFF */
11972             /* PR 21139.  */
11973             if (sym_index >= num_syms)
11974               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11975                      sym_index);
11976             else
11977               saved_sym = symtab + sym_index;
11978             return TRUE;
11979
11980           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11981           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11982             goto handle_sym_diff;
11983
11984           case 5: /* R_MSP430_16_BYTE */
11985           case 9: /* R_MSP430_8 */
11986             if (uses_msp430x_relocs (filedata))
11987               break;
11988             goto handle_sym_diff;
11989
11990           case 2: /* R_MSP430_ABS16 */
11991           case 15: /* R_MSP430X_ABS16 */
11992             if (! uses_msp430x_relocs (filedata))
11993               break;
11994             goto handle_sym_diff;
11995
11996           handle_sym_diff:
11997             if (saved_sym != NULL)
11998               {
11999                 int reloc_size = reloc_type == 1 ? 4 : 2;
12000                 bfd_vma value;
12001
12002                 if (sym_index >= num_syms)
12003                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12004                          sym_index);
12005                 else
12006                   {
12007                     value = reloc->r_addend + (symtab[sym_index].st_value
12008                                                - saved_sym->st_value);
12009
12010                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12011                       byte_put (start + reloc->r_offset, value, reloc_size);
12012                     else
12013                       /* PR 21137 */
12014                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12015                              (long) reloc->r_offset);
12016                   }
12017
12018                 saved_sym = NULL;
12019                 return TRUE;
12020               }
12021             break;
12022
12023           default:
12024             if (saved_sym != NULL)
12025               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12026             break;
12027           }
12028         break;
12029       }
12030
12031     case EM_MN10300:
12032     case EM_CYGNUS_MN10300:
12033       {
12034         static Elf_Internal_Sym * saved_sym = NULL;
12035
12036         if (reloc == NULL)
12037           {
12038             saved_sym = NULL;
12039             return TRUE;
12040           }
12041
12042         switch (reloc_type)
12043           {
12044           case 34: /* R_MN10300_ALIGN */
12045             return TRUE;
12046           case 33: /* R_MN10300_SYM_DIFF */
12047             if (sym_index >= num_syms)
12048               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12049                      sym_index);
12050             else
12051               saved_sym = symtab + sym_index;
12052             return TRUE;
12053
12054           case 1: /* R_MN10300_32 */
12055           case 2: /* R_MN10300_16 */
12056             if (saved_sym != NULL)
12057               {
12058                 int reloc_size = reloc_type == 1 ? 4 : 2;
12059                 bfd_vma value;
12060
12061                 if (sym_index >= num_syms)
12062                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12063                          sym_index);
12064                 else
12065                   {
12066                     value = reloc->r_addend + (symtab[sym_index].st_value
12067                                                - saved_sym->st_value);
12068
12069                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12070                       byte_put (start + reloc->r_offset, value, reloc_size);
12071                     else
12072                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12073                              (long) reloc->r_offset);
12074                   }
12075
12076                 saved_sym = NULL;
12077                 return TRUE;
12078               }
12079             break;
12080           default:
12081             if (saved_sym != NULL)
12082               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12083             break;
12084           }
12085         break;
12086       }
12087
12088     case EM_RL78:
12089       {
12090         static bfd_vma saved_sym1 = 0;
12091         static bfd_vma saved_sym2 = 0;
12092         static bfd_vma value;
12093
12094         if (reloc == NULL)
12095           {
12096             saved_sym1 = saved_sym2 = 0;
12097             return TRUE;
12098           }
12099
12100         switch (reloc_type)
12101           {
12102           case 0x80: /* R_RL78_SYM.  */
12103             saved_sym1 = saved_sym2;
12104             if (sym_index >= num_syms)
12105               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12106                      sym_index);
12107             else
12108               {
12109                 saved_sym2 = symtab[sym_index].st_value;
12110                 saved_sym2 += reloc->r_addend;
12111               }
12112             return TRUE;
12113
12114           case 0x83: /* R_RL78_OPsub.  */
12115             value = saved_sym1 - saved_sym2;
12116             saved_sym2 = saved_sym1 = 0;
12117             return TRUE;
12118             break;
12119
12120           case 0x41: /* R_RL78_ABS32.  */
12121             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12122               byte_put (start + reloc->r_offset, value, 4);
12123             else
12124               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12125                      (long) reloc->r_offset);
12126             value = 0;
12127             return TRUE;
12128
12129           case 0x43: /* R_RL78_ABS16.  */
12130             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12131               byte_put (start + reloc->r_offset, value, 2);
12132             else
12133               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12134                      (long) reloc->r_offset);
12135             value = 0;
12136             return TRUE;
12137
12138           default:
12139             break;
12140           }
12141         break;
12142       }
12143     }
12144
12145   return FALSE;
12146 }
12147
12148 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12149    DWARF debug sections.  This is a target specific test.  Note - we do not
12150    go through the whole including-target-headers-multiple-times route, (as
12151    we have already done with <elf/h8.h>) because this would become very
12152    messy and even then this function would have to contain target specific
12153    information (the names of the relocs instead of their numeric values).
12154    FIXME: This is not the correct way to solve this problem.  The proper way
12155    is to have target specific reloc sizing and typing functions created by
12156    the reloc-macros.h header, in the same way that it already creates the
12157    reloc naming functions.  */
12158
12159 static bfd_boolean
12160 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12161 {
12162   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12163   switch (filedata->file_header.e_machine)
12164     {
12165     case EM_386:
12166     case EM_IAMCU:
12167       return reloc_type == 1; /* R_386_32.  */
12168     case EM_68K:
12169       return reloc_type == 1; /* R_68K_32.  */
12170     case EM_860:
12171       return reloc_type == 1; /* R_860_32.  */
12172     case EM_960:
12173       return reloc_type == 2; /* R_960_32.  */
12174     case EM_AARCH64:
12175       return (reloc_type == 258
12176               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12177     case EM_ADAPTEVA_EPIPHANY:
12178       return reloc_type == 3;
12179     case EM_ALPHA:
12180       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12181     case EM_ARC:
12182       return reloc_type == 1; /* R_ARC_32.  */
12183     case EM_ARC_COMPACT:
12184     case EM_ARC_COMPACT2:
12185       return reloc_type == 4; /* R_ARC_32.  */
12186     case EM_ARM:
12187       return reloc_type == 2; /* R_ARM_ABS32 */
12188     case EM_AVR_OLD:
12189     case EM_AVR:
12190       return reloc_type == 1;
12191     case EM_BLACKFIN:
12192       return reloc_type == 0x12; /* R_byte4_data.  */
12193     case EM_CRIS:
12194       return reloc_type == 3; /* R_CRIS_32.  */
12195     case EM_CR16:
12196       return reloc_type == 3; /* R_CR16_NUM32.  */
12197     case EM_CRX:
12198       return reloc_type == 15; /* R_CRX_NUM32.  */
12199     case EM_CYGNUS_FRV:
12200       return reloc_type == 1;
12201     case EM_CYGNUS_D10V:
12202     case EM_D10V:
12203       return reloc_type == 6; /* R_D10V_32.  */
12204     case EM_CYGNUS_D30V:
12205     case EM_D30V:
12206       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12207     case EM_DLX:
12208       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12209     case EM_CYGNUS_FR30:
12210     case EM_FR30:
12211       return reloc_type == 3; /* R_FR30_32.  */
12212     case EM_FT32:
12213       return reloc_type == 1; /* R_FT32_32.  */
12214     case EM_H8S:
12215     case EM_H8_300:
12216     case EM_H8_300H:
12217       return reloc_type == 1; /* R_H8_DIR32.  */
12218     case EM_IA_64:
12219       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12220               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12221               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12222               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12223     case EM_IP2K_OLD:
12224     case EM_IP2K:
12225       return reloc_type == 2; /* R_IP2K_32.  */
12226     case EM_IQ2000:
12227       return reloc_type == 2; /* R_IQ2000_32.  */
12228     case EM_LATTICEMICO32:
12229       return reloc_type == 3; /* R_LM32_32.  */
12230     case EM_M32C_OLD:
12231     case EM_M32C:
12232       return reloc_type == 3; /* R_M32C_32.  */
12233     case EM_M32R:
12234       return reloc_type == 34; /* R_M32R_32_RELA.  */
12235     case EM_68HC11:
12236     case EM_68HC12:
12237       return reloc_type == 6; /* R_M68HC11_32.  */
12238     case EM_MCORE:
12239       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12240     case EM_CYGNUS_MEP:
12241       return reloc_type == 4; /* R_MEP_32.  */
12242     case EM_METAG:
12243       return reloc_type == 2; /* R_METAG_ADDR32.  */
12244     case EM_MICROBLAZE:
12245       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12246     case EM_MIPS:
12247       return reloc_type == 2; /* R_MIPS_32.  */
12248     case EM_MMIX:
12249       return reloc_type == 4; /* R_MMIX_32.  */
12250     case EM_CYGNUS_MN10200:
12251     case EM_MN10200:
12252       return reloc_type == 1; /* R_MN10200_32.  */
12253     case EM_CYGNUS_MN10300:
12254     case EM_MN10300:
12255       return reloc_type == 1; /* R_MN10300_32.  */
12256     case EM_MOXIE:
12257       return reloc_type == 1; /* R_MOXIE_32.  */
12258     case EM_MSP430_OLD:
12259     case EM_MSP430:
12260       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12261     case EM_MT:
12262       return reloc_type == 2; /* R_MT_32.  */
12263     case EM_NDS32:
12264       return reloc_type == 20; /* R_NDS32_RELA.  */
12265     case EM_ALTERA_NIOS2:
12266       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12267     case EM_NIOS32:
12268       return reloc_type == 1; /* R_NIOS_32.  */
12269     case EM_OR1K:
12270       return reloc_type == 1; /* R_OR1K_32.  */
12271     case EM_PARISC:
12272       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12273               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12274     case EM_PJ:
12275     case EM_PJ_OLD:
12276       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12277     case EM_PPC64:
12278       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12279     case EM_PPC:
12280       return reloc_type == 1; /* R_PPC_ADDR32.  */
12281     case EM_TI_PRU:
12282       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12283     case EM_RISCV:
12284       return reloc_type == 1; /* R_RISCV_32.  */
12285     case EM_RL78:
12286       return reloc_type == 1; /* R_RL78_DIR32.  */
12287     case EM_RX:
12288       return reloc_type == 1; /* R_RX_DIR32.  */
12289     case EM_S370:
12290       return reloc_type == 1; /* R_I370_ADDR31.  */
12291     case EM_S390_OLD:
12292     case EM_S390:
12293       return reloc_type == 4; /* R_S390_32.  */
12294     case EM_SCORE:
12295       return reloc_type == 8; /* R_SCORE_ABS32.  */
12296     case EM_SH:
12297       return reloc_type == 1; /* R_SH_DIR32.  */
12298     case EM_SPARC32PLUS:
12299     case EM_SPARCV9:
12300     case EM_SPARC:
12301       return reloc_type == 3 /* R_SPARC_32.  */
12302         || reloc_type == 23; /* R_SPARC_UA32.  */
12303     case EM_SPU:
12304       return reloc_type == 6; /* R_SPU_ADDR32 */
12305     case EM_TI_C6000:
12306       return reloc_type == 1; /* R_C6000_ABS32.  */
12307     case EM_TILEGX:
12308       return reloc_type == 2; /* R_TILEGX_32.  */
12309     case EM_TILEPRO:
12310       return reloc_type == 1; /* R_TILEPRO_32.  */
12311     case EM_CYGNUS_V850:
12312     case EM_V850:
12313       return reloc_type == 6; /* R_V850_ABS32.  */
12314     case EM_V800:
12315       return reloc_type == 0x33; /* R_V810_WORD.  */
12316     case EM_VAX:
12317       return reloc_type == 1; /* R_VAX_32.  */
12318     case EM_VISIUM:
12319       return reloc_type == 3;  /* R_VISIUM_32. */
12320     case EM_WEBASSEMBLY:
12321       return reloc_type == 1;  /* R_WASM32_32.  */
12322     case EM_X86_64:
12323     case EM_L1OM:
12324     case EM_K1OM:
12325       return reloc_type == 10; /* R_X86_64_32.  */
12326     case EM_XC16X:
12327     case EM_C166:
12328       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12329     case EM_XGATE:
12330       return reloc_type == 4; /* R_XGATE_32.  */
12331     case EM_XSTORMY16:
12332       return reloc_type == 1; /* R_XSTROMY16_32.  */
12333     case EM_XTENSA_OLD:
12334     case EM_XTENSA:
12335       return reloc_type == 1; /* R_XTENSA_32.  */
12336     default:
12337       {
12338         static unsigned int prev_warn = 0;
12339
12340         /* Avoid repeating the same warning multiple times.  */
12341         if (prev_warn != filedata->file_header.e_machine)
12342           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12343                  filedata->file_header.e_machine);
12344         prev_warn = filedata->file_header.e_machine;
12345         return FALSE;
12346       }
12347     }
12348 }
12349
12350 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12351    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12352
12353 static bfd_boolean
12354 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12355 {
12356   switch (filedata->file_header.e_machine)
12357   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12358     {
12359     case EM_386:
12360     case EM_IAMCU:
12361       return reloc_type == 2;  /* R_386_PC32.  */
12362     case EM_68K:
12363       return reloc_type == 4;  /* R_68K_PC32.  */
12364     case EM_AARCH64:
12365       return reloc_type == 261; /* R_AARCH64_PREL32 */
12366     case EM_ADAPTEVA_EPIPHANY:
12367       return reloc_type == 6;
12368     case EM_ALPHA:
12369       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12370     case EM_ARC_COMPACT:
12371     case EM_ARC_COMPACT2:
12372       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12373     case EM_ARM:
12374       return reloc_type == 3;  /* R_ARM_REL32 */
12375     case EM_AVR_OLD:
12376     case EM_AVR:
12377       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12378     case EM_MICROBLAZE:
12379       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12380     case EM_OR1K:
12381       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12382     case EM_PARISC:
12383       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12384     case EM_PPC:
12385       return reloc_type == 26; /* R_PPC_REL32.  */
12386     case EM_PPC64:
12387       return reloc_type == 26; /* R_PPC64_REL32.  */
12388     case EM_S390_OLD:
12389     case EM_S390:
12390       return reloc_type == 5;  /* R_390_PC32.  */
12391     case EM_SH:
12392       return reloc_type == 2;  /* R_SH_REL32.  */
12393     case EM_SPARC32PLUS:
12394     case EM_SPARCV9:
12395     case EM_SPARC:
12396       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12397     case EM_SPU:
12398       return reloc_type == 13; /* R_SPU_REL32.  */
12399     case EM_TILEGX:
12400       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12401     case EM_TILEPRO:
12402       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12403     case EM_VISIUM:
12404       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12405     case EM_X86_64:
12406     case EM_L1OM:
12407     case EM_K1OM:
12408       return reloc_type == 2;  /* R_X86_64_PC32.  */
12409     case EM_XTENSA_OLD:
12410     case EM_XTENSA:
12411       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12412     default:
12413       /* Do not abort or issue an error message here.  Not all targets use
12414          pc-relative 32-bit relocs in their DWARF debug information and we
12415          have already tested for target coverage in is_32bit_abs_reloc.  A
12416          more helpful warning message will be generated by apply_relocations
12417          anyway, so just return.  */
12418       return FALSE;
12419     }
12420 }
12421
12422 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12423    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12424
12425 static bfd_boolean
12426 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12427 {
12428   switch (filedata->file_header.e_machine)
12429     {
12430     case EM_AARCH64:
12431       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12432     case EM_ALPHA:
12433       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12434     case EM_IA_64:
12435       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12436               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12437     case EM_PARISC:
12438       return reloc_type == 80; /* R_PARISC_DIR64.  */
12439     case EM_PPC64:
12440       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12441     case EM_RISCV:
12442       return reloc_type == 2; /* R_RISCV_64.  */
12443     case EM_SPARC32PLUS:
12444     case EM_SPARCV9:
12445     case EM_SPARC:
12446       return reloc_type == 32 /* R_SPARC_64.  */
12447         || reloc_type == 54; /* R_SPARC_UA64.  */
12448     case EM_X86_64:
12449     case EM_L1OM:
12450     case EM_K1OM:
12451       return reloc_type == 1; /* R_X86_64_64.  */
12452     case EM_S390_OLD:
12453     case EM_S390:
12454       return reloc_type == 22;  /* R_S390_64.  */
12455     case EM_TILEGX:
12456       return reloc_type == 1; /* R_TILEGX_64.  */
12457     case EM_MIPS:
12458       return reloc_type == 18;  /* R_MIPS_64.  */
12459     default:
12460       return FALSE;
12461     }
12462 }
12463
12464 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12465    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12466
12467 static bfd_boolean
12468 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12469 {
12470   switch (filedata->file_header.e_machine)
12471     {
12472     case EM_AARCH64:
12473       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12474     case EM_ALPHA:
12475       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12476     case EM_IA_64:
12477       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12478               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12479     case EM_PARISC:
12480       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12481     case EM_PPC64:
12482       return reloc_type == 44; /* R_PPC64_REL64.  */
12483     case EM_SPARC32PLUS:
12484     case EM_SPARCV9:
12485     case EM_SPARC:
12486       return reloc_type == 46; /* R_SPARC_DISP64.  */
12487     case EM_X86_64:
12488     case EM_L1OM:
12489     case EM_K1OM:
12490       return reloc_type == 24; /* R_X86_64_PC64.  */
12491     case EM_S390_OLD:
12492     case EM_S390:
12493       return reloc_type == 23;  /* R_S390_PC64.  */
12494     case EM_TILEGX:
12495       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12496     default:
12497       return FALSE;
12498     }
12499 }
12500
12501 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12502    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12503
12504 static bfd_boolean
12505 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12506 {
12507   switch (filedata->file_header.e_machine)
12508     {
12509     case EM_CYGNUS_MN10200:
12510     case EM_MN10200:
12511       return reloc_type == 4; /* R_MN10200_24.  */
12512     case EM_FT32:
12513       return reloc_type == 5; /* R_FT32_20.  */
12514     default:
12515       return FALSE;
12516     }
12517 }
12518
12519 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12520    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12521
12522 static bfd_boolean
12523 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12524 {
12525   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12526   switch (filedata->file_header.e_machine)
12527     {
12528     case EM_ARC:
12529     case EM_ARC_COMPACT:
12530     case EM_ARC_COMPACT2:
12531       return reloc_type == 2; /* R_ARC_16.  */
12532     case EM_ADAPTEVA_EPIPHANY:
12533       return reloc_type == 5;
12534     case EM_AVR_OLD:
12535     case EM_AVR:
12536       return reloc_type == 4; /* R_AVR_16.  */
12537     case EM_CYGNUS_D10V:
12538     case EM_D10V:
12539       return reloc_type == 3; /* R_D10V_16.  */
12540     case EM_FT32:
12541       return reloc_type == 2; /* R_FT32_16.  */
12542     case EM_H8S:
12543     case EM_H8_300:
12544     case EM_H8_300H:
12545       return reloc_type == R_H8_DIR16;
12546     case EM_IP2K_OLD:
12547     case EM_IP2K:
12548       return reloc_type == 1; /* R_IP2K_16.  */
12549     case EM_M32C_OLD:
12550     case EM_M32C:
12551       return reloc_type == 1; /* R_M32C_16 */
12552     case EM_CYGNUS_MN10200:
12553     case EM_MN10200:
12554       return reloc_type == 2; /* R_MN10200_16.  */
12555     case EM_CYGNUS_MN10300:
12556     case EM_MN10300:
12557       return reloc_type == 2; /* R_MN10300_16.  */
12558     case EM_MSP430:
12559       if (uses_msp430x_relocs (filedata))
12560         return reloc_type == 2; /* R_MSP430_ABS16.  */
12561       /* Fall through.  */
12562     case EM_MSP430_OLD:
12563       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12564     case EM_NDS32:
12565       return reloc_type == 19; /* R_NDS32_RELA.  */
12566     case EM_ALTERA_NIOS2:
12567       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12568     case EM_NIOS32:
12569       return reloc_type == 9; /* R_NIOS_16.  */
12570     case EM_OR1K:
12571       return reloc_type == 2; /* R_OR1K_16.  */
12572     case EM_TI_PRU:
12573       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12574     case EM_TI_C6000:
12575       return reloc_type == 2; /* R_C6000_ABS16.  */
12576     case EM_VISIUM:
12577       return reloc_type == 2; /* R_VISIUM_16. */
12578     case EM_XC16X:
12579     case EM_C166:
12580       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12581     case EM_XGATE:
12582       return reloc_type == 3; /* R_XGATE_16.  */
12583     default:
12584       return FALSE;
12585     }
12586 }
12587
12588 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12589    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12590
12591 static bfd_boolean
12592 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12593 {
12594   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12595   switch (filedata->file_header.e_machine)
12596     {
12597     case EM_RISCV:
12598       return reloc_type == 35; /* R_RISCV_ADD32.  */
12599     default:
12600       return FALSE;
12601     }
12602 }
12603
12604 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12605    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12606
12607 static bfd_boolean
12608 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12609 {
12610   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12611   switch (filedata->file_header.e_machine)
12612     {
12613     case EM_RISCV:
12614       return reloc_type == 39; /* R_RISCV_SUB32.  */
12615     default:
12616       return FALSE;
12617     }
12618 }
12619
12620 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12621    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12622
12623 static bfd_boolean
12624 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12625 {
12626   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12627   switch (filedata->file_header.e_machine)
12628     {
12629     case EM_RISCV:
12630       return reloc_type == 36; /* R_RISCV_ADD64.  */
12631     default:
12632       return FALSE;
12633     }
12634 }
12635
12636 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12637    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12638
12639 static bfd_boolean
12640 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12641 {
12642   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12643   switch (filedata->file_header.e_machine)
12644     {
12645     case EM_RISCV:
12646       return reloc_type == 40; /* R_RISCV_SUB64.  */
12647     default:
12648       return FALSE;
12649     }
12650 }
12651
12652 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12653    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12654
12655 static bfd_boolean
12656 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12657 {
12658   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12659   switch (filedata->file_header.e_machine)
12660     {
12661     case EM_RISCV:
12662       return reloc_type == 34; /* R_RISCV_ADD16.  */
12663     default:
12664       return FALSE;
12665     }
12666 }
12667
12668 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12669    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12670
12671 static bfd_boolean
12672 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12673 {
12674   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12675   switch (filedata->file_header.e_machine)
12676     {
12677     case EM_RISCV:
12678       return reloc_type == 38; /* R_RISCV_SUB16.  */
12679     default:
12680       return FALSE;
12681     }
12682 }
12683
12684 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12685    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12686
12687 static bfd_boolean
12688 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12689 {
12690   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12691   switch (filedata->file_header.e_machine)
12692     {
12693     case EM_RISCV:
12694       return reloc_type == 33; /* R_RISCV_ADD8.  */
12695     default:
12696       return FALSE;
12697     }
12698 }
12699
12700 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12701    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12702
12703 static bfd_boolean
12704 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12705 {
12706   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12707   switch (filedata->file_header.e_machine)
12708     {
12709     case EM_RISCV:
12710       return reloc_type == 37; /* R_RISCV_SUB8.  */
12711     default:
12712       return FALSE;
12713     }
12714 }
12715
12716 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12717    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12718
12719 static bfd_boolean
12720 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12721 {
12722   switch (filedata->file_header.e_machine)
12723     {
12724     case EM_386:     /* R_386_NONE.  */
12725     case EM_68K:     /* R_68K_NONE.  */
12726     case EM_ADAPTEVA_EPIPHANY:
12727     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12728     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12729     case EM_ARC:     /* R_ARC_NONE.  */
12730     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12731     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12732     case EM_ARM:     /* R_ARM_NONE.  */
12733     case EM_C166:    /* R_XC16X_NONE.  */
12734     case EM_CRIS:    /* R_CRIS_NONE.  */
12735     case EM_FT32:    /* R_FT32_NONE.  */
12736     case EM_IA_64:   /* R_IA64_NONE.  */
12737     case EM_K1OM:    /* R_X86_64_NONE.  */
12738     case EM_L1OM:    /* R_X86_64_NONE.  */
12739     case EM_M32R:    /* R_M32R_NONE.  */
12740     case EM_MIPS:    /* R_MIPS_NONE.  */
12741     case EM_MN10300: /* R_MN10300_NONE.  */
12742     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12743     case EM_NIOS32:  /* R_NIOS_NONE.  */
12744     case EM_OR1K:    /* R_OR1K_NONE. */
12745     case EM_PARISC:  /* R_PARISC_NONE.  */
12746     case EM_PPC64:   /* R_PPC64_NONE.  */
12747     case EM_PPC:     /* R_PPC_NONE.  */
12748     case EM_RISCV:   /* R_RISCV_NONE.  */
12749     case EM_S390:    /* R_390_NONE.  */
12750     case EM_S390_OLD:
12751     case EM_SH:      /* R_SH_NONE.  */
12752     case EM_SPARC32PLUS:
12753     case EM_SPARC:   /* R_SPARC_NONE.  */
12754     case EM_SPARCV9:
12755     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12756     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12757     case EM_TI_C6000:/* R_C6000_NONE.  */
12758     case EM_X86_64:  /* R_X86_64_NONE.  */
12759     case EM_XC16X:
12760     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12761       return reloc_type == 0;
12762
12763     case EM_AARCH64:
12764       return reloc_type == 0 || reloc_type == 256;
12765     case EM_AVR_OLD:
12766     case EM_AVR:
12767       return (reloc_type == 0 /* R_AVR_NONE.  */
12768               || reloc_type == 30 /* R_AVR_DIFF8.  */
12769               || reloc_type == 31 /* R_AVR_DIFF16.  */
12770               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12771     case EM_METAG:
12772       return reloc_type == 3; /* R_METAG_NONE.  */
12773     case EM_NDS32:
12774       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12775               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12776               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12777               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12778               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12779     case EM_TI_PRU:
12780       return (reloc_type == 0       /* R_PRU_NONE.  */
12781               || reloc_type == 65   /* R_PRU_DIFF8.  */
12782               || reloc_type == 66   /* R_PRU_DIFF16.  */
12783               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12784     case EM_XTENSA_OLD:
12785     case EM_XTENSA:
12786       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12787               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12788               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12789               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12790     }
12791   return FALSE;
12792 }
12793
12794 /* Returns TRUE if there is a relocation against
12795    section NAME at OFFSET bytes.  */
12796
12797 bfd_boolean
12798 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12799 {
12800   Elf_Internal_Rela * relocs;
12801   Elf_Internal_Rela * rp;
12802
12803   if (dsec == NULL || dsec->reloc_info == NULL)
12804     return FALSE;
12805
12806   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12807
12808   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12809     if (rp->r_offset == offset)
12810       return TRUE;
12811
12812    return FALSE;
12813 }
12814
12815 /* Apply relocations to a section.
12816    Returns TRUE upon success, FALSE otherwise.
12817    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12818    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
12819    will be set to the number of relocs loaded.
12820
12821    Note: So far support has been added only for those relocations
12822    which can be found in debug sections. FIXME: Add support for
12823    more relocations ?  */
12824
12825 static bfd_boolean
12826 apply_relocations (Filedata *                 filedata,
12827                    const Elf_Internal_Shdr *  section,
12828                    unsigned char *            start,
12829                    bfd_size_type              size,
12830                    void **                    relocs_return,
12831                    unsigned long *            num_relocs_return)
12832 {
12833   Elf_Internal_Shdr * relsec;
12834   unsigned char * end = start + size;
12835   bfd_boolean res = TRUE;
12836
12837   if (relocs_return != NULL)
12838     {
12839       * (Elf_Internal_Rela **) relocs_return = NULL;
12840       * num_relocs_return = 0;
12841     }
12842
12843   if (filedata->file_header.e_type != ET_REL)
12844     /* No relocs to apply.  */
12845     return TRUE;
12846
12847   /* Find the reloc section associated with the section.  */
12848   for (relsec = filedata->section_headers;
12849        relsec < filedata->section_headers + filedata->file_header.e_shnum;
12850        ++relsec)
12851     {
12852       bfd_boolean is_rela;
12853       unsigned long num_relocs;
12854       Elf_Internal_Rela * relocs;
12855       Elf_Internal_Rela * rp;
12856       Elf_Internal_Shdr * symsec;
12857       Elf_Internal_Sym * symtab;
12858       unsigned long num_syms;
12859       Elf_Internal_Sym * sym;
12860
12861       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12862           || relsec->sh_info >= filedata->file_header.e_shnum
12863           || filedata->section_headers + relsec->sh_info != section
12864           || relsec->sh_size == 0
12865           || relsec->sh_link >= filedata->file_header.e_shnum)
12866         continue;
12867
12868       is_rela = relsec->sh_type == SHT_RELA;
12869
12870       if (is_rela)
12871         {
12872           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
12873                                   relsec->sh_size, & relocs, & num_relocs))
12874             return FALSE;
12875         }
12876       else
12877         {
12878           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
12879                                  relsec->sh_size, & relocs, & num_relocs))
12880             return FALSE;
12881         }
12882
12883       /* SH uses RELA but uses in place value instead of the addend field.  */
12884       if (filedata->file_header.e_machine == EM_SH)
12885         is_rela = FALSE;
12886
12887       symsec = filedata->section_headers + relsec->sh_link;
12888       if (symsec->sh_type != SHT_SYMTAB
12889           && symsec->sh_type != SHT_DYNSYM)
12890         return FALSE;
12891       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
12892
12893       for (rp = relocs; rp < relocs + num_relocs; ++rp)
12894         {
12895           bfd_vma         addend;
12896           unsigned int    reloc_type;
12897           unsigned int    reloc_size;
12898           bfd_boolean     reloc_inplace = FALSE;
12899           bfd_boolean     reloc_subtract = FALSE;
12900           unsigned char * rloc;
12901           unsigned long   sym_index;
12902
12903           reloc_type = get_reloc_type (filedata, rp->r_info);
12904
12905           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
12906             continue;
12907           else if (is_none_reloc (filedata, reloc_type))
12908             continue;
12909           else if (is_32bit_abs_reloc (filedata, reloc_type)
12910                    || is_32bit_pcrel_reloc (filedata, reloc_type))
12911             reloc_size = 4;
12912           else if (is_64bit_abs_reloc (filedata, reloc_type)
12913                    || is_64bit_pcrel_reloc (filedata, reloc_type))
12914             reloc_size = 8;
12915           else if (is_24bit_abs_reloc (filedata, reloc_type))
12916             reloc_size = 3;
12917           else if (is_16bit_abs_reloc (filedata, reloc_type))
12918             reloc_size = 2;
12919           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
12920                                                                  reloc_type))
12921                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
12922             {
12923               reloc_size = 4;
12924               reloc_inplace = TRUE;
12925             }
12926           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
12927                                                                  reloc_type))
12928                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
12929             {
12930               reloc_size = 8;
12931               reloc_inplace = TRUE;
12932             }
12933           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
12934                                                                  reloc_type))
12935                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
12936             {
12937               reloc_size = 2;
12938               reloc_inplace = TRUE;
12939             }
12940           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
12941                                                                 reloc_type))
12942                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
12943             {
12944               reloc_size = 1;
12945               reloc_inplace = TRUE;
12946             }
12947           else
12948             {
12949               static unsigned int prev_reloc = 0;
12950
12951               if (reloc_type != prev_reloc)
12952                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12953                       reloc_type, printable_section_name (filedata, section));
12954               prev_reloc = reloc_type;
12955               res = FALSE;
12956               continue;
12957             }
12958
12959           rloc = start + rp->r_offset;
12960           if ((rloc + reloc_size) > end || (rloc < start))
12961             {
12962               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12963                     (unsigned long) rp->r_offset,
12964                     printable_section_name (filedata, section));
12965               res = FALSE;
12966               continue;
12967             }
12968
12969           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12970           if (sym_index >= num_syms)
12971             {
12972               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12973                     sym_index, printable_section_name (filedata, section));
12974               res = FALSE;
12975               continue;
12976             }
12977           sym = symtab + sym_index;
12978
12979           /* If the reloc has a symbol associated with it,
12980              make sure that it is of an appropriate type.
12981
12982              Relocations against symbols without type can happen.
12983              Gcc -feliminate-dwarf2-dups may generate symbols
12984              without type for debug info.
12985
12986              Icc generates relocations against function symbols
12987              instead of local labels.
12988
12989              Relocations against object symbols can happen, eg when
12990              referencing a global array.  For an example of this see
12991              the _clz.o binary in libgcc.a.  */
12992           if (sym != symtab
12993               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12994               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12995             {
12996               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
12997                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
12998                     printable_section_name (filedata, relsec),
12999                     (long int)(rp - relocs));
13000               res = FALSE;
13001               continue;
13002             }
13003
13004           addend = 0;
13005           if (is_rela)
13006             addend += rp->r_addend;
13007           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13008              partial_inplace.  */
13009           if (!is_rela
13010               || (filedata->file_header.e_machine == EM_XTENSA
13011                   && reloc_type == 1)
13012               || ((filedata->file_header.e_machine == EM_PJ
13013                    || filedata->file_header.e_machine == EM_PJ_OLD)
13014                   && reloc_type == 1)
13015               || ((filedata->file_header.e_machine == EM_D30V
13016                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13017                   && reloc_type == 12)
13018               || reloc_inplace)
13019             addend += byte_get (rloc, reloc_size);
13020
13021           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13022               || is_64bit_pcrel_reloc (filedata, reloc_type))
13023             {
13024               /* On HPPA, all pc-relative relocations are biased by 8.  */
13025               if (filedata->file_header.e_machine == EM_PARISC)
13026                 addend -= 8;
13027               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13028                         reloc_size);
13029             }
13030           else if (reloc_subtract)
13031             byte_put (rloc, addend - sym->st_value, reloc_size);
13032           else
13033             byte_put (rloc, addend + sym->st_value, reloc_size);
13034         }
13035
13036       free (symtab);
13037       /* Let the target specific reloc processing code know that
13038          we have finished with these relocs.  */
13039       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13040
13041       if (relocs_return)
13042         {
13043           * (Elf_Internal_Rela **) relocs_return = relocs;
13044           * num_relocs_return = num_relocs;
13045         }
13046       else
13047         free (relocs);
13048
13049       break;
13050     }
13051
13052   return res;
13053 }
13054
13055 #ifdef SUPPORT_DISASSEMBLY
13056 static bfd_boolean
13057 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13058 {
13059   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13060
13061   /* FIXME: XXX -- to be done --- XXX */
13062
13063   return TRUE;
13064 }
13065 #endif
13066
13067 /* Reads in the contents of SECTION from FILE, returning a pointer
13068    to a malloc'ed buffer or NULL if something went wrong.  */
13069
13070 static char *
13071 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13072 {
13073   bfd_size_type num_bytes = section->sh_size;
13074
13075   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13076     {
13077       printf (_("Section '%s' has no data to dump.\n"),
13078               printable_section_name (filedata, section));
13079       return NULL;
13080     }
13081
13082   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13083                              _("section contents"));
13084 }
13085
13086 /* Uncompresses a section that was compressed using zlib, in place.  */
13087
13088 static bfd_boolean
13089 uncompress_section_contents (unsigned char **   buffer,
13090                              dwarf_size_type    uncompressed_size,
13091                              dwarf_size_type *  size)
13092 {
13093   dwarf_size_type compressed_size = *size;
13094   unsigned char * compressed_buffer = *buffer;
13095   unsigned char * uncompressed_buffer;
13096   z_stream strm;
13097   int rc;
13098
13099   /* It is possible the section consists of several compressed
13100      buffers concatenated together, so we uncompress in a loop.  */
13101   /* PR 18313: The state field in the z_stream structure is supposed
13102      to be invisible to the user (ie us), but some compilers will
13103      still complain about it being used without initialisation.  So
13104      we first zero the entire z_stream structure and then set the fields
13105      that we need.  */
13106   memset (& strm, 0, sizeof strm);
13107   strm.avail_in = compressed_size;
13108   strm.next_in = (Bytef *) compressed_buffer;
13109   strm.avail_out = uncompressed_size;
13110   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13111
13112   rc = inflateInit (& strm);
13113   while (strm.avail_in > 0)
13114     {
13115       if (rc != Z_OK)
13116         goto fail;
13117       strm.next_out = ((Bytef *) uncompressed_buffer
13118                        + (uncompressed_size - strm.avail_out));
13119       rc = inflate (&strm, Z_FINISH);
13120       if (rc != Z_STREAM_END)
13121         goto fail;
13122       rc = inflateReset (& strm);
13123     }
13124   rc = inflateEnd (& strm);
13125   if (rc != Z_OK
13126       || strm.avail_out != 0)
13127     goto fail;
13128
13129   *buffer = uncompressed_buffer;
13130   *size = uncompressed_size;
13131   return TRUE;
13132
13133  fail:
13134   free (uncompressed_buffer);
13135   /* Indicate decompression failure.  */
13136   *buffer = NULL;
13137   return FALSE;
13138 }
13139
13140 static bfd_boolean
13141 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13142 {
13143   Elf_Internal_Shdr *  relsec;
13144   bfd_size_type        num_bytes;
13145   unsigned char *      data;
13146   unsigned char *      end;
13147   unsigned char *      real_start;
13148   unsigned char *      start;
13149   bfd_boolean          some_strings_shown;
13150
13151   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13152   if (start == NULL)
13153     /* PR 21820: Do not fail if the section was empty.  */
13154     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13155
13156   num_bytes = section->sh_size;
13157
13158   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13159
13160   if (decompress_dumps)
13161     {
13162       dwarf_size_type new_size = num_bytes;
13163       dwarf_size_type uncompressed_size = 0;
13164
13165       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13166         {
13167           Elf_Internal_Chdr chdr;
13168           unsigned int compression_header_size
13169             = get_compression_header (& chdr, (unsigned char *) start,
13170                                       num_bytes);
13171
13172           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13173             {
13174               warn (_("section '%s' has unsupported compress type: %d\n"),
13175                     printable_section_name (filedata, section), chdr.ch_type);
13176               return FALSE;
13177             }
13178           else if (chdr.ch_addralign != section->sh_addralign)
13179             {
13180               warn (_("compressed section '%s' is corrupted\n"),
13181                     printable_section_name (filedata, section));
13182               return FALSE;
13183             }
13184           uncompressed_size = chdr.ch_size;
13185           start += compression_header_size;
13186           new_size -= compression_header_size;
13187         }
13188       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13189         {
13190           /* Read the zlib header.  In this case, it should be "ZLIB"
13191              followed by the uncompressed section size, 8 bytes in
13192              big-endian order.  */
13193           uncompressed_size = start[4]; uncompressed_size <<= 8;
13194           uncompressed_size += start[5]; uncompressed_size <<= 8;
13195           uncompressed_size += start[6]; uncompressed_size <<= 8;
13196           uncompressed_size += start[7]; uncompressed_size <<= 8;
13197           uncompressed_size += start[8]; uncompressed_size <<= 8;
13198           uncompressed_size += start[9]; uncompressed_size <<= 8;
13199           uncompressed_size += start[10]; uncompressed_size <<= 8;
13200           uncompressed_size += start[11];
13201           start += 12;
13202           new_size -= 12;
13203         }
13204
13205       if (uncompressed_size)
13206         {
13207           if (uncompress_section_contents (& start,
13208                                            uncompressed_size, & new_size))
13209             num_bytes = new_size;
13210           else
13211             {
13212               error (_("Unable to decompress section %s\n"),
13213                      printable_section_name (filedata, section));
13214               return FALSE;
13215             }
13216         }
13217       else
13218         start = real_start;
13219     }
13220
13221   /* If the section being dumped has relocations against it the user might
13222      be expecting these relocations to have been applied.  Check for this
13223      case and issue a warning message in order to avoid confusion.
13224      FIXME: Maybe we ought to have an option that dumps a section with
13225      relocs applied ?  */
13226   for (relsec = filedata->section_headers;
13227        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13228        ++relsec)
13229     {
13230       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13231           || relsec->sh_info >= filedata->file_header.e_shnum
13232           || filedata->section_headers + relsec->sh_info != section
13233           || relsec->sh_size == 0
13234           || relsec->sh_link >= filedata->file_header.e_shnum)
13235         continue;
13236
13237       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13238       break;
13239     }
13240
13241   data = start;
13242   end  = start + num_bytes;
13243   some_strings_shown = FALSE;
13244
13245   while (data < end)
13246     {
13247       while (!ISPRINT (* data))
13248         if (++ data >= end)
13249           break;
13250
13251       if (data < end)
13252         {
13253           size_t maxlen = end - data;
13254
13255 #ifndef __MSVCRT__
13256           /* PR 11128: Use two separate invocations in order to work
13257              around bugs in the Solaris 8 implementation of printf.  */
13258           printf ("  [%6tx]  ", data - start);
13259 #else
13260           printf ("  [%6Ix]  ", (size_t) (data - start));
13261 #endif
13262           if (maxlen > 0)
13263             {
13264               print_symbol ((int) maxlen, (const char *) data);
13265               putchar ('\n');
13266               data += strnlen ((const char *) data, maxlen);
13267             }
13268           else
13269             {
13270               printf (_("<corrupt>\n"));
13271               data = end;
13272             }
13273           some_strings_shown = TRUE;
13274         }
13275     }
13276
13277   if (! some_strings_shown)
13278     printf (_("  No strings found in this section."));
13279
13280   free (real_start);
13281
13282   putchar ('\n');
13283   return TRUE;
13284 }
13285
13286 static bfd_boolean
13287 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13288                        Filedata *           filedata,
13289                        bfd_boolean          relocate)
13290 {
13291   Elf_Internal_Shdr * relsec;
13292   bfd_size_type       bytes;
13293   bfd_size_type       section_size;
13294   bfd_vma             addr;
13295   unsigned char *     data;
13296   unsigned char *     real_start;
13297   unsigned char *     start;
13298
13299   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13300   if (start == NULL)
13301     /* PR 21820: Do not fail if the section was empty.  */
13302     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13303
13304   section_size = section->sh_size;
13305
13306   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13307
13308   if (decompress_dumps)
13309     {
13310       dwarf_size_type new_size = section_size;
13311       dwarf_size_type uncompressed_size = 0;
13312
13313       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13314         {
13315           Elf_Internal_Chdr chdr;
13316           unsigned int compression_header_size
13317             = get_compression_header (& chdr, start, section_size);
13318
13319           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13320             {
13321               warn (_("section '%s' has unsupported compress type: %d\n"),
13322                     printable_section_name (filedata, section), chdr.ch_type);
13323               return FALSE;
13324             }
13325           else if (chdr.ch_addralign != section->sh_addralign)
13326             {
13327               warn (_("compressed section '%s' is corrupted\n"),
13328                     printable_section_name (filedata, section));
13329               return FALSE;
13330             }
13331           uncompressed_size = chdr.ch_size;
13332           start += compression_header_size;
13333           new_size -= compression_header_size;
13334         }
13335       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13336         {
13337           /* Read the zlib header.  In this case, it should be "ZLIB"
13338              followed by the uncompressed section size, 8 bytes in
13339              big-endian order.  */
13340           uncompressed_size = start[4]; uncompressed_size <<= 8;
13341           uncompressed_size += start[5]; uncompressed_size <<= 8;
13342           uncompressed_size += start[6]; uncompressed_size <<= 8;
13343           uncompressed_size += start[7]; uncompressed_size <<= 8;
13344           uncompressed_size += start[8]; uncompressed_size <<= 8;
13345           uncompressed_size += start[9]; uncompressed_size <<= 8;
13346           uncompressed_size += start[10]; uncompressed_size <<= 8;
13347           uncompressed_size += start[11];
13348           start += 12;
13349           new_size -= 12;
13350         }
13351
13352       if (uncompressed_size)
13353         {
13354           if (uncompress_section_contents (& start, uncompressed_size,
13355                                            & new_size))
13356             {
13357               section_size = new_size;
13358             }
13359           else
13360             {
13361               error (_("Unable to decompress section %s\n"),
13362                      printable_section_name (filedata, section));
13363               /* FIXME: Print the section anyway ?  */
13364               return FALSE;
13365             }
13366         }
13367       else
13368         start = real_start;
13369     }
13370
13371   if (relocate)
13372     {
13373       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13374         return FALSE;
13375     }
13376   else
13377     {
13378       /* If the section being dumped has relocations against it the user might
13379          be expecting these relocations to have been applied.  Check for this
13380          case and issue a warning message in order to avoid confusion.
13381          FIXME: Maybe we ought to have an option that dumps a section with
13382          relocs applied ?  */
13383       for (relsec = filedata->section_headers;
13384            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13385            ++relsec)
13386         {
13387           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13388               || relsec->sh_info >= filedata->file_header.e_shnum
13389               || filedata->section_headers + relsec->sh_info != section
13390               || relsec->sh_size == 0
13391               || relsec->sh_link >= filedata->file_header.e_shnum)
13392             continue;
13393
13394           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13395           break;
13396         }
13397     }
13398
13399   addr = section->sh_addr;
13400   bytes = section_size;
13401   data = start;
13402
13403   while (bytes)
13404     {
13405       int j;
13406       int k;
13407       int lbytes;
13408
13409       lbytes = (bytes > 16 ? 16 : bytes);
13410
13411       printf ("  0x%8.8lx ", (unsigned long) addr);
13412
13413       for (j = 0; j < 16; j++)
13414         {
13415           if (j < lbytes)
13416             printf ("%2.2x", data[j]);
13417           else
13418             printf ("  ");
13419
13420           if ((j & 3) == 3)
13421             printf (" ");
13422         }
13423
13424       for (j = 0; j < lbytes; j++)
13425         {
13426           k = data[j];
13427           if (k >= ' ' && k < 0x7f)
13428             printf ("%c", k);
13429           else
13430             printf (".");
13431         }
13432
13433       putchar ('\n');
13434
13435       data  += lbytes;
13436       addr  += lbytes;
13437       bytes -= lbytes;
13438     }
13439
13440   free (real_start);
13441
13442   putchar ('\n');
13443   return TRUE;
13444 }
13445
13446 static bfd_boolean
13447 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13448                              const Elf_Internal_Shdr *        sec,
13449                              void *                           data)
13450 {
13451   struct dwarf_section * section = &debug_displays [debug].section;
13452   char buf [64];
13453   Filedata * filedata = (Filedata *) data;
13454
13455   if (section->start != NULL)
13456     {
13457       /* If it is already loaded, do nothing.  */
13458       if (streq (section->filename, filedata->file_name))
13459         return TRUE;
13460       free (section->start);
13461     }
13462
13463   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13464   section->address = sec->sh_addr;
13465   section->user_data = NULL;
13466   section->filename = filedata->file_name;
13467   section->start = (unsigned char *) get_data (NULL, filedata,
13468                                                sec->sh_offset, 1,
13469                                                sec->sh_size, buf);
13470   if (section->start == NULL)
13471     section->size = 0;
13472   else
13473     {
13474       unsigned char *start = section->start;
13475       dwarf_size_type size = sec->sh_size;
13476       dwarf_size_type uncompressed_size = 0;
13477
13478       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13479         {
13480           Elf_Internal_Chdr chdr;
13481           unsigned int compression_header_size;
13482
13483           if (size < (is_32bit_elf
13484                       ? sizeof (Elf32_External_Chdr)
13485                       : sizeof (Elf64_External_Chdr)))
13486             {
13487               warn (_("compressed section %s is too small to contain a compression header"),
13488                     section->name);
13489               return FALSE;
13490             }
13491
13492           compression_header_size = get_compression_header (&chdr, start, size);
13493
13494           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13495             {
13496               warn (_("section '%s' has unsupported compress type: %d\n"),
13497                     section->name, chdr.ch_type);
13498               return FALSE;
13499             }
13500           else if (chdr.ch_addralign != sec->sh_addralign)
13501             {
13502               warn (_("compressed section '%s' is corrupted\n"),
13503                     section->name);
13504               return FALSE;
13505             }
13506           uncompressed_size = chdr.ch_size;
13507           start += compression_header_size;
13508           size -= compression_header_size;
13509         }
13510       else if (size > 12 && streq ((char *) start, "ZLIB"))
13511         {
13512           /* Read the zlib header.  In this case, it should be "ZLIB"
13513              followed by the uncompressed section size, 8 bytes in
13514              big-endian order.  */
13515           uncompressed_size = start[4]; uncompressed_size <<= 8;
13516           uncompressed_size += start[5]; uncompressed_size <<= 8;
13517           uncompressed_size += start[6]; uncompressed_size <<= 8;
13518           uncompressed_size += start[7]; uncompressed_size <<= 8;
13519           uncompressed_size += start[8]; uncompressed_size <<= 8;
13520           uncompressed_size += start[9]; uncompressed_size <<= 8;
13521           uncompressed_size += start[10]; uncompressed_size <<= 8;
13522           uncompressed_size += start[11];
13523           start += 12;
13524           size -= 12;
13525         }
13526
13527       if (uncompressed_size)
13528         {
13529           if (uncompress_section_contents (&start, uncompressed_size,
13530                                            &size))
13531             {
13532               /* Free the compressed buffer, update the section buffer
13533                  and the section size if uncompress is successful.  */
13534               free (section->start);
13535               section->start = start;
13536             }
13537           else
13538             {
13539               error (_("Unable to decompress section %s\n"),
13540                      printable_section_name (filedata, sec));
13541               return FALSE;
13542             }
13543         }
13544
13545       section->size = size;
13546     }
13547
13548   if (section->start == NULL)
13549     return FALSE;
13550
13551   if (debug_displays [debug].relocate)
13552     {
13553       if (! apply_relocations (filedata, sec, section->start, section->size,
13554                                & section->reloc_info, & section->num_relocs))
13555         return FALSE;
13556     }
13557   else
13558     {
13559       section->reloc_info = NULL;
13560       section->num_relocs = 0;
13561     }
13562
13563   return TRUE;
13564 }
13565
13566 /* If this is not NULL, load_debug_section will only look for sections
13567    within the list of sections given here.  */
13568 static unsigned int * section_subset = NULL;
13569
13570 bfd_boolean
13571 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13572 {
13573   struct dwarf_section * section = &debug_displays [debug].section;
13574   Elf_Internal_Shdr * sec;
13575   Filedata * filedata = (Filedata *) data;
13576
13577   /* Without section headers we cannot find any sections.  */
13578   if (filedata->section_headers == NULL)
13579     return FALSE;
13580
13581   if (filedata->string_table == NULL
13582       && filedata->file_header.e_shstrndx != SHN_UNDEF
13583       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13584     {
13585       Elf_Internal_Shdr * strs;
13586
13587       /* Read in the string table, so that we have section names to scan.  */
13588       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13589
13590       if (strs != NULL && strs->sh_size != 0)
13591         {
13592           filedata->string_table
13593             = (char *) get_data (NULL, filedata, strs->sh_offset,
13594                                  1, strs->sh_size, _("string table"));
13595
13596           filedata->string_table_length
13597             = filedata->string_table != NULL ? strs->sh_size : 0;
13598         }
13599     }
13600
13601   /* Locate the debug section.  */
13602   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13603   if (sec != NULL)
13604     section->name = section->uncompressed_name;
13605   else
13606     {
13607       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13608       if (sec != NULL)
13609         section->name = section->compressed_name;
13610     }
13611   if (sec == NULL)
13612     return FALSE;
13613
13614   /* If we're loading from a subset of sections, and we've loaded
13615      a section matching this name before, it's likely that it's a
13616      different one.  */
13617   if (section_subset != NULL)
13618     free_debug_section (debug);
13619
13620   return load_specific_debug_section (debug, sec, data);
13621 }
13622
13623 void
13624 free_debug_section (enum dwarf_section_display_enum debug)
13625 {
13626   struct dwarf_section * section = &debug_displays [debug].section;
13627
13628   if (section->start == NULL)
13629     return;
13630
13631   free ((char *) section->start);
13632   section->start = NULL;
13633   section->address = 0;
13634   section->size = 0;
13635 }
13636
13637 static bfd_boolean
13638 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13639 {
13640   char * name = SECTION_NAME (section);
13641   const char * print_name = printable_section_name (filedata, section);
13642   bfd_size_type length;
13643   bfd_boolean result = TRUE;
13644   int i;
13645
13646   length = section->sh_size;
13647   if (length == 0)
13648     {
13649       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13650       return TRUE;
13651     }
13652   if (section->sh_type == SHT_NOBITS)
13653     {
13654       /* There is no point in dumping the contents of a debugging section
13655          which has the NOBITS type - the bits in the file will be random.
13656          This can happen when a file containing a .eh_frame section is
13657          stripped with the --only-keep-debug command line option.  */
13658       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13659               print_name);
13660       return FALSE;
13661     }
13662
13663   if (const_strneq (name, ".gnu.linkonce.wi."))
13664     name = ".debug_info";
13665
13666   /* See if we know how to display the contents of this section.  */
13667   for (i = 0; i < max; i++)
13668     {
13669       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13670       struct dwarf_section_display *   display = debug_displays + i;
13671       struct dwarf_section *           sec = & display->section;
13672
13673       if (streq (sec->uncompressed_name, name)
13674           || (id == line && const_strneq (name, ".debug_line."))
13675           || streq (sec->compressed_name, name))
13676         {
13677           bfd_boolean secondary = (section != find_section (filedata, name));
13678
13679           if (secondary)
13680             free_debug_section (id);
13681
13682           if (i == line && const_strneq (name, ".debug_line."))
13683             sec->name = name;
13684           else if (streq (sec->uncompressed_name, name))
13685             sec->name = sec->uncompressed_name;
13686           else
13687             sec->name = sec->compressed_name;
13688
13689           if (load_specific_debug_section (id, section, filedata))
13690             {
13691               /* If this debug section is part of a CU/TU set in a .dwp file,
13692                  restrict load_debug_section to the sections in that set.  */
13693               section_subset = find_cu_tu_set (filedata, shndx);
13694
13695               result &= display->display (sec, filedata);
13696
13697               section_subset = NULL;
13698
13699               if (secondary || (id != info && id != abbrev))
13700                 free_debug_section (id);
13701             }
13702           break;
13703         }
13704     }
13705
13706   if (i == max)
13707     {
13708       printf (_("Unrecognized debug section: %s\n"), print_name);
13709       result = FALSE;
13710     }
13711
13712   return result;
13713 }
13714
13715 /* Set DUMP_SECTS for all sections where dumps were requested
13716    based on section name.  */
13717
13718 static void
13719 initialise_dumps_byname (Filedata * filedata)
13720 {
13721   struct dump_list_entry * cur;
13722
13723   for (cur = dump_sects_byname; cur; cur = cur->next)
13724     {
13725       unsigned int i;
13726       bfd_boolean any = FALSE;
13727
13728       for (i = 0; i < filedata->file_header.e_shnum; i++)
13729         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13730           {
13731             request_dump_bynumber (filedata, i, cur->type);
13732             any = TRUE;
13733           }
13734
13735       if (!any)
13736         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13737               cur->name);
13738     }
13739 }
13740
13741 static bfd_boolean
13742 process_section_contents (Filedata * filedata)
13743 {
13744   Elf_Internal_Shdr * section;
13745   unsigned int i;
13746   bfd_boolean res = TRUE;
13747
13748   if (! do_dump)
13749     return TRUE;
13750
13751   initialise_dumps_byname (filedata);
13752
13753   for (i = 0, section = filedata->section_headers;
13754        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13755        i++, section++)
13756     {
13757       dump_type dump = filedata->dump_sects[i];
13758
13759 #ifdef SUPPORT_DISASSEMBLY
13760       if (dump & DISASS_DUMP)
13761         {
13762           if (! disassemble_section (section, filedata))
13763             res = FALSE;
13764         }
13765 #endif
13766       if (dump & HEX_DUMP)
13767         {
13768           if (! dump_section_as_bytes (section, filedata, FALSE))
13769             res = FALSE;
13770         }
13771
13772       if (dump & RELOC_DUMP)
13773         {
13774           if (! dump_section_as_bytes (section, filedata, TRUE))
13775             res = FALSE;
13776         }
13777
13778       if (dump & STRING_DUMP)
13779         {
13780           if (! dump_section_as_strings (section, filedata))
13781             res = FALSE;
13782         }
13783
13784       if (dump & DEBUG_DUMP)
13785         {
13786           if (! display_debug_section (i, section, filedata))
13787             res = FALSE;
13788         }
13789     }
13790
13791   /* Check to see if the user requested a
13792      dump of a section that does not exist.  */
13793   while (i < filedata->num_dump_sects)
13794     {
13795       if (filedata->dump_sects[i])
13796         {
13797           warn (_("Section %d was not dumped because it does not exist!\n"), i);
13798           res = FALSE;
13799         }
13800       i++;
13801     }
13802
13803   return res;
13804 }
13805
13806 static void
13807 process_mips_fpe_exception (int mask)
13808 {
13809   if (mask)
13810     {
13811       bfd_boolean first = TRUE;
13812
13813       if (mask & OEX_FPU_INEX)
13814         fputs ("INEX", stdout), first = FALSE;
13815       if (mask & OEX_FPU_UFLO)
13816         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13817       if (mask & OEX_FPU_OFLO)
13818         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13819       if (mask & OEX_FPU_DIV0)
13820         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13821       if (mask & OEX_FPU_INVAL)
13822         printf ("%sINVAL", first ? "" : "|");
13823     }
13824   else
13825     fputs ("0", stdout);
13826 }
13827
13828 /* Display's the value of TAG at location P.  If TAG is
13829    greater than 0 it is assumed to be an unknown tag, and
13830    a message is printed to this effect.  Otherwise it is
13831    assumed that a message has already been printed.
13832
13833    If the bottom bit of TAG is set it assumed to have a
13834    string value, otherwise it is assumed to have an integer
13835    value.
13836
13837    Returns an updated P pointing to the first unread byte
13838    beyond the end of TAG's value.
13839
13840    Reads at or beyond END will not be made.  */
13841
13842 static unsigned char *
13843 display_tag_value (signed int tag,
13844                    unsigned char * p,
13845                    const unsigned char * const end)
13846 {
13847   unsigned long val;
13848
13849   if (tag > 0)
13850     printf ("  Tag_unknown_%d: ", tag);
13851
13852   if (p >= end)
13853     {
13854       warn (_("<corrupt tag>\n"));
13855     }
13856   else if (tag & 1)
13857     {
13858       /* PR 17531 file: 027-19978-0.004.  */
13859       size_t maxlen = (end - p) - 1;
13860
13861       putchar ('"');
13862       if (maxlen > 0)
13863         {
13864           print_symbol ((int) maxlen, (const char *) p);
13865           p += strnlen ((char *) p, maxlen) + 1;
13866         }
13867       else
13868         {
13869           printf (_("<corrupt string tag>"));
13870           p = (unsigned char *) end;
13871         }
13872       printf ("\"\n");
13873     }
13874   else
13875     {
13876       unsigned int len;
13877
13878       val = read_uleb128 (p, &len, end);
13879       p += len;
13880       printf ("%ld (0x%lx)\n", val, val);
13881     }
13882
13883   assert (p <= end);
13884   return p;
13885 }
13886
13887 /* ARC ABI attributes section.  */
13888
13889 static unsigned char *
13890 display_arc_attribute (unsigned char * p,
13891                        const unsigned char * const end)
13892 {
13893   unsigned int tag;
13894   unsigned int len;
13895   unsigned int val;
13896
13897   tag = read_uleb128 (p, &len, end);
13898   p += len;
13899
13900   switch (tag)
13901     {
13902     case Tag_ARC_PCS_config:
13903       val = read_uleb128 (p, &len, end);
13904       p += len;
13905       printf ("  Tag_ARC_PCS_config: ");
13906       switch (val)
13907         {
13908         case 0:
13909           printf (_("Absent/Non standard\n"));
13910           break;
13911         case 1:
13912           printf (_("Bare metal/mwdt\n"));
13913           break;
13914         case 2:
13915           printf (_("Bare metal/newlib\n"));
13916           break;
13917         case 3:
13918           printf (_("Linux/uclibc\n"));
13919           break;
13920         case 4:
13921           printf (_("Linux/glibc\n"));
13922           break;
13923         default:
13924           printf (_("Unknown\n"));
13925           break;
13926         }
13927       break;
13928
13929     case Tag_ARC_CPU_base:
13930       val = read_uleb128 (p, &len, end);
13931       p += len;
13932       printf ("  Tag_ARC_CPU_base: ");
13933       switch (val)
13934         {
13935         default:
13936         case TAG_CPU_NONE:
13937           printf (_("Absent\n"));
13938           break;
13939         case TAG_CPU_ARC6xx:
13940           printf ("ARC6xx\n");
13941           break;
13942         case TAG_CPU_ARC7xx:
13943           printf ("ARC7xx\n");
13944           break;
13945         case TAG_CPU_ARCEM:
13946           printf ("ARCEM\n");
13947           break;
13948         case TAG_CPU_ARCHS:
13949           printf ("ARCHS\n");
13950           break;
13951         }
13952       break;
13953
13954     case Tag_ARC_CPU_variation:
13955       val = read_uleb128 (p, &len, end);
13956       p += len;
13957       printf ("  Tag_ARC_CPU_variation: ");
13958       switch (val)
13959         {
13960         default:
13961           if (val > 0 && val < 16)
13962               printf ("Core%d\n", val);
13963           else
13964               printf ("Unknown\n");
13965           break;
13966
13967         case 0:
13968           printf (_("Absent\n"));
13969           break;
13970         }
13971       break;
13972
13973     case Tag_ARC_CPU_name:
13974       printf ("  Tag_ARC_CPU_name: ");
13975       p = display_tag_value (-1, p, end);
13976       break;
13977
13978     case Tag_ARC_ABI_rf16:
13979       val = read_uleb128 (p, &len, end);
13980       p += len;
13981       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
13982       break;
13983
13984     case Tag_ARC_ABI_osver:
13985       val = read_uleb128 (p, &len, end);
13986       p += len;
13987       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
13988       break;
13989
13990     case Tag_ARC_ABI_pic:
13991     case Tag_ARC_ABI_sda:
13992       val = read_uleb128 (p, &len, end);
13993       p += len;
13994       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
13995               : "  Tag_ARC_ABI_pic: ");
13996       switch (val)
13997         {
13998         case 0:
13999           printf (_("Absent\n"));
14000           break;
14001         case 1:
14002           printf ("MWDT\n");
14003           break;
14004         case 2:
14005           printf ("GNU\n");
14006           break;
14007         default:
14008           printf (_("Unknown\n"));
14009           break;
14010         }
14011       break;
14012
14013     case Tag_ARC_ABI_tls:
14014       val = read_uleb128 (p, &len, end);
14015       p += len;
14016       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14017       break;
14018
14019     case Tag_ARC_ABI_enumsize:
14020       val = read_uleb128 (p, &len, end);
14021       p += len;
14022       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14023               _("smallest"));
14024       break;
14025
14026     case Tag_ARC_ABI_exceptions:
14027       val = read_uleb128 (p, &len, end);
14028       p += len;
14029       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14030               : _("default"));
14031       break;
14032
14033     case Tag_ARC_ABI_double_size:
14034       val = read_uleb128 (p, &len, end);
14035       p += len;
14036       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14037       break;
14038
14039     case Tag_ARC_ISA_config:
14040       printf ("  Tag_ARC_ISA_config: ");
14041       p = display_tag_value (-1, p, end);
14042       break;
14043
14044     case Tag_ARC_ISA_apex:
14045       printf ("  Tag_ARC_ISA_apex: ");
14046       p = display_tag_value (-1, p, end);
14047       break;
14048
14049     case Tag_ARC_ISA_mpy_option:
14050       val = read_uleb128 (p, &len, end);
14051       p += len;
14052       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14053       break;
14054
14055     default:
14056       return display_tag_value (tag & 1, p, end);
14057     }
14058
14059   return p;
14060 }
14061
14062 /* ARM EABI attributes section.  */
14063 typedef struct
14064 {
14065   unsigned int tag;
14066   const char * name;
14067   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14068   unsigned int type;
14069   const char ** table;
14070 } arm_attr_public_tag;
14071
14072 static const char * arm_attr_tag_CPU_arch[] =
14073   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14074    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14075    "v8-M.mainline"};
14076 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14077 static const char * arm_attr_tag_THUMB_ISA_use[] =
14078   {"No", "Thumb-1", "Thumb-2", "Yes"};
14079 static const char * arm_attr_tag_FP_arch[] =
14080   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14081    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14082 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14083 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14084   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14085    "NEON for ARMv8.1"};
14086 static const char * arm_attr_tag_PCS_config[] =
14087   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14088    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14089 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14090   {"V6", "SB", "TLS", "Unused"};
14091 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14092   {"Absolute", "PC-relative", "SB-relative", "None"};
14093 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14094   {"Absolute", "PC-relative", "None"};
14095 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14096   {"None", "direct", "GOT-indirect"};
14097 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14098   {"None", "??? 1", "2", "??? 3", "4"};
14099 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14100 static const char * arm_attr_tag_ABI_FP_denormal[] =
14101   {"Unused", "Needed", "Sign only"};
14102 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14103 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14104 static const char * arm_attr_tag_ABI_FP_number_model[] =
14105   {"Unused", "Finite", "RTABI", "IEEE 754"};
14106 static const char * arm_attr_tag_ABI_enum_size[] =
14107   {"Unused", "small", "int", "forced to int"};
14108 static const char * arm_attr_tag_ABI_HardFP_use[] =
14109   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14110 static const char * arm_attr_tag_ABI_VFP_args[] =
14111   {"AAPCS", "VFP registers", "custom", "compatible"};
14112 static const char * arm_attr_tag_ABI_WMMX_args[] =
14113   {"AAPCS", "WMMX registers", "custom"};
14114 static const char * arm_attr_tag_ABI_optimization_goals[] =
14115   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14116     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14117 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14118   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14119     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14120 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14121 static const char * arm_attr_tag_FP_HP_extension[] =
14122   {"Not Allowed", "Allowed"};
14123 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14124   {"None", "IEEE 754", "Alternative Format"};
14125 static const char * arm_attr_tag_DSP_extension[] =
14126   {"Follow architecture", "Allowed"};
14127 static const char * arm_attr_tag_MPextension_use[] =
14128   {"Not Allowed", "Allowed"};
14129 static const char * arm_attr_tag_DIV_use[] =
14130   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14131     "Allowed in v7-A with integer division extension"};
14132 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14133 static const char * arm_attr_tag_Virtualization_use[] =
14134   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14135     "TrustZone and Virtualization Extensions"};
14136 static const char * arm_attr_tag_MPextension_use_legacy[] =
14137   {"Not Allowed", "Allowed"};
14138
14139 #define LOOKUP(id, name) \
14140   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14141 static arm_attr_public_tag arm_attr_public_tags[] =
14142 {
14143   {4, "CPU_raw_name", 1, NULL},
14144   {5, "CPU_name", 1, NULL},
14145   LOOKUP(6, CPU_arch),
14146   {7, "CPU_arch_profile", 0, NULL},
14147   LOOKUP(8, ARM_ISA_use),
14148   LOOKUP(9, THUMB_ISA_use),
14149   LOOKUP(10, FP_arch),
14150   LOOKUP(11, WMMX_arch),
14151   LOOKUP(12, Advanced_SIMD_arch),
14152   LOOKUP(13, PCS_config),
14153   LOOKUP(14, ABI_PCS_R9_use),
14154   LOOKUP(15, ABI_PCS_RW_data),
14155   LOOKUP(16, ABI_PCS_RO_data),
14156   LOOKUP(17, ABI_PCS_GOT_use),
14157   LOOKUP(18, ABI_PCS_wchar_t),
14158   LOOKUP(19, ABI_FP_rounding),
14159   LOOKUP(20, ABI_FP_denormal),
14160   LOOKUP(21, ABI_FP_exceptions),
14161   LOOKUP(22, ABI_FP_user_exceptions),
14162   LOOKUP(23, ABI_FP_number_model),
14163   {24, "ABI_align_needed", 0, NULL},
14164   {25, "ABI_align_preserved", 0, NULL},
14165   LOOKUP(26, ABI_enum_size),
14166   LOOKUP(27, ABI_HardFP_use),
14167   LOOKUP(28, ABI_VFP_args),
14168   LOOKUP(29, ABI_WMMX_args),
14169   LOOKUP(30, ABI_optimization_goals),
14170   LOOKUP(31, ABI_FP_optimization_goals),
14171   {32, "compatibility", 0, NULL},
14172   LOOKUP(34, CPU_unaligned_access),
14173   LOOKUP(36, FP_HP_extension),
14174   LOOKUP(38, ABI_FP_16bit_format),
14175   LOOKUP(42, MPextension_use),
14176   LOOKUP(44, DIV_use),
14177   LOOKUP(46, DSP_extension),
14178   {64, "nodefaults", 0, NULL},
14179   {65, "also_compatible_with", 0, NULL},
14180   LOOKUP(66, T2EE_use),
14181   {67, "conformance", 1, NULL},
14182   LOOKUP(68, Virtualization_use),
14183   LOOKUP(70, MPextension_use_legacy)
14184 };
14185 #undef LOOKUP
14186
14187 static unsigned char *
14188 display_arm_attribute (unsigned char * p,
14189                        const unsigned char * const end)
14190 {
14191   unsigned int tag;
14192   unsigned int len;
14193   unsigned int val;
14194   arm_attr_public_tag * attr;
14195   unsigned i;
14196   unsigned int type;
14197
14198   tag = read_uleb128 (p, &len, end);
14199   p += len;
14200   attr = NULL;
14201   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14202     {
14203       if (arm_attr_public_tags[i].tag == tag)
14204         {
14205           attr = &arm_attr_public_tags[i];
14206           break;
14207         }
14208     }
14209
14210   if (attr)
14211     {
14212       printf ("  Tag_%s: ", attr->name);
14213       switch (attr->type)
14214         {
14215         case 0:
14216           switch (tag)
14217             {
14218             case 7: /* Tag_CPU_arch_profile.  */
14219               val = read_uleb128 (p, &len, end);
14220               p += len;
14221               switch (val)
14222                 {
14223                 case 0: printf (_("None\n")); break;
14224                 case 'A': printf (_("Application\n")); break;
14225                 case 'R': printf (_("Realtime\n")); break;
14226                 case 'M': printf (_("Microcontroller\n")); break;
14227                 case 'S': printf (_("Application or Realtime\n")); break;
14228                 default: printf ("??? (%d)\n", val); break;
14229                 }
14230               break;
14231
14232             case 24: /* Tag_align_needed.  */
14233               val = read_uleb128 (p, &len, end);
14234               p += len;
14235               switch (val)
14236                 {
14237                 case 0: printf (_("None\n")); break;
14238                 case 1: printf (_("8-byte\n")); break;
14239                 case 2: printf (_("4-byte\n")); break;
14240                 case 3: printf ("??? 3\n"); break;
14241                 default:
14242                   if (val <= 12)
14243                     printf (_("8-byte and up to %d-byte extended\n"),
14244                             1 << val);
14245                   else
14246                     printf ("??? (%d)\n", val);
14247                   break;
14248                 }
14249               break;
14250
14251             case 25: /* Tag_align_preserved.  */
14252               val = read_uleb128 (p, &len, end);
14253               p += len;
14254               switch (val)
14255                 {
14256                 case 0: printf (_("None\n")); break;
14257                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14258                 case 2: printf (_("8-byte\n")); break;
14259                 case 3: printf ("??? 3\n"); break;
14260                 default:
14261                   if (val <= 12)
14262                     printf (_("8-byte and up to %d-byte extended\n"),
14263                             1 << val);
14264                   else
14265                     printf ("??? (%d)\n", val);
14266                   break;
14267                 }
14268               break;
14269
14270             case 32: /* Tag_compatibility.  */
14271               {
14272                 val = read_uleb128 (p, &len, end);
14273                 p += len;
14274                 printf (_("flag = %d, vendor = "), val);
14275                 if (p < end - 1)
14276                   {
14277                     size_t maxlen = (end - p) - 1;
14278
14279                     print_symbol ((int) maxlen, (const char *) p);
14280                     p += strnlen ((char *) p, maxlen) + 1;
14281                   }
14282                 else
14283                   {
14284                     printf (_("<corrupt>"));
14285                     p = (unsigned char *) end;
14286                   }
14287                 putchar ('\n');
14288               }
14289               break;
14290
14291             case 64: /* Tag_nodefaults.  */
14292               /* PR 17531: file: 001-505008-0.01.  */
14293               if (p < end)
14294                 p++;
14295               printf (_("True\n"));
14296               break;
14297
14298             case 65: /* Tag_also_compatible_with.  */
14299               val = read_uleb128 (p, &len, end);
14300               p += len;
14301               if (val == 6 /* Tag_CPU_arch.  */)
14302                 {
14303                   val = read_uleb128 (p, &len, end);
14304                   p += len;
14305                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14306                     printf ("??? (%d)\n", val);
14307                   else
14308                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14309                 }
14310               else
14311                 printf ("???\n");
14312               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14313                 ;
14314               break;
14315
14316             default:
14317               printf (_("<unknown: %d>\n"), tag);
14318               break;
14319             }
14320           return p;
14321
14322         case 1:
14323           return display_tag_value (-1, p, end);
14324         case 2:
14325           return display_tag_value (0, p, end);
14326
14327         default:
14328           assert (attr->type & 0x80);
14329           val = read_uleb128 (p, &len, end);
14330           p += len;
14331           type = attr->type & 0x7f;
14332           if (val >= type)
14333             printf ("??? (%d)\n", val);
14334           else
14335             printf ("%s\n", attr->table[val]);
14336           return p;
14337         }
14338     }
14339
14340   return display_tag_value (tag, p, end);
14341 }
14342
14343 static unsigned char *
14344 display_gnu_attribute (unsigned char * p,
14345                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14346                        const unsigned char * const end)
14347 {
14348   int tag;
14349   unsigned int len;
14350   unsigned int val;
14351
14352   tag = read_uleb128 (p, &len, end);
14353   p += len;
14354
14355   /* Tag_compatibility is the only generic GNU attribute defined at
14356      present.  */
14357   if (tag == 32)
14358     {
14359       val = read_uleb128 (p, &len, end);
14360       p += len;
14361
14362       printf (_("flag = %d, vendor = "), val);
14363       if (p == end)
14364         {
14365           printf (_("<corrupt>\n"));
14366           warn (_("corrupt vendor attribute\n"));
14367         }
14368       else
14369         {
14370           if (p < end - 1)
14371             {
14372               size_t maxlen = (end - p) - 1;
14373
14374               print_symbol ((int) maxlen, (const char *) p);
14375               p += strnlen ((char *) p, maxlen) + 1;
14376             }
14377           else
14378             {
14379               printf (_("<corrupt>"));
14380               p = (unsigned char *) end;
14381             }
14382           putchar ('\n');
14383         }
14384       return p;
14385     }
14386
14387   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14388     return display_proc_gnu_attribute (p, tag, end);
14389
14390   return display_tag_value (tag, p, end);
14391 }
14392
14393 static unsigned char *
14394 display_power_gnu_attribute (unsigned char * p,
14395                              unsigned int tag,
14396                              const unsigned char * const end)
14397 {
14398   unsigned int len;
14399   unsigned int val;
14400
14401   if (tag == Tag_GNU_Power_ABI_FP)
14402     {
14403       val = read_uleb128 (p, &len, end);
14404       p += len;
14405       printf ("  Tag_GNU_Power_ABI_FP: ");
14406       if (len == 0)
14407         {
14408           printf (_("<corrupt>\n"));
14409           return p;
14410         }
14411
14412       if (val > 15)
14413         printf ("(%#x), ", val);
14414
14415       switch (val & 3)
14416         {
14417         case 0:
14418           printf (_("unspecified hard/soft float, "));
14419           break;
14420         case 1:
14421           printf (_("hard float, "));
14422           break;
14423         case 2:
14424           printf (_("soft float, "));
14425           break;
14426         case 3:
14427           printf (_("single-precision hard float, "));
14428           break;
14429         }
14430
14431       switch (val & 0xC)
14432         {
14433         case 0:
14434           printf (_("unspecified long double\n"));
14435           break;
14436         case 4:
14437           printf (_("128-bit IBM long double\n"));
14438           break;
14439         case 8:
14440           printf (_("64-bit long double\n"));
14441           break;
14442         case 12:
14443           printf (_("128-bit IEEE long double\n"));
14444           break;
14445         }
14446       return p;
14447     }
14448
14449   if (tag == Tag_GNU_Power_ABI_Vector)
14450     {
14451       val = read_uleb128 (p, &len, end);
14452       p += len;
14453       printf ("  Tag_GNU_Power_ABI_Vector: ");
14454       if (len == 0)
14455         {
14456           printf (_("<corrupt>\n"));
14457           return p;
14458         }
14459
14460       if (val > 3)
14461         printf ("(%#x), ", val);
14462
14463       switch (val & 3)
14464         {
14465         case 0:
14466           printf (_("unspecified\n"));
14467           break;
14468         case 1:
14469           printf (_("generic\n"));
14470           break;
14471         case 2:
14472           printf ("AltiVec\n");
14473           break;
14474         case 3:
14475           printf ("SPE\n");
14476           break;
14477         }
14478       return p;
14479     }
14480
14481   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14482     {
14483       val = read_uleb128 (p, &len, end);
14484       p += len;
14485       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14486       if (len == 0)
14487         {
14488           printf (_("<corrupt>\n"));
14489           return p;
14490         }
14491
14492       if (val > 2)
14493         printf ("(%#x), ", val);
14494
14495       switch (val & 3)
14496         {
14497         case 0:
14498           printf (_("unspecified\n"));
14499           break;
14500         case 1:
14501           printf ("r3/r4\n");
14502           break;
14503         case 2:
14504           printf (_("memory\n"));
14505           break;
14506         case 3:
14507           printf ("???\n");
14508           break;
14509         }
14510       return p;
14511     }
14512
14513   return display_tag_value (tag & 1, p, end);
14514 }
14515
14516 static unsigned char *
14517 display_s390_gnu_attribute (unsigned char * p,
14518                             unsigned int tag,
14519                             const unsigned char * const end)
14520 {
14521   unsigned int len;
14522   int val;
14523
14524   if (tag == Tag_GNU_S390_ABI_Vector)
14525     {
14526       val = read_uleb128 (p, &len, end);
14527       p += len;
14528       printf ("  Tag_GNU_S390_ABI_Vector: ");
14529
14530       switch (val)
14531         {
14532         case 0:
14533           printf (_("any\n"));
14534           break;
14535         case 1:
14536           printf (_("software\n"));
14537           break;
14538         case 2:
14539           printf (_("hardware\n"));
14540           break;
14541         default:
14542           printf ("??? (%d)\n", val);
14543           break;
14544         }
14545       return p;
14546    }
14547
14548   return display_tag_value (tag & 1, p, end);
14549 }
14550
14551 static void
14552 display_sparc_hwcaps (unsigned int mask)
14553 {
14554   if (mask)
14555     {
14556       bfd_boolean first = TRUE;
14557
14558       if (mask & ELF_SPARC_HWCAP_MUL32)
14559         fputs ("mul32", stdout), first = FALSE;
14560       if (mask & ELF_SPARC_HWCAP_DIV32)
14561         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14562       if (mask & ELF_SPARC_HWCAP_FSMULD)
14563         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14564       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14565         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14566       if (mask & ELF_SPARC_HWCAP_POPC)
14567         printf ("%spopc", first ? "" : "|"), first = FALSE;
14568       if (mask & ELF_SPARC_HWCAP_VIS)
14569         printf ("%svis", first ? "" : "|"), first = FALSE;
14570       if (mask & ELF_SPARC_HWCAP_VIS2)
14571         printf ("%svis2", first ? "" : "|"), first = FALSE;
14572       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14573         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14574       if (mask & ELF_SPARC_HWCAP_FMAF)
14575         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14576       if (mask & ELF_SPARC_HWCAP_VIS3)
14577         printf ("%svis3", first ? "" : "|"), first = FALSE;
14578       if (mask & ELF_SPARC_HWCAP_HPC)
14579         printf ("%shpc", first ? "" : "|"), first = FALSE;
14580       if (mask & ELF_SPARC_HWCAP_RANDOM)
14581         printf ("%srandom", first ? "" : "|"), first = FALSE;
14582       if (mask & ELF_SPARC_HWCAP_TRANS)
14583         printf ("%strans", first ? "" : "|"), first = FALSE;
14584       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14585         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14586       if (mask & ELF_SPARC_HWCAP_IMA)
14587         printf ("%sima", first ? "" : "|"), first = FALSE;
14588       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14589         printf ("%scspare", first ? "" : "|"), first = FALSE;
14590     }
14591   else
14592     fputc ('0', stdout);
14593   fputc ('\n', stdout);
14594 }
14595
14596 static void
14597 display_sparc_hwcaps2 (unsigned int mask)
14598 {
14599   if (mask)
14600     {
14601       bfd_boolean first = TRUE;
14602
14603       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14604         fputs ("fjathplus", stdout), first = FALSE;
14605       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14606         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14607       if (mask & ELF_SPARC_HWCAP2_ADP)
14608         printf ("%sadp", first ? "" : "|"), first = FALSE;
14609       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14610         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14611       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14612         printf ("%smwait", first ? "" : "|"), first = FALSE;
14613       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14614         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14615       if (mask & ELF_SPARC_HWCAP2_XMONT)
14616         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14617       if (mask & ELF_SPARC_HWCAP2_NSEC)
14618         printf ("%snsec", first ? "" : "|"), first = FALSE;
14619       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14620         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14621       if (mask & ELF_SPARC_HWCAP2_FJDES)
14622         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14623       if (mask & ELF_SPARC_HWCAP2_FJAES)
14624         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14625     }
14626   else
14627     fputc ('0', stdout);
14628   fputc ('\n', stdout);
14629 }
14630
14631 static unsigned char *
14632 display_sparc_gnu_attribute (unsigned char * p,
14633                              unsigned int tag,
14634                              const unsigned char * const end)
14635 {
14636   unsigned int len;
14637   int val;
14638
14639   if (tag == Tag_GNU_Sparc_HWCAPS)
14640     {
14641       val = read_uleb128 (p, &len, end);
14642       p += len;
14643       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14644       display_sparc_hwcaps (val);
14645       return p;
14646     }
14647   if (tag == Tag_GNU_Sparc_HWCAPS2)
14648     {
14649       val = read_uleb128 (p, &len, end);
14650       p += len;
14651       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14652       display_sparc_hwcaps2 (val);
14653       return p;
14654     }
14655
14656   return display_tag_value (tag, p, end);
14657 }
14658
14659 static void
14660 print_mips_fp_abi_value (unsigned int val)
14661 {
14662   switch (val)
14663     {
14664     case Val_GNU_MIPS_ABI_FP_ANY:
14665       printf (_("Hard or soft float\n"));
14666       break;
14667     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14668       printf (_("Hard float (double precision)\n"));
14669       break;
14670     case Val_GNU_MIPS_ABI_FP_SINGLE:
14671       printf (_("Hard float (single precision)\n"));
14672       break;
14673     case Val_GNU_MIPS_ABI_FP_SOFT:
14674       printf (_("Soft float\n"));
14675       break;
14676     case Val_GNU_MIPS_ABI_FP_OLD_64:
14677       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14678       break;
14679     case Val_GNU_MIPS_ABI_FP_XX:
14680       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14681       break;
14682     case Val_GNU_MIPS_ABI_FP_64:
14683       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14684       break;
14685     case Val_GNU_MIPS_ABI_FP_64A:
14686       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14687       break;
14688     case Val_GNU_MIPS_ABI_FP_NAN2008:
14689       printf (_("NaN 2008 compatibility\n"));
14690       break;
14691     default:
14692       printf ("??? (%d)\n", val);
14693       break;
14694     }
14695 }
14696
14697 static unsigned char *
14698 display_mips_gnu_attribute (unsigned char * p,
14699                             unsigned int tag,
14700                             const unsigned char * const end)
14701 {
14702   if (tag == Tag_GNU_MIPS_ABI_FP)
14703     {
14704       unsigned int len;
14705       unsigned int val;
14706
14707       val = read_uleb128 (p, &len, end);
14708       p += len;
14709       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14710
14711       print_mips_fp_abi_value (val);
14712
14713       return p;
14714    }
14715
14716   if (tag == Tag_GNU_MIPS_ABI_MSA)
14717     {
14718       unsigned int len;
14719       unsigned int val;
14720
14721       val = read_uleb128 (p, &len, end);
14722       p += len;
14723       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14724
14725       switch (val)
14726         {
14727         case Val_GNU_MIPS_ABI_MSA_ANY:
14728           printf (_("Any MSA or not\n"));
14729           break;
14730         case Val_GNU_MIPS_ABI_MSA_128:
14731           printf (_("128-bit MSA\n"));
14732           break;
14733         default:
14734           printf ("??? (%d)\n", val);
14735           break;
14736         }
14737       return p;
14738     }
14739
14740   return display_tag_value (tag & 1, p, end);
14741 }
14742
14743 static unsigned char *
14744 display_tic6x_attribute (unsigned char * p,
14745                          const unsigned char * const end)
14746 {
14747   unsigned int tag;
14748   unsigned int len;
14749   int val;
14750
14751   tag = read_uleb128 (p, &len, end);
14752   p += len;
14753
14754   switch (tag)
14755     {
14756     case Tag_ISA:
14757       val = read_uleb128 (p, &len, end);
14758       p += len;
14759       printf ("  Tag_ISA: ");
14760
14761       switch (val)
14762         {
14763         case C6XABI_Tag_ISA_none:
14764           printf (_("None\n"));
14765           break;
14766         case C6XABI_Tag_ISA_C62X:
14767           printf ("C62x\n");
14768           break;
14769         case C6XABI_Tag_ISA_C67X:
14770           printf ("C67x\n");
14771           break;
14772         case C6XABI_Tag_ISA_C67XP:
14773           printf ("C67x+\n");
14774           break;
14775         case C6XABI_Tag_ISA_C64X:
14776           printf ("C64x\n");
14777           break;
14778         case C6XABI_Tag_ISA_C64XP:
14779           printf ("C64x+\n");
14780           break;
14781         case C6XABI_Tag_ISA_C674X:
14782           printf ("C674x\n");
14783           break;
14784         default:
14785           printf ("??? (%d)\n", val);
14786           break;
14787         }
14788       return p;
14789
14790     case Tag_ABI_wchar_t:
14791       val = read_uleb128 (p, &len, end);
14792       p += len;
14793       printf ("  Tag_ABI_wchar_t: ");
14794       switch (val)
14795         {
14796         case 0:
14797           printf (_("Not used\n"));
14798           break;
14799         case 1:
14800           printf (_("2 bytes\n"));
14801           break;
14802         case 2:
14803           printf (_("4 bytes\n"));
14804           break;
14805         default:
14806           printf ("??? (%d)\n", val);
14807           break;
14808         }
14809       return p;
14810
14811     case Tag_ABI_stack_align_needed:
14812       val = read_uleb128 (p, &len, end);
14813       p += len;
14814       printf ("  Tag_ABI_stack_align_needed: ");
14815       switch (val)
14816         {
14817         case 0:
14818           printf (_("8-byte\n"));
14819           break;
14820         case 1:
14821           printf (_("16-byte\n"));
14822           break;
14823         default:
14824           printf ("??? (%d)\n", val);
14825           break;
14826         }
14827       return p;
14828
14829     case Tag_ABI_stack_align_preserved:
14830       val = read_uleb128 (p, &len, end);
14831       p += len;
14832       printf ("  Tag_ABI_stack_align_preserved: ");
14833       switch (val)
14834         {
14835         case 0:
14836           printf (_("8-byte\n"));
14837           break;
14838         case 1:
14839           printf (_("16-byte\n"));
14840           break;
14841         default:
14842           printf ("??? (%d)\n", val);
14843           break;
14844         }
14845       return p;
14846
14847     case Tag_ABI_DSBT:
14848       val = read_uleb128 (p, &len, end);
14849       p += len;
14850       printf ("  Tag_ABI_DSBT: ");
14851       switch (val)
14852         {
14853         case 0:
14854           printf (_("DSBT addressing not used\n"));
14855           break;
14856         case 1:
14857           printf (_("DSBT addressing used\n"));
14858           break;
14859         default:
14860           printf ("??? (%d)\n", val);
14861           break;
14862         }
14863       return p;
14864
14865     case Tag_ABI_PID:
14866       val = read_uleb128 (p, &len, end);
14867       p += len;
14868       printf ("  Tag_ABI_PID: ");
14869       switch (val)
14870         {
14871         case 0:
14872           printf (_("Data addressing position-dependent\n"));
14873           break;
14874         case 1:
14875           printf (_("Data addressing position-independent, GOT near DP\n"));
14876           break;
14877         case 2:
14878           printf (_("Data addressing position-independent, GOT far from DP\n"));
14879           break;
14880         default:
14881           printf ("??? (%d)\n", val);
14882           break;
14883         }
14884       return p;
14885
14886     case Tag_ABI_PIC:
14887       val = read_uleb128 (p, &len, end);
14888       p += len;
14889       printf ("  Tag_ABI_PIC: ");
14890       switch (val)
14891         {
14892         case 0:
14893           printf (_("Code addressing position-dependent\n"));
14894           break;
14895         case 1:
14896           printf (_("Code addressing position-independent\n"));
14897           break;
14898         default:
14899           printf ("??? (%d)\n", val);
14900           break;
14901         }
14902       return p;
14903
14904     case Tag_ABI_array_object_alignment:
14905       val = read_uleb128 (p, &len, end);
14906       p += len;
14907       printf ("  Tag_ABI_array_object_alignment: ");
14908       switch (val)
14909         {
14910         case 0:
14911           printf (_("8-byte\n"));
14912           break;
14913         case 1:
14914           printf (_("4-byte\n"));
14915           break;
14916         case 2:
14917           printf (_("16-byte\n"));
14918           break;
14919         default:
14920           printf ("??? (%d)\n", val);
14921           break;
14922         }
14923       return p;
14924
14925     case Tag_ABI_array_object_align_expected:
14926       val = read_uleb128 (p, &len, end);
14927       p += len;
14928       printf ("  Tag_ABI_array_object_align_expected: ");
14929       switch (val)
14930         {
14931         case 0:
14932           printf (_("8-byte\n"));
14933           break;
14934         case 1:
14935           printf (_("4-byte\n"));
14936           break;
14937         case 2:
14938           printf (_("16-byte\n"));
14939           break;
14940         default:
14941           printf ("??? (%d)\n", val);
14942           break;
14943         }
14944       return p;
14945
14946     case Tag_ABI_compatibility:
14947       {
14948         val = read_uleb128 (p, &len, end);
14949         p += len;
14950         printf ("  Tag_ABI_compatibility: ");
14951         printf (_("flag = %d, vendor = "), val);
14952         if (p < end - 1)
14953           {
14954             size_t maxlen = (end - p) - 1;
14955
14956             print_symbol ((int) maxlen, (const char *) p);
14957             p += strnlen ((char *) p, maxlen) + 1;
14958           }
14959         else
14960           {
14961             printf (_("<corrupt>"));
14962             p = (unsigned char *) end;
14963           }
14964         putchar ('\n');
14965         return p;
14966       }
14967
14968     case Tag_ABI_conformance:
14969       {
14970         printf ("  Tag_ABI_conformance: \"");
14971         if (p < end - 1)
14972           {
14973             size_t maxlen = (end - p) - 1;
14974
14975             print_symbol ((int) maxlen, (const char *) p);
14976             p += strnlen ((char *) p, maxlen) + 1;
14977           }
14978         else
14979           {
14980             printf (_("<corrupt>"));
14981             p = (unsigned char *) end;
14982           }
14983         printf ("\"\n");
14984         return p;
14985       }
14986     }
14987
14988   return display_tag_value (tag, p, end);
14989 }
14990
14991 static void
14992 display_raw_attribute (unsigned char * p, unsigned char const * const end)
14993 {
14994   unsigned long addr = 0;
14995   size_t bytes = end - p;
14996
14997   assert (end > p);
14998   while (bytes)
14999     {
15000       int j;
15001       int k;
15002       int lbytes = (bytes > 16 ? 16 : bytes);
15003
15004       printf ("  0x%8.8lx ", addr);
15005
15006       for (j = 0; j < 16; j++)
15007         {
15008           if (j < lbytes)
15009             printf ("%2.2x", p[j]);
15010           else
15011             printf ("  ");
15012
15013           if ((j & 3) == 3)
15014             printf (" ");
15015         }
15016
15017       for (j = 0; j < lbytes; j++)
15018         {
15019           k = p[j];
15020           if (k >= ' ' && k < 0x7f)
15021             printf ("%c", k);
15022           else
15023             printf (".");
15024         }
15025
15026       putchar ('\n');
15027
15028       p  += lbytes;
15029       bytes -= lbytes;
15030       addr += lbytes;
15031     }
15032
15033   putchar ('\n');
15034 }
15035
15036 static unsigned char *
15037 display_msp430x_attribute (unsigned char * p,
15038                            const unsigned char * const end)
15039 {
15040   unsigned int len;
15041   unsigned int val;
15042   unsigned int tag;
15043
15044   tag = read_uleb128 (p, & len, end);
15045   p += len;
15046
15047   switch (tag)
15048     {
15049     case OFBA_MSPABI_Tag_ISA:
15050       val = read_uleb128 (p, &len, end);
15051       p += len;
15052       printf ("  Tag_ISA: ");
15053       switch (val)
15054         {
15055         case 0: printf (_("None\n")); break;
15056         case 1: printf (_("MSP430\n")); break;
15057         case 2: printf (_("MSP430X\n")); break;
15058         default: printf ("??? (%d)\n", val); break;
15059         }
15060       break;
15061
15062     case OFBA_MSPABI_Tag_Code_Model:
15063       val = read_uleb128 (p, &len, end);
15064       p += len;
15065       printf ("  Tag_Code_Model: ");
15066       switch (val)
15067         {
15068         case 0: printf (_("None\n")); break;
15069         case 1: printf (_("Small\n")); break;
15070         case 2: printf (_("Large\n")); break;
15071         default: printf ("??? (%d)\n", val); break;
15072         }
15073       break;
15074
15075     case OFBA_MSPABI_Tag_Data_Model:
15076       val = read_uleb128 (p, &len, end);
15077       p += len;
15078       printf ("  Tag_Data_Model: ");
15079       switch (val)
15080         {
15081         case 0: printf (_("None\n")); break;
15082         case 1: printf (_("Small\n")); break;
15083         case 2: printf (_("Large\n")); break;
15084         case 3: printf (_("Restricted Large\n")); break;
15085         default: printf ("??? (%d)\n", val); break;
15086         }
15087       break;
15088
15089     default:
15090       printf (_("  <unknown tag %d>: "), tag);
15091
15092       if (tag & 1)
15093         {
15094           putchar ('"');
15095           if (p < end - 1)
15096             {
15097               size_t maxlen = (end - p) - 1;
15098
15099               print_symbol ((int) maxlen, (const char *) p);
15100               p += strnlen ((char *) p, maxlen) + 1;
15101             }
15102           else
15103             {
15104               printf (_("<corrupt>"));
15105               p = (unsigned char *) end;
15106             }
15107           printf ("\"\n");
15108         }
15109       else
15110         {
15111           val = read_uleb128 (p, &len, end);
15112           p += len;
15113           printf ("%d (0x%x)\n", val, val);
15114         }
15115       break;
15116    }
15117
15118   assert (p <= end);
15119   return p;
15120 }
15121
15122 static bfd_boolean
15123 process_attributes (Filedata * filedata,
15124                     const char * public_name,
15125                     unsigned int proc_type,
15126                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15127                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15128 {
15129   Elf_Internal_Shdr * sect;
15130   unsigned i;
15131   bfd_boolean res = TRUE;
15132
15133   /* Find the section header so that we get the size.  */
15134   for (i = 0, sect = filedata->section_headers;
15135        i < filedata->file_header.e_shnum;
15136        i++, sect++)
15137     {
15138       unsigned char * contents;
15139       unsigned char * p;
15140
15141       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15142         continue;
15143
15144       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15145                                              sect->sh_size, _("attributes"));
15146       if (contents == NULL)
15147         {
15148           res = FALSE;
15149           continue;
15150         }
15151
15152       p = contents;
15153       /* The first character is the version of the attributes.
15154          Currently only version 1, (aka 'A') is recognised here.  */
15155       if (*p != 'A')
15156         {
15157           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15158           res = FALSE;
15159         }
15160       else
15161         {
15162           bfd_vma section_len;
15163
15164           section_len = sect->sh_size - 1;
15165           p++;
15166
15167           while (section_len > 0)
15168             {
15169               bfd_vma attr_len;
15170               unsigned int namelen;
15171               bfd_boolean public_section;
15172               bfd_boolean gnu_section;
15173
15174               if (section_len <= 4)
15175                 {
15176                   error (_("Tag section ends prematurely\n"));
15177                   res = FALSE;
15178                   break;
15179                 }
15180               attr_len = byte_get (p, 4);
15181               p += 4;
15182
15183               if (attr_len > section_len)
15184                 {
15185                   error (_("Bad attribute length (%u > %u)\n"),
15186                           (unsigned) attr_len, (unsigned) section_len);
15187                   attr_len = section_len;
15188                   res = FALSE;
15189                 }
15190               /* PR 17531: file: 001-101425-0.004  */
15191               else if (attr_len < 5)
15192                 {
15193                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15194                   res = FALSE;
15195                   break;
15196                 }
15197
15198               section_len -= attr_len;
15199               attr_len -= 4;
15200
15201               namelen = strnlen ((char *) p, attr_len) + 1;
15202               if (namelen == 0 || namelen >= attr_len)
15203                 {
15204                   error (_("Corrupt attribute section name\n"));
15205                   res = FALSE;
15206                   break;
15207                 }
15208
15209               printf (_("Attribute Section: "));
15210               print_symbol (INT_MAX, (const char *) p);
15211               putchar ('\n');
15212
15213               if (public_name && streq ((char *) p, public_name))
15214                 public_section = TRUE;
15215               else
15216                 public_section = FALSE;
15217
15218               if (streq ((char *) p, "gnu"))
15219                 gnu_section = TRUE;
15220               else
15221                 gnu_section = FALSE;
15222
15223               p += namelen;
15224               attr_len -= namelen;
15225
15226               while (attr_len > 0 && p < contents + sect->sh_size)
15227                 {
15228                   int tag;
15229                   int val;
15230                   bfd_vma size;
15231                   unsigned char * end;
15232
15233                   /* PR binutils/17531: Safe handling of corrupt files.  */
15234                   if (attr_len < 6)
15235                     {
15236                       error (_("Unused bytes at end of section\n"));
15237                       res = FALSE;
15238                       section_len = 0;
15239                       break;
15240                     }
15241
15242                   tag = *(p++);
15243                   size = byte_get (p, 4);
15244                   if (size > attr_len)
15245                     {
15246                       error (_("Bad subsection length (%u > %u)\n"),
15247                               (unsigned) size, (unsigned) attr_len);
15248                       res = FALSE;
15249                       size = attr_len;
15250                     }
15251                   /* PR binutils/17531: Safe handling of corrupt files.  */
15252                   if (size < 6)
15253                     {
15254                       error (_("Bad subsection length (%u < 6)\n"),
15255                               (unsigned) size);
15256                       res = FALSE;
15257                       section_len = 0;
15258                       break;
15259                     }
15260
15261                   attr_len -= size;
15262                   end = p + size - 1;
15263                   assert (end <= contents + sect->sh_size);
15264                   p += 4;
15265
15266                   switch (tag)
15267                     {
15268                     case 1:
15269                       printf (_("File Attributes\n"));
15270                       break;
15271                     case 2:
15272                       printf (_("Section Attributes:"));
15273                       goto do_numlist;
15274                     case 3:
15275                       printf (_("Symbol Attributes:"));
15276                       /* Fall through.  */
15277                     do_numlist:
15278                       for (;;)
15279                         {
15280                           unsigned int j;
15281
15282                           val = read_uleb128 (p, &j, end);
15283                           p += j;
15284                           if (val == 0)
15285                             break;
15286                           printf (" %d", val);
15287                         }
15288                       printf ("\n");
15289                       break;
15290                     default:
15291                       printf (_("Unknown tag: %d\n"), tag);
15292                       public_section = FALSE;
15293                       break;
15294                     }
15295
15296                   if (public_section && display_pub_attribute != NULL)
15297                     {
15298                       while (p < end)
15299                         p = display_pub_attribute (p, end);
15300                       assert (p == end);
15301                     }
15302                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15303                     {
15304                       while (p < end)
15305                         p = display_gnu_attribute (p,
15306                                                    display_proc_gnu_attribute,
15307                                                    end);
15308                       assert (p == end);
15309                     }
15310                   else if (p < end)
15311                     {
15312                       printf (_("  Unknown attribute:\n"));
15313                       display_raw_attribute (p, end);
15314                       p = end;
15315                     }
15316                   else
15317                     attr_len = 0;
15318                 }
15319             }
15320         }
15321
15322       free (contents);
15323     }
15324
15325   return res;
15326 }
15327
15328 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15329    Print the Address, Access and Initial fields of an entry at VMA ADDR
15330    and return the VMA of the next entry, or -1 if there was a problem.
15331    Does not read from DATA_END or beyond.  */
15332
15333 static bfd_vma
15334 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15335                       unsigned char * data_end)
15336 {
15337   printf ("  ");
15338   print_vma (addr, LONG_HEX);
15339   printf (" ");
15340   if (addr < pltgot + 0xfff0)
15341     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15342   else
15343     printf ("%10s", "");
15344   printf (" ");
15345   if (data == NULL)
15346     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15347   else
15348     {
15349       bfd_vma entry;
15350       unsigned char * from = data + addr - pltgot;
15351
15352       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15353         {
15354           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15355           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15356           return (bfd_vma) -1;
15357         }
15358       else
15359         {
15360           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15361           print_vma (entry, LONG_HEX);
15362         }
15363     }
15364   return addr + (is_32bit_elf ? 4 : 8);
15365 }
15366
15367 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15368    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15369    ADDR and return the VMA of the next entry.  */
15370
15371 static bfd_vma
15372 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15373 {
15374   printf ("  ");
15375   print_vma (addr, LONG_HEX);
15376   printf (" ");
15377   if (data == NULL)
15378     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15379   else
15380     {
15381       bfd_vma entry;
15382
15383       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15384       print_vma (entry, LONG_HEX);
15385     }
15386   return addr + (is_32bit_elf ? 4 : 8);
15387 }
15388
15389 static void
15390 print_mips_ases (unsigned int mask)
15391 {
15392   if (mask & AFL_ASE_DSP)
15393     fputs ("\n\tDSP ASE", stdout);
15394   if (mask & AFL_ASE_DSPR2)
15395     fputs ("\n\tDSP R2 ASE", stdout);
15396   if (mask & AFL_ASE_DSPR3)
15397     fputs ("\n\tDSP R3 ASE", stdout);
15398   if (mask & AFL_ASE_EVA)
15399     fputs ("\n\tEnhanced VA Scheme", stdout);
15400   if (mask & AFL_ASE_MCU)
15401     fputs ("\n\tMCU (MicroController) ASE", stdout);
15402   if (mask & AFL_ASE_MDMX)
15403     fputs ("\n\tMDMX ASE", stdout);
15404   if (mask & AFL_ASE_MIPS3D)
15405     fputs ("\n\tMIPS-3D ASE", stdout);
15406   if (mask & AFL_ASE_MT)
15407     fputs ("\n\tMT ASE", stdout);
15408   if (mask & AFL_ASE_SMARTMIPS)
15409     fputs ("\n\tSmartMIPS ASE", stdout);
15410   if (mask & AFL_ASE_VIRT)
15411     fputs ("\n\tVZ ASE", stdout);
15412   if (mask & AFL_ASE_MSA)
15413     fputs ("\n\tMSA ASE", stdout);
15414   if (mask & AFL_ASE_MIPS16)
15415     fputs ("\n\tMIPS16 ASE", stdout);
15416   if (mask & AFL_ASE_MICROMIPS)
15417     fputs ("\n\tMICROMIPS ASE", stdout);
15418   if (mask & AFL_ASE_XPA)
15419     fputs ("\n\tXPA ASE", stdout);
15420   if (mask & AFL_ASE_MIPS16E2)
15421     fputs ("\n\tMIPS16e2 ASE", stdout);
15422   if (mask == 0)
15423     fprintf (stdout, "\n\t%s", _("None"));
15424   else if ((mask & ~AFL_ASE_MASK) != 0)
15425     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15426 }
15427
15428 static void
15429 print_mips_isa_ext (unsigned int isa_ext)
15430 {
15431   switch (isa_ext)
15432     {
15433     case 0:
15434       fputs (_("None"), stdout);
15435       break;
15436     case AFL_EXT_XLR:
15437       fputs ("RMI XLR", stdout);
15438       break;
15439     case AFL_EXT_OCTEON3:
15440       fputs ("Cavium Networks Octeon3", stdout);
15441       break;
15442     case AFL_EXT_OCTEON2:
15443       fputs ("Cavium Networks Octeon2", stdout);
15444       break;
15445     case AFL_EXT_OCTEONP:
15446       fputs ("Cavium Networks OcteonP", stdout);
15447       break;
15448     case AFL_EXT_LOONGSON_3A:
15449       fputs ("Loongson 3A", stdout);
15450       break;
15451     case AFL_EXT_OCTEON:
15452       fputs ("Cavium Networks Octeon", stdout);
15453       break;
15454     case AFL_EXT_5900:
15455       fputs ("Toshiba R5900", stdout);
15456       break;
15457     case AFL_EXT_4650:
15458       fputs ("MIPS R4650", stdout);
15459       break;
15460     case AFL_EXT_4010:
15461       fputs ("LSI R4010", stdout);
15462       break;
15463     case AFL_EXT_4100:
15464       fputs ("NEC VR4100", stdout);
15465       break;
15466     case AFL_EXT_3900:
15467       fputs ("Toshiba R3900", stdout);
15468       break;
15469     case AFL_EXT_10000:
15470       fputs ("MIPS R10000", stdout);
15471       break;
15472     case AFL_EXT_SB1:
15473       fputs ("Broadcom SB-1", stdout);
15474       break;
15475     case AFL_EXT_4111:
15476       fputs ("NEC VR4111/VR4181", stdout);
15477       break;
15478     case AFL_EXT_4120:
15479       fputs ("NEC VR4120", stdout);
15480       break;
15481     case AFL_EXT_5400:
15482       fputs ("NEC VR5400", stdout);
15483       break;
15484     case AFL_EXT_5500:
15485       fputs ("NEC VR5500", stdout);
15486       break;
15487     case AFL_EXT_LOONGSON_2E:
15488       fputs ("ST Microelectronics Loongson 2E", stdout);
15489       break;
15490     case AFL_EXT_LOONGSON_2F:
15491       fputs ("ST Microelectronics Loongson 2F", stdout);
15492       break;
15493     case AFL_EXT_INTERAPTIV_MR2:
15494       fputs ("Imagination interAptiv MR2", stdout);
15495       break;
15496     default:
15497       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15498     }
15499 }
15500
15501 static signed int
15502 get_mips_reg_size (int reg_size)
15503 {
15504   return (reg_size == AFL_REG_NONE) ? 0
15505          : (reg_size == AFL_REG_32) ? 32
15506          : (reg_size == AFL_REG_64) ? 64
15507          : (reg_size == AFL_REG_128) ? 128
15508          : -1;
15509 }
15510
15511 static bfd_boolean
15512 process_mips_specific (Filedata * filedata)
15513 {
15514   Elf_Internal_Dyn * entry;
15515   Elf_Internal_Shdr *sect = NULL;
15516   size_t liblist_offset = 0;
15517   size_t liblistno = 0;
15518   size_t conflictsno = 0;
15519   size_t options_offset = 0;
15520   size_t conflicts_offset = 0;
15521   size_t pltrelsz = 0;
15522   size_t pltrel = 0;
15523   bfd_vma pltgot = 0;
15524   bfd_vma mips_pltgot = 0;
15525   bfd_vma jmprel = 0;
15526   bfd_vma local_gotno = 0;
15527   bfd_vma gotsym = 0;
15528   bfd_vma symtabno = 0;
15529   bfd_boolean res = TRUE;
15530
15531   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15532                             display_mips_gnu_attribute))
15533     res = FALSE;
15534
15535   sect = find_section (filedata, ".MIPS.abiflags");
15536
15537   if (sect != NULL)
15538     {
15539       Elf_External_ABIFlags_v0 *abiflags_ext;
15540       Elf_Internal_ABIFlags_v0 abiflags_in;
15541
15542       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15543         {
15544           error (_("Corrupt MIPS ABI Flags section.\n"));
15545           res = FALSE;
15546         }
15547       else
15548         {
15549           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15550                                    sect->sh_size, _("MIPS ABI Flags section"));
15551           if (abiflags_ext)
15552             {
15553               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15554               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15555               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15556               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15557               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15558               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15559               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15560               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15561               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15562               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15563               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15564
15565               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15566               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15567               if (abiflags_in.isa_rev > 1)
15568                 printf ("r%d", abiflags_in.isa_rev);
15569               printf ("\nGPR size: %d",
15570                       get_mips_reg_size (abiflags_in.gpr_size));
15571               printf ("\nCPR1 size: %d",
15572                       get_mips_reg_size (abiflags_in.cpr1_size));
15573               printf ("\nCPR2 size: %d",
15574                       get_mips_reg_size (abiflags_in.cpr2_size));
15575               fputs ("\nFP ABI: ", stdout);
15576               print_mips_fp_abi_value (abiflags_in.fp_abi);
15577               fputs ("ISA Extension: ", stdout);
15578               print_mips_isa_ext (abiflags_in.isa_ext);
15579               fputs ("\nASEs:", stdout);
15580               print_mips_ases (abiflags_in.ases);
15581               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15582               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15583               fputc ('\n', stdout);
15584               free (abiflags_ext);
15585             }
15586         }
15587     }
15588
15589   /* We have a lot of special sections.  Thanks SGI!  */
15590   if (dynamic_section == NULL)
15591     {
15592       /* No dynamic information available.  See if there is static GOT.  */
15593       sect = find_section (filedata, ".got");
15594       if (sect != NULL)
15595         {
15596           unsigned char *data_end;
15597           unsigned char *data;
15598           bfd_vma ent, end;
15599           int addr_size;
15600
15601           pltgot = sect->sh_addr;
15602
15603           ent = pltgot;
15604           addr_size = (is_32bit_elf ? 4 : 8);
15605           end = pltgot + sect->sh_size;
15606
15607           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15608                                              end - pltgot, 1,
15609                                              _("Global Offset Table data"));
15610           /* PR 12855: Null data is handled gracefully throughout.  */
15611           data_end = data + (end - pltgot);
15612
15613           printf (_("\nStatic GOT:\n"));
15614           printf (_(" Canonical gp value: "));
15615           print_vma (ent + 0x7ff0, LONG_HEX);
15616           printf ("\n\n");
15617
15618           /* In a dynamic binary GOT[0] is reserved for the dynamic
15619              loader to store the lazy resolver pointer, however in
15620              a static binary it may well have been omitted and GOT
15621              reduced to a table of addresses.
15622              PR 21344: Check for the entry being fully available
15623              before fetching it.  */
15624           if (data
15625               && data + ent - pltgot + addr_size <= data_end
15626               && byte_get (data + ent - pltgot, addr_size) == 0)
15627             {
15628               printf (_(" Reserved entries:\n"));
15629               printf (_("  %*s %10s %*s\n"),
15630                       addr_size * 2, _("Address"), _("Access"),
15631                       addr_size * 2, _("Value"));
15632               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15633               printf ("\n");
15634               if (ent == (bfd_vma) -1)
15635                 goto sgot_print_fail;
15636
15637               /* Check for the MSB of GOT[1] being set, identifying a
15638                  GNU object.  This entry will be used by some runtime
15639                  loaders, to store the module pointer.  Otherwise this
15640                  is an ordinary local entry.
15641                  PR 21344: Check for the entry being fully available
15642                  before fetching it.  */
15643               if (data
15644                   && data + ent - pltgot + addr_size <= data_end
15645                   && (byte_get (data + ent - pltgot, addr_size)
15646                       >> (addr_size * 8 - 1)) != 0)
15647                 {
15648                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15649                   printf ("\n");
15650                   if (ent == (bfd_vma) -1)
15651                     goto sgot_print_fail;
15652                 }
15653               printf ("\n");
15654             }
15655
15656           if (data != NULL && ent < end)
15657             {
15658               printf (_(" Local entries:\n"));
15659               printf ("  %*s %10s %*s\n",
15660                       addr_size * 2, _("Address"), _("Access"),
15661                       addr_size * 2, _("Value"));
15662               while (ent < end)
15663                 {
15664                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15665                   printf ("\n");
15666                   if (ent == (bfd_vma) -1)
15667                     goto sgot_print_fail;
15668                 }
15669               printf ("\n");
15670             }
15671
15672         sgot_print_fail:
15673           if (data)
15674             free (data);
15675         }
15676       return res;
15677     }
15678
15679   for (entry = dynamic_section;
15680        /* PR 17531 file: 012-50589-0.004.  */
15681        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15682        ++entry)
15683     switch (entry->d_tag)
15684       {
15685       case DT_MIPS_LIBLIST:
15686         liblist_offset
15687           = offset_from_vma (filedata, entry->d_un.d_val,
15688                              liblistno * sizeof (Elf32_External_Lib));
15689         break;
15690       case DT_MIPS_LIBLISTNO:
15691         liblistno = entry->d_un.d_val;
15692         break;
15693       case DT_MIPS_OPTIONS:
15694         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15695         break;
15696       case DT_MIPS_CONFLICT:
15697         conflicts_offset
15698           = offset_from_vma (filedata, entry->d_un.d_val,
15699                              conflictsno * sizeof (Elf32_External_Conflict));
15700         break;
15701       case DT_MIPS_CONFLICTNO:
15702         conflictsno = entry->d_un.d_val;
15703         break;
15704       case DT_PLTGOT:
15705         pltgot = entry->d_un.d_ptr;
15706         break;
15707       case DT_MIPS_LOCAL_GOTNO:
15708         local_gotno = entry->d_un.d_val;
15709         break;
15710       case DT_MIPS_GOTSYM:
15711         gotsym = entry->d_un.d_val;
15712         break;
15713       case DT_MIPS_SYMTABNO:
15714         symtabno = entry->d_un.d_val;
15715         break;
15716       case DT_MIPS_PLTGOT:
15717         mips_pltgot = entry->d_un.d_ptr;
15718         break;
15719       case DT_PLTREL:
15720         pltrel = entry->d_un.d_val;
15721         break;
15722       case DT_PLTRELSZ:
15723         pltrelsz = entry->d_un.d_val;
15724         break;
15725       case DT_JMPREL:
15726         jmprel = entry->d_un.d_ptr;
15727         break;
15728       default:
15729         break;
15730       }
15731
15732   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15733     {
15734       Elf32_External_Lib * elib;
15735       size_t cnt;
15736
15737       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15738                                               liblistno,
15739                                               sizeof (Elf32_External_Lib),
15740                                               _("liblist section data"));
15741       if (elib)
15742         {
15743           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15744                             "\nSection '.liblist' contains %lu entries:\n",
15745                             (unsigned long) liblistno),
15746                   (unsigned long) liblistno);
15747           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15748                  stdout);
15749
15750           for (cnt = 0; cnt < liblistno; ++cnt)
15751             {
15752               Elf32_Lib liblist;
15753               time_t atime;
15754               char timebuf[128];
15755               struct tm * tmp;
15756
15757               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15758               atime = BYTE_GET (elib[cnt].l_time_stamp);
15759               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15760               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15761               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15762
15763               tmp = gmtime (&atime);
15764               snprintf (timebuf, sizeof (timebuf),
15765                         "%04u-%02u-%02uT%02u:%02u:%02u",
15766                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15767                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15768
15769               printf ("%3lu: ", (unsigned long) cnt);
15770               if (VALID_DYNAMIC_NAME (liblist.l_name))
15771                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15772               else
15773                 printf (_("<corrupt: %9ld>"), liblist.l_name);
15774               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15775                       liblist.l_version);
15776
15777               if (liblist.l_flags == 0)
15778                 puts (_(" NONE"));
15779               else
15780                 {
15781                   static const struct
15782                   {
15783                     const char * name;
15784                     int bit;
15785                   }
15786                   l_flags_vals[] =
15787                   {
15788                     { " EXACT_MATCH", LL_EXACT_MATCH },
15789                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15790                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15791                     { " EXPORTS", LL_EXPORTS },
15792                     { " DELAY_LOAD", LL_DELAY_LOAD },
15793                     { " DELTA", LL_DELTA }
15794                   };
15795                   int flags = liblist.l_flags;
15796                   size_t fcnt;
15797
15798                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15799                     if ((flags & l_flags_vals[fcnt].bit) != 0)
15800                       {
15801                         fputs (l_flags_vals[fcnt].name, stdout);
15802                         flags ^= l_flags_vals[fcnt].bit;
15803                       }
15804                   if (flags != 0)
15805                     printf (" %#x", (unsigned int) flags);
15806
15807                   puts ("");
15808                 }
15809             }
15810
15811           free (elib);
15812         }
15813       else
15814         res = FALSE;
15815     }
15816
15817   if (options_offset != 0)
15818     {
15819       Elf_External_Options * eopt;
15820       Elf_Internal_Options * iopt;
15821       Elf_Internal_Options * option;
15822       size_t offset;
15823       int cnt;
15824       sect = filedata->section_headers;
15825
15826       /* Find the section header so that we get the size.  */
15827       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
15828       /* PR 17533 file: 012-277276-0.004.  */
15829       if (sect == NULL)
15830         {
15831           error (_("No MIPS_OPTIONS header found\n"));
15832           return FALSE;
15833         }
15834
15835       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
15836                                                 sect->sh_size, _("options"));
15837       if (eopt)
15838         {
15839           iopt = (Elf_Internal_Options *)
15840               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15841           if (iopt == NULL)
15842             {
15843               error (_("Out of memory allocating space for MIPS options\n"));
15844               return FALSE;
15845             }
15846
15847           offset = cnt = 0;
15848           option = iopt;
15849
15850           while (offset <= sect->sh_size - sizeof (* eopt))
15851             {
15852               Elf_External_Options * eoption;
15853
15854               eoption = (Elf_External_Options *) ((char *) eopt + offset);
15855
15856               option->kind = BYTE_GET (eoption->kind);
15857               option->size = BYTE_GET (eoption->size);
15858               option->section = BYTE_GET (eoption->section);
15859               option->info = BYTE_GET (eoption->info);
15860
15861               /* PR 17531: file: ffa0fa3b.  */
15862               if (option->size < sizeof (* eopt)
15863                   || offset + option->size > sect->sh_size)
15864                 {
15865                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
15866                   return FALSE;
15867                 }
15868               offset += option->size;
15869
15870               ++option;
15871               ++cnt;
15872             }
15873
15874           printf (ngettext ("\nSection '%s' contains %d entry:\n",
15875                             "\nSection '%s' contains %d entries:\n",
15876                             cnt),
15877                   printable_section_name (filedata, sect), cnt);
15878
15879           option = iopt;
15880           offset = 0;
15881
15882           while (cnt-- > 0)
15883             {
15884               size_t len;
15885
15886               switch (option->kind)
15887                 {
15888                 case ODK_NULL:
15889                   /* This shouldn't happen.  */
15890                   printf (" NULL       %d %lx", option->section, option->info);
15891                   break;
15892                 case ODK_REGINFO:
15893                   printf (" REGINFO    ");
15894                   if (filedata->file_header.e_machine == EM_MIPS)
15895                     {
15896                       /* 32bit form.  */
15897                       Elf32_External_RegInfo * ereg;
15898                       Elf32_RegInfo reginfo;
15899
15900                       ereg = (Elf32_External_RegInfo *) (option + 1);
15901                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15902                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15903                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15904                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15905                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15906                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15907
15908                       printf ("GPR %08lx  GP 0x%lx\n",
15909                               reginfo.ri_gprmask,
15910                               (unsigned long) reginfo.ri_gp_value);
15911                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15912                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15913                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15914                     }
15915                   else
15916                     {
15917                       /* 64 bit form.  */
15918                       Elf64_External_RegInfo * ereg;
15919                       Elf64_Internal_RegInfo reginfo;
15920
15921                       ereg = (Elf64_External_RegInfo *) (option + 1);
15922                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
15923                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15924                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15925                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15926                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15927                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
15928
15929                       printf ("GPR %08lx  GP 0x",
15930                               reginfo.ri_gprmask);
15931                       printf_vma (reginfo.ri_gp_value);
15932                       printf ("\n");
15933
15934                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
15935                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15936                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15937                     }
15938                   ++option;
15939                   continue;
15940                 case ODK_EXCEPTIONS:
15941                   fputs (" EXCEPTIONS fpe_min(", stdout);
15942                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15943                   fputs (") fpe_max(", stdout);
15944                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15945                   fputs (")", stdout);
15946
15947                   if (option->info & OEX_PAGE0)
15948                     fputs (" PAGE0", stdout);
15949                   if (option->info & OEX_SMM)
15950                     fputs (" SMM", stdout);
15951                   if (option->info & OEX_FPDBUG)
15952                     fputs (" FPDBUG", stdout);
15953                   if (option->info & OEX_DISMISS)
15954                     fputs (" DISMISS", stdout);
15955                   break;
15956                 case ODK_PAD:
15957                   fputs (" PAD       ", stdout);
15958                   if (option->info & OPAD_PREFIX)
15959                     fputs (" PREFIX", stdout);
15960                   if (option->info & OPAD_POSTFIX)
15961                     fputs (" POSTFIX", stdout);
15962                   if (option->info & OPAD_SYMBOL)
15963                     fputs (" SYMBOL", stdout);
15964                   break;
15965                 case ODK_HWPATCH:
15966                   fputs (" HWPATCH   ", stdout);
15967                   if (option->info & OHW_R4KEOP)
15968                     fputs (" R4KEOP", stdout);
15969                   if (option->info & OHW_R8KPFETCH)
15970                     fputs (" R8KPFETCH", stdout);
15971                   if (option->info & OHW_R5KEOP)
15972                     fputs (" R5KEOP", stdout);
15973                   if (option->info & OHW_R5KCVTL)
15974                     fputs (" R5KCVTL", stdout);
15975                   break;
15976                 case ODK_FILL:
15977                   fputs (" FILL       ", stdout);
15978                   /* XXX Print content of info word?  */
15979                   break;
15980                 case ODK_TAGS:
15981                   fputs (" TAGS       ", stdout);
15982                   /* XXX Print content of info word?  */
15983                   break;
15984                 case ODK_HWAND:
15985                   fputs (" HWAND     ", stdout);
15986                   if (option->info & OHWA0_R4KEOP_CHECKED)
15987                     fputs (" R4KEOP_CHECKED", stdout);
15988                   if (option->info & OHWA0_R4KEOP_CLEAN)
15989                     fputs (" R4KEOP_CLEAN", stdout);
15990                   break;
15991                 case ODK_HWOR:
15992                   fputs (" HWOR      ", stdout);
15993                   if (option->info & OHWA0_R4KEOP_CHECKED)
15994                     fputs (" R4KEOP_CHECKED", stdout);
15995                   if (option->info & OHWA0_R4KEOP_CLEAN)
15996                     fputs (" R4KEOP_CLEAN", stdout);
15997                   break;
15998                 case ODK_GP_GROUP:
15999                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16000                           option->info & OGP_GROUP,
16001                           (option->info & OGP_SELF) >> 16);
16002                   break;
16003                 case ODK_IDENT:
16004                   printf (" IDENT     %#06lx  self-contained %#06lx",
16005                           option->info & OGP_GROUP,
16006                           (option->info & OGP_SELF) >> 16);
16007                   break;
16008                 default:
16009                   /* This shouldn't happen.  */
16010                   printf (" %3d ???     %d %lx",
16011                           option->kind, option->section, option->info);
16012                   break;
16013                 }
16014
16015               len = sizeof (* eopt);
16016               while (len < option->size)
16017                 {
16018                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16019
16020                   if (ISPRINT (datum))
16021                     printf ("%c", datum);
16022                   else
16023                     printf ("\\%03o", datum);
16024                   len ++;
16025                 }
16026               fputs ("\n", stdout);
16027
16028               offset += option->size;
16029               ++option;
16030             }
16031
16032           free (eopt);
16033         }
16034       else
16035         res = FALSE;
16036     }
16037
16038   if (conflicts_offset != 0 && conflictsno != 0)
16039     {
16040       Elf32_Conflict * iconf;
16041       size_t cnt;
16042
16043       if (dynamic_symbols == NULL)
16044         {
16045           error (_("conflict list found without a dynamic symbol table\n"));
16046           return FALSE;
16047         }
16048
16049       /* PR 21345 - print a slightly more helpful error message
16050          if we are sure that the cmalloc will fail.  */
16051       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16052         {
16053           error (_("Overlarge number of conflicts detected: %lx\n"),
16054                  (long) conflictsno);
16055           return FALSE;
16056         }
16057
16058       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16059       if (iconf == NULL)
16060         {
16061           error (_("Out of memory allocating space for dynamic conflicts\n"));
16062           return FALSE;
16063         }
16064
16065       if (is_32bit_elf)
16066         {
16067           Elf32_External_Conflict * econf32;
16068
16069           econf32 = (Elf32_External_Conflict *)
16070               get_data (NULL, filedata, conflicts_offset, conflictsno,
16071                         sizeof (* econf32), _("conflict"));
16072           if (!econf32)
16073             return FALSE;
16074
16075           for (cnt = 0; cnt < conflictsno; ++cnt)
16076             iconf[cnt] = BYTE_GET (econf32[cnt]);
16077
16078           free (econf32);
16079         }
16080       else
16081         {
16082           Elf64_External_Conflict * econf64;
16083
16084           econf64 = (Elf64_External_Conflict *)
16085               get_data (NULL, filedata, conflicts_offset, conflictsno,
16086                         sizeof (* econf64), _("conflict"));
16087           if (!econf64)
16088             return FALSE;
16089
16090           for (cnt = 0; cnt < conflictsno; ++cnt)
16091             iconf[cnt] = BYTE_GET (econf64[cnt]);
16092
16093           free (econf64);
16094         }
16095
16096       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16097                         "\nSection '.conflict' contains %lu entries:\n",
16098                         (unsigned long) conflictsno),
16099               (unsigned long) conflictsno);
16100       puts (_("  Num:    Index       Value  Name"));
16101
16102       for (cnt = 0; cnt < conflictsno; ++cnt)
16103         {
16104           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16105
16106           if (iconf[cnt] >= num_dynamic_syms)
16107             printf (_("<corrupt symbol index>"));
16108           else
16109             {
16110               Elf_Internal_Sym * psym;
16111
16112               psym = & dynamic_symbols[iconf[cnt]];
16113               print_vma (psym->st_value, FULL_HEX);
16114               putchar (' ');
16115               if (VALID_DYNAMIC_NAME (psym->st_name))
16116                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16117               else
16118                 printf (_("<corrupt: %14ld>"), psym->st_name);
16119             }
16120           putchar ('\n');
16121         }
16122
16123       free (iconf);
16124     }
16125
16126   if (pltgot != 0 && local_gotno != 0)
16127     {
16128       bfd_vma ent, local_end, global_end;
16129       size_t i, offset;
16130       unsigned char * data;
16131       unsigned char * data_end;
16132       int addr_size;
16133
16134       ent = pltgot;
16135       addr_size = (is_32bit_elf ? 4 : 8);
16136       local_end = pltgot + local_gotno * addr_size;
16137
16138       /* PR binutils/17533 file: 012-111227-0.004  */
16139       if (symtabno < gotsym)
16140         {
16141           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16142                  (unsigned long) gotsym, (unsigned long) symtabno);
16143           return FALSE;
16144         }
16145
16146       global_end = local_end + (symtabno - gotsym) * addr_size;
16147       /* PR 17531: file: 54c91a34.  */
16148       if (global_end < local_end)
16149         {
16150           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16151           return FALSE;
16152         }
16153
16154       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16155       data = (unsigned char *) get_data (NULL, filedata, offset,
16156                                          global_end - pltgot, 1,
16157                                          _("Global Offset Table data"));
16158       /* PR 12855: Null data is handled gracefully throughout.  */
16159       data_end = data + (global_end - pltgot);
16160
16161       printf (_("\nPrimary GOT:\n"));
16162       printf (_(" Canonical gp value: "));
16163       print_vma (pltgot + 0x7ff0, LONG_HEX);
16164       printf ("\n\n");
16165
16166       printf (_(" Reserved entries:\n"));
16167       printf (_("  %*s %10s %*s Purpose\n"),
16168               addr_size * 2, _("Address"), _("Access"),
16169               addr_size * 2, _("Initial"));
16170       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16171       printf (_(" Lazy resolver\n"));
16172       if (ent == (bfd_vma) -1)
16173         goto got_print_fail;
16174
16175       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16176          This entry will be used by some runtime loaders, to store the
16177          module pointer.  Otherwise this is an ordinary local entry.
16178          PR 21344: Check for the entry being fully available before
16179          fetching it.  */
16180       if (data
16181           && data + ent - pltgot + addr_size <= data_end
16182           && (byte_get (data + ent - pltgot, addr_size)
16183               >> (addr_size * 8 - 1)) != 0)
16184         {
16185           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16186           printf (_(" Module pointer (GNU extension)\n"));
16187           if (ent == (bfd_vma) -1)
16188             goto got_print_fail;
16189         }
16190       printf ("\n");
16191
16192       if (data != NULL && ent < local_end)
16193         {
16194           printf (_(" Local entries:\n"));
16195           printf ("  %*s %10s %*s\n",
16196                   addr_size * 2, _("Address"), _("Access"),
16197                   addr_size * 2, _("Initial"));
16198           while (ent < local_end)
16199             {
16200               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16201               printf ("\n");
16202               if (ent == (bfd_vma) -1)
16203                 goto got_print_fail;
16204             }
16205           printf ("\n");
16206         }
16207
16208       if (data != NULL && gotsym < symtabno)
16209         {
16210           int sym_width;
16211
16212           printf (_(" Global entries:\n"));
16213           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16214                   addr_size * 2, _("Address"),
16215                   _("Access"),
16216                   addr_size * 2, _("Initial"),
16217                   addr_size * 2, _("Sym.Val."),
16218                   _("Type"),
16219                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16220                   _("Ndx"), _("Name"));
16221
16222           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16223
16224           for (i = gotsym; i < symtabno; i++)
16225             {
16226               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16227               printf (" ");
16228
16229               if (dynamic_symbols == NULL)
16230                 printf (_("<no dynamic symbols>"));
16231               else if (i < num_dynamic_syms)
16232                 {
16233                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16234
16235                   print_vma (psym->st_value, LONG_HEX);
16236                   printf (" %-7s %3s ",
16237                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16238                           get_symbol_index_type (filedata, psym->st_shndx));
16239
16240                   if (VALID_DYNAMIC_NAME (psym->st_name))
16241                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16242                   else
16243                     printf (_("<corrupt: %14ld>"), psym->st_name);
16244                 }
16245               else
16246                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16247                         (unsigned long) i);
16248
16249               printf ("\n");
16250               if (ent == (bfd_vma) -1)
16251                 break;
16252             }
16253           printf ("\n");
16254         }
16255
16256     got_print_fail:
16257       if (data)
16258         free (data);
16259     }
16260
16261   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16262     {
16263       bfd_vma ent, end;
16264       size_t offset, rel_offset;
16265       unsigned long count, i;
16266       unsigned char * data;
16267       int addr_size, sym_width;
16268       Elf_Internal_Rela * rels;
16269
16270       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16271       if (pltrel == DT_RELA)
16272         {
16273           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16274             return FALSE;
16275         }
16276       else
16277         {
16278           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16279             return FALSE;
16280         }
16281
16282       ent = mips_pltgot;
16283       addr_size = (is_32bit_elf ? 4 : 8);
16284       end = mips_pltgot + (2 + count) * addr_size;
16285
16286       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16287       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16288                                          1, _("Procedure Linkage Table data"));
16289       if (data == NULL)
16290         return FALSE;
16291
16292       printf ("\nPLT GOT:\n\n");
16293       printf (_(" Reserved entries:\n"));
16294       printf (_("  %*s %*s Purpose\n"),
16295               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16296       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16297       printf (_(" PLT lazy resolver\n"));
16298       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16299       printf (_(" Module pointer\n"));
16300       printf ("\n");
16301
16302       printf (_(" Entries:\n"));
16303       printf ("  %*s %*s %*s %-7s %3s %s\n",
16304               addr_size * 2, _("Address"),
16305               addr_size * 2, _("Initial"),
16306               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16307       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16308       for (i = 0; i < count; i++)
16309         {
16310           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16311
16312           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16313           printf (" ");
16314
16315           if (idx >= num_dynamic_syms)
16316             printf (_("<corrupt symbol index: %lu>"), idx);
16317           else
16318             {
16319               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16320
16321               print_vma (psym->st_value, LONG_HEX);
16322               printf (" %-7s %3s ",
16323                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16324                       get_symbol_index_type (filedata, psym->st_shndx));
16325               if (VALID_DYNAMIC_NAME (psym->st_name))
16326                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16327               else
16328                 printf (_("<corrupt: %14ld>"), psym->st_name);
16329             }
16330           printf ("\n");
16331         }
16332       printf ("\n");
16333
16334       if (data)
16335         free (data);
16336       free (rels);
16337     }
16338
16339   return res;
16340 }
16341
16342 static bfd_boolean
16343 process_nds32_specific (Filedata * filedata)
16344 {
16345   Elf_Internal_Shdr *sect = NULL;
16346
16347   sect = find_section (filedata, ".nds32_e_flags");
16348   if (sect != NULL)
16349     {
16350       unsigned int *flag;
16351
16352       printf ("\nNDS32 elf flags section:\n");
16353       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16354                        sect->sh_size, _("NDS32 elf flags section"));
16355
16356       if (! flag)
16357         return FALSE;
16358
16359       switch ((*flag) & 0x3)
16360         {
16361         case 0:
16362           printf ("(VEC_SIZE):\tNo entry.\n");
16363           break;
16364         case 1:
16365           printf ("(VEC_SIZE):\t4 bytes\n");
16366           break;
16367         case 2:
16368           printf ("(VEC_SIZE):\t16 bytes\n");
16369           break;
16370         case 3:
16371           printf ("(VEC_SIZE):\treserved\n");
16372           break;
16373         }
16374     }
16375
16376   return TRUE;
16377 }
16378
16379 static bfd_boolean
16380 process_gnu_liblist (Filedata * filedata)
16381 {
16382   Elf_Internal_Shdr * section;
16383   Elf_Internal_Shdr * string_sec;
16384   Elf32_External_Lib * elib;
16385   char * strtab;
16386   size_t strtab_size;
16387   size_t cnt;
16388   unsigned long num_liblist;
16389   unsigned i;
16390   bfd_boolean res = TRUE;
16391
16392   if (! do_arch)
16393     return TRUE;
16394
16395   for (i = 0, section = filedata->section_headers;
16396        i < filedata->file_header.e_shnum;
16397        i++, section++)
16398     {
16399       switch (section->sh_type)
16400         {
16401         case SHT_GNU_LIBLIST:
16402           if (section->sh_link >= filedata->file_header.e_shnum)
16403             break;
16404
16405           elib = (Elf32_External_Lib *)
16406               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16407                         _("liblist section data"));
16408
16409           if (elib == NULL)
16410             {
16411               res = FALSE;
16412               break;
16413             }
16414
16415           string_sec = filedata->section_headers + section->sh_link;
16416           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16417                                       string_sec->sh_size,
16418                                       _("liblist string table"));
16419           if (strtab == NULL
16420               || section->sh_entsize != sizeof (Elf32_External_Lib))
16421             {
16422               free (elib);
16423               free (strtab);
16424               res = FALSE;
16425               break;
16426             }
16427           strtab_size = string_sec->sh_size;
16428
16429           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16430           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16431                             "\nLibrary list section '%s' contains %lu entries:\n",
16432                             num_liblist),
16433                   printable_section_name (filedata, section),
16434                   num_liblist);
16435
16436           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16437
16438           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16439                ++cnt)
16440             {
16441               Elf32_Lib liblist;
16442               time_t atime;
16443               char timebuf[128];
16444               struct tm * tmp;
16445
16446               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16447               atime = BYTE_GET (elib[cnt].l_time_stamp);
16448               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16449               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16450               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16451
16452               tmp = gmtime (&atime);
16453               snprintf (timebuf, sizeof (timebuf),
16454                         "%04u-%02u-%02uT%02u:%02u:%02u",
16455                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16456                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16457
16458               printf ("%3lu: ", (unsigned long) cnt);
16459               if (do_wide)
16460                 printf ("%-20s", liblist.l_name < strtab_size
16461                         ? strtab + liblist.l_name : _("<corrupt>"));
16462               else
16463                 printf ("%-20.20s", liblist.l_name < strtab_size
16464                         ? strtab + liblist.l_name : _("<corrupt>"));
16465               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16466                       liblist.l_version, liblist.l_flags);
16467             }
16468
16469           free (elib);
16470           free (strtab);
16471         }
16472     }
16473
16474   return res;
16475 }
16476
16477 static const char *
16478 get_note_type (Filedata * filedata, unsigned e_type)
16479 {
16480   static char buff[64];
16481
16482   if (filedata->file_header.e_type == ET_CORE)
16483     switch (e_type)
16484       {
16485       case NT_AUXV:
16486         return _("NT_AUXV (auxiliary vector)");
16487       case NT_PRSTATUS:
16488         return _("NT_PRSTATUS (prstatus structure)");
16489       case NT_FPREGSET:
16490         return _("NT_FPREGSET (floating point registers)");
16491       case NT_PRPSINFO:
16492         return _("NT_PRPSINFO (prpsinfo structure)");
16493       case NT_TASKSTRUCT:
16494         return _("NT_TASKSTRUCT (task structure)");
16495       case NT_PRXFPREG:
16496         return _("NT_PRXFPREG (user_xfpregs structure)");
16497       case NT_PPC_VMX:
16498         return _("NT_PPC_VMX (ppc Altivec registers)");
16499       case NT_PPC_VSX:
16500         return _("NT_PPC_VSX (ppc VSX registers)");
16501       case NT_PPC_TAR:
16502         return _("NT_PPC_TAR (ppc TAR register)");
16503       case NT_PPC_PPR:
16504         return _("NT_PPC_PPR (ppc PPR register)");
16505       case NT_PPC_DSCR:
16506         return _("NT_PPC_DSCR (ppc DSCR register)");
16507       case NT_PPC_EBB:
16508         return _("NT_PPC_EBB (ppc EBB registers)");
16509       case NT_PPC_PMU:
16510         return _("NT_PPC_PMU (ppc PMU registers)");
16511       case NT_PPC_TM_CGPR:
16512         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16513       case NT_PPC_TM_CFPR:
16514         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16515       case NT_PPC_TM_CVMX:
16516         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16517       case NT_PPC_TM_CVSX:
16518         return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16519       case NT_PPC_TM_SPR:
16520         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16521       case NT_PPC_TM_CTAR:
16522         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16523       case NT_PPC_TM_CPPR:
16524         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16525       case NT_PPC_TM_CDSCR:
16526         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16527       case NT_386_TLS:
16528         return _("NT_386_TLS (x86 TLS information)");
16529       case NT_386_IOPERM:
16530         return _("NT_386_IOPERM (x86 I/O permissions)");
16531       case NT_X86_XSTATE:
16532         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16533       case NT_S390_HIGH_GPRS:
16534         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16535       case NT_S390_TIMER:
16536         return _("NT_S390_TIMER (s390 timer register)");
16537       case NT_S390_TODCMP:
16538         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16539       case NT_S390_TODPREG:
16540         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16541       case NT_S390_CTRS:
16542         return _("NT_S390_CTRS (s390 control registers)");
16543       case NT_S390_PREFIX:
16544         return _("NT_S390_PREFIX (s390 prefix register)");
16545       case NT_S390_LAST_BREAK:
16546         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16547       case NT_S390_SYSTEM_CALL:
16548         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16549       case NT_S390_TDB:
16550         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16551       case NT_S390_VXRS_LOW:
16552         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16553       case NT_S390_VXRS_HIGH:
16554         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16555       case NT_S390_GS_CB:
16556         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16557       case NT_S390_GS_BC:
16558         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16559       case NT_ARM_VFP:
16560         return _("NT_ARM_VFP (arm VFP registers)");
16561       case NT_ARM_TLS:
16562         return _("NT_ARM_TLS (AArch TLS registers)");
16563       case NT_ARM_HW_BREAK:
16564         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16565       case NT_ARM_HW_WATCH:
16566         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16567       case NT_PSTATUS:
16568         return _("NT_PSTATUS (pstatus structure)");
16569       case NT_FPREGS:
16570         return _("NT_FPREGS (floating point registers)");
16571       case NT_PSINFO:
16572         return _("NT_PSINFO (psinfo structure)");
16573       case NT_LWPSTATUS:
16574         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16575       case NT_LWPSINFO:
16576         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16577       case NT_WIN32PSTATUS:
16578         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16579       case NT_SIGINFO:
16580         return _("NT_SIGINFO (siginfo_t data)");
16581       case NT_FILE:
16582         return _("NT_FILE (mapped files)");
16583       default:
16584         break;
16585       }
16586   else
16587     switch (e_type)
16588       {
16589       case NT_VERSION:
16590         return _("NT_VERSION (version)");
16591       case NT_ARCH:
16592         return _("NT_ARCH (architecture)");
16593       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16594         return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16595       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16596         return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16597       default:
16598         break;
16599       }
16600
16601   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16602   return buff;
16603 }
16604
16605 static bfd_boolean
16606 print_core_note (Elf_Internal_Note *pnote)
16607 {
16608   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16609   bfd_vma count, page_size;
16610   unsigned char *descdata, *filenames, *descend;
16611
16612   if (pnote->type != NT_FILE)
16613     {
16614       if (do_wide)
16615         printf ("\n");
16616       return TRUE;
16617     }
16618
16619 #ifndef BFD64
16620   if (!is_32bit_elf)
16621     {
16622       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16623       /* Still "successful".  */
16624       return TRUE;
16625     }
16626 #endif
16627
16628   if (pnote->descsz < 2 * addr_size)
16629     {
16630       error (_("    Malformed note - too short for header\n"));
16631       return FALSE;
16632     }
16633
16634   descdata = (unsigned char *) pnote->descdata;
16635   descend = descdata + pnote->descsz;
16636
16637   if (descdata[pnote->descsz - 1] != '\0')
16638     {
16639       error (_("    Malformed note - does not end with \\0\n"));
16640       return FALSE;
16641     }
16642
16643   count = byte_get (descdata, addr_size);
16644   descdata += addr_size;
16645
16646   page_size = byte_get (descdata, addr_size);
16647   descdata += addr_size;
16648
16649   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16650       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16651     {
16652       error (_("    Malformed note - too short for supplied file count\n"));
16653       return FALSE;
16654     }
16655
16656   printf (_("    Page size: "));
16657   print_vma (page_size, DEC);
16658   printf ("\n");
16659
16660   printf (_("    %*s%*s%*s\n"),
16661           (int) (2 + 2 * addr_size), _("Start"),
16662           (int) (4 + 2 * addr_size), _("End"),
16663           (int) (4 + 2 * addr_size), _("Page Offset"));
16664   filenames = descdata + count * 3 * addr_size;
16665   while (count-- > 0)
16666     {
16667       bfd_vma start, end, file_ofs;
16668
16669       if (filenames == descend)
16670         {
16671           error (_("    Malformed note - filenames end too early\n"));
16672           return FALSE;
16673         }
16674
16675       start = byte_get (descdata, addr_size);
16676       descdata += addr_size;
16677       end = byte_get (descdata, addr_size);
16678       descdata += addr_size;
16679       file_ofs = byte_get (descdata, addr_size);
16680       descdata += addr_size;
16681
16682       printf ("    ");
16683       print_vma (start, FULL_HEX);
16684       printf ("  ");
16685       print_vma (end, FULL_HEX);
16686       printf ("  ");
16687       print_vma (file_ofs, FULL_HEX);
16688       printf ("\n        %s\n", filenames);
16689
16690       filenames += 1 + strlen ((char *) filenames);
16691     }
16692
16693   return TRUE;
16694 }
16695
16696 static const char *
16697 get_gnu_elf_note_type (unsigned e_type)
16698 {
16699   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16700   switch (e_type)
16701     {
16702     case NT_GNU_ABI_TAG:
16703       return _("NT_GNU_ABI_TAG (ABI version tag)");
16704     case NT_GNU_HWCAP:
16705       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16706     case NT_GNU_BUILD_ID:
16707       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16708     case NT_GNU_GOLD_VERSION:
16709       return _("NT_GNU_GOLD_VERSION (gold version)");
16710     case NT_GNU_PROPERTY_TYPE_0:
16711       return _("NT_GNU_PROPERTY_TYPE_0");
16712     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16713       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16714     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16715       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16716     default:
16717       {
16718         static char buff[64];
16719
16720         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16721         return buff;
16722       }
16723     }
16724 }
16725
16726 static void
16727 decode_x86_isa (unsigned int bitmask)
16728 {
16729   while (bitmask)
16730     {
16731       unsigned int bit = bitmask & (- bitmask);
16732
16733       bitmask &= ~ bit;
16734       switch (bit)
16735         {
16736         case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
16737         case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
16738         case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
16739         case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
16740         case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
16741         case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
16742         case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
16743         case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
16744         case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
16745         case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
16746         case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
16747         case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
16748         case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
16749         case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
16750         case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
16751         case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
16752         case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
16753         case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
16754         default: printf (_("<unknown: %x>"), bit); break;
16755         }
16756       if (bitmask)
16757         printf (", ");
16758     }
16759 }
16760
16761 static void
16762 decode_x86_feature (unsigned int type, unsigned int bitmask)
16763 {
16764   while (bitmask)
16765     {
16766       unsigned int bit = bitmask & (- bitmask);
16767
16768       bitmask &= ~ bit;
16769       switch (bit)
16770         {
16771         case GNU_PROPERTY_X86_FEATURE_1_IBT:
16772           switch (type)
16773             {
16774             case GNU_PROPERTY_X86_FEATURE_1_AND:
16775               printf ("IBT");
16776               break;
16777             default:
16778               /* This should never happen.  */
16779               abort ();
16780             }
16781           break;
16782         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
16783           switch (type)
16784             {
16785             case GNU_PROPERTY_X86_FEATURE_1_AND:
16786               printf ("SHSTK");
16787               break;
16788             default:
16789               /* This should never happen.  */
16790               abort ();
16791             }
16792           break;
16793         default:
16794           printf (_("<unknown: %x>"), bit);
16795           break;
16796         }
16797       if (bitmask)
16798         printf (", ");
16799     }
16800 }
16801
16802 static void
16803 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
16804 {
16805   unsigned char * ptr = (unsigned char *) pnote->descdata;
16806   unsigned char * ptr_end = ptr + pnote->descsz;
16807   unsigned int    size = is_32bit_elf ? 4 : 8;
16808
16809   printf (_("      Properties: "));
16810
16811   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
16812     {
16813       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
16814       return;
16815     }
16816
16817   while (ptr < ptr_end)
16818     {
16819       unsigned int j;
16820       unsigned int type;
16821       unsigned int datasz;
16822
16823       if ((size_t) (ptr_end - ptr) < 8)
16824         {
16825           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
16826           break;
16827         }
16828
16829       type = byte_get (ptr, 4);
16830       datasz = byte_get (ptr + 4, 4);
16831
16832       ptr += 8;
16833
16834       if (datasz > (size_t) (ptr_end - ptr))
16835         {
16836           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16837                   type, datasz);
16838           break;
16839         }
16840
16841       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
16842         {
16843           if (filedata->file_header.e_machine == EM_X86_64
16844               || filedata->file_header.e_machine == EM_IAMCU
16845               || filedata->file_header.e_machine == EM_386)
16846             {
16847               switch (type)
16848                 {
16849                 case GNU_PROPERTY_X86_ISA_1_USED:
16850                   printf ("x86 ISA used: ");
16851                   if (datasz != 4)
16852                     printf (_("<corrupt length: %#x> "), datasz);
16853                   else
16854                     decode_x86_isa (byte_get (ptr, 4));
16855                   goto next;
16856
16857                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16858                   printf ("x86 ISA needed: ");
16859                   if (datasz != 4)
16860                     printf (_("<corrupt length: %#x> "), datasz);
16861                   else
16862                     decode_x86_isa (byte_get (ptr, 4));
16863                   goto next;
16864
16865                 case GNU_PROPERTY_X86_FEATURE_1_AND:
16866                   printf ("x86 feature: ");
16867                   if (datasz != 4)
16868                     printf (_("<corrupt length: %#x> "), datasz);
16869                   else
16870                     decode_x86_feature (type, byte_get (ptr, 4));
16871                   goto next;
16872
16873                 default:
16874                   break;
16875                 }
16876             }
16877         }
16878       else
16879         {
16880           switch (type)
16881             {
16882             case GNU_PROPERTY_STACK_SIZE:
16883               printf (_("stack size: "));
16884               if (datasz != size)
16885                 printf (_("<corrupt length: %#x> "), datasz);
16886               else
16887                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
16888               goto next;
16889
16890             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
16891               printf ("no copy on protected ");
16892               if (datasz)
16893                 printf (_("<corrupt length: %#x> "), datasz);
16894               goto next;
16895
16896             default:
16897               break;
16898             }
16899         }
16900
16901       if (type < GNU_PROPERTY_LOPROC)
16902         printf (_("<unknown type %#x data: "), type);
16903       else if (type < GNU_PROPERTY_LOUSER)
16904         printf (_("<procesor-specific type %#x data: "), type);
16905       else
16906         printf (_("<application-specific type %#x data: "), type);
16907       for (j = 0; j < datasz; ++j)
16908         printf ("%02x ", ptr[j] & 0xff);
16909       printf (">");
16910
16911 next:
16912       ptr += ((datasz + (size - 1)) & ~ (size - 1));
16913       if (ptr == ptr_end)
16914         break;
16915
16916       if (do_wide)
16917         printf (", ");
16918       else
16919         printf ("\n\t");
16920     }
16921
16922   printf ("\n");
16923 }
16924
16925 static bfd_boolean
16926 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
16927 {
16928   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
16929   switch (pnote->type)
16930     {
16931     case NT_GNU_BUILD_ID:
16932       {
16933         unsigned long i;
16934
16935         printf (_("    Build ID: "));
16936         for (i = 0; i < pnote->descsz; ++i)
16937           printf ("%02x", pnote->descdata[i] & 0xff);
16938         printf ("\n");
16939       }
16940       break;
16941
16942     case NT_GNU_ABI_TAG:
16943       {
16944         unsigned long os, major, minor, subminor;
16945         const char *osname;
16946
16947         /* PR 17531: file: 030-599401-0.004.  */
16948         if (pnote->descsz < 16)
16949           {
16950             printf (_("    <corrupt GNU_ABI_TAG>\n"));
16951             break;
16952           }
16953
16954         os = byte_get ((unsigned char *) pnote->descdata, 4);
16955         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16956         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16957         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16958
16959         switch (os)
16960           {
16961           case GNU_ABI_TAG_LINUX:
16962             osname = "Linux";
16963             break;
16964           case GNU_ABI_TAG_HURD:
16965             osname = "Hurd";
16966             break;
16967           case GNU_ABI_TAG_SOLARIS:
16968             osname = "Solaris";
16969             break;
16970           case GNU_ABI_TAG_FREEBSD:
16971             osname = "FreeBSD";
16972             break;
16973           case GNU_ABI_TAG_NETBSD:
16974             osname = "NetBSD";
16975             break;
16976           case GNU_ABI_TAG_SYLLABLE:
16977             osname = "Syllable";
16978             break;
16979           case GNU_ABI_TAG_NACL:
16980             osname = "NaCl";
16981             break;
16982           default:
16983             osname = "Unknown";
16984             break;
16985           }
16986
16987         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16988                 major, minor, subminor);
16989       }
16990       break;
16991
16992     case NT_GNU_GOLD_VERSION:
16993       {
16994         unsigned long i;
16995
16996         printf (_("    Version: "));
16997         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16998           printf ("%c", pnote->descdata[i]);
16999         printf ("\n");
17000       }
17001       break;
17002
17003     case NT_GNU_HWCAP:
17004       {
17005         unsigned long num_entries, mask;
17006
17007         /* Hardware capabilities information.  Word 0 is the number of entries.
17008            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17009            is a series of entries, where each entry is a single byte followed
17010            by a nul terminated string.  The byte gives the bit number to test
17011            if enabled in the bitmask.  */
17012         printf (_("      Hardware Capabilities: "));
17013         if (pnote->descsz < 8)
17014           {
17015             error (_("<corrupt GNU_HWCAP>\n"));
17016             return FALSE;
17017           }
17018         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17019         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17020         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17021         /* FIXME: Add code to display the entries... */
17022       }
17023       break;
17024
17025     case NT_GNU_PROPERTY_TYPE_0:
17026       print_gnu_property_note (filedata, pnote);
17027       break;
17028
17029     default:
17030       /* Handle unrecognised types.  An error message should have already been
17031          created by get_gnu_elf_note_type(), so all that we need to do is to
17032          display the data.  */
17033       {
17034         unsigned long i;
17035
17036         printf (_("    Description data: "));
17037         for (i = 0; i < pnote->descsz; ++i)
17038           printf ("%02x ", pnote->descdata[i] & 0xff);
17039         printf ("\n");
17040       }
17041       break;
17042     }
17043
17044   return TRUE;
17045 }
17046
17047 static const char *
17048 get_v850_elf_note_type (enum v850_notes n_type)
17049 {
17050   static char buff[64];
17051
17052   switch (n_type)
17053     {
17054     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17055     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17056     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17057     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17058     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17059     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17060     default:
17061       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17062       return buff;
17063     }
17064 }
17065
17066 static bfd_boolean
17067 print_v850_note (Elf_Internal_Note * pnote)
17068 {
17069   unsigned int val;
17070
17071   if (pnote->descsz != 4)
17072     return FALSE;
17073
17074   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17075
17076   if (val == 0)
17077     {
17078       printf (_("not set\n"));
17079       return TRUE;
17080     }
17081
17082   switch (pnote->type)
17083     {
17084     case V850_NOTE_ALIGNMENT:
17085       switch (val)
17086         {
17087         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17088         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17089         }
17090       break;
17091
17092     case V850_NOTE_DATA_SIZE:
17093       switch (val)
17094         {
17095         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17096         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17097         }
17098       break;
17099
17100     case V850_NOTE_FPU_INFO:
17101       switch (val)
17102         {
17103         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17104         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17105         }
17106       break;
17107
17108     case V850_NOTE_MMU_INFO:
17109     case V850_NOTE_CACHE_INFO:
17110     case V850_NOTE_SIMD_INFO:
17111       if (val == EF_RH850_SIMD)
17112         {
17113           printf (_("yes\n"));
17114           return TRUE;
17115         }
17116       break;
17117
17118     default:
17119       /* An 'unknown note type' message will already have been displayed.  */
17120       break;
17121     }
17122
17123   printf (_("unknown value: %x\n"), val);
17124   return FALSE;
17125 }
17126
17127 static bfd_boolean
17128 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17129 {
17130   unsigned int version;
17131
17132   switch (pnote->type)
17133     {
17134     case NT_NETBSD_IDENT:
17135       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17136       if ((version / 10000) % 100)
17137         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17138                 version, version / 100000000, (version / 1000000) % 100,
17139                 (version / 10000) % 100 > 26 ? "Z" : "",
17140                 'A' + (version / 10000) % 26);
17141       else
17142         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17143                 version, version / 100000000, (version / 1000000) % 100,
17144                 (version / 100) % 100);
17145       return TRUE;
17146
17147     case NT_NETBSD_MARCH:
17148       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17149               pnote->descdata);
17150       return TRUE;
17151
17152     default:
17153       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17154               pnote->type);
17155       return FALSE;
17156     }
17157 }
17158
17159 static const char *
17160 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17161 {
17162   switch (e_type)
17163     {
17164     case NT_FREEBSD_THRMISC:
17165       return _("NT_THRMISC (thrmisc structure)");
17166     case NT_FREEBSD_PROCSTAT_PROC:
17167       return _("NT_PROCSTAT_PROC (proc data)");
17168     case NT_FREEBSD_PROCSTAT_FILES:
17169       return _("NT_PROCSTAT_FILES (files data)");
17170     case NT_FREEBSD_PROCSTAT_VMMAP:
17171       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17172     case NT_FREEBSD_PROCSTAT_GROUPS:
17173       return _("NT_PROCSTAT_GROUPS (groups data)");
17174     case NT_FREEBSD_PROCSTAT_UMASK:
17175       return _("NT_PROCSTAT_UMASK (umask data)");
17176     case NT_FREEBSD_PROCSTAT_RLIMIT:
17177       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17178     case NT_FREEBSD_PROCSTAT_OSREL:
17179       return _("NT_PROCSTAT_OSREL (osreldate data)");
17180     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17181       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17182     case NT_FREEBSD_PROCSTAT_AUXV:
17183       return _("NT_PROCSTAT_AUXV (auxv data)");
17184     case NT_FREEBSD_PTLWPINFO:
17185       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17186     }
17187   return get_note_type (filedata, e_type);
17188 }
17189
17190 static const char *
17191 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17192 {
17193   static char buff[64];
17194
17195   if (e_type == NT_NETBSDCORE_PROCINFO)
17196     return _("NetBSD procinfo structure");
17197
17198   /* As of Jan 2002 there are no other machine-independent notes
17199      defined for NetBSD core files.  If the note type is less
17200      than the start of the machine-dependent note types, we don't
17201      understand it.  */
17202
17203   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17204     {
17205       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17206       return buff;
17207     }
17208
17209   switch (filedata->file_header.e_machine)
17210     {
17211     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17212        and PT_GETFPREGS == mach+2.  */
17213
17214     case EM_OLD_ALPHA:
17215     case EM_ALPHA:
17216     case EM_SPARC:
17217     case EM_SPARC32PLUS:
17218     case EM_SPARCV9:
17219       switch (e_type)
17220         {
17221         case NT_NETBSDCORE_FIRSTMACH + 0:
17222           return _("PT_GETREGS (reg structure)");
17223         case NT_NETBSDCORE_FIRSTMACH + 2:
17224           return _("PT_GETFPREGS (fpreg structure)");
17225         default:
17226           break;
17227         }
17228       break;
17229
17230     /* On all other arch's, PT_GETREGS == mach+1 and
17231        PT_GETFPREGS == mach+3.  */
17232     default:
17233       switch (e_type)
17234         {
17235         case NT_NETBSDCORE_FIRSTMACH + 1:
17236           return _("PT_GETREGS (reg structure)");
17237         case NT_NETBSDCORE_FIRSTMACH + 3:
17238           return _("PT_GETFPREGS (fpreg structure)");
17239         default:
17240           break;
17241         }
17242     }
17243
17244   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17245             e_type - NT_NETBSDCORE_FIRSTMACH);
17246   return buff;
17247 }
17248
17249 static const char *
17250 get_stapsdt_note_type (unsigned e_type)
17251 {
17252   static char buff[64];
17253
17254   switch (e_type)
17255     {
17256     case NT_STAPSDT:
17257       return _("NT_STAPSDT (SystemTap probe descriptors)");
17258
17259     default:
17260       break;
17261     }
17262
17263   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17264   return buff;
17265 }
17266
17267 static bfd_boolean
17268 print_stapsdt_note (Elf_Internal_Note *pnote)
17269 {
17270   int addr_size = is_32bit_elf ? 4 : 8;
17271   char *data = pnote->descdata;
17272   char *data_end = pnote->descdata + pnote->descsz;
17273   bfd_vma pc, base_addr, semaphore;
17274   char *provider, *probe, *arg_fmt;
17275
17276   pc = byte_get ((unsigned char *) data, addr_size);
17277   data += addr_size;
17278   base_addr = byte_get ((unsigned char *) data, addr_size);
17279   data += addr_size;
17280   semaphore = byte_get ((unsigned char *) data, addr_size);
17281   data += addr_size;
17282
17283   provider = data;
17284   data += strlen (data) + 1;
17285   probe = data;
17286   data += strlen (data) + 1;
17287   arg_fmt = data;
17288   data += strlen (data) + 1;
17289
17290   printf (_("    Provider: %s\n"), provider);
17291   printf (_("    Name: %s\n"), probe);
17292   printf (_("    Location: "));
17293   print_vma (pc, FULL_HEX);
17294   printf (_(", Base: "));
17295   print_vma (base_addr, FULL_HEX);
17296   printf (_(", Semaphore: "));
17297   print_vma (semaphore, FULL_HEX);
17298   printf ("\n");
17299   printf (_("    Arguments: %s\n"), arg_fmt);
17300
17301   return data == data_end;
17302 }
17303
17304 static const char *
17305 get_ia64_vms_note_type (unsigned e_type)
17306 {
17307   static char buff[64];
17308
17309   switch (e_type)
17310     {
17311     case NT_VMS_MHD:
17312       return _("NT_VMS_MHD (module header)");
17313     case NT_VMS_LNM:
17314       return _("NT_VMS_LNM (language name)");
17315     case NT_VMS_SRC:
17316       return _("NT_VMS_SRC (source files)");
17317     case NT_VMS_TITLE:
17318       return "NT_VMS_TITLE";
17319     case NT_VMS_EIDC:
17320       return _("NT_VMS_EIDC (consistency check)");
17321     case NT_VMS_FPMODE:
17322       return _("NT_VMS_FPMODE (FP mode)");
17323     case NT_VMS_LINKTIME:
17324       return "NT_VMS_LINKTIME";
17325     case NT_VMS_IMGNAM:
17326       return _("NT_VMS_IMGNAM (image name)");
17327     case NT_VMS_IMGID:
17328       return _("NT_VMS_IMGID (image id)");
17329     case NT_VMS_LINKID:
17330       return _("NT_VMS_LINKID (link id)");
17331     case NT_VMS_IMGBID:
17332       return _("NT_VMS_IMGBID (build id)");
17333     case NT_VMS_GSTNAM:
17334       return _("NT_VMS_GSTNAM (sym table name)");
17335     case NT_VMS_ORIG_DYN:
17336       return "NT_VMS_ORIG_DYN";
17337     case NT_VMS_PATCHTIME:
17338       return "NT_VMS_PATCHTIME";
17339     default:
17340       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17341       return buff;
17342     }
17343 }
17344
17345 static bfd_boolean
17346 print_ia64_vms_note (Elf_Internal_Note * pnote)
17347 {
17348   switch (pnote->type)
17349     {
17350     case NT_VMS_MHD:
17351       if (pnote->descsz > 36)
17352         {
17353           size_t l = strlen (pnote->descdata + 34);
17354           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17355           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17356           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17357           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17358         }
17359       else
17360         printf (_("    Invalid size\n"));
17361       break;
17362     case NT_VMS_LNM:
17363       printf (_("   Language: %s\n"), pnote->descdata);
17364       break;
17365 #ifdef BFD64
17366     case NT_VMS_FPMODE:
17367       printf (_("   Floating Point mode: "));
17368       printf ("0x%016" BFD_VMA_FMT "x\n",
17369               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17370       break;
17371     case NT_VMS_LINKTIME:
17372       printf (_("   Link time: "));
17373       print_vms_time
17374         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17375       printf ("\n");
17376       break;
17377     case NT_VMS_PATCHTIME:
17378       printf (_("   Patch time: "));
17379       print_vms_time
17380         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17381       printf ("\n");
17382       break;
17383     case NT_VMS_ORIG_DYN:
17384       printf (_("   Major id: %u,  minor id: %u\n"),
17385               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17386               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17387       printf (_("   Last modified  : "));
17388       print_vms_time
17389         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17390       printf (_("\n   Link flags  : "));
17391       printf ("0x%016" BFD_VMA_FMT "x\n",
17392               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17393       printf (_("   Header flags: 0x%08x\n"),
17394               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17395       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17396       break;
17397 #endif
17398     case NT_VMS_IMGNAM:
17399       printf (_("    Image name: %s\n"), pnote->descdata);
17400       break;
17401     case NT_VMS_GSTNAM:
17402       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17403       break;
17404     case NT_VMS_IMGID:
17405       printf (_("    Image id: %s\n"), pnote->descdata);
17406       break;
17407     case NT_VMS_LINKID:
17408       printf (_("    Linker id: %s\n"), pnote->descdata);
17409       break;
17410     default:
17411       return FALSE;
17412     }
17413   return TRUE;
17414 }
17415
17416 /* Print the name of the symbol associated with a build attribute
17417    that is attached to address OFFSET.  */
17418
17419 static bfd_boolean
17420 print_symbol_for_build_attribute (Filedata *     filedata,
17421                                   unsigned long  offset,
17422                                   bfd_boolean    is_open_attr)
17423 {
17424   static Filedata *         saved_filedata = NULL;
17425   static char *             strtab;
17426   static unsigned long      strtablen;
17427   static Elf_Internal_Sym * symtab;
17428   static unsigned long      nsyms;
17429   Elf_Internal_Sym *        saved_sym = NULL;
17430   Elf_Internal_Sym *        sym;
17431
17432   if (filedata->section_headers != NULL
17433       && (saved_filedata == NULL || filedata != saved_filedata))
17434     {
17435       Elf_Internal_Shdr * symsec;
17436
17437       /* Load the symbol and string sections.  */
17438       for (symsec = filedata->section_headers;
17439            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17440            symsec ++)
17441         {
17442           if (symsec->sh_type == SHT_SYMTAB)
17443             {
17444               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17445
17446               if (symsec->sh_link < filedata->file_header.e_shnum)
17447                 {
17448                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17449
17450                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17451                                               1, strtab_sec->sh_size,
17452                                               _("string table"));
17453                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17454                 }
17455             }
17456         }
17457       saved_filedata = filedata;
17458     }
17459
17460   if (symtab == NULL || strtab == NULL)
17461     {
17462       printf ("\n");
17463       return FALSE;
17464     }
17465
17466   /* Find a symbol whose value matches offset.  */
17467   for (sym = symtab; sym < symtab + nsyms; sym ++)
17468     if (sym->st_value == offset)
17469       {
17470         if (sym->st_name >= strtablen)
17471           /* Huh ?  This should not happen.  */
17472           continue;
17473
17474         if (strtab[sym->st_name] == 0)
17475           continue;
17476
17477         if (is_open_attr)
17478           {
17479             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17480                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17481                FUNC symbols entirely.  */
17482             switch (ELF_ST_TYPE (sym->st_info))
17483               {
17484               case STT_FILE:
17485                 saved_sym = sym;
17486                 /* We can stop searching now.  */
17487                 sym = symtab + nsyms;
17488                 continue;
17489
17490               case STT_OBJECT:
17491                 saved_sym = sym;
17492                 continue;
17493
17494               case STT_FUNC:
17495                 /* Ignore function symbols.  */
17496                 continue;
17497
17498               default:
17499                 break;
17500               }
17501
17502             switch (ELF_ST_BIND (sym->st_info))
17503               {
17504               case STB_GLOBAL:
17505                 if (saved_sym == NULL
17506                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17507                   saved_sym = sym;
17508                 break;
17509
17510               case STB_LOCAL:
17511                 if (saved_sym == NULL)
17512                   saved_sym = sym;
17513                 break;
17514
17515               default:
17516                 break;
17517               }
17518           }
17519         else
17520           {
17521             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
17522               continue;
17523
17524             saved_sym = sym;
17525             break;
17526           }
17527       }
17528
17529   printf (" (%s: %s)\n",
17530           is_open_attr ? _("file") : _("func"),
17531           saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
17532   return TRUE;
17533 }
17534
17535 static bfd_boolean
17536 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
17537                                        Filedata *           filedata)
17538 {
17539   static unsigned long global_offset = 0;
17540   unsigned long        offset;
17541   unsigned int         desc_size = is_32bit_elf ? 4 : 8;
17542   bfd_boolean          is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
17543
17544   if (pnote->descsz == 0)
17545     {
17546       if (is_open_attr)
17547         {
17548           printf (_("    Applies from offset %#lx\n"), global_offset);
17549           return TRUE;
17550         }
17551       else
17552         {
17553           printf (_("    Applies to func at %#lx"), global_offset);
17554           return print_symbol_for_build_attribute (filedata, global_offset, is_open_attr);
17555         }
17556     }
17557
17558   if (pnote->descsz != desc_size)
17559     {
17560       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
17561       printf (_("    <invalid descsz>"));
17562       return FALSE;
17563     }
17564
17565   offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
17566
17567   if (is_open_attr)
17568     {
17569       printf (_("    Applies from offset %#lx"), offset);
17570       global_offset = offset;
17571     }
17572   else
17573     {
17574       printf (_("    Applies to func at %#lx"), offset);
17575     }
17576
17577   return print_symbol_for_build_attribute (filedata, offset, is_open_attr);
17578 }
17579
17580 static bfd_boolean
17581 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
17582 {
17583   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
17584   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
17585   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
17586   char         name_type;
17587   char         name_attribute;
17588   const char * expected_types;
17589   const char * name = pnote->namedata;
17590   const char * text;
17591   signed int   left;
17592
17593   if (name == NULL || pnote->namesz < 2)
17594     {
17595       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
17596       print_symbol (-20, _("  <corrupt name>"));
17597       return FALSE;
17598     }
17599
17600   left = 20;
17601
17602   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
17603   if (name[0] == 'G' && name[1] == 'A')
17604     {
17605       printf ("GA");
17606       name += 2;
17607       left -= 2;
17608     }
17609
17610   switch ((name_type = * name))
17611     {
17612     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17613     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17614     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17615     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17616       printf ("%c", * name);
17617       left --;
17618       break;
17619     default:
17620       error (_("unrecognised attribute type in name field: %d\n"), name_type);
17621       print_symbol (-20, _("<unknown name type>"));
17622       return FALSE;
17623     }
17624
17625   ++ name;
17626   text = NULL;
17627
17628   switch ((name_attribute = * name))
17629     {
17630     case GNU_BUILD_ATTRIBUTE_VERSION:
17631       text = _("<version>");
17632       expected_types = string_expected;
17633       ++ name;
17634       break;
17635     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17636       text = _("<stack prot>");
17637       expected_types = "!+*";
17638       ++ name;
17639       break;
17640     case GNU_BUILD_ATTRIBUTE_RELRO:
17641       text = _("<relro>");
17642       expected_types = bool_expected;
17643       ++ name;
17644       break;
17645     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
17646       text = _("<stack size>");
17647       expected_types = number_expected;
17648       ++ name;
17649       break;
17650     case GNU_BUILD_ATTRIBUTE_TOOL:
17651       text = _("<tool>");
17652       expected_types = string_expected;
17653       ++ name;
17654       break;
17655     case GNU_BUILD_ATTRIBUTE_ABI:
17656       text = _("<ABI>");
17657       expected_types = "$*";
17658       ++ name;
17659       break;
17660     case GNU_BUILD_ATTRIBUTE_PIC:
17661       text = _("<PIC>");
17662       expected_types = number_expected;
17663       ++ name;
17664       break;
17665     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
17666       text = _("<short enum>");
17667       expected_types = bool_expected;
17668       ++ name;
17669       break;
17670     default:
17671       if (ISPRINT (* name))
17672         {
17673           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
17674
17675           if (len > left && ! do_wide)
17676             len = left;
17677           printf ("%.*s:", len, name);
17678           left -= len;
17679           name += len;
17680         }
17681       else
17682         {
17683           static char tmpbuf [128];
17684
17685           error (_("unrecognised byte in name field: %d\n"), * name);
17686           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
17687           text = tmpbuf;
17688           name ++;
17689         }
17690       expected_types = "*$!+";
17691       break;
17692     }
17693
17694   if (text)
17695     left -= printf ("%s", text);
17696
17697   if (strchr (expected_types, name_type) == NULL)
17698     warn (_("attribute does not have an expected type (%c)\n"), name_type);
17699
17700   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
17701     {
17702       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17703              (unsigned long) pnote->namesz,
17704              (long) (name - pnote->namedata));
17705       return FALSE;
17706     }
17707
17708   if (left < 1 && ! do_wide)
17709     return TRUE;
17710
17711   switch (name_type)
17712     {
17713     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
17714       {
17715         unsigned int        bytes;
17716         unsigned long long  val = 0;
17717         unsigned int        shift = 0;
17718         char *              decoded = NULL;
17719
17720         bytes = pnote->namesz - (name - pnote->namedata);
17721         if (bytes > 0)
17722           /* The -1 is because the name field is always 0 terminated, and we
17723              want to be able to ensure that the shift in the while loop below
17724              will not overflow.  */
17725           -- bytes;
17726
17727         if (bytes > sizeof (val))
17728           {
17729             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17730                    bytes);
17731             bytes = sizeof (val);
17732           }
17733         /* We do not bother to warn if bytes == 0 as this can
17734            happen with some early versions of the gcc plugin.  */
17735
17736         while (bytes --)
17737           {
17738             unsigned long byte = (* name ++) & 0xff;
17739
17740             val |= byte << shift;
17741             shift += 8;
17742           }
17743
17744         switch (name_attribute)
17745           {
17746           case GNU_BUILD_ATTRIBUTE_PIC:
17747             switch (val)
17748               {
17749               case 0: decoded = "static"; break;
17750               case 1: decoded = "pic"; break;
17751               case 2: decoded = "PIC"; break;
17752               case 3: decoded = "pie"; break;
17753               case 4: decoded = "PIE"; break;
17754               default: break;
17755               }
17756             break;
17757           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
17758             switch (val)
17759               {
17760                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
17761               case 0: decoded = "off"; break;
17762               case 1: decoded = "on"; break;
17763               case 2: decoded = "all"; break;
17764               case 3: decoded = "strong"; break;
17765               case 4: decoded = "explicit"; break;
17766               default: break;
17767               }
17768             break;
17769           default:
17770             break;
17771           }
17772
17773         if (decoded != NULL)
17774           {
17775             print_symbol (-left, decoded);
17776             left = 0;
17777           }
17778         else if (val == 0)
17779           {
17780             printf ("0x0");
17781             left -= 3;
17782           }
17783         else
17784           {
17785             if (do_wide)
17786               left -= printf ("0x%llx", val);
17787             else
17788               left -= printf ("0x%-.*llx", left, val);
17789           }
17790       }
17791       break;
17792     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
17793       left -= print_symbol (- left, name);
17794       break;
17795     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
17796       left -= print_symbol (- left, "true");
17797       break;
17798     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
17799       left -= print_symbol (- left, "false");
17800       break;
17801     }
17802
17803   if (do_wide && left > 0)
17804     printf ("%-*s", left, " ");
17805
17806   return TRUE;
17807 }
17808
17809 /* Note that by the ELF standard, the name field is already null byte
17810    terminated, and namesz includes the terminating null byte.
17811    I.E. the value of namesz for the name "FSF" is 4.
17812
17813    If the value of namesz is zero, there is no name present.  */
17814
17815 static bfd_boolean
17816 process_note (Elf_Internal_Note *  pnote,
17817               Filedata *           filedata)
17818 {
17819   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
17820   const char * nt;
17821
17822   if (pnote->namesz == 0)
17823     /* If there is no note name, then use the default set of
17824        note type strings.  */
17825     nt = get_note_type (filedata, pnote->type);
17826
17827   else if (const_strneq (pnote->namedata, "GNU"))
17828     /* GNU-specific object file notes.  */
17829     nt = get_gnu_elf_note_type (pnote->type);
17830
17831   else if (const_strneq (pnote->namedata, "FreeBSD"))
17832     /* FreeBSD-specific core file notes.  */
17833     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
17834
17835   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
17836     /* NetBSD-specific core file notes.  */
17837     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
17838
17839   else if (const_strneq (pnote->namedata, "NetBSD"))
17840     /* NetBSD-specific core file notes.  */
17841     return process_netbsd_elf_note (pnote);
17842
17843   else if (strneq (pnote->namedata, "SPU/", 4))
17844     {
17845       /* SPU-specific core file notes.  */
17846       nt = pnote->namedata + 4;
17847       name = "SPU";
17848     }
17849
17850   else if (const_strneq (pnote->namedata, "IPF/VMS"))
17851     /* VMS/ia64-specific file notes.  */
17852     nt = get_ia64_vms_note_type (pnote->type);
17853
17854   else if (const_strneq (pnote->namedata, "stapsdt"))
17855     nt = get_stapsdt_note_type (pnote->type);
17856
17857   else
17858     /* Don't recognize this note name; just use the default set of
17859        note type strings.  */
17860     nt = get_note_type (filedata, pnote->type);
17861
17862   printf ("  ");
17863
17864   if (((const_strneq (pnote->namedata, "GA")
17865         && strchr ("*$!+", pnote->namedata[2]) != NULL)
17866        || strchr ("*$!+", pnote->namedata[0]) != NULL)
17867       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17868           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17869     print_gnu_build_attribute_name (pnote);
17870   else
17871     print_symbol (-20, name);
17872
17873   if (do_wide)
17874     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
17875   else
17876     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
17877
17878   if (const_strneq (pnote->namedata, "IPF/VMS"))
17879     return print_ia64_vms_note (pnote);
17880   else if (const_strneq (pnote->namedata, "GNU"))
17881     return print_gnu_note (filedata, pnote);
17882   else if (const_strneq (pnote->namedata, "stapsdt"))
17883     return print_stapsdt_note (pnote);
17884   else if (const_strneq (pnote->namedata, "CORE"))
17885     return print_core_note (pnote);
17886   else if (((const_strneq (pnote->namedata, "GA")
17887              && strchr ("*$!+", pnote->namedata[2]) != NULL)
17888             || strchr ("*$!+", pnote->namedata[0]) != NULL)
17889            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
17890                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
17891     return print_gnu_build_attribute_description (pnote, filedata);
17892
17893   if (pnote->descsz)
17894     {
17895       unsigned long i;
17896
17897       printf (_("   description data: "));
17898       for (i = 0; i < pnote->descsz; i++)
17899         printf ("%02x ", pnote->descdata[i]);
17900       if (!do_wide)
17901         printf ("\n");
17902     }
17903
17904   if (do_wide)
17905     printf ("\n");
17906
17907   return TRUE;
17908 }
17909
17910 static bfd_boolean
17911 process_notes_at (Filedata *           filedata,
17912                   Elf_Internal_Shdr *  section,
17913                   bfd_vma              offset,
17914                   bfd_vma              length,
17915                   bfd_vma              align)
17916 {
17917   Elf_External_Note * pnotes;
17918   Elf_External_Note * external;
17919   char *              end;
17920   bfd_boolean         res = TRUE;
17921
17922   if (length <= 0)
17923     return FALSE;
17924
17925   if (section)
17926     {
17927       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
17928       if (pnotes)
17929         {
17930           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
17931             return FALSE;
17932         }
17933     }
17934   else
17935     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
17936                                              _("notes"));
17937
17938   if (pnotes == NULL)
17939     return FALSE;
17940
17941   external = pnotes;
17942
17943   if (section)
17944     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
17945   else
17946     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17947             (unsigned long) offset, (unsigned long) length);
17948
17949   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
17950      specifies that notes should be aligned to 4 bytes in 32-bit
17951      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
17952      we also support 4 byte alignment in 64-bit objects.  If section
17953      alignment is less than 4, we treate alignment as 4 bytes.   */
17954   if (align < 4)
17955     align = 4;
17956   else if (align != 4 && align != 8)
17957     {
17958       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
17959             (long) align);
17960       return FALSE;
17961     }
17962
17963   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17964
17965   end = (char *) pnotes + length;
17966   while ((char *) external < end)
17967     {
17968       Elf_Internal_Note inote;
17969       size_t min_notesz;
17970       char * next;
17971       char * temp = NULL;
17972       size_t data_remaining = end - (char *) external;
17973
17974       if (!is_ia64_vms (filedata))
17975         {
17976           /* PR binutils/15191
17977              Make sure that there is enough data to read.  */
17978           min_notesz = offsetof (Elf_External_Note, name);
17979           if (data_remaining < min_notesz)
17980             {
17981               warn (ngettext ("Corrupt note: only %ld byte remains, "
17982                               "not enough for a full note\n",
17983                               "Corrupt note: only %ld bytes remain, "
17984                               "not enough for a full note\n",
17985                               data_remaining),
17986                     (long) data_remaining);
17987               break;
17988             }
17989           data_remaining -= min_notesz;
17990
17991           inote.type     = BYTE_GET (external->type);
17992           inote.namesz   = BYTE_GET (external->namesz);
17993           inote.namedata = external->name;
17994           inote.descsz   = BYTE_GET (external->descsz);
17995           inote.descdata = ((char *) external
17996                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
17997           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
17998           next = ((char *) external
17999                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18000         }
18001       else
18002         {
18003           Elf64_External_VMS_Note *vms_external;
18004
18005           /* PR binutils/15191
18006              Make sure that there is enough data to read.  */
18007           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18008           if (data_remaining < min_notesz)
18009             {
18010               warn (ngettext ("Corrupt note: only %ld byte remains, "
18011                               "not enough for a full note\n",
18012                               "Corrupt note: only %ld bytes remain, "
18013                               "not enough for a full note\n",
18014                               data_remaining),
18015                     (long) data_remaining);
18016               break;
18017             }
18018           data_remaining -= min_notesz;
18019
18020           vms_external = (Elf64_External_VMS_Note *) external;
18021           inote.type     = BYTE_GET (vms_external->type);
18022           inote.namesz   = BYTE_GET (vms_external->namesz);
18023           inote.namedata = vms_external->name;
18024           inote.descsz   = BYTE_GET (vms_external->descsz);
18025           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18026           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18027           next = inote.descdata + align_power (inote.descsz, 3);
18028         }
18029
18030       /* PR 17531: file: 3443835e.  */
18031       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18032       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18033           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18034           || (size_t) (next - inote.descdata) < inote.descsz
18035           || ((size_t) (next - inote.descdata)
18036               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18037         {
18038           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18039                 (unsigned long) ((char *) external - (char *) pnotes));
18040           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18041                 inote.type, inote.namesz, inote.descsz, (int) align);
18042           break;
18043         }
18044
18045       external = (Elf_External_Note *) next;
18046
18047       /* Verify that name is null terminated.  It appears that at least
18048          one version of Linux (RedHat 6.0) generates corefiles that don't
18049          comply with the ELF spec by failing to include the null byte in
18050          namesz.  */
18051       if (inote.namedata[inote.namesz - 1] != '\0')
18052         {
18053           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18054             {
18055               temp = (char *) malloc (inote.namesz + 1);
18056               if (temp == NULL)
18057                 {
18058                   error (_("Out of memory allocating space for inote name\n"));
18059                   res = FALSE;
18060                   break;
18061                 }
18062
18063               memcpy (temp, inote.namedata, inote.namesz);
18064               inote.namedata = temp;
18065             }
18066           inote.namedata[inote.namesz] = 0;
18067         }
18068
18069       if (! process_note (& inote, filedata))
18070         res = FALSE;
18071
18072       if (temp != NULL)
18073         {
18074           free (temp);
18075           temp = NULL;
18076         }
18077     }
18078
18079   free (pnotes);
18080
18081   return res;
18082 }
18083
18084 static bfd_boolean
18085 process_corefile_note_segments (Filedata * filedata)
18086 {
18087   Elf_Internal_Phdr * segment;
18088   unsigned int i;
18089   bfd_boolean res = TRUE;
18090
18091   if (! get_program_headers (filedata))
18092     return TRUE;
18093
18094   for (i = 0, segment = filedata->program_headers;
18095        i < filedata->file_header.e_phnum;
18096        i++, segment++)
18097     {
18098       if (segment->p_type == PT_NOTE)
18099         if (! process_notes_at (filedata, NULL,
18100                                 (bfd_vma) segment->p_offset,
18101                                 (bfd_vma) segment->p_filesz,
18102                                 (bfd_vma) segment->p_align))
18103           res = FALSE;
18104     }
18105
18106   return res;
18107 }
18108
18109 static bfd_boolean
18110 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18111 {
18112   Elf_External_Note * pnotes;
18113   Elf_External_Note * external;
18114   char * end;
18115   bfd_boolean res = TRUE;
18116
18117   if (length <= 0)
18118     return FALSE;
18119
18120   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18121                                            _("v850 notes"));
18122   if (pnotes == NULL)
18123     return FALSE;
18124
18125   external = pnotes;
18126   end = (char*) pnotes + length;
18127
18128   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18129           (unsigned long) offset, (unsigned long) length);
18130
18131   while ((char *) external + sizeof (Elf_External_Note) < end)
18132     {
18133       Elf_External_Note * next;
18134       Elf_Internal_Note inote;
18135
18136       inote.type     = BYTE_GET (external->type);
18137       inote.namesz   = BYTE_GET (external->namesz);
18138       inote.namedata = external->name;
18139       inote.descsz   = BYTE_GET (external->descsz);
18140       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18141       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18142
18143       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18144         {
18145           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18146           inote.descdata = inote.namedata;
18147           inote.namesz   = 0;
18148         }
18149
18150       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18151
18152       if (   ((char *) next > end)
18153           || ((char *) next <  (char *) pnotes))
18154         {
18155           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18156                 (unsigned long) ((char *) external - (char *) pnotes));
18157           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18158                 inote.type, inote.namesz, inote.descsz);
18159           break;
18160         }
18161
18162       external = next;
18163
18164       /* Prevent out-of-bounds indexing.  */
18165       if (   inote.namedata + inote.namesz > end
18166           || inote.namedata + inote.namesz < inote.namedata)
18167         {
18168           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18169                 (unsigned long) ((char *) external - (char *) pnotes));
18170           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18171                 inote.type, inote.namesz, inote.descsz);
18172           break;
18173         }
18174
18175       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18176
18177       if (! print_v850_note (& inote))
18178         {
18179           res = FALSE;
18180           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18181                   inote.namesz, inote.descsz);
18182         }
18183     }
18184
18185   free (pnotes);
18186
18187   return res;
18188 }
18189
18190 static bfd_boolean
18191 process_note_sections (Filedata * filedata)
18192 {
18193   Elf_Internal_Shdr * section;
18194   unsigned long i;
18195   unsigned int n = 0;
18196   bfd_boolean res = TRUE;
18197
18198   for (i = 0, section = filedata->section_headers;
18199        i < filedata->file_header.e_shnum && section != NULL;
18200        i++, section++)
18201     {
18202       if (section->sh_type == SHT_NOTE)
18203         {
18204           if (! process_notes_at (filedata, section,
18205                                   (bfd_vma) section->sh_offset,
18206                                   (bfd_vma) section->sh_size,
18207                                   (bfd_vma) section->sh_addralign))
18208             res = FALSE;
18209           n++;
18210         }
18211
18212       if ((   filedata->file_header.e_machine == EM_V800
18213            || filedata->file_header.e_machine == EM_V850
18214            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18215           && section->sh_type == SHT_RENESAS_INFO)
18216         {
18217           if (! process_v850_notes (filedata,
18218                                     (bfd_vma) section->sh_offset,
18219                                     (bfd_vma) section->sh_size))
18220             res = FALSE;
18221           n++;
18222         }
18223     }
18224
18225   if (n == 0)
18226     /* Try processing NOTE segments instead.  */
18227     return process_corefile_note_segments (filedata);
18228
18229   return res;
18230 }
18231
18232 static bfd_boolean
18233 process_notes (Filedata * filedata)
18234 {
18235   /* If we have not been asked to display the notes then do nothing.  */
18236   if (! do_notes)
18237     return TRUE;
18238
18239   if (filedata->file_header.e_type != ET_CORE)
18240     return process_note_sections (filedata);
18241
18242   /* No program headers means no NOTE segment.  */
18243   if (filedata->file_header.e_phnum > 0)
18244     return process_corefile_note_segments (filedata);
18245
18246   printf (_("No note segments present in the core file.\n"));
18247   return TRUE;
18248 }
18249
18250 static unsigned char *
18251 display_public_gnu_attributes (unsigned char * start,
18252                                const unsigned char * const end)
18253 {
18254   printf (_("  Unknown GNU attribute: %s\n"), start);
18255
18256   start += strnlen ((char *) start, end - start);
18257   display_raw_attribute (start, end);
18258
18259   return (unsigned char *) end;
18260 }
18261
18262 static unsigned char *
18263 display_generic_attribute (unsigned char * start,
18264                            unsigned int tag,
18265                            const unsigned char * const end)
18266 {
18267   if (tag == 0)
18268     return (unsigned char *) end;
18269
18270   return display_tag_value (tag, start, end);
18271 }
18272
18273 static bfd_boolean
18274 process_arch_specific (Filedata * filedata)
18275 {
18276   if (! do_arch)
18277     return TRUE;
18278
18279   switch (filedata->file_header.e_machine)
18280     {
18281     case EM_ARC:
18282     case EM_ARC_COMPACT:
18283     case EM_ARC_COMPACT2:
18284       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18285                                  display_arc_attribute,
18286                                  display_generic_attribute);
18287     case EM_ARM:
18288       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18289                                  display_arm_attribute,
18290                                  display_generic_attribute);
18291
18292     case EM_MIPS:
18293     case EM_MIPS_RS3_LE:
18294       return process_mips_specific (filedata);
18295
18296     case EM_MSP430:
18297      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18298                                 display_msp430x_attribute,
18299                                 display_generic_attribute);
18300
18301     case EM_NDS32:
18302       return process_nds32_specific (filedata);
18303
18304     case EM_PPC:
18305     case EM_PPC64:
18306       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18307                                  display_power_gnu_attribute);
18308
18309     case EM_S390:
18310     case EM_S390_OLD:
18311       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18312                                  display_s390_gnu_attribute);
18313
18314     case EM_SPARC:
18315     case EM_SPARC32PLUS:
18316     case EM_SPARCV9:
18317       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18318                                  display_sparc_gnu_attribute);
18319
18320     case EM_TI_C6000:
18321       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18322                                  display_tic6x_attribute,
18323                                  display_generic_attribute);
18324
18325     default:
18326       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18327                                  display_public_gnu_attributes,
18328                                  display_generic_attribute);
18329     }
18330 }
18331
18332 static bfd_boolean
18333 get_file_header (Filedata * filedata)
18334 {
18335   /* Read in the identity array.  */
18336   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18337     return FALSE;
18338
18339   /* Determine how to read the rest of the header.  */
18340   switch (filedata->file_header.e_ident[EI_DATA])
18341     {
18342     default:
18343     case ELFDATANONE:
18344     case ELFDATA2LSB:
18345       byte_get = byte_get_little_endian;
18346       byte_put = byte_put_little_endian;
18347       break;
18348     case ELFDATA2MSB:
18349       byte_get = byte_get_big_endian;
18350       byte_put = byte_put_big_endian;
18351       break;
18352     }
18353
18354   /* For now we only support 32 bit and 64 bit ELF files.  */
18355   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18356
18357   /* Read in the rest of the header.  */
18358   if (is_32bit_elf)
18359     {
18360       Elf32_External_Ehdr ehdr32;
18361
18362       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18363         return FALSE;
18364
18365       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18366       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18367       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18368       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18369       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18370       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18371       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18372       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18373       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18374       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18375       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18376       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18377       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18378     }
18379   else
18380     {
18381       Elf64_External_Ehdr ehdr64;
18382
18383       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18384          we will not be able to cope with the 64bit data found in
18385          64 ELF files.  Detect this now and abort before we start
18386          overwriting things.  */
18387       if (sizeof (bfd_vma) < 8)
18388         {
18389           error (_("This instance of readelf has been built without support for a\n\
18390 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18391           return FALSE;
18392         }
18393
18394       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18395         return FALSE;
18396
18397       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18398       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18399       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18400       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18401       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18402       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18403       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18404       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18405       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18406       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18407       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18408       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18409       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18410     }
18411
18412   if (filedata->file_header.e_shoff)
18413     {
18414       /* There may be some extensions in the first section header.  Don't
18415          bomb if we can't read it.  */
18416       if (is_32bit_elf)
18417         get_32bit_section_headers (filedata, TRUE);
18418       else
18419         get_64bit_section_headers (filedata, TRUE);
18420     }
18421
18422   return TRUE;
18423 }
18424
18425 static void
18426 close_file (Filedata * filedata)
18427 {
18428   if (filedata)
18429     {
18430       if (filedata->handle)
18431         fclose (filedata->handle);
18432       free (filedata);
18433     }
18434 }
18435
18436 void
18437 close_debug_file (void * data)
18438 {
18439   close_file ((Filedata *) data);
18440 }
18441
18442 static Filedata *
18443 open_file (const char * pathname)
18444 {
18445   struct stat  statbuf;
18446   Filedata *   filedata = NULL;
18447
18448   if (stat (pathname, & statbuf) < 0
18449       || ! S_ISREG (statbuf.st_mode))
18450     goto fail;
18451
18452   filedata = calloc (1, sizeof * filedata);
18453   if (filedata == NULL)
18454     goto fail;
18455
18456   filedata->handle = fopen (pathname, "rb");
18457   if (filedata->handle == NULL)
18458     goto fail;
18459
18460   filedata->file_size = (bfd_size_type) statbuf.st_size;
18461   filedata->file_name = pathname;
18462
18463   if (! get_file_header (filedata))
18464     goto fail;
18465
18466   if (filedata->file_header.e_shoff)
18467     {
18468       bfd_boolean res;
18469
18470       /* Read the section headers again, this time for real.  */
18471       if (is_32bit_elf)
18472         res = get_32bit_section_headers (filedata, FALSE);
18473       else
18474         res = get_64bit_section_headers (filedata, FALSE);
18475
18476       if (!res)
18477         goto fail;
18478     }
18479
18480   return filedata;
18481
18482  fail:
18483   if (filedata)
18484     {
18485       if (filedata->handle)
18486         fclose (filedata->handle);
18487       free (filedata);
18488     }
18489   return NULL;
18490 }
18491
18492 void *
18493 open_debug_file (const char * pathname)
18494 {
18495   return open_file (pathname);
18496 }
18497
18498 /* Process one ELF object file according to the command line options.
18499    This file may actually be stored in an archive.  The file is
18500    positioned at the start of the ELF object.  Returns TRUE if no
18501    problems were encountered, FALSE otherwise.  */
18502
18503 static bfd_boolean
18504 process_object (Filedata * filedata)
18505 {
18506   Filedata * separates;
18507   unsigned int i;
18508   bfd_boolean res = TRUE;
18509
18510   if (! get_file_header (filedata))
18511     {
18512       error (_("%s: Failed to read file header\n"), filedata->file_name);
18513       return FALSE;
18514     }
18515
18516   /* Initialise per file variables.  */
18517   for (i = ARRAY_SIZE (version_info); i--;)
18518     version_info[i] = 0;
18519
18520   for (i = ARRAY_SIZE (dynamic_info); i--;)
18521     dynamic_info[i] = 0;
18522   dynamic_info_DT_GNU_HASH = 0;
18523
18524   /* Process the file.  */
18525   if (show_name)
18526     printf (_("\nFile: %s\n"), filedata->file_name);
18527
18528   /* Initialise the dump_sects array from the cmdline_dump_sects array.
18529      Note we do this even if cmdline_dump_sects is empty because we
18530      must make sure that the dump_sets array is zeroed out before each
18531      object file is processed.  */
18532   if (filedata->num_dump_sects > cmdline.num_dump_sects)
18533     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
18534
18535   if (cmdline.num_dump_sects > 0)
18536     {
18537       if (filedata->num_dump_sects == 0)
18538         /* A sneaky way of allocating the dump_sects array.  */
18539         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
18540
18541       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
18542       memcpy (filedata->dump_sects, cmdline.dump_sects,
18543               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
18544     }
18545
18546   if (! process_file_header (filedata))
18547     return FALSE;
18548
18549   if (! process_section_headers (filedata))
18550     {
18551       /* Without loaded section headers we cannot process lots of things.  */
18552       do_unwind = do_version = do_dump = do_arch = FALSE;
18553
18554       if (! do_using_dynamic)
18555         do_syms = do_dyn_syms = do_reloc = FALSE;
18556     }
18557
18558   if (! process_section_groups (filedata))
18559     /* Without loaded section groups we cannot process unwind.  */
18560     do_unwind = FALSE;
18561
18562   if (process_program_headers (filedata))
18563     process_dynamic_section (filedata);
18564   else
18565     res = FALSE;
18566
18567   if (! process_relocs (filedata))
18568     res = FALSE;
18569
18570   if (! process_unwind (filedata))
18571     res = FALSE;
18572
18573   if (! process_symbol_table (filedata))
18574     res = FALSE;
18575
18576   if (! process_syminfo (filedata))
18577     res = FALSE;
18578
18579   if (! process_version_sections (filedata))
18580     res = FALSE;
18581
18582   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
18583     separates = load_separate_debug_file (filedata, filedata->file_name);
18584   else
18585     separates = NULL;
18586
18587   if (! process_section_contents (filedata))
18588     res = FALSE;
18589
18590   if (separates)
18591     {
18592       if (! process_section_headers (separates))
18593         res = FALSE;
18594       else if (! process_section_contents (separates))
18595         res = FALSE;
18596     }
18597
18598   if (! process_notes (filedata))
18599     res = FALSE;
18600
18601   if (! process_gnu_liblist (filedata))
18602     res = FALSE;
18603
18604   if (! process_arch_specific (filedata))
18605     res = FALSE;
18606
18607   free (filedata->program_headers);
18608   filedata->program_headers = NULL;
18609
18610   free (filedata->section_headers);
18611   filedata->section_headers = NULL;
18612
18613   free (filedata->string_table);
18614   filedata->string_table = NULL;
18615   filedata->string_table_length = 0;
18616
18617   if (dynamic_strings)
18618     {
18619       free (dynamic_strings);
18620       dynamic_strings = NULL;
18621       dynamic_strings_length = 0;
18622     }
18623
18624   if (dynamic_symbols)
18625     {
18626       free (dynamic_symbols);
18627       dynamic_symbols = NULL;
18628       num_dynamic_syms = 0;
18629     }
18630
18631   if (dynamic_syminfo)
18632     {
18633       free (dynamic_syminfo);
18634       dynamic_syminfo = NULL;
18635     }
18636
18637   if (dynamic_section)
18638     {
18639       free (dynamic_section);
18640       dynamic_section = NULL;
18641     }
18642
18643   if (section_headers_groups)
18644     {
18645       free (section_headers_groups);
18646       section_headers_groups = NULL;
18647     }
18648
18649   if (section_groups)
18650     {
18651       struct group_list * g;
18652       struct group_list * next;
18653
18654       for (i = 0; i < group_count; i++)
18655         {
18656           for (g = section_groups [i].root; g != NULL; g = next)
18657             {
18658               next = g->next;
18659               free (g);
18660             }
18661         }
18662
18663       free (section_groups);
18664       section_groups = NULL;
18665     }
18666
18667   free_debug_memory ();
18668
18669   return res;
18670 }
18671
18672 /* Process an ELF archive.
18673    On entry the file is positioned just after the ARMAG string.
18674    Returns TRUE upon success, FALSE otherwise.  */
18675
18676 static bfd_boolean
18677 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
18678 {
18679   struct archive_info arch;
18680   struct archive_info nested_arch;
18681   size_t got;
18682   bfd_boolean ret = TRUE;
18683
18684   show_name = TRUE;
18685
18686   /* The ARCH structure is used to hold information about this archive.  */
18687   arch.file_name = NULL;
18688   arch.file = NULL;
18689   arch.index_array = NULL;
18690   arch.sym_table = NULL;
18691   arch.longnames = NULL;
18692
18693   /* The NESTED_ARCH structure is used as a single-item cache of information
18694      about a nested archive (when members of a thin archive reside within
18695      another regular archive file).  */
18696   nested_arch.file_name = NULL;
18697   nested_arch.file = NULL;
18698   nested_arch.index_array = NULL;
18699   nested_arch.sym_table = NULL;
18700   nested_arch.longnames = NULL;
18701
18702   if (setup_archive (&arch, filedata->file_name, filedata->handle,
18703                      is_thin_archive, do_archive_index) != 0)
18704     {
18705       ret = FALSE;
18706       goto out;
18707     }
18708
18709   if (do_archive_index)
18710     {
18711       if (arch.sym_table == NULL)
18712         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
18713       else
18714         {
18715           unsigned long i, l;
18716           unsigned long current_pos;
18717
18718           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18719                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
18720
18721           current_pos = ftell (filedata->handle);
18722
18723           for (i = l = 0; i < arch.index_num; i++)
18724             {
18725               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
18726                 {
18727                   char * member_name;
18728
18729                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
18730
18731                   if (member_name != NULL)
18732                     {
18733                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
18734
18735                       if (qualified_name != NULL)
18736                         {
18737                           printf (_("Contents of binary %s at offset "), qualified_name);
18738                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
18739                           putchar ('\n');
18740                           free (qualified_name);
18741                         }
18742                     }
18743                 }
18744
18745               if (l >= arch.sym_size)
18746                 {
18747                   error (_("%s: end of the symbol table reached before the end of the index\n"),
18748                          filedata->file_name);
18749                   ret = FALSE;
18750                   break;
18751                 }
18752               /* PR 17531: file: 0b6630b2.  */
18753               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
18754               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
18755             }
18756
18757           if (arch.uses_64bit_indicies)
18758             l = (l + 7) & ~ 7;
18759           else
18760             l += l & 1;
18761
18762           if (l < arch.sym_size)
18763             {
18764               error (ngettext ("%s: %ld byte remains in the symbol table, "
18765                                "but without corresponding entries in "
18766                                "the index table\n",
18767                                "%s: %ld bytes remain in the symbol table, "
18768                                "but without corresponding entries in "
18769                                "the index table\n",
18770                                arch.sym_size - l),
18771                      filedata->file_name, arch.sym_size - l);
18772               ret = FALSE;
18773             }
18774
18775           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
18776             {
18777               error (_("%s: failed to seek back to start of object files in the archive\n"),
18778                      filedata->file_name);
18779               ret = FALSE;
18780               goto out;
18781             }
18782         }
18783
18784       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
18785           && !do_segments && !do_header && !do_dump && !do_version
18786           && !do_histogram && !do_debugging && !do_arch && !do_notes
18787           && !do_section_groups && !do_dyn_syms)
18788         {
18789           ret = TRUE; /* Archive index only.  */
18790           goto out;
18791         }
18792     }
18793
18794   while (1)
18795     {
18796       char * name;
18797       size_t namelen;
18798       char * qualified_name;
18799
18800       /* Read the next archive header.  */
18801       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
18802         {
18803           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
18804           return FALSE;
18805         }
18806       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
18807       if (got != sizeof arch.arhdr)
18808         {
18809           if (got == 0)
18810             break;
18811           error (_("%s: failed to read archive header\n"), filedata->file_name);
18812           ret = FALSE;
18813           break;
18814         }
18815       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
18816         {
18817           error (_("%s: did not find a valid archive header\n"), arch.file_name);
18818           ret = FALSE;
18819           break;
18820         }
18821
18822       arch.next_arhdr_offset += sizeof arch.arhdr;
18823
18824       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
18825       if (archive_file_size & 01)
18826         ++archive_file_size;
18827
18828       name = get_archive_member_name (&arch, &nested_arch);
18829       if (name == NULL)
18830         {
18831           error (_("%s: bad archive file name\n"), filedata->file_name);
18832           ret = FALSE;
18833           break;
18834         }
18835       namelen = strlen (name);
18836
18837       qualified_name = make_qualified_name (&arch, &nested_arch, name);
18838       if (qualified_name == NULL)
18839         {
18840           error (_("%s: bad archive file name\n"), filedata->file_name);
18841           ret = FALSE;
18842           break;
18843         }
18844
18845       if (is_thin_archive && arch.nested_member_origin == 0)
18846         {
18847           /* This is a proxy for an external member of a thin archive.  */
18848           Filedata * member_filedata;
18849           char * member_file_name = adjust_relative_path
18850             (filedata->file_name, name, namelen);
18851
18852           if (member_file_name == NULL)
18853             {
18854               ret = FALSE;
18855               break;
18856             }
18857
18858           member_filedata = open_file (member_file_name);
18859           if (member_filedata == NULL)
18860             {
18861               error (_("Input file '%s' is not readable.\n"), member_file_name);
18862               free (member_file_name);
18863               ret = FALSE;
18864               break;
18865             }
18866
18867           archive_file_offset = arch.nested_member_origin;
18868           member_filedata->file_name = qualified_name;
18869
18870           if (! process_object (member_filedata))
18871             ret = FALSE;
18872
18873           close_file (member_filedata);
18874           free (member_file_name);
18875         }
18876       else if (is_thin_archive)
18877         {
18878           Filedata thin_filedata;
18879
18880           memset (&thin_filedata, 0, sizeof (thin_filedata));
18881
18882           /* PR 15140: Allow for corrupt thin archives.  */
18883           if (nested_arch.file == NULL)
18884             {
18885               error (_("%s: contains corrupt thin archive: %s\n"),
18886                      filedata->file_name, name);
18887               ret = FALSE;
18888               break;
18889             }
18890
18891           /* This is a proxy for a member of a nested archive.  */
18892           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
18893
18894           /* The nested archive file will have been opened and setup by
18895              get_archive_member_name.  */
18896           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
18897             {
18898               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
18899               ret = FALSE;
18900               break;
18901             }
18902
18903           thin_filedata.handle = nested_arch.file;
18904           thin_filedata.file_name = qualified_name;
18905
18906           if (! process_object (& thin_filedata))
18907             ret = FALSE;
18908         }
18909       else
18910         {
18911           archive_file_offset = arch.next_arhdr_offset;
18912           arch.next_arhdr_offset += archive_file_size;
18913
18914           filedata->file_name = qualified_name;
18915           if (! process_object (filedata))
18916             ret = FALSE;
18917         }
18918
18919       if (filedata->dump_sects != NULL)
18920         {
18921           free (filedata->dump_sects);
18922           filedata->dump_sects = NULL;
18923           filedata->num_dump_sects = 0;
18924         }
18925
18926       free (qualified_name);
18927     }
18928
18929  out:
18930   if (nested_arch.file != NULL)
18931     fclose (nested_arch.file);
18932   release_archive (&nested_arch);
18933   release_archive (&arch);
18934
18935   return ret;
18936 }
18937
18938 static bfd_boolean
18939 process_file (char * file_name)
18940 {
18941   Filedata * filedata = NULL;
18942   struct stat statbuf;
18943   char armag[SARMAG];
18944   bfd_boolean ret = TRUE;
18945
18946   if (stat (file_name, &statbuf) < 0)
18947     {
18948       if (errno == ENOENT)
18949         error (_("'%s': No such file\n"), file_name);
18950       else
18951         error (_("Could not locate '%s'.  System error message: %s\n"),
18952                file_name, strerror (errno));
18953       return FALSE;
18954     }
18955
18956   if (! S_ISREG (statbuf.st_mode))
18957     {
18958       error (_("'%s' is not an ordinary file\n"), file_name);
18959       return FALSE;
18960     }
18961
18962   filedata = calloc (1, sizeof * filedata);
18963   if (filedata == NULL)
18964     {
18965       error (_("Out of memory allocating file data structure\n"));
18966       return FALSE;
18967     }
18968
18969   filedata->file_name = file_name;
18970   filedata->handle = fopen (file_name, "rb");
18971   if (filedata->handle == NULL)
18972     {
18973       error (_("Input file '%s' is not readable.\n"), file_name);
18974       free (filedata);
18975       return FALSE;
18976     }
18977
18978   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
18979     {
18980       error (_("%s: Failed to read file's magic number\n"), file_name);
18981       fclose (filedata->handle);
18982       free (filedata);
18983       return FALSE;
18984     }
18985
18986   filedata->file_size = (bfd_size_type) statbuf.st_size;
18987
18988   if (memcmp (armag, ARMAG, SARMAG) == 0)
18989     {
18990       if (! process_archive (filedata, FALSE))
18991         ret = FALSE;
18992     }
18993   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
18994     {
18995       if ( ! process_archive (filedata, TRUE))
18996         ret = FALSE;
18997     }
18998   else
18999     {
19000       if (do_archive_index)
19001         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19002                file_name);
19003
19004       rewind (filedata->handle);
19005       archive_file_size = archive_file_offset = 0;
19006
19007       if (! process_object (filedata))
19008         ret = FALSE;
19009     }
19010
19011   fclose (filedata->handle);
19012   free (filedata);
19013
19014   return ret;
19015 }
19016
19017 #ifdef SUPPORT_DISASSEMBLY
19018 /* Needed by the i386 disassembler.  For extra credit, someone could
19019    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19020    symbols.  */
19021
19022 void
19023 print_address (unsigned int addr, FILE * outfile)
19024 {
19025   fprintf (outfile,"0x%8.8x", addr);
19026 }
19027
19028 /* Needed by the i386 disassembler.  */
19029
19030 void
19031 db_task_printsym (unsigned int addr)
19032 {
19033   print_address (addr, stderr);
19034 }
19035 #endif
19036
19037 int
19038 main (int argc, char ** argv)
19039 {
19040   int err;
19041
19042 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19043   setlocale (LC_MESSAGES, "");
19044 #endif
19045 #if defined (HAVE_SETLOCALE)
19046   setlocale (LC_CTYPE, "");
19047 #endif
19048   bindtextdomain (PACKAGE, LOCALEDIR);
19049   textdomain (PACKAGE);
19050
19051   expandargv (&argc, &argv);
19052
19053   cmdline.file_name = "<cmdline>";
19054   parse_args (& cmdline, argc, argv);
19055
19056   if (optind < (argc - 1))
19057     show_name = TRUE;
19058   else if (optind >= argc)
19059     {
19060       warn (_("Nothing to do.\n"));
19061       usage (stderr);
19062     }
19063
19064   err = FALSE;
19065   while (optind < argc)
19066     if (! process_file (argv[optind++]))
19067       err = TRUE;
19068
19069   if (cmdline.dump_sects != NULL)
19070     free (cmdline.dump_sects);
19071
19072   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19073 }