binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2019 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 #include "ctf-api.h"
  64
  65 #include "elf/common.h"
  66 #include "elf/external.h"
  67 #include "elf/internal.h"
  68
  69
  70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  71    we can obtain the H8 reloc numbers.  We need these for the
  72    get_reloc_size() function.  We include h8.h again after defining
  73    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  74
  75 #include "elf/h8.h"
  76 #undef _ELF_H8_H
  77
  78 /* Undo the effects of #including reloc-macros.h.  */
  79
  80 #undef START_RELOC_NUMBERS
  81 #undef RELOC_NUMBER
  82 #undef FAKE_RELOC
  83 #undef EMPTY_RELOC
  84 #undef END_RELOC_NUMBERS
  85 #undef _RELOC_MACROS_H
  86
  87 /* The following headers use the elf/reloc-macros.h file to
  88    automatically generate relocation recognition functions
  89    such as elf_mips_reloc_type()  */
  90
  91 #define RELOC_MACROS_GEN_FUNC
  92
  93 #include "elf/aarch64.h"
  94 #include "elf/alpha.h"
  95 #include "elf/arc.h"
  96 #include "elf/arm.h"
  97 #include "elf/avr.h"
  98 #include "elf/bfin.h"
  99 #include "elf/cr16.h"
 100 #include "elf/cris.h"
 101 #include "elf/crx.h"
 102 #include "elf/csky.h"
 103 #include "elf/d10v.h"
 104 #include "elf/d30v.h"
 105 #include "elf/dlx.h"
 106 #include "elf/bpf.h"
 107 #include "elf/epiphany.h"
 108 #include "elf/fr30.h"
 109 #include "elf/frv.h"
 110 #include "elf/ft32.h"
 111 #include "elf/h8.h"
 112 #include "elf/hppa.h"
 113 #include "elf/i386.h"
 114 #include "elf/i370.h"
 115 #include "elf/i860.h"
 116 #include "elf/i960.h"
 117 #include "elf/ia64.h"
 118 #include "elf/ip2k.h"
 119 #include "elf/lm32.h"
 120 #include "elf/iq2000.h"
 121 #include "elf/m32c.h"
 122 #include "elf/m32r.h"
 123 #include "elf/m68k.h"
 124 #include "elf/m68hc11.h"
 125 #include "elf/s12z.h"
 126 #include "elf/mcore.h"
 127 #include "elf/mep.h"
 128 #include "elf/metag.h"
 129 #include "elf/microblaze.h"
 130 #include "elf/mips.h"
 131 #include "elf/mmix.h"
 132 #include "elf/mn10200.h"
 133 #include "elf/mn10300.h"
 134 #include "elf/moxie.h"
 135 #include "elf/mt.h"
 136 #include "elf/msp430.h"
 137 #include "elf/nds32.h"
 138 #include "elf/nfp.h"
 139 #include "elf/nios2.h"
 140 #include "elf/or1k.h"
 141 #include "elf/pj.h"
 142 #include "elf/ppc.h"
 143 #include "elf/ppc64.h"
 144 #include "elf/pru.h"
 145 #include "elf/riscv.h"
 146 #include "elf/rl78.h"
 147 #include "elf/rx.h"
 148 #include "elf/s390.h"
 149 #include "elf/score.h"
 150 #include "elf/sh.h"
 151 #include "elf/sparc.h"
 152 #include "elf/spu.h"
 153 #include "elf/tic6x.h"
 154 #include "elf/tilegx.h"
 155 #include "elf/tilepro.h"
 156 #include "elf/v850.h"
 157 #include "elf/vax.h"
 158 #include "elf/visium.h"
 159 #include "elf/wasm32.h"
 160 #include "elf/x86-64.h"
 161 #include "elf/xc16x.h"
 162 #include "elf/xgate.h"
 163 #include "elf/xstormy16.h"
 164 #include "elf/xtensa.h"
 165
 166 #include "getopt.h"
 167 #include "libiberty.h"
 168 #include "safe-ctype.h"
 169 #include "filenames.h"
 170
 171 #ifndef offsetof
 172 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 173 #endif
 174
 175 typedef struct elf_section_list
 176 {
 177   Elf_Internal_Shdr *        hdr;
 178   struct elf_section_list *  next;
 179 } elf_section_list;
 180
 181 /* Flag bits indicating particular types of dump.  */
 182 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 183 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 184 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 185 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 186 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 187 #define CTF_DUMP        (1 << 5)        /* The --ctf command line switch.  */
 188
 189 typedef unsigned char dump_type;
 190
 191 /* A linked list of the section names for which dumps were requested.  */
 192 struct dump_list_entry
 193 {
 194   char *                    name;
 195   dump_type                 type;
 196   struct dump_list_entry *  next;
 197 };
 198
 199 typedef struct filedata
 200 {
 201   const char *         file_name;
 202   FILE *               handle;
 203   bfd_size_type        file_size;
 204   Elf_Internal_Ehdr    file_header;
 205   Elf_Internal_Shdr *  section_headers;
 206   Elf_Internal_Phdr *  program_headers;
 207   char *               string_table;
 208   unsigned long        string_table_length;
 209   /* A dynamic array of flags indicating for which sections a dump of
 210      some kind has been requested.  It is reset on a per-object file
 211      basis and then initialised from the cmdline_dump_sects array,
 212      the results of interpreting the -w switch, and the
 213      dump_sects_byname list.  */
 214   dump_type *          dump_sects;
 215   unsigned int         num_dump_sects;
 216 } Filedata;
 217
 218 char * program_name = "readelf";
 219
 220 static unsigned long archive_file_offset;
 221 static unsigned long archive_file_size;
 222 static unsigned long dynamic_addr;
 223 static bfd_size_type dynamic_size;
 224 static size_t dynamic_nent;
 225 static char * dynamic_strings;
 226 static unsigned long dynamic_strings_length;
 227 static unsigned long num_dynamic_syms;
 228 static Elf_Internal_Sym * dynamic_symbols;
 229 static Elf_Internal_Syminfo * dynamic_syminfo;
 230 static unsigned long dynamic_syminfo_offset;
 231 static unsigned int dynamic_syminfo_nent;
 232 static char program_interpreter[PATH_MAX];
 233 static bfd_vma dynamic_info[DT_ENCODING];
 234 static bfd_vma dynamic_info_DT_GNU_HASH;
 235 static bfd_vma version_info[16];
 236 static Elf_Internal_Dyn *  dynamic_section;
 237 static elf_section_list * symtab_shndx_list;
 238 static bfd_boolean show_name = FALSE;
 239 static bfd_boolean do_dynamic = FALSE;
 240 static bfd_boolean do_syms = FALSE;
 241 static bfd_boolean do_dyn_syms = FALSE;
 242 static bfd_boolean do_reloc = FALSE;
 243 static bfd_boolean do_sections = FALSE;
 244 static bfd_boolean do_section_groups = FALSE;
 245 static bfd_boolean do_section_details = FALSE;
 246 static bfd_boolean do_segments = FALSE;
 247 static bfd_boolean do_unwind = FALSE;
 248 static bfd_boolean do_using_dynamic = FALSE;
 249 static bfd_boolean do_header = FALSE;
 250 static bfd_boolean do_dump = FALSE;
 251 static bfd_boolean do_version = FALSE;
 252 static bfd_boolean do_histogram = FALSE;
 253 static bfd_boolean do_debugging = FALSE;
 254 static bfd_boolean do_ctf = FALSE;
 255 static bfd_boolean do_arch = FALSE;
 256 static bfd_boolean do_notes = FALSE;
 257 static bfd_boolean do_archive_index = FALSE;
 258 static bfd_boolean is_32bit_elf = FALSE;
 259 static bfd_boolean decompress_dumps = FALSE;
 260
 261 static char *dump_ctf_parent_name;
 262 static char *dump_ctf_symtab_name;
 263 static char *dump_ctf_strtab_name;
 264
 265 struct group_list
 266 {
 267   struct group_list *  next;
 268   unsigned int         section_index;
 269 };
 270
 271 struct group
 272 {
 273   struct group_list *  root;
 274   unsigned int         group_index;
 275 };
 276
 277 static size_t           group_count;
 278 static struct group *   section_groups;
 279 static struct group **  section_headers_groups;
 280
 281 /* A dynamic array of flags indicating for which sections a dump
 282    has been requested via command line switches.  */
 283 static Filedata         cmdline;
 284
 285 static struct dump_list_entry * dump_sects_byname;
 286
 287 /* How to print a vma value.  */
 288 typedef enum print_mode
 289 {
 290   HEX,
 291   DEC,
 292   DEC_5,
 293   UNSIGNED,
 294   PREFIX_HEX,
 295   FULL_HEX,
 296   LONG_HEX
 297 }
 298 print_mode;
 299
 300 /* Versioned symbol info.  */
 301 enum versioned_symbol_info
 302 {
 303   symbol_undefined,
 304   symbol_hidden,
 305   symbol_public
 306 };
 307
 308 static const char * get_symbol_version_string
 309   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 310    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 311
 312 #define UNKNOWN -1
 313
 314 #define SECTION_NAME(X)                                         \
 315   ((X) == NULL ? _("<none>")                                    \
 316    : filedata->string_table == NULL ? _("<no-strings>")         \
 317    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 318   : filedata->string_table + (X)->sh_name))
 319
 320 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 321
 322 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 323   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 324    : get_64bit_elf_symbols (file, section, sym_count))
 325
 326 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 327 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 328    already been called and verified that the string exists.  */
 329 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 330
 331 #define REMOVE_ARCH_BITS(ADDR)                  \
 332   do                                            \
 333     {                                           \
 334       if (filedata->file_header.e_machine == EM_ARM)    \
 335         (ADDR) &= ~1;                           \
 336     }                                           \
 337   while (0)
 338 \f
 339 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 340    BFD_FMA_FMT can't be used in translated strings.  */
 341
 342 static const char *
 343 bfd_vmatoa (char *fmtch, bfd_vma value)
 344 {
 345   /* bfd_vmatoa is used more then once in a printf call for output.
 346      Cycle through an array of buffers.  */
 347   static int buf_pos = 0;
 348   static struct bfd_vmatoa_buf
 349   {
 350     char place[64];
 351   } buf[4];
 352   char *ret;
 353   char fmt[32];
 354
 355   ret = buf[buf_pos++].place;
 356   buf_pos %= ARRAY_SIZE (buf);
 357
 358   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 359   snprintf (ret, sizeof (buf[0].place), fmt, value);
 360   return ret;
 361 }
 362
 363 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 364    OFFSET + the offset of the current archive member, if we are examining an
 365    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 366    allocate a buffer using malloc and fill that.  In either case return the
 367    pointer to the start of the retrieved data or NULL if something went wrong.
 368    If something does go wrong and REASON is not NULL then emit an error
 369    message using REASON as part of the context.  */
 370
 371 static void *
 372 get_data (void *         var,
 373           Filedata *     filedata,
 374           unsigned long  offset,
 375           bfd_size_type  size,
 376           bfd_size_type  nmemb,
 377           const char *   reason)
 378 {
 379   void * mvar;
 380   bfd_size_type amt = size * nmemb;
 381
 382   if (size == 0 || nmemb == 0)
 383     return NULL;
 384
 385   /* If the size_t type is smaller than the bfd_size_type, eg because
 386      you are building a 32-bit tool on a 64-bit host, then make sure
 387      that when the sizes are cast to (size_t) no information is lost.  */
 388   if ((size_t) size != size
 389       || (size_t) nmemb != nmemb
 390       || (size_t) amt != amt)
 391     {
 392       if (reason)
 393         error (_("Size truncation prevents reading %s"
 394                  " elements of size %s for %s\n"),
 395                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 396       return NULL;
 397     }
 398
 399   /* Check for size overflow.  */
 400   if (amt / size != nmemb || (size_t) amt + 1 == 0)
 401     {
 402       if (reason)
 403         error (_("Size overflow prevents reading %s"
 404                  " elements of size %s for %s\n"),
 405                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 406       return NULL;
 407     }
 408
 409   /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
 410      attempting to allocate memory when the read is bound to fail.  */
 411   if (archive_file_offset > filedata->file_size
 412       || offset > filedata->file_size - archive_file_offset
 413       || amt > filedata->file_size - archive_file_offset - offset)
 414     {
 415       if (reason)
 416         error (_("Reading %s bytes extends past end of file for %s\n"),
 417                bfd_vmatoa ("u", amt), reason);
 418       return NULL;
 419     }
 420
 421   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 422     {
 423       if (reason)
 424         error (_("Unable to seek to 0x%lx for %s\n"),
 425                archive_file_offset + offset, reason);
 426       return NULL;
 427     }
 428
 429   mvar = var;
 430   if (mvar == NULL)
 431     {
 432       /* + 1 so that we can '\0' terminate invalid string table sections.  */
 433       mvar = malloc ((size_t) amt + 1);
 434
 435       if (mvar == NULL)
 436         {
 437           if (reason)
 438             error (_("Out of memory allocating %s bytes for %s\n"),
 439                    bfd_vmatoa ("u", amt), reason);
 440           return NULL;
 441         }
 442
 443       ((char *) mvar)[amt] = '\0';
 444     }
 445
 446   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 447     {
 448       if (reason)
 449         error (_("Unable to read in %s bytes of %s\n"),
 450                bfd_vmatoa ("u", amt), reason);
 451       if (mvar != var)
 452         free (mvar);
 453       return NULL;
 454     }
 455
 456   return mvar;
 457 }
 458
 459 /* Print a VMA value in the MODE specified.
 460    Returns the number of characters displayed.  */
 461
 462 static unsigned int
 463 print_vma (bfd_vma vma, print_mode mode)
 464 {
 465   unsigned int nc = 0;
 466
 467   switch (mode)
 468     {
 469     case FULL_HEX:
 470       nc = printf ("0x");
 471       /* Fall through.  */
 472     case LONG_HEX:
 473 #ifdef BFD64
 474       if (is_32bit_elf)
 475         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 476 #endif
 477       printf_vma (vma);
 478       return nc + 16;
 479
 480     case DEC_5:
 481       if (vma <= 99999)
 482         return printf ("%5" BFD_VMA_FMT "d", vma);
 483       /* Fall through.  */
 484     case PREFIX_HEX:
 485       nc = printf ("0x");
 486       /* Fall through.  */
 487     case HEX:
 488       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 489
 490     case DEC:
 491       return printf ("%" BFD_VMA_FMT "d", vma);
 492
 493     case UNSIGNED:
 494       return printf ("%" BFD_VMA_FMT "u", vma);
 495
 496     default:
 497       /* FIXME: Report unrecognised mode ?  */
 498       return 0;
 499     }
 500 }
 501
 502 /* Display a symbol on stdout.  Handles the display of control characters and
 503    multibye characters (assuming the host environment supports them).
 504
 505    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 506
 507    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 508    padding as necessary.
 509
 510    Returns the number of emitted characters.  */
 511
 512 static unsigned int
 513 print_symbol (signed int width, const char *symbol)
 514 {
 515   bfd_boolean extra_padding = FALSE;
 516   signed int num_printed = 0;
 517 #ifdef HAVE_MBSTATE_T
 518   mbstate_t state;
 519 #endif
 520   unsigned int width_remaining;
 521
 522   if (width < 0)
 523     {
 524       /* Keep the width positive.  This helps the code below.  */
 525       width = - width;
 526       extra_padding = TRUE;
 527     }
 528   else if (width == 0)
 529     return 0;
 530
 531   if (do_wide)
 532     /* Set the remaining width to a very large value.
 533        This simplifies the code below.  */
 534     width_remaining = INT_MAX;
 535   else
 536     width_remaining = width;
 537
 538 #ifdef HAVE_MBSTATE_T
 539   /* Initialise the multibyte conversion state.  */
 540   memset (& state, 0, sizeof (state));
 541 #endif
 542
 543   while (width_remaining)
 544     {
 545       size_t  n;
 546       const char c = *symbol++;
 547
 548       if (c == 0)
 549         break;
 550
 551       /* Do not print control characters directly as they can affect terminal
 552          settings.  Such characters usually appear in the names generated
 553          by the assembler for local labels.  */
 554       if (ISCNTRL (c))
 555         {
 556           if (width_remaining < 2)
 557             break;
 558
 559           printf ("^%c", c + 0x40);
 560           width_remaining -= 2;
 561           num_printed += 2;
 562         }
 563       else if (ISPRINT (c))
 564         {
 565           putchar (c);
 566           width_remaining --;
 567           num_printed ++;
 568         }
 569       else
 570         {
 571 #ifdef HAVE_MBSTATE_T
 572           wchar_t w;
 573 #endif
 574           /* Let printf do the hard work of displaying multibyte characters.  */
 575           printf ("%.1s", symbol - 1);
 576           width_remaining --;
 577           num_printed ++;
 578
 579 #ifdef HAVE_MBSTATE_T
 580           /* Try to find out how many bytes made up the character that was
 581              just printed.  Advance the symbol pointer past the bytes that
 582              were displayed.  */
 583           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 584 #else
 585           n = 1;
 586 #endif
 587           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 588             symbol += (n - 1);
 589         }
 590     }
 591
 592   if (extra_padding && num_printed < width)
 593     {
 594       /* Fill in the remaining spaces.  */
 595       printf ("%-*s", width - num_printed, " ");
 596       num_printed = width;
 597     }
 598
 599   return num_printed;
 600 }
 601
 602 /* Returns a pointer to a static buffer containing a printable version of
 603    the given section's name.  Like print_symbol, except that it does not try
 604    to print multibyte characters, it just interprets them as hex values.  */
 605
 606 static const char *
 607 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 608 {
 609 #define MAX_PRINT_SEC_NAME_LEN 128
 610   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 611   const char * name = SECTION_NAME (sec);
 612   char *       buf = sec_name_buf;
 613   char         c;
 614   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 615
 616   while ((c = * name ++) != 0)
 617     {
 618       if (ISCNTRL (c))
 619         {
 620           if (remaining < 2)
 621             break;
 622
 623           * buf ++ = '^';
 624           * buf ++ = c + 0x40;
 625           remaining -= 2;
 626         }
 627       else if (ISPRINT (c))
 628         {
 629           * buf ++ = c;
 630           remaining -= 1;
 631         }
 632       else
 633         {
 634           static char hex[17] = "0123456789ABCDEF";
 635
 636           if (remaining < 4)
 637             break;
 638           * buf ++ = '<';
 639           * buf ++ = hex[(c & 0xf0) >> 4];
 640           * buf ++ = hex[c & 0x0f];
 641           * buf ++ = '>';
 642           remaining -= 4;
 643         }
 644
 645       if (remaining == 0)
 646         break;
 647     }
 648
 649   * buf = 0;
 650   return sec_name_buf;
 651 }
 652
 653 static const char *
 654 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 655 {
 656   if (ndx >= filedata->file_header.e_shnum)
 657     return _("<corrupt>");
 658
 659   return printable_section_name (filedata, filedata->section_headers + ndx);
 660 }
 661
 662 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 663
 664 static Elf_Internal_Shdr *
 665 find_section (Filedata * filedata, const char * name)
 666 {
 667   unsigned int i;
 668
 669   if (filedata->section_headers == NULL)
 670     return NULL;
 671
 672   for (i = 0; i < filedata->file_header.e_shnum; i++)
 673     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 674       return filedata->section_headers + i;
 675
 676   return NULL;
 677 }
 678
 679 /* Return a pointer to a section containing ADDR, or NULL if no such
 680    section exists.  */
 681
 682 static Elf_Internal_Shdr *
 683 find_section_by_address (Filedata * filedata, bfd_vma addr)
 684 {
 685   unsigned int i;
 686
 687   if (filedata->section_headers == NULL)
 688     return NULL;
 689
 690   for (i = 0; i < filedata->file_header.e_shnum; i++)
 691     {
 692       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 693
 694       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 695         return sec;
 696     }
 697
 698   return NULL;
 699 }
 700
 701 static Elf_Internal_Shdr *
 702 find_section_by_type (Filedata * filedata, unsigned int type)
 703 {
 704   unsigned int i;
 705
 706   if (filedata->section_headers == NULL)
 707     return NULL;
 708
 709   for (i = 0; i < filedata->file_header.e_shnum; i++)
 710     {
 711       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 712
 713       if (sec->sh_type == type)
 714         return sec;
 715     }
 716
 717   return NULL;
 718 }
 719
 720 /* Return a pointer to section NAME, or NULL if no such section exists,
 721    restricted to the list of sections given in SET.  */
 722
 723 static Elf_Internal_Shdr *
 724 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 725 {
 726   unsigned int i;
 727
 728   if (filedata->section_headers == NULL)
 729     return NULL;
 730
 731   if (set != NULL)
 732     {
 733       while ((i = *set++) > 0)
 734         {
 735           /* See PR 21156 for a reproducer.  */
 736           if (i >= filedata->file_header.e_shnum)
 737             continue; /* FIXME: Should we issue an error message ?  */
 738
 739           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 740             return filedata->section_headers + i;
 741         }
 742     }
 743
 744   return find_section (filedata, name);
 745 }
 746
 747 /* Read an unsigned LEB128 encoded value from DATA.
 748    Set *LENGTH_RETURN to the number of bytes read.  */
 749
 750 static inline unsigned long
 751 read_uleb128 (unsigned char * data,
 752               unsigned int * length_return,
 753               const unsigned char * const end)
 754 {
 755   return read_leb128 (data, length_return, FALSE, end);
 756 }
 757
 758 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 759    This OS has so many departures from the ELF standard that we test it at
 760    many places.  */
 761
 762 static inline bfd_boolean
 763 is_ia64_vms (Filedata * filedata)
 764 {
 765   return filedata->file_header.e_machine == EM_IA_64
 766     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 767 }
 768
 769 /* Guess the relocation size commonly used by the specific machines.  */
 770
 771 static bfd_boolean
 772 guess_is_rela (unsigned int e_machine)
 773 {
 774   switch (e_machine)
 775     {
 776       /* Targets that use REL relocations.  */
 777     case EM_386:
 778     case EM_IAMCU:
 779     case EM_960:
 780     case EM_ARM:
 781     case EM_D10V:
 782     case EM_CYGNUS_D10V:
 783     case EM_DLX:
 784     case EM_MIPS:
 785     case EM_MIPS_RS3_LE:
 786     case EM_CYGNUS_M32R:
 787     case EM_SCORE:
 788     case EM_XGATE:
 789     case EM_NFP:
 790     case EM_BPF:
 791       return FALSE;
 792
 793       /* Targets that use RELA relocations.  */
 794     case EM_68K:
 795     case EM_860:
 796     case EM_AARCH64:
 797     case EM_ADAPTEVA_EPIPHANY:
 798     case EM_ALPHA:
 799     case EM_ALTERA_NIOS2:
 800     case EM_ARC:
 801     case EM_ARC_COMPACT:
 802     case EM_ARC_COMPACT2:
 803     case EM_AVR:
 804     case EM_AVR_OLD:
 805     case EM_BLACKFIN:
 806     case EM_CR16:
 807     case EM_CRIS:
 808     case EM_CRX:
 809     case EM_CSKY:
 810     case EM_D30V:
 811     case EM_CYGNUS_D30V:
 812     case EM_FR30:
 813     case EM_FT32:
 814     case EM_CYGNUS_FR30:
 815     case EM_CYGNUS_FRV:
 816     case EM_H8S:
 817     case EM_H8_300:
 818     case EM_H8_300H:
 819     case EM_IA_64:
 820     case EM_IP2K:
 821     case EM_IP2K_OLD:
 822     case EM_IQ2000:
 823     case EM_LATTICEMICO32:
 824     case EM_M32C_OLD:
 825     case EM_M32C:
 826     case EM_M32R:
 827     case EM_MCORE:
 828     case EM_CYGNUS_MEP:
 829     case EM_METAG:
 830     case EM_MMIX:
 831     case EM_MN10200:
 832     case EM_CYGNUS_MN10200:
 833     case EM_MN10300:
 834     case EM_CYGNUS_MN10300:
 835     case EM_MOXIE:
 836     case EM_MSP430:
 837     case EM_MSP430_OLD:
 838     case EM_MT:
 839     case EM_NDS32:
 840     case EM_NIOS32:
 841     case EM_OR1K:
 842     case EM_PPC64:
 843     case EM_PPC:
 844     case EM_TI_PRU:
 845     case EM_RISCV:
 846     case EM_RL78:
 847     case EM_RX:
 848     case EM_S390:
 849     case EM_S390_OLD:
 850     case EM_SH:
 851     case EM_SPARC:
 852     case EM_SPARC32PLUS:
 853     case EM_SPARCV9:
 854     case EM_SPU:
 855     case EM_TI_C6000:
 856     case EM_TILEGX:
 857     case EM_TILEPRO:
 858     case EM_V800:
 859     case EM_V850:
 860     case EM_CYGNUS_V850:
 861     case EM_VAX:
 862     case EM_VISIUM:
 863     case EM_X86_64:
 864     case EM_L1OM:
 865     case EM_K1OM:
 866     case EM_XSTORMY16:
 867     case EM_XTENSA:
 868     case EM_XTENSA_OLD:
 869     case EM_MICROBLAZE:
 870     case EM_MICROBLAZE_OLD:
 871     case EM_WEBASSEMBLY:
 872       return TRUE;
 873
 874     case EM_68HC05:
 875     case EM_68HC08:
 876     case EM_68HC11:
 877     case EM_68HC16:
 878     case EM_FX66:
 879     case EM_ME16:
 880     case EM_MMA:
 881     case EM_NCPU:
 882     case EM_NDR1:
 883     case EM_PCP:
 884     case EM_ST100:
 885     case EM_ST19:
 886     case EM_ST7:
 887     case EM_ST9PLUS:
 888     case EM_STARCORE:
 889     case EM_SVX:
 890     case EM_TINYJ:
 891     default:
 892       warn (_("Don't know about relocations on this machine architecture\n"));
 893       return FALSE;
 894     }
 895 }
 896
 897 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 898    Returns TRUE upon success, FALSE otherwise.  If successful then a
 899    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 900    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 901    responsibility to free the allocated buffer.  */
 902
 903 static bfd_boolean
 904 slurp_rela_relocs (Filedata *            filedata,
 905                    unsigned long         rel_offset,
 906                    unsigned long         rel_size,
 907                    Elf_Internal_Rela **  relasp,
 908                    unsigned long *       nrelasp)
 909 {
 910   Elf_Internal_Rela * relas;
 911   size_t nrelas;
 912   unsigned int i;
 913
 914   if (is_32bit_elf)
 915     {
 916       Elf32_External_Rela * erelas;
 917
 918       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 919                                                  rel_size, _("32-bit relocation data"));
 920       if (!erelas)
 921         return FALSE;
 922
 923       nrelas = rel_size / sizeof (Elf32_External_Rela);
 924
 925       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 926                                              sizeof (Elf_Internal_Rela));
 927
 928       if (relas == NULL)
 929         {
 930           free (erelas);
 931           error (_("out of memory parsing relocs\n"));
 932           return FALSE;
 933         }
 934
 935       for (i = 0; i < nrelas; i++)
 936         {
 937           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 938           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 939           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 940         }
 941
 942       free (erelas);
 943     }
 944   else
 945     {
 946       Elf64_External_Rela * erelas;
 947
 948       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 949                                                  rel_size, _("64-bit relocation data"));
 950       if (!erelas)
 951         return FALSE;
 952
 953       nrelas = rel_size / sizeof (Elf64_External_Rela);
 954
 955       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 956                                              sizeof (Elf_Internal_Rela));
 957
 958       if (relas == NULL)
 959         {
 960           free (erelas);
 961           error (_("out of memory parsing relocs\n"));
 962           return FALSE;
 963         }
 964
 965       for (i = 0; i < nrelas; i++)
 966         {
 967           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 968           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 969           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 970
 971           /* The #ifdef BFD64 below is to prevent a compile time
 972              warning.  We know that if we do not have a 64 bit data
 973              type that we will never execute this code anyway.  */
 974 #ifdef BFD64
 975           if (filedata->file_header.e_machine == EM_MIPS
 976               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 977             {
 978               /* In little-endian objects, r_info isn't really a
 979                  64-bit little-endian value: it has a 32-bit
 980                  little-endian symbol index followed by four
 981                  individual byte fields.  Reorder INFO
 982                  accordingly.  */
 983               bfd_vma inf = relas[i].r_info;
 984               inf = (((inf & 0xffffffff) << 32)
 985                       | ((inf >> 56) & 0xff)
 986                       | ((inf >> 40) & 0xff00)
 987                       | ((inf >> 24) & 0xff0000)
 988                       | ((inf >> 8) & 0xff000000));
 989               relas[i].r_info = inf;
 990             }
 991 #endif /* BFD64 */
 992         }
 993
 994       free (erelas);
 995     }
 996
 997   *relasp = relas;
 998   *nrelasp = nrelas;
 999   return TRUE;
1000 }
1001
1002 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1003    Returns TRUE upon success, FALSE otherwise.  If successful then a
1004    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1005    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
1006    responsibility to free the allocated buffer.  */
1007
1008 static bfd_boolean
1009 slurp_rel_relocs (Filedata *            filedata,
1010                   unsigned long         rel_offset,
1011                   unsigned long         rel_size,
1012                   Elf_Internal_Rela **  relsp,
1013                   unsigned long *       nrelsp)
1014 {
1015   Elf_Internal_Rela * rels;
1016   size_t nrels;
1017   unsigned int i;
1018
1019   if (is_32bit_elf)
1020     {
1021       Elf32_External_Rel * erels;
1022
1023       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1024                                                rel_size, _("32-bit relocation data"));
1025       if (!erels)
1026         return FALSE;
1027
1028       nrels = rel_size / sizeof (Elf32_External_Rel);
1029
1030       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1031
1032       if (rels == NULL)
1033         {
1034           free (erels);
1035           error (_("out of memory parsing relocs\n"));
1036           return FALSE;
1037         }
1038
1039       for (i = 0; i < nrels; i++)
1040         {
1041           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1042           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1043           rels[i].r_addend = 0;
1044         }
1045
1046       free (erels);
1047     }
1048   else
1049     {
1050       Elf64_External_Rel * erels;
1051
1052       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1053                                                rel_size, _("64-bit relocation data"));
1054       if (!erels)
1055         return FALSE;
1056
1057       nrels = rel_size / sizeof (Elf64_External_Rel);
1058
1059       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1060
1061       if (rels == NULL)
1062         {
1063           free (erels);
1064           error (_("out of memory parsing relocs\n"));
1065           return FALSE;
1066         }
1067
1068       for (i = 0; i < nrels; i++)
1069         {
1070           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1071           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1072           rels[i].r_addend = 0;
1073
1074           /* The #ifdef BFD64 below is to prevent a compile time
1075              warning.  We know that if we do not have a 64 bit data
1076              type that we will never execute this code anyway.  */
1077 #ifdef BFD64
1078           if (filedata->file_header.e_machine == EM_MIPS
1079               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1080             {
1081               /* In little-endian objects, r_info isn't really a
1082                  64-bit little-endian value: it has a 32-bit
1083                  little-endian symbol index followed by four
1084                  individual byte fields.  Reorder INFO
1085                  accordingly.  */
1086               bfd_vma inf = rels[i].r_info;
1087               inf = (((inf & 0xffffffff) << 32)
1088                      | ((inf >> 56) & 0xff)
1089                      | ((inf >> 40) & 0xff00)
1090                      | ((inf >> 24) & 0xff0000)
1091                      | ((inf >> 8) & 0xff000000));
1092               rels[i].r_info = inf;
1093             }
1094 #endif /* BFD64 */
1095         }
1096
1097       free (erels);
1098     }
1099
1100   *relsp = rels;
1101   *nrelsp = nrels;
1102   return TRUE;
1103 }
1104
1105 /* Returns the reloc type extracted from the reloc info field.  */
1106
1107 static unsigned int
1108 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1109 {
1110   if (is_32bit_elf)
1111     return ELF32_R_TYPE (reloc_info);
1112
1113   switch (filedata->file_header.e_machine)
1114     {
1115     case EM_MIPS:
1116       /* Note: We assume that reloc_info has already been adjusted for us.  */
1117       return ELF64_MIPS_R_TYPE (reloc_info);
1118
1119     case EM_SPARCV9:
1120       return ELF64_R_TYPE_ID (reloc_info);
1121
1122     default:
1123       return ELF64_R_TYPE (reloc_info);
1124     }
1125 }
1126
1127 /* Return the symbol index extracted from the reloc info field.  */
1128
1129 static bfd_vma
1130 get_reloc_symindex (bfd_vma reloc_info)
1131 {
1132   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1133 }
1134
1135 static inline bfd_boolean
1136 uses_msp430x_relocs (Filedata * filedata)
1137 {
1138   return
1139     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1140     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1141     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1142         /* TI compiler uses ELFOSABI_NONE.  */
1143         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1144 }
1145
1146 /* Display the contents of the relocation data found at the specified
1147    offset.  */
1148
1149 static bfd_boolean
1150 dump_relocations (Filedata *          filedata,
1151                   unsigned long       rel_offset,
1152                   unsigned long       rel_size,
1153                   Elf_Internal_Sym *  symtab,
1154                   unsigned long       nsyms,
1155                   char *              strtab,
1156                   unsigned long       strtablen,
1157                   int                 is_rela,
1158                   bfd_boolean         is_dynsym)
1159 {
1160   unsigned long i;
1161   Elf_Internal_Rela * rels;
1162   bfd_boolean res = TRUE;
1163
1164   if (is_rela == UNKNOWN)
1165     is_rela = guess_is_rela (filedata->file_header.e_machine);
1166
1167   if (is_rela)
1168     {
1169       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1170         return FALSE;
1171     }
1172   else
1173     {
1174       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1175         return FALSE;
1176     }
1177
1178   if (is_32bit_elf)
1179     {
1180       if (is_rela)
1181         {
1182           if (do_wide)
1183             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1184           else
1185             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1186         }
1187       else
1188         {
1189           if (do_wide)
1190             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1191           else
1192             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1193         }
1194     }
1195   else
1196     {
1197       if (is_rela)
1198         {
1199           if (do_wide)
1200             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1201           else
1202             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1203         }
1204       else
1205         {
1206           if (do_wide)
1207             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1208           else
1209             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1210         }
1211     }
1212
1213   for (i = 0; i < rel_size; i++)
1214     {
1215       const char * rtype;
1216       bfd_vma offset;
1217       bfd_vma inf;
1218       bfd_vma symtab_index;
1219       bfd_vma type;
1220
1221       offset = rels[i].r_offset;
1222       inf    = rels[i].r_info;
1223
1224       type = get_reloc_type (filedata, inf);
1225       symtab_index = get_reloc_symindex  (inf);
1226
1227       if (is_32bit_elf)
1228         {
1229           printf ("%8.8lx  %8.8lx ",
1230                   (unsigned long) offset & 0xffffffff,
1231                   (unsigned long) inf & 0xffffffff);
1232         }
1233       else
1234         {
1235 #if BFD_HOST_64BIT_LONG
1236           printf (do_wide
1237                   ? "%16.16lx  %16.16lx "
1238                   : "%12.12lx  %12.12lx ",
1239                   offset, inf);
1240 #elif BFD_HOST_64BIT_LONG_LONG
1241 #ifndef __MSVCRT__
1242           printf (do_wide
1243                   ? "%16.16llx  %16.16llx "
1244                   : "%12.12llx  %12.12llx ",
1245                   offset, inf);
1246 #else
1247           printf (do_wide
1248                   ? "%16.16I64x  %16.16I64x "
1249                   : "%12.12I64x  %12.12I64x ",
1250                   offset, inf);
1251 #endif
1252 #else
1253           printf (do_wide
1254                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1255                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1256                   _bfd_int64_high (offset),
1257                   _bfd_int64_low (offset),
1258                   _bfd_int64_high (inf),
1259                   _bfd_int64_low (inf));
1260 #endif
1261         }
1262
1263       switch (filedata->file_header.e_machine)
1264         {
1265         default:
1266           rtype = NULL;
1267           break;
1268
1269         case EM_AARCH64:
1270           rtype = elf_aarch64_reloc_type (type);
1271           break;
1272
1273         case EM_M32R:
1274         case EM_CYGNUS_M32R:
1275           rtype = elf_m32r_reloc_type (type);
1276           break;
1277
1278         case EM_386:
1279         case EM_IAMCU:
1280           rtype = elf_i386_reloc_type (type);
1281           break;
1282
1283         case EM_68HC11:
1284         case EM_68HC12:
1285           rtype = elf_m68hc11_reloc_type (type);
1286           break;
1287
1288         case EM_S12Z:
1289           rtype = elf_s12z_reloc_type (type);
1290           break;
1291
1292         case EM_68K:
1293           rtype = elf_m68k_reloc_type (type);
1294           break;
1295
1296         case EM_960:
1297           rtype = elf_i960_reloc_type (type);
1298           break;
1299
1300         case EM_AVR:
1301         case EM_AVR_OLD:
1302           rtype = elf_avr_reloc_type (type);
1303           break;
1304
1305         case EM_OLD_SPARCV9:
1306         case EM_SPARC32PLUS:
1307         case EM_SPARCV9:
1308         case EM_SPARC:
1309           rtype = elf_sparc_reloc_type (type);
1310           break;
1311
1312         case EM_SPU:
1313           rtype = elf_spu_reloc_type (type);
1314           break;
1315
1316         case EM_V800:
1317           rtype = v800_reloc_type (type);
1318           break;
1319         case EM_V850:
1320         case EM_CYGNUS_V850:
1321           rtype = v850_reloc_type (type);
1322           break;
1323
1324         case EM_D10V:
1325         case EM_CYGNUS_D10V:
1326           rtype = elf_d10v_reloc_type (type);
1327           break;
1328
1329         case EM_D30V:
1330         case EM_CYGNUS_D30V:
1331           rtype = elf_d30v_reloc_type (type);
1332           break;
1333
1334         case EM_DLX:
1335           rtype = elf_dlx_reloc_type (type);
1336           break;
1337
1338         case EM_SH:
1339           rtype = elf_sh_reloc_type (type);
1340           break;
1341
1342         case EM_MN10300:
1343         case EM_CYGNUS_MN10300:
1344           rtype = elf_mn10300_reloc_type (type);
1345           break;
1346
1347         case EM_MN10200:
1348         case EM_CYGNUS_MN10200:
1349           rtype = elf_mn10200_reloc_type (type);
1350           break;
1351
1352         case EM_FR30:
1353         case EM_CYGNUS_FR30:
1354           rtype = elf_fr30_reloc_type (type);
1355           break;
1356
1357         case EM_CYGNUS_FRV:
1358           rtype = elf_frv_reloc_type (type);
1359           break;
1360
1361         case EM_CSKY:
1362           rtype = elf_csky_reloc_type (type);
1363           break;
1364
1365         case EM_FT32:
1366           rtype = elf_ft32_reloc_type (type);
1367           break;
1368
1369         case EM_MCORE:
1370           rtype = elf_mcore_reloc_type (type);
1371           break;
1372
1373         case EM_MMIX:
1374           rtype = elf_mmix_reloc_type (type);
1375           break;
1376
1377         case EM_MOXIE:
1378           rtype = elf_moxie_reloc_type (type);
1379           break;
1380
1381         case EM_MSP430:
1382           if (uses_msp430x_relocs (filedata))
1383             {
1384               rtype = elf_msp430x_reloc_type (type);
1385               break;
1386             }
1387           /* Fall through.  */
1388         case EM_MSP430_OLD:
1389           rtype = elf_msp430_reloc_type (type);
1390           break;
1391
1392         case EM_NDS32:
1393           rtype = elf_nds32_reloc_type (type);
1394           break;
1395
1396         case EM_PPC:
1397           rtype = elf_ppc_reloc_type (type);
1398           break;
1399
1400         case EM_PPC64:
1401           rtype = elf_ppc64_reloc_type (type);
1402           break;
1403
1404         case EM_MIPS:
1405         case EM_MIPS_RS3_LE:
1406           rtype = elf_mips_reloc_type (type);
1407           break;
1408
1409         case EM_RISCV:
1410           rtype = elf_riscv_reloc_type (type);
1411           break;
1412
1413         case EM_ALPHA:
1414           rtype = elf_alpha_reloc_type (type);
1415           break;
1416
1417         case EM_ARM:
1418           rtype = elf_arm_reloc_type (type);
1419           break;
1420
1421         case EM_ARC:
1422         case EM_ARC_COMPACT:
1423         case EM_ARC_COMPACT2:
1424           rtype = elf_arc_reloc_type (type);
1425           break;
1426
1427         case EM_PARISC:
1428           rtype = elf_hppa_reloc_type (type);
1429           break;
1430
1431         case EM_H8_300:
1432         case EM_H8_300H:
1433         case EM_H8S:
1434           rtype = elf_h8_reloc_type (type);
1435           break;
1436
1437         case EM_OR1K:
1438           rtype = elf_or1k_reloc_type (type);
1439           break;
1440
1441         case EM_PJ:
1442         case EM_PJ_OLD:
1443           rtype = elf_pj_reloc_type (type);
1444           break;
1445         case EM_IA_64:
1446           rtype = elf_ia64_reloc_type (type);
1447           break;
1448
1449         case EM_CRIS:
1450           rtype = elf_cris_reloc_type (type);
1451           break;
1452
1453         case EM_860:
1454           rtype = elf_i860_reloc_type (type);
1455           break;
1456
1457         case EM_X86_64:
1458         case EM_L1OM:
1459         case EM_K1OM:
1460           rtype = elf_x86_64_reloc_type (type);
1461           break;
1462
1463         case EM_S370:
1464           rtype = i370_reloc_type (type);
1465           break;
1466
1467         case EM_S390_OLD:
1468         case EM_S390:
1469           rtype = elf_s390_reloc_type (type);
1470           break;
1471
1472         case EM_SCORE:
1473           rtype = elf_score_reloc_type (type);
1474           break;
1475
1476         case EM_XSTORMY16:
1477           rtype = elf_xstormy16_reloc_type (type);
1478           break;
1479
1480         case EM_CRX:
1481           rtype = elf_crx_reloc_type (type);
1482           break;
1483
1484         case EM_VAX:
1485           rtype = elf_vax_reloc_type (type);
1486           break;
1487
1488         case EM_VISIUM:
1489           rtype = elf_visium_reloc_type (type);
1490           break;
1491
1492         case EM_BPF:
1493           rtype = elf_bpf_reloc_type (type);
1494           break;
1495
1496         case EM_ADAPTEVA_EPIPHANY:
1497           rtype = elf_epiphany_reloc_type (type);
1498           break;
1499
1500         case EM_IP2K:
1501         case EM_IP2K_OLD:
1502           rtype = elf_ip2k_reloc_type (type);
1503           break;
1504
1505         case EM_IQ2000:
1506           rtype = elf_iq2000_reloc_type (type);
1507           break;
1508
1509         case EM_XTENSA_OLD:
1510         case EM_XTENSA:
1511           rtype = elf_xtensa_reloc_type (type);
1512           break;
1513
1514         case EM_LATTICEMICO32:
1515           rtype = elf_lm32_reloc_type (type);
1516           break;
1517
1518         case EM_M32C_OLD:
1519         case EM_M32C:
1520           rtype = elf_m32c_reloc_type (type);
1521           break;
1522
1523         case EM_MT:
1524           rtype = elf_mt_reloc_type (type);
1525           break;
1526
1527         case EM_BLACKFIN:
1528           rtype = elf_bfin_reloc_type (type);
1529           break;
1530
1531         case EM_CYGNUS_MEP:
1532           rtype = elf_mep_reloc_type (type);
1533           break;
1534
1535         case EM_CR16:
1536           rtype = elf_cr16_reloc_type (type);
1537           break;
1538
1539         case EM_MICROBLAZE:
1540         case EM_MICROBLAZE_OLD:
1541           rtype = elf_microblaze_reloc_type (type);
1542           break;
1543
1544         case EM_RL78:
1545           rtype = elf_rl78_reloc_type (type);
1546           break;
1547
1548         case EM_RX:
1549           rtype = elf_rx_reloc_type (type);
1550           break;
1551
1552         case EM_METAG:
1553           rtype = elf_metag_reloc_type (type);
1554           break;
1555
1556         case EM_XC16X:
1557         case EM_C166:
1558           rtype = elf_xc16x_reloc_type (type);
1559           break;
1560
1561         case EM_TI_C6000:
1562           rtype = elf_tic6x_reloc_type (type);
1563           break;
1564
1565         case EM_TILEGX:
1566           rtype = elf_tilegx_reloc_type (type);
1567           break;
1568
1569         case EM_TILEPRO:
1570           rtype = elf_tilepro_reloc_type (type);
1571           break;
1572
1573         case EM_WEBASSEMBLY:
1574           rtype = elf_wasm32_reloc_type (type);
1575           break;
1576
1577         case EM_XGATE:
1578           rtype = elf_xgate_reloc_type (type);
1579           break;
1580
1581         case EM_ALTERA_NIOS2:
1582           rtype = elf_nios2_reloc_type (type);
1583           break;
1584
1585         case EM_TI_PRU:
1586           rtype = elf_pru_reloc_type (type);
1587           break;
1588
1589         case EM_NFP:
1590           if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1591             rtype = elf_nfp3200_reloc_type (type);
1592           else
1593             rtype = elf_nfp_reloc_type (type);
1594           break;
1595         }
1596
1597       if (rtype == NULL)
1598         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1599       else
1600         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1601
1602       if (filedata->file_header.e_machine == EM_ALPHA
1603           && rtype != NULL
1604           && streq (rtype, "R_ALPHA_LITUSE")
1605           && is_rela)
1606         {
1607           switch (rels[i].r_addend)
1608             {
1609             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1610             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1611             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1612             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1613             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1614             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1615             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1616             default: rtype = NULL;
1617             }
1618
1619           if (rtype)
1620             printf (" (%s)", rtype);
1621           else
1622             {
1623               putchar (' ');
1624               printf (_("<unknown addend: %lx>"),
1625                       (unsigned long) rels[i].r_addend);
1626               res = FALSE;
1627             }
1628         }
1629       else if (symtab_index)
1630         {
1631           if (symtab == NULL || symtab_index >= nsyms)
1632             {
1633               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1634               res = FALSE;
1635             }
1636           else
1637             {
1638               Elf_Internal_Sym * psym;
1639               const char * version_string;
1640               enum versioned_symbol_info sym_info;
1641               unsigned short vna_other;
1642
1643               psym = symtab + symtab_index;
1644
1645               version_string
1646                 = get_symbol_version_string (filedata, is_dynsym,
1647                                              strtab, strtablen,
1648                                              symtab_index,
1649                                              psym,
1650                                              &sym_info,
1651                                              &vna_other);
1652
1653               printf (" ");
1654
1655               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1656                 {
1657                   const char * name;
1658                   unsigned int len;
1659                   unsigned int width = is_32bit_elf ? 8 : 14;
1660
1661                   /* Relocations against GNU_IFUNC symbols do not use the value
1662                      of the symbol as the address to relocate against.  Instead
1663                      they invoke the function named by the symbol and use its
1664                      result as the address for relocation.
1665
1666                      To indicate this to the user, do not display the value of
1667                      the symbol in the "Symbols's Value" field.  Instead show
1668                      its name followed by () as a hint that the symbol is
1669                      invoked.  */
1670
1671                   if (strtab == NULL
1672                       || psym->st_name == 0
1673                       || psym->st_name >= strtablen)
1674                     name = "??";
1675                   else
1676                     name = strtab + psym->st_name;
1677
1678                   len = print_symbol (width, name);
1679                   if (version_string)
1680                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1681                             version_string);
1682                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1683                 }
1684               else
1685                 {
1686                   print_vma (psym->st_value, LONG_HEX);
1687
1688                   printf (is_32bit_elf ? "   " : " ");
1689                 }
1690
1691               if (psym->st_name == 0)
1692                 {
1693                   const char * sec_name = "<null>";
1694                   char name_buf[40];
1695
1696                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1697                     {
1698                       if (psym->st_shndx < filedata->file_header.e_shnum)
1699                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1700                       else if (psym->st_shndx == SHN_ABS)
1701                         sec_name = "ABS";
1702                       else if (psym->st_shndx == SHN_COMMON)
1703                         sec_name = "COMMON";
1704                       else if ((filedata->file_header.e_machine == EM_MIPS
1705                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1706                                || (filedata->file_header.e_machine == EM_TI_C6000
1707                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1708                         sec_name = "SCOMMON";
1709                       else if (filedata->file_header.e_machine == EM_MIPS
1710                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1711                         sec_name = "SUNDEF";
1712                       else if ((filedata->file_header.e_machine == EM_X86_64
1713                                 || filedata->file_header.e_machine == EM_L1OM
1714                                 || filedata->file_header.e_machine == EM_K1OM)
1715                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1716                         sec_name = "LARGE_COMMON";
1717                       else if (filedata->file_header.e_machine == EM_IA_64
1718                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1719                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1720                         sec_name = "ANSI_COM";
1721                       else if (is_ia64_vms (filedata)
1722                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1723                         sec_name = "VMS_SYMVEC";
1724                       else
1725                         {
1726                           sprintf (name_buf, "<section 0x%x>",
1727                                    (unsigned int) psym->st_shndx);
1728                           sec_name = name_buf;
1729                         }
1730                     }
1731                   print_symbol (22, sec_name);
1732                 }
1733               else if (strtab == NULL)
1734                 printf (_("<string table index: %3ld>"), psym->st_name);
1735               else if (psym->st_name >= strtablen)
1736                 {
1737                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1738                   res = FALSE;
1739                 }
1740               else
1741                 {
1742                   print_symbol (22, strtab + psym->st_name);
1743                   if (version_string)
1744                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1745                             version_string);
1746                 }
1747
1748               if (is_rela)
1749                 {
1750                   bfd_vma off = rels[i].r_addend;
1751
1752                   if ((bfd_signed_vma) off < 0)
1753                     printf (" - %" BFD_VMA_FMT "x", - off);
1754                   else
1755                     printf (" + %" BFD_VMA_FMT "x", off);
1756                 }
1757             }
1758         }
1759       else if (is_rela)
1760         {
1761           bfd_vma off = rels[i].r_addend;
1762
1763           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1764           if ((bfd_signed_vma) off < 0)
1765             printf ("-%" BFD_VMA_FMT "x", - off);
1766           else
1767             printf ("%" BFD_VMA_FMT "x", off);
1768         }
1769
1770       if (filedata->file_header.e_machine == EM_SPARCV9
1771           && rtype != NULL
1772           && streq (rtype, "R_SPARC_OLO10"))
1773         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1774
1775       putchar ('\n');
1776
1777 #ifdef BFD64
1778       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1779         {
1780           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1781           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1782           const char * rtype2 = elf_mips_reloc_type (type2);
1783           const char * rtype3 = elf_mips_reloc_type (type3);
1784
1785           printf ("                    Type2: ");
1786
1787           if (rtype2 == NULL)
1788             printf (_("unrecognized: %-7lx"),
1789                     (unsigned long) type2 & 0xffffffff);
1790           else
1791             printf ("%-17.17s", rtype2);
1792
1793           printf ("\n                    Type3: ");
1794
1795           if (rtype3 == NULL)
1796             printf (_("unrecognized: %-7lx"),
1797                     (unsigned long) type3 & 0xffffffff);
1798           else
1799             printf ("%-17.17s", rtype3);
1800
1801           putchar ('\n');
1802         }
1803 #endif /* BFD64 */
1804     }
1805
1806   free (rels);
1807
1808   return res;
1809 }
1810
1811 static const char *
1812 get_aarch64_dynamic_type (unsigned long type)
1813 {
1814   switch (type)
1815     {
1816     case DT_AARCH64_BTI_PLT:  return "AARCH64_BTI_PLT";
1817     case DT_AARCH64_PAC_PLT:  return "AARCH64_PAC_PLT";
1818     case DT_AARCH64_VARIANT_PCS:  return "AARCH64_VARIANT_PCS";
1819     default:
1820       return NULL;
1821     }
1822 }
1823
1824 static const char *
1825 get_mips_dynamic_type (unsigned long type)
1826 {
1827   switch (type)
1828     {
1829     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1830     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1831     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1832     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1833     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1834     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1835     case DT_MIPS_MSYM: return "MIPS_MSYM";
1836     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1837     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1838     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1839     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1840     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1841     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1842     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1843     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1844     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1845     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1846     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1847     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1848     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1849     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1850     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1851     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1852     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1853     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1854     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1855     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1856     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1857     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1858     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1859     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1860     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1861     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1862     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1863     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1864     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1865     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1866     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1867     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1868     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1869     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1870     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1871     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1872     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1873     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1874     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1875     default:
1876       return NULL;
1877     }
1878 }
1879
1880 static const char *
1881 get_sparc64_dynamic_type (unsigned long type)
1882 {
1883   switch (type)
1884     {
1885     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1886     default:
1887       return NULL;
1888     }
1889 }
1890
1891 static const char *
1892 get_ppc_dynamic_type (unsigned long type)
1893 {
1894   switch (type)
1895     {
1896     case DT_PPC_GOT:    return "PPC_GOT";
1897     case DT_PPC_OPT:    return "PPC_OPT";
1898     default:
1899       return NULL;
1900     }
1901 }
1902
1903 static const char *
1904 get_ppc64_dynamic_type (unsigned long type)
1905 {
1906   switch (type)
1907     {
1908     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1909     case DT_PPC64_OPD:    return "PPC64_OPD";
1910     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1911     case DT_PPC64_OPT:    return "PPC64_OPT";
1912     default:
1913       return NULL;
1914     }
1915 }
1916
1917 static const char *
1918 get_parisc_dynamic_type (unsigned long type)
1919 {
1920   switch (type)
1921     {
1922     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1923     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1924     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1925     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1926     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1927     case DT_HP_PREINIT:         return "HP_PREINIT";
1928     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1929     case DT_HP_NEEDED:          return "HP_NEEDED";
1930     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1931     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1932     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1933     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1934     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1935     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1936     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1937     case DT_HP_FILTERED:        return "HP_FILTERED";
1938     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1939     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1940     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1941     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1942     case DT_PLT:                return "PLT";
1943     case DT_PLT_SIZE:           return "PLT_SIZE";
1944     case DT_DLT:                return "DLT";
1945     case DT_DLT_SIZE:           return "DLT_SIZE";
1946     default:
1947       return NULL;
1948     }
1949 }
1950
1951 static const char *
1952 get_ia64_dynamic_type (unsigned long type)
1953 {
1954   switch (type)
1955     {
1956     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1957     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1958     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1959     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1960     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1961     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1962     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1963     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1964     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1965     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1966     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1967     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1968     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1969     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1970     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1971     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1972     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1973     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1974     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1975     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1976     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1977     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1978     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1979     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1980     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1981     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1982     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1983     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1984     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1985     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1986     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1987     default:
1988       return NULL;
1989     }
1990 }
1991
1992 static const char *
1993 get_solaris_section_type (unsigned long type)
1994 {
1995   switch (type)
1996     {
1997     case 0x6fffffee: return "SUNW_ancillary";
1998     case 0x6fffffef: return "SUNW_capchain";
1999     case 0x6ffffff0: return "SUNW_capinfo";
2000     case 0x6ffffff1: return "SUNW_symsort";
2001     case 0x6ffffff2: return "SUNW_tlssort";
2002     case 0x6ffffff3: return "SUNW_LDYNSYM";
2003     case 0x6ffffff4: return "SUNW_dof";
2004     case 0x6ffffff5: return "SUNW_cap";
2005     case 0x6ffffff6: return "SUNW_SIGNATURE";
2006     case 0x6ffffff7: return "SUNW_ANNOTATE";
2007     case 0x6ffffff8: return "SUNW_DEBUGSTR";
2008     case 0x6ffffff9: return "SUNW_DEBUG";
2009     case 0x6ffffffa: return "SUNW_move";
2010     case 0x6ffffffb: return "SUNW_COMDAT";
2011     case 0x6ffffffc: return "SUNW_syminfo";
2012     case 0x6ffffffd: return "SUNW_verdef";
2013     case 0x6ffffffe: return "SUNW_verneed";
2014     case 0x6fffffff: return "SUNW_versym";
2015     case 0x70000000: return "SPARC_GOTDATA";
2016     default: return NULL;
2017     }
2018 }
2019
2020 static const char *
2021 get_alpha_dynamic_type (unsigned long type)
2022 {
2023   switch (type)
2024     {
2025     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2026     default: return NULL;
2027     }
2028 }
2029
2030 static const char *
2031 get_score_dynamic_type (unsigned long type)
2032 {
2033   switch (type)
2034     {
2035     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2036     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
2037     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
2038     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
2039     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
2040     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
2041     default:                    return NULL;
2042     }
2043 }
2044
2045 static const char *
2046 get_tic6x_dynamic_type (unsigned long type)
2047 {
2048   switch (type)
2049     {
2050     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2051     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2052     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2053     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2054     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2055     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2056     default:                   return NULL;
2057     }
2058 }
2059
2060 static const char *
2061 get_nios2_dynamic_type (unsigned long type)
2062 {
2063   switch (type)
2064     {
2065     case DT_NIOS2_GP: return "NIOS2_GP";
2066     default:          return NULL;
2067     }
2068 }
2069
2070 static const char *
2071 get_solaris_dynamic_type (unsigned long type)
2072 {
2073   switch (type)
2074     {
2075     case 0x6000000d: return "SUNW_AUXILIARY";
2076     case 0x6000000e: return "SUNW_RTLDINF";
2077     case 0x6000000f: return "SUNW_FILTER";
2078     case 0x60000010: return "SUNW_CAP";
2079     case 0x60000011: return "SUNW_SYMTAB";
2080     case 0x60000012: return "SUNW_SYMSZ";
2081     case 0x60000013: return "SUNW_SORTENT";
2082     case 0x60000014: return "SUNW_SYMSORT";
2083     case 0x60000015: return "SUNW_SYMSORTSZ";
2084     case 0x60000016: return "SUNW_TLSSORT";
2085     case 0x60000017: return "SUNW_TLSSORTSZ";
2086     case 0x60000018: return "SUNW_CAPINFO";
2087     case 0x60000019: return "SUNW_STRPAD";
2088     case 0x6000001a: return "SUNW_CAPCHAIN";
2089     case 0x6000001b: return "SUNW_LDMACH";
2090     case 0x6000001d: return "SUNW_CAPCHAINENT";
2091     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2092     case 0x60000021: return "SUNW_PARENT";
2093     case 0x60000023: return "SUNW_ASLR";
2094     case 0x60000025: return "SUNW_RELAX";
2095     case 0x60000029: return "SUNW_NXHEAP";
2096     case 0x6000002b: return "SUNW_NXSTACK";
2097
2098     case 0x70000001: return "SPARC_REGISTER";
2099     case 0x7ffffffd: return "AUXILIARY";
2100     case 0x7ffffffe: return "USED";
2101     case 0x7fffffff: return "FILTER";
2102
2103     default: return NULL;
2104     }
2105 }
2106
2107 static const char *
2108 get_dynamic_type (Filedata * filedata, unsigned long type)
2109 {
2110   static char buff[64];
2111
2112   switch (type)
2113     {
2114     case DT_NULL:       return "NULL";
2115     case DT_NEEDED:     return "NEEDED";
2116     case DT_PLTRELSZ:   return "PLTRELSZ";
2117     case DT_PLTGOT:     return "PLTGOT";
2118     case DT_HASH:       return "HASH";
2119     case DT_STRTAB:     return "STRTAB";
2120     case DT_SYMTAB:     return "SYMTAB";
2121     case DT_RELA:       return "RELA";
2122     case DT_RELASZ:     return "RELASZ";
2123     case DT_RELAENT:    return "RELAENT";
2124     case DT_STRSZ:      return "STRSZ";
2125     case DT_SYMENT:     return "SYMENT";
2126     case DT_INIT:       return "INIT";
2127     case DT_FINI:       return "FINI";
2128     case DT_SONAME:     return "SONAME";
2129     case DT_RPATH:      return "RPATH";
2130     case DT_SYMBOLIC:   return "SYMBOLIC";
2131     case DT_REL:        return "REL";
2132     case DT_RELSZ:      return "RELSZ";
2133     case DT_RELENT:     return "RELENT";
2134     case DT_PLTREL:     return "PLTREL";
2135     case DT_DEBUG:      return "DEBUG";
2136     case DT_TEXTREL:    return "TEXTREL";
2137     case DT_JMPREL:     return "JMPREL";
2138     case DT_BIND_NOW:   return "BIND_NOW";
2139     case DT_INIT_ARRAY: return "INIT_ARRAY";
2140     case DT_FINI_ARRAY: return "FINI_ARRAY";
2141     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2142     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2143     case DT_RUNPATH:    return "RUNPATH";
2144     case DT_FLAGS:      return "FLAGS";
2145
2146     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2147     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2148     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2149
2150     case DT_CHECKSUM:   return "CHECKSUM";
2151     case DT_PLTPADSZ:   return "PLTPADSZ";
2152     case DT_MOVEENT:    return "MOVEENT";
2153     case DT_MOVESZ:     return "MOVESZ";
2154     case DT_FEATURE:    return "FEATURE";
2155     case DT_POSFLAG_1:  return "POSFLAG_1";
2156     case DT_SYMINSZ:    return "SYMINSZ";
2157     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2158
2159     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2160     case DT_CONFIG:     return "CONFIG";
2161     case DT_DEPAUDIT:   return "DEPAUDIT";
2162     case DT_AUDIT:      return "AUDIT";
2163     case DT_PLTPAD:     return "PLTPAD";
2164     case DT_MOVETAB:    return "MOVETAB";
2165     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2166
2167     case DT_VERSYM:     return "VERSYM";
2168
2169     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2170     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2171     case DT_RELACOUNT:  return "RELACOUNT";
2172     case DT_RELCOUNT:   return "RELCOUNT";
2173     case DT_FLAGS_1:    return "FLAGS_1";
2174     case DT_VERDEF:     return "VERDEF";
2175     case DT_VERDEFNUM:  return "VERDEFNUM";
2176     case DT_VERNEED:    return "VERNEED";
2177     case DT_VERNEEDNUM: return "VERNEEDNUM";
2178
2179     case DT_AUXILIARY:  return "AUXILIARY";
2180     case DT_USED:       return "USED";
2181     case DT_FILTER:     return "FILTER";
2182
2183     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2184     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2185     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2186     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2187     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2188     case DT_GNU_HASH:   return "GNU_HASH";
2189
2190     default:
2191       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2192         {
2193           const char * result;
2194
2195           switch (filedata->file_header.e_machine)
2196             {
2197             case EM_AARCH64:
2198               result = get_aarch64_dynamic_type (type);
2199               break;
2200             case EM_MIPS:
2201             case EM_MIPS_RS3_LE:
2202               result = get_mips_dynamic_type (type);
2203               break;
2204             case EM_SPARCV9:
2205               result = get_sparc64_dynamic_type (type);
2206               break;
2207             case EM_PPC:
2208               result = get_ppc_dynamic_type (type);
2209               break;
2210             case EM_PPC64:
2211               result = get_ppc64_dynamic_type (type);
2212               break;
2213             case EM_IA_64:
2214               result = get_ia64_dynamic_type (type);
2215               break;
2216             case EM_ALPHA:
2217               result = get_alpha_dynamic_type (type);
2218               break;
2219             case EM_SCORE:
2220               result = get_score_dynamic_type (type);
2221               break;
2222             case EM_TI_C6000:
2223               result = get_tic6x_dynamic_type (type);
2224               break;
2225             case EM_ALTERA_NIOS2:
2226               result = get_nios2_dynamic_type (type);
2227               break;
2228             default:
2229               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2230                 result = get_solaris_dynamic_type (type);
2231               else
2232                 result = NULL;
2233               break;
2234             }
2235
2236           if (result != NULL)
2237             return result;
2238
2239           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2240         }
2241       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2242                || (filedata->file_header.e_machine == EM_PARISC
2243                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2244         {
2245           const char * result;
2246
2247           switch (filedata->file_header.e_machine)
2248             {
2249             case EM_PARISC:
2250               result = get_parisc_dynamic_type (type);
2251               break;
2252             case EM_IA_64:
2253               result = get_ia64_dynamic_type (type);
2254               break;
2255             default:
2256               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2257                 result = get_solaris_dynamic_type (type);
2258               else
2259                 result = NULL;
2260               break;
2261             }
2262
2263           if (result != NULL)
2264             return result;
2265
2266           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2267                     type);
2268         }
2269       else
2270         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2271
2272       return buff;
2273     }
2274 }
2275
2276 static char *
2277 get_file_type (unsigned e_type)
2278 {
2279   static char buff[32];
2280
2281   switch (e_type)
2282     {
2283     case ET_NONE: return _("NONE (None)");
2284     case ET_REL:  return _("REL (Relocatable file)");
2285     case ET_EXEC: return _("EXEC (Executable file)");
2286     case ET_DYN:  return _("DYN (Shared object file)");
2287     case ET_CORE: return _("CORE (Core file)");
2288
2289     default:
2290       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2291         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2292       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2293         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2294       else
2295         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2296       return buff;
2297     }
2298 }
2299
2300 static char *
2301 get_machine_name (unsigned e_machine)
2302 {
2303   static char buff[64]; /* XXX */
2304
2305   switch (e_machine)
2306     {
2307       /* Please keep this switch table sorted by increasing EM_ value.  */
2308       /* 0 */
2309     case EM_NONE:               return _("None");
2310     case EM_M32:                return "WE32100";
2311     case EM_SPARC:              return "Sparc";
2312     case EM_386:                return "Intel 80386";
2313     case EM_68K:                return "MC68000";
2314     case EM_88K:                return "MC88000";
2315     case EM_IAMCU:              return "Intel MCU";
2316     case EM_860:                return "Intel 80860";
2317     case EM_MIPS:               return "MIPS R3000";
2318     case EM_S370:               return "IBM System/370";
2319       /* 10 */
2320     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2321     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2322     case EM_PARISC:             return "HPPA";
2323     case EM_VPP550:             return "Fujitsu VPP500";
2324     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2325     case EM_960:                return "Intel 80960";
2326     case EM_PPC:                return "PowerPC";
2327       /* 20 */
2328     case EM_PPC64:              return "PowerPC64";
2329     case EM_S390_OLD:
2330     case EM_S390:               return "IBM S/390";
2331     case EM_SPU:                return "SPU";
2332       /* 30 */
2333     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2334     case EM_FR20:               return "Fujitsu FR20";
2335     case EM_RH32:               return "TRW RH32";
2336     case EM_MCORE:              return "MCORE";
2337       /* 40 */
2338     case EM_ARM:                return "ARM";
2339     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2340     case EM_SH:                 return "Renesas / SuperH SH";
2341     case EM_SPARCV9:            return "Sparc v9";
2342     case EM_TRICORE:            return "Siemens Tricore";
2343     case EM_ARC:                return "ARC";
2344     case EM_H8_300:             return "Renesas H8/300";
2345     case EM_H8_300H:            return "Renesas H8/300H";
2346     case EM_H8S:                return "Renesas H8S";
2347     case EM_H8_500:             return "Renesas H8/500";
2348       /* 50 */
2349     case EM_IA_64:              return "Intel IA-64";
2350     case EM_MIPS_X:             return "Stanford MIPS-X";
2351     case EM_COLDFIRE:           return "Motorola Coldfire";
2352     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2353     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2354     case EM_PCP:                return "Siemens PCP";
2355     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2356     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2357     case EM_STARCORE:           return "Motorola Star*Core processor";
2358     case EM_ME16:               return "Toyota ME16 processor";
2359       /* 60 */
2360     case EM_ST100:              return "STMicroelectronics ST100 processor";
2361     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2362     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2363     case EM_PDSP:               return "Sony DSP processor";
2364     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2365     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2366     case EM_FX66:               return "Siemens FX66 microcontroller";
2367     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2368     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2369     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2370       /* 70 */
2371     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2372     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2373     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2374     case EM_SVX:                return "Silicon Graphics SVx";
2375     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2376     case EM_VAX:                return "Digital VAX";
2377     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2378     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2379     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2380     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2381       /* 80 */
2382     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2383     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2384     case EM_PRISM:              return "Vitesse Prism";
2385     case EM_AVR_OLD:
2386     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2387     case EM_CYGNUS_FR30:
2388     case EM_FR30:               return "Fujitsu FR30";
2389     case EM_CYGNUS_D10V:
2390     case EM_D10V:               return "d10v";
2391     case EM_CYGNUS_D30V:
2392     case EM_D30V:               return "d30v";
2393     case EM_CYGNUS_V850:
2394     case EM_V850:               return "Renesas V850";
2395     case EM_CYGNUS_M32R:
2396     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2397     case EM_CYGNUS_MN10300:
2398     case EM_MN10300:            return "mn10300";
2399       /* 90 */
2400     case EM_CYGNUS_MN10200:
2401     case EM_MN10200:            return "mn10200";
2402     case EM_PJ:                 return "picoJava";
2403     case EM_OR1K:               return "OpenRISC 1000";
2404     case EM_ARC_COMPACT:        return "ARCompact";
2405     case EM_XTENSA_OLD:
2406     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2407     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2408     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2409     case EM_NS32K:              return "National Semiconductor 32000 series";
2410     case EM_TPC:                return "Tenor Network TPC processor";
2411     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2412       /* 100 */
2413     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2414     case EM_IP2K_OLD:
2415     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2416     case EM_MAX:                return "MAX Processor";
2417     case EM_CR:                 return "National Semiconductor CompactRISC";
2418     case EM_F2MC16:             return "Fujitsu F2MC16";
2419     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2420     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2421     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2422     case EM_SEP:                return "Sharp embedded microprocessor";
2423     case EM_ARCA:               return "Arca RISC microprocessor";
2424       /* 110 */
2425     case EM_UNICORE:            return "Unicore";
2426     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2427     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2428     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2429     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2430     case EM_XGATE:              return "Motorola XGATE embedded processor";
2431     case EM_C166:
2432     case EM_XC16X:              return "Infineon Technologies xc16x";
2433     case EM_M16C:               return "Renesas M16C series microprocessors";
2434     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2435     case EM_CE:                 return "Freescale Communication Engine RISC core";
2436       /* 120 */
2437     case EM_M32C:               return "Renesas M32c";
2438       /* 130 */
2439     case EM_TSK3000:            return "Altium TSK3000 core";
2440     case EM_RS08:               return "Freescale RS08 embedded processor";
2441     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2442     case EM_SCORE:              return "SUNPLUS S+Core";
2443     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2444     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2445     case EM_LATTICEMICO32:      return "Lattice Mico32";
2446     case EM_SE_C17:             return "Seiko Epson C17 family";
2447       /* 140 */
2448     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2449     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2450     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2451     case EM_TI_PRU:             return "TI PRU I/O processor";
2452       /* 160 */
2453     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2454     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2455     case EM_R32C:               return "Renesas R32C series microprocessors";
2456     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2457     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2458     case EM_8051:               return "Intel 8051 and variants";
2459     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2460     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2461     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2462     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2463       /* 170 */
2464     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2465     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2466     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2467     case EM_RX:                 return "Renesas RX";
2468     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2469     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2470     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2471     case EM_CR16:
2472     case EM_MICROBLAZE:
2473     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2474     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2475     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2476       /* 180 */
2477     case EM_L1OM:               return "Intel L1OM";
2478     case EM_K1OM:               return "Intel K1OM";
2479     case EM_INTEL182:           return "Intel (reserved)";
2480     case EM_AARCH64:            return "AArch64";
2481     case EM_ARM184:             return "ARM (reserved)";
2482     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2483     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2484     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2485     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2486       /* 190 */
2487     case EM_CUDA:               return "NVIDIA CUDA architecture";
2488     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2489     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2490     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2491     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2492     case EM_ARC_COMPACT2:       return "ARCv2";
2493     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2494     case EM_RL78:               return "Renesas RL78";
2495     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2496     case EM_78K0R:              return "Renesas 78K0R";
2497       /* 200 */
2498     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2499     case EM_BA1:                return "Beyond BA1 CPU architecture";
2500     case EM_BA2:                return "Beyond BA2 CPU architecture";
2501     case EM_XCORE:              return "XMOS xCORE processor family";
2502     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2503       /* 210 */
2504     case EM_KM32:               return "KM211 KM32 32-bit processor";
2505     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2506     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2507     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2508     case EM_KVARC:              return "KM211 KVARC processor";
2509     case EM_CDP:                return "Paneve CDP architecture family";
2510     case EM_COGE:               return "Cognitive Smart Memory Processor";
2511     case EM_COOL:               return "Bluechip Systems CoolEngine";
2512     case EM_NORC:               return "Nanoradio Optimized RISC";
2513     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2514       /* 220 */
2515     case EM_Z80:                return "Zilog Z80";
2516     case EM_VISIUM:             return "CDS VISIUMcore processor";
2517     case EM_FT32:               return "FTDI Chip FT32";
2518     case EM_MOXIE:              return "Moxie";
2519     case EM_AMDGPU:             return "AMD GPU";
2520     case EM_RISCV:              return "RISC-V";
2521     case EM_LANAI:              return "Lanai 32-bit processor";
2522     case EM_BPF:                return "Linux BPF";
2523     case EM_NFP:                return "Netronome Flow Processor";
2524
2525       /* Large numbers...  */
2526     case EM_MT:                 return "Morpho Techologies MT processor";
2527     case EM_ALPHA:              return "Alpha";
2528     case EM_WEBASSEMBLY:        return "Web Assembly";
2529     case EM_DLX:                return "OpenDLX";
2530     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2531     case EM_IQ2000:             return "Vitesse IQ2000";
2532     case EM_M32C_OLD:
2533     case EM_NIOS32:             return "Altera Nios";
2534     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2535     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2536     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2537     case EM_S12Z:               return "Freescale S12Z";
2538     case EM_CSKY:               return "C-SKY";
2539
2540     default:
2541       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2542       return buff;
2543     }
2544 }
2545
2546 static void
2547 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2548 {
2549   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2550      other compilers don't a specific architecture type in the e_flags, and
2551      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2552      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2553      architectures.
2554
2555      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2556      but also sets a specific architecture type in the e_flags field.
2557
2558      However, when decoding the flags we don't worry if we see an
2559      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2560      ARCEM architecture type.  */
2561
2562   switch (e_flags & EF_ARC_MACH_MSK)
2563     {
2564       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2565     case EF_ARC_CPU_ARCV2EM:
2566       strcat (buf, ", ARC EM");
2567       break;
2568     case EF_ARC_CPU_ARCV2HS:
2569       strcat (buf, ", ARC HS");
2570       break;
2571
2572       /* We only expect these to occur for EM_ARC_COMPACT.  */
2573     case E_ARC_MACH_ARC600:
2574       strcat (buf, ", ARC600");
2575       break;
2576     case E_ARC_MACH_ARC601:
2577       strcat (buf, ", ARC601");
2578       break;
2579     case E_ARC_MACH_ARC700:
2580       strcat (buf, ", ARC700");
2581       break;
2582
2583       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2584          new ELF with new architecture being read by an old version of
2585          readelf, or (c) An ELF built with non-GNU compiler that does not
2586          set the architecture in the e_flags.  */
2587     default:
2588       if (e_machine == EM_ARC_COMPACT)
2589         strcat (buf, ", Unknown ARCompact");
2590       else
2591         strcat (buf, ", Unknown ARC");
2592       break;
2593     }
2594
2595   switch (e_flags & EF_ARC_OSABI_MSK)
2596     {
2597     case E_ARC_OSABI_ORIG:
2598       strcat (buf, ", (ABI:legacy)");
2599       break;
2600     case E_ARC_OSABI_V2:
2601       strcat (buf, ", (ABI:v2)");
2602       break;
2603       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2604     case E_ARC_OSABI_V3:
2605       strcat (buf, ", v3 no-legacy-syscalls ABI");
2606       break;
2607     case E_ARC_OSABI_V4:
2608       strcat (buf, ", v4 ABI");
2609       break;
2610     default:
2611       strcat (buf, ", unrecognised ARC OSABI flag");
2612       break;
2613     }
2614 }
2615
2616 static void
2617 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2618 {
2619   unsigned eabi;
2620   bfd_boolean unknown = FALSE;
2621
2622   eabi = EF_ARM_EABI_VERSION (e_flags);
2623   e_flags &= ~ EF_ARM_EABIMASK;
2624
2625   /* Handle "generic" ARM flags.  */
2626   if (e_flags & EF_ARM_RELEXEC)
2627     {
2628       strcat (buf, ", relocatable executable");
2629       e_flags &= ~ EF_ARM_RELEXEC;
2630     }
2631
2632   if (e_flags & EF_ARM_PIC)
2633     {
2634       strcat (buf, ", position independent");
2635       e_flags &= ~ EF_ARM_PIC;
2636     }
2637
2638   /* Now handle EABI specific flags.  */
2639   switch (eabi)
2640     {
2641     default:
2642       strcat (buf, ", <unrecognized EABI>");
2643       if (e_flags)
2644         unknown = TRUE;
2645       break;
2646
2647     case EF_ARM_EABI_VER1:
2648       strcat (buf, ", Version1 EABI");
2649       while (e_flags)
2650         {
2651           unsigned flag;
2652
2653           /* Process flags one bit at a time.  */
2654           flag = e_flags & - e_flags;
2655           e_flags &= ~ flag;
2656
2657           switch (flag)
2658             {
2659             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2660               strcat (buf, ", sorted symbol tables");
2661               break;
2662
2663             default:
2664               unknown = TRUE;
2665               break;
2666             }
2667         }
2668       break;
2669
2670     case EF_ARM_EABI_VER2:
2671       strcat (buf, ", Version2 EABI");
2672       while (e_flags)
2673         {
2674           unsigned flag;
2675
2676           /* Process flags one bit at a time.  */
2677           flag = e_flags & - e_flags;
2678           e_flags &= ~ flag;
2679
2680           switch (flag)
2681             {
2682             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2683               strcat (buf, ", sorted symbol tables");
2684               break;
2685
2686             case EF_ARM_DYNSYMSUSESEGIDX:
2687               strcat (buf, ", dynamic symbols use segment index");
2688               break;
2689
2690             case EF_ARM_MAPSYMSFIRST:
2691               strcat (buf, ", mapping symbols precede others");
2692               break;
2693
2694             default:
2695               unknown = TRUE;
2696               break;
2697             }
2698         }
2699       break;
2700
2701     case EF_ARM_EABI_VER3:
2702       strcat (buf, ", Version3 EABI");
2703       break;
2704
2705     case EF_ARM_EABI_VER4:
2706       strcat (buf, ", Version4 EABI");
2707       while (e_flags)
2708         {
2709           unsigned flag;
2710
2711           /* Process flags one bit at a time.  */
2712           flag = e_flags & - e_flags;
2713           e_flags &= ~ flag;
2714
2715           switch (flag)
2716             {
2717             case EF_ARM_BE8:
2718               strcat (buf, ", BE8");
2719               break;
2720
2721             case EF_ARM_LE8:
2722               strcat (buf, ", LE8");
2723               break;
2724
2725             default:
2726               unknown = TRUE;
2727               break;
2728             }
2729         }
2730       break;
2731
2732     case EF_ARM_EABI_VER5:
2733       strcat (buf, ", Version5 EABI");
2734       while (e_flags)
2735         {
2736           unsigned flag;
2737
2738           /* Process flags one bit at a time.  */
2739           flag = e_flags & - e_flags;
2740           e_flags &= ~ flag;
2741
2742           switch (flag)
2743             {
2744             case EF_ARM_BE8:
2745               strcat (buf, ", BE8");
2746               break;
2747
2748             case EF_ARM_LE8:
2749               strcat (buf, ", LE8");
2750               break;
2751
2752             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2753               strcat (buf, ", soft-float ABI");
2754               break;
2755
2756             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2757               strcat (buf, ", hard-float ABI");
2758               break;
2759
2760             default:
2761               unknown = TRUE;
2762               break;
2763             }
2764         }
2765       break;
2766
2767     case EF_ARM_EABI_UNKNOWN:
2768       strcat (buf, ", GNU EABI");
2769       while (e_flags)
2770         {
2771           unsigned flag;
2772
2773           /* Process flags one bit at a time.  */
2774           flag = e_flags & - e_flags;
2775           e_flags &= ~ flag;
2776
2777           switch (flag)
2778             {
2779             case EF_ARM_INTERWORK:
2780               strcat (buf, ", interworking enabled");
2781               break;
2782
2783             case EF_ARM_APCS_26:
2784               strcat (buf, ", uses APCS/26");
2785               break;
2786
2787             case EF_ARM_APCS_FLOAT:
2788               strcat (buf, ", uses APCS/float");
2789               break;
2790
2791             case EF_ARM_PIC:
2792               strcat (buf, ", position independent");
2793               break;
2794
2795             case EF_ARM_ALIGN8:
2796               strcat (buf, ", 8 bit structure alignment");
2797               break;
2798
2799             case EF_ARM_NEW_ABI:
2800               strcat (buf, ", uses new ABI");
2801               break;
2802
2803             case EF_ARM_OLD_ABI:
2804               strcat (buf, ", uses old ABI");
2805               break;
2806
2807             case EF_ARM_SOFT_FLOAT:
2808               strcat (buf, ", software FP");
2809               break;
2810
2811             case EF_ARM_VFP_FLOAT:
2812               strcat (buf, ", VFP");
2813               break;
2814
2815             case EF_ARM_MAVERICK_FLOAT:
2816               strcat (buf, ", Maverick FP");
2817               break;
2818
2819             default:
2820               unknown = TRUE;
2821               break;
2822             }
2823         }
2824     }
2825
2826   if (unknown)
2827     strcat (buf,_(", <unknown>"));
2828 }
2829
2830 static void
2831 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2832 {
2833   --size; /* Leave space for null terminator.  */
2834
2835   switch (e_flags & EF_AVR_MACH)
2836     {
2837     case E_AVR_MACH_AVR1:
2838       strncat (buf, ", avr:1", size);
2839       break;
2840     case E_AVR_MACH_AVR2:
2841       strncat (buf, ", avr:2", size);
2842       break;
2843     case E_AVR_MACH_AVR25:
2844       strncat (buf, ", avr:25", size);
2845       break;
2846     case E_AVR_MACH_AVR3:
2847       strncat (buf, ", avr:3", size);
2848       break;
2849     case E_AVR_MACH_AVR31:
2850       strncat (buf, ", avr:31", size);
2851       break;
2852     case E_AVR_MACH_AVR35:
2853       strncat (buf, ", avr:35", size);
2854       break;
2855     case E_AVR_MACH_AVR4:
2856       strncat (buf, ", avr:4", size);
2857       break;
2858     case E_AVR_MACH_AVR5:
2859       strncat (buf, ", avr:5", size);
2860       break;
2861     case E_AVR_MACH_AVR51:
2862       strncat (buf, ", avr:51", size);
2863       break;
2864     case E_AVR_MACH_AVR6:
2865       strncat (buf, ", avr:6", size);
2866       break;
2867     case E_AVR_MACH_AVRTINY:
2868       strncat (buf, ", avr:100", size);
2869       break;
2870     case E_AVR_MACH_XMEGA1:
2871       strncat (buf, ", avr:101", size);
2872       break;
2873     case E_AVR_MACH_XMEGA2:
2874       strncat (buf, ", avr:102", size);
2875       break;
2876     case E_AVR_MACH_XMEGA3:
2877       strncat (buf, ", avr:103", size);
2878       break;
2879     case E_AVR_MACH_XMEGA4:
2880       strncat (buf, ", avr:104", size);
2881       break;
2882     case E_AVR_MACH_XMEGA5:
2883       strncat (buf, ", avr:105", size);
2884       break;
2885     case E_AVR_MACH_XMEGA6:
2886       strncat (buf, ", avr:106", size);
2887       break;
2888     case E_AVR_MACH_XMEGA7:
2889       strncat (buf, ", avr:107", size);
2890       break;
2891     default:
2892       strncat (buf, ", avr:<unknown>", size);
2893       break;
2894     }
2895
2896   size -= strlen (buf);
2897   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2898     strncat (buf, ", link-relax", size);
2899 }
2900
2901 static void
2902 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2903 {
2904   unsigned abi;
2905   unsigned arch;
2906   unsigned config;
2907   unsigned version;
2908   bfd_boolean has_fpu = FALSE;
2909   unsigned int r = 0;
2910
2911   static const char *ABI_STRINGS[] =
2912   {
2913     "ABI v0", /* use r5 as return register; only used in N1213HC */
2914     "ABI v1", /* use r0 as return register */
2915     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2916     "ABI v2fp", /* for FPU */
2917     "AABI",
2918     "ABI2 FP+"
2919   };
2920   static const char *VER_STRINGS[] =
2921   {
2922     "Andes ELF V1.3 or older",
2923     "Andes ELF V1.3.1",
2924     "Andes ELF V1.4"
2925   };
2926   static const char *ARCH_STRINGS[] =
2927   {
2928     "",
2929     "Andes Star v1.0",
2930     "Andes Star v2.0",
2931     "Andes Star v3.0",
2932     "Andes Star v3.0m"
2933   };
2934
2935   abi = EF_NDS_ABI & e_flags;
2936   arch = EF_NDS_ARCH & e_flags;
2937   config = EF_NDS_INST & e_flags;
2938   version = EF_NDS32_ELF_VERSION & e_flags;
2939
2940   memset (buf, 0, size);
2941
2942   switch (abi)
2943     {
2944     case E_NDS_ABI_V0:
2945     case E_NDS_ABI_V1:
2946     case E_NDS_ABI_V2:
2947     case E_NDS_ABI_V2FP:
2948     case E_NDS_ABI_AABI:
2949     case E_NDS_ABI_V2FP_PLUS:
2950       /* In case there are holes in the array.  */
2951       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2952       break;
2953
2954     default:
2955       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2956       break;
2957     }
2958
2959   switch (version)
2960     {
2961     case E_NDS32_ELF_VER_1_2:
2962     case E_NDS32_ELF_VER_1_3:
2963     case E_NDS32_ELF_VER_1_4:
2964       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2965       break;
2966
2967     default:
2968       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2969       break;
2970     }
2971
2972   if (E_NDS_ABI_V0 == abi)
2973     {
2974       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2975       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2976       if (arch == E_NDS_ARCH_STAR_V1_0)
2977         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2978       return;
2979     }
2980
2981   switch (arch)
2982     {
2983     case E_NDS_ARCH_STAR_V1_0:
2984     case E_NDS_ARCH_STAR_V2_0:
2985     case E_NDS_ARCH_STAR_V3_0:
2986     case E_NDS_ARCH_STAR_V3_M:
2987       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2988       break;
2989
2990     default:
2991       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2992       /* ARCH version determines how the e_flags are interpreted.
2993          If it is unknown, we cannot proceed.  */
2994       return;
2995     }
2996
2997   /* Newer ABI; Now handle architecture specific flags.  */
2998   if (arch == E_NDS_ARCH_STAR_V1_0)
2999     {
3000       if (config & E_NDS32_HAS_MFUSR_PC_INST)
3001         r += snprintf (buf + r, size -r, ", MFUSR_PC");
3002
3003       if (!(config & E_NDS32_HAS_NO_MAC_INST))
3004         r += snprintf (buf + r, size -r, ", MAC");
3005
3006       if (config & E_NDS32_HAS_DIV_INST)
3007         r += snprintf (buf + r, size -r, ", DIV");
3008
3009       if (config & E_NDS32_HAS_16BIT_INST)
3010         r += snprintf (buf + r, size -r, ", 16b");
3011     }
3012   else
3013     {
3014       if (config & E_NDS32_HAS_MFUSR_PC_INST)
3015         {
3016           if (version <= E_NDS32_ELF_VER_1_3)
3017             r += snprintf (buf + r, size -r, ", [B8]");
3018           else
3019             r += snprintf (buf + r, size -r, ", EX9");
3020         }
3021
3022       if (config & E_NDS32_HAS_MAC_DX_INST)
3023         r += snprintf (buf + r, size -r, ", MAC_DX");
3024
3025       if (config & E_NDS32_HAS_DIV_DX_INST)
3026         r += snprintf (buf + r, size -r, ", DIV_DX");
3027
3028       if (config & E_NDS32_HAS_16BIT_INST)
3029         {
3030           if (version <= E_NDS32_ELF_VER_1_3)
3031             r += snprintf (buf + r, size -r, ", 16b");
3032           else
3033             r += snprintf (buf + r, size -r, ", IFC");
3034         }
3035     }
3036
3037   if (config & E_NDS32_HAS_EXT_INST)
3038     r += snprintf (buf + r, size -r, ", PERF1");
3039
3040   if (config & E_NDS32_HAS_EXT2_INST)
3041     r += snprintf (buf + r, size -r, ", PERF2");
3042
3043   if (config & E_NDS32_HAS_FPU_INST)
3044     {
3045       has_fpu = TRUE;
3046       r += snprintf (buf + r, size -r, ", FPU_SP");
3047     }
3048
3049   if (config & E_NDS32_HAS_FPU_DP_INST)
3050     {
3051       has_fpu = TRUE;
3052       r += snprintf (buf + r, size -r, ", FPU_DP");
3053     }
3054
3055   if (config & E_NDS32_HAS_FPU_MAC_INST)
3056     {
3057       has_fpu = TRUE;
3058       r += snprintf (buf + r, size -r, ", FPU_MAC");
3059     }
3060
3061   if (has_fpu)
3062     {
3063       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3064         {
3065         case E_NDS32_FPU_REG_8SP_4DP:
3066           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3067           break;
3068         case E_NDS32_FPU_REG_16SP_8DP:
3069           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3070           break;
3071         case E_NDS32_FPU_REG_32SP_16DP:
3072           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3073           break;
3074         case E_NDS32_FPU_REG_32SP_32DP:
3075           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3076           break;
3077         }
3078     }
3079
3080   if (config & E_NDS32_HAS_AUDIO_INST)
3081     r += snprintf (buf + r, size -r, ", AUDIO");
3082
3083   if (config & E_NDS32_HAS_STRING_INST)
3084     r += snprintf (buf + r, size -r, ", STR");
3085
3086   if (config & E_NDS32_HAS_REDUCED_REGS)
3087     r += snprintf (buf + r, size -r, ", 16REG");
3088
3089   if (config & E_NDS32_HAS_VIDEO_INST)
3090     {
3091       if (version <= E_NDS32_ELF_VER_1_3)
3092         r += snprintf (buf + r, size -r, ", VIDEO");
3093       else
3094         r += snprintf (buf + r, size -r, ", SATURATION");
3095     }
3096
3097   if (config & E_NDS32_HAS_ENCRIPT_INST)
3098     r += snprintf (buf + r, size -r, ", ENCRP");
3099
3100   if (config & E_NDS32_HAS_L2C_INST)
3101     r += snprintf (buf + r, size -r, ", L2C");
3102 }
3103
3104 static char *
3105 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3106 {
3107   static char buf[1024];
3108
3109   buf[0] = '\0';
3110
3111   if (e_flags)
3112     {
3113       switch (e_machine)
3114         {
3115         default:
3116           break;
3117
3118         case EM_ARC_COMPACT2:
3119         case EM_ARC_COMPACT:
3120           decode_ARC_machine_flags (e_flags, e_machine, buf);
3121           break;
3122
3123         case EM_ARM:
3124           decode_ARM_machine_flags (e_flags, buf);
3125           break;
3126
3127         case EM_AVR:
3128           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3129           break;
3130
3131         case EM_BLACKFIN:
3132           if (e_flags & EF_BFIN_PIC)
3133             strcat (buf, ", PIC");
3134
3135           if (e_flags & EF_BFIN_FDPIC)
3136             strcat (buf, ", FDPIC");
3137
3138           if (e_flags & EF_BFIN_CODE_IN_L1)
3139             strcat (buf, ", code in L1");
3140
3141           if (e_flags & EF_BFIN_DATA_IN_L1)
3142             strcat (buf, ", data in L1");
3143
3144           break;
3145
3146         case EM_CYGNUS_FRV:
3147           switch (e_flags & EF_FRV_CPU_MASK)
3148             {
3149             case EF_FRV_CPU_GENERIC:
3150               break;
3151
3152             default:
3153               strcat (buf, ", fr???");
3154               break;
3155
3156             case EF_FRV_CPU_FR300:
3157               strcat (buf, ", fr300");
3158               break;
3159
3160             case EF_FRV_CPU_FR400:
3161               strcat (buf, ", fr400");
3162               break;
3163             case EF_FRV_CPU_FR405:
3164               strcat (buf, ", fr405");
3165               break;
3166
3167             case EF_FRV_CPU_FR450:
3168               strcat (buf, ", fr450");
3169               break;
3170
3171             case EF_FRV_CPU_FR500:
3172               strcat (buf, ", fr500");
3173               break;
3174             case EF_FRV_CPU_FR550:
3175               strcat (buf, ", fr550");
3176               break;
3177
3178             case EF_FRV_CPU_SIMPLE:
3179               strcat (buf, ", simple");
3180               break;
3181             case EF_FRV_CPU_TOMCAT:
3182               strcat (buf, ", tomcat");
3183               break;
3184             }
3185           break;
3186
3187         case EM_68K:
3188           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3189             strcat (buf, ", m68000");
3190           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3191             strcat (buf, ", cpu32");
3192           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3193             strcat (buf, ", fido_a");
3194           else
3195             {
3196               char const * isa = _("unknown");
3197               char const * mac = _("unknown mac");
3198               char const * additional = NULL;
3199
3200               switch (e_flags & EF_M68K_CF_ISA_MASK)
3201                 {
3202                 case EF_M68K_CF_ISA_A_NODIV:
3203                   isa = "A";
3204                   additional = ", nodiv";
3205                   break;
3206                 case EF_M68K_CF_ISA_A:
3207                   isa = "A";
3208                   break;
3209                 case EF_M68K_CF_ISA_A_PLUS:
3210                   isa = "A+";
3211                   break;
3212                 case EF_M68K_CF_ISA_B_NOUSP:
3213                   isa = "B";
3214                   additional = ", nousp";
3215                   break;
3216                 case EF_M68K_CF_ISA_B:
3217                   isa = "B";
3218                   break;
3219                 case EF_M68K_CF_ISA_C:
3220                   isa = "C";
3221                   break;
3222                 case EF_M68K_CF_ISA_C_NODIV:
3223                   isa = "C";
3224                   additional = ", nodiv";
3225                   break;
3226                 }
3227               strcat (buf, ", cf, isa ");
3228               strcat (buf, isa);
3229               if (additional)
3230                 strcat (buf, additional);
3231               if (e_flags & EF_M68K_CF_FLOAT)
3232                 strcat (buf, ", float");
3233               switch (e_flags & EF_M68K_CF_MAC_MASK)
3234                 {
3235                 case 0:
3236                   mac = NULL;
3237                   break;
3238                 case EF_M68K_CF_MAC:
3239                   mac = "mac";
3240                   break;
3241                 case EF_M68K_CF_EMAC:
3242                   mac = "emac";
3243                   break;
3244                 case EF_M68K_CF_EMAC_B:
3245                   mac = "emac_b";
3246                   break;
3247                 }
3248               if (mac)
3249                 {
3250                   strcat (buf, ", ");
3251                   strcat (buf, mac);
3252                 }
3253             }
3254           break;
3255
3256         case EM_CYGNUS_MEP:
3257           switch (e_flags & EF_MEP_CPU_MASK)
3258             {
3259             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3260             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3261             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3262             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3263             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3264             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3265             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3266             }
3267
3268           switch (e_flags & EF_MEP_COP_MASK)
3269             {
3270             case EF_MEP_COP_NONE: break;
3271             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3272             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3273             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3274             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3275             default: strcat (buf, _("<unknown MeP copro type>")); break;
3276             }
3277
3278           if (e_flags & EF_MEP_LIBRARY)
3279             strcat (buf, ", Built for Library");
3280
3281           if (e_flags & EF_MEP_INDEX_MASK)
3282             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3283                      e_flags & EF_MEP_INDEX_MASK);
3284
3285           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3286             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3287                      e_flags & ~ EF_MEP_ALL_FLAGS);
3288           break;
3289
3290         case EM_PPC:
3291           if (e_flags & EF_PPC_EMB)
3292             strcat (buf, ", emb");
3293
3294           if (e_flags & EF_PPC_RELOCATABLE)
3295             strcat (buf, _(", relocatable"));
3296
3297           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3298             strcat (buf, _(", relocatable-lib"));
3299           break;
3300
3301         case EM_PPC64:
3302           if (e_flags & EF_PPC64_ABI)
3303             {
3304               char abi[] = ", abiv0";
3305
3306               abi[6] += e_flags & EF_PPC64_ABI;
3307               strcat (buf, abi);
3308             }
3309           break;
3310
3311         case EM_V800:
3312           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3313             strcat (buf, ", RH850 ABI");
3314
3315           if (e_flags & EF_V800_850E3)
3316             strcat (buf, ", V3 architecture");
3317
3318           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3319             strcat (buf, ", FPU not used");
3320
3321           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3322             strcat (buf, ", regmode: COMMON");
3323
3324           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3325             strcat (buf, ", r4 not used");
3326
3327           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3328             strcat (buf, ", r30 not used");
3329
3330           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3331             strcat (buf, ", r5 not used");
3332
3333           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3334             strcat (buf, ", r2 not used");
3335
3336           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3337             {
3338               switch (e_flags & - e_flags)
3339                 {
3340                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3341                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3342                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3343                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3344                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3345                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3346                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3347                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3348                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3349                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3350                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3351                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3352                 default: break;
3353                 }
3354             }
3355           break;
3356
3357         case EM_V850:
3358         case EM_CYGNUS_V850:
3359           switch (e_flags & EF_V850_ARCH)
3360             {
3361             case E_V850E3V5_ARCH:
3362               strcat (buf, ", v850e3v5");
3363               break;
3364             case E_V850E2V3_ARCH:
3365               strcat (buf, ", v850e2v3");
3366               break;
3367             case E_V850E2_ARCH:
3368               strcat (buf, ", v850e2");
3369               break;
3370             case E_V850E1_ARCH:
3371               strcat (buf, ", v850e1");
3372               break;
3373             case E_V850E_ARCH:
3374               strcat (buf, ", v850e");
3375               break;
3376             case E_V850_ARCH:
3377               strcat (buf, ", v850");
3378               break;
3379             default:
3380               strcat (buf, _(", unknown v850 architecture variant"));
3381               break;
3382             }
3383           break;
3384
3385         case EM_M32R:
3386         case EM_CYGNUS_M32R:
3387           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3388             strcat (buf, ", m32r");
3389           break;
3390
3391         case EM_MIPS:
3392         case EM_MIPS_RS3_LE:
3393           if (e_flags & EF_MIPS_NOREORDER)
3394             strcat (buf, ", noreorder");
3395
3396           if (e_flags & EF_MIPS_PIC)
3397             strcat (buf, ", pic");
3398
3399           if (e_flags & EF_MIPS_CPIC)
3400             strcat (buf, ", cpic");
3401
3402           if (e_flags & EF_MIPS_UCODE)
3403             strcat (buf, ", ugen_reserved");
3404
3405           if (e_flags & EF_MIPS_ABI2)
3406             strcat (buf, ", abi2");
3407
3408           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3409             strcat (buf, ", odk first");
3410
3411           if (e_flags & EF_MIPS_32BITMODE)
3412             strcat (buf, ", 32bitmode");
3413
3414           if (e_flags & EF_MIPS_NAN2008)
3415             strcat (buf, ", nan2008");
3416
3417           if (e_flags & EF_MIPS_FP64)
3418             strcat (buf, ", fp64");
3419
3420           switch ((e_flags & EF_MIPS_MACH))
3421             {
3422             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3423             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3424             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3425             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3426             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3427             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3428             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3429             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3430             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3431             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3432             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3433             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3434             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3435             case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3436             case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3437             case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3438             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3439             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3440             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3441             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3442             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3443             case 0:
3444             /* We simply ignore the field in this case to avoid confusion:
3445                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3446                extension.  */
3447               break;
3448             default: strcat (buf, _(", unknown CPU")); break;
3449             }
3450
3451           switch ((e_flags & EF_MIPS_ABI))
3452             {
3453             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3454             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3455             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3456             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3457             case 0:
3458             /* We simply ignore the field in this case to avoid confusion:
3459                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3460                This means it is likely to be an o32 file, but not for
3461                sure.  */
3462               break;
3463             default: strcat (buf, _(", unknown ABI")); break;
3464             }
3465
3466           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3467             strcat (buf, ", mdmx");
3468
3469           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3470             strcat (buf, ", mips16");
3471
3472           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3473             strcat (buf, ", micromips");
3474
3475           switch ((e_flags & EF_MIPS_ARCH))
3476             {
3477             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3478             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3479             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3480             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3481             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3482             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3483             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3484             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3485             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3486             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3487             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3488             default: strcat (buf, _(", unknown ISA")); break;
3489             }
3490           break;
3491
3492         case EM_NDS32:
3493           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3494           break;
3495
3496         case EM_NFP:
3497           switch (EF_NFP_MACH (e_flags))
3498             {
3499             case E_NFP_MACH_3200:
3500               strcat (buf, ", NFP-32xx");
3501               break;
3502             case E_NFP_MACH_6000:
3503               strcat (buf, ", NFP-6xxx");
3504               break;
3505             }
3506           break;
3507
3508         case EM_RISCV:
3509           if (e_flags & EF_RISCV_RVC)
3510             strcat (buf, ", RVC");
3511
3512           if (e_flags & EF_RISCV_RVE)
3513             strcat (buf, ", RVE");
3514
3515           switch (e_flags & EF_RISCV_FLOAT_ABI)
3516             {
3517             case EF_RISCV_FLOAT_ABI_SOFT:
3518               strcat (buf, ", soft-float ABI");
3519               break;
3520
3521             case EF_RISCV_FLOAT_ABI_SINGLE:
3522               strcat (buf, ", single-float ABI");
3523               break;
3524
3525             case EF_RISCV_FLOAT_ABI_DOUBLE:
3526               strcat (buf, ", double-float ABI");
3527               break;
3528
3529             case EF_RISCV_FLOAT_ABI_QUAD:
3530               strcat (buf, ", quad-float ABI");
3531               break;
3532             }
3533           break;
3534
3535         case EM_SH:
3536           switch ((e_flags & EF_SH_MACH_MASK))
3537             {
3538             case EF_SH1: strcat (buf, ", sh1"); break;
3539             case EF_SH2: strcat (buf, ", sh2"); break;
3540             case EF_SH3: strcat (buf, ", sh3"); break;
3541             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3542             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3543             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3544             case EF_SH3E: strcat (buf, ", sh3e"); break;
3545             case EF_SH4: strcat (buf, ", sh4"); break;
3546             case EF_SH5: strcat (buf, ", sh5"); break;
3547             case EF_SH2E: strcat (buf, ", sh2e"); break;
3548             case EF_SH4A: strcat (buf, ", sh4a"); break;
3549             case EF_SH2A: strcat (buf, ", sh2a"); break;
3550             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3551             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3552             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3553             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3554             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3555             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3556             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3557             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3558             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3559             default: strcat (buf, _(", unknown ISA")); break;
3560             }
3561
3562           if (e_flags & EF_SH_PIC)
3563             strcat (buf, ", pic");
3564
3565           if (e_flags & EF_SH_FDPIC)
3566             strcat (buf, ", fdpic");
3567           break;
3568
3569         case EM_OR1K:
3570           if (e_flags & EF_OR1K_NODELAY)
3571             strcat (buf, ", no delay");
3572           break;
3573
3574         case EM_SPARCV9:
3575           if (e_flags & EF_SPARC_32PLUS)
3576             strcat (buf, ", v8+");
3577
3578           if (e_flags & EF_SPARC_SUN_US1)
3579             strcat (buf, ", ultrasparcI");
3580
3581           if (e_flags & EF_SPARC_SUN_US3)
3582             strcat (buf, ", ultrasparcIII");
3583
3584           if (e_flags & EF_SPARC_HAL_R1)
3585             strcat (buf, ", halr1");
3586
3587           if (e_flags & EF_SPARC_LEDATA)
3588             strcat (buf, ", ledata");
3589
3590           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3591             strcat (buf, ", tso");
3592
3593           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3594             strcat (buf, ", pso");
3595
3596           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3597             strcat (buf, ", rmo");
3598           break;
3599
3600         case EM_PARISC:
3601           switch (e_flags & EF_PARISC_ARCH)
3602             {
3603             case EFA_PARISC_1_0:
3604               strcpy (buf, ", PA-RISC 1.0");
3605               break;
3606             case EFA_PARISC_1_1:
3607               strcpy (buf, ", PA-RISC 1.1");
3608               break;
3609             case EFA_PARISC_2_0:
3610               strcpy (buf, ", PA-RISC 2.0");
3611               break;
3612             default:
3613               break;
3614             }
3615           if (e_flags & EF_PARISC_TRAPNIL)
3616             strcat (buf, ", trapnil");
3617           if (e_flags & EF_PARISC_EXT)
3618             strcat (buf, ", ext");
3619           if (e_flags & EF_PARISC_LSB)
3620             strcat (buf, ", lsb");
3621           if (e_flags & EF_PARISC_WIDE)
3622             strcat (buf, ", wide");
3623           if (e_flags & EF_PARISC_NO_KABP)
3624             strcat (buf, ", no kabp");
3625           if (e_flags & EF_PARISC_LAZYSWAP)
3626             strcat (buf, ", lazyswap");
3627           break;
3628
3629         case EM_PJ:
3630         case EM_PJ_OLD:
3631           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3632             strcat (buf, ", new calling convention");
3633
3634           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3635             strcat (buf, ", gnu calling convention");
3636           break;
3637
3638         case EM_IA_64:
3639           if ((e_flags & EF_IA_64_ABI64))
3640             strcat (buf, ", 64-bit");
3641           else
3642             strcat (buf, ", 32-bit");
3643           if ((e_flags & EF_IA_64_REDUCEDFP))
3644             strcat (buf, ", reduced fp model");
3645           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3646             strcat (buf, ", no function descriptors, constant gp");
3647           else if ((e_flags & EF_IA_64_CONS_GP))
3648             strcat (buf, ", constant gp");
3649           if ((e_flags & EF_IA_64_ABSOLUTE))
3650             strcat (buf, ", absolute");
3651           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3652             {
3653               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3654                 strcat (buf, ", vms_linkages");
3655               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3656                 {
3657                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3658                   break;
3659                 case EF_IA_64_VMS_COMCOD_WARNING:
3660                   strcat (buf, ", warning");
3661                   break;
3662                 case EF_IA_64_VMS_COMCOD_ERROR:
3663                   strcat (buf, ", error");
3664                   break;
3665                 case EF_IA_64_VMS_COMCOD_ABORT:
3666                   strcat (buf, ", abort");
3667                   break;
3668                 default:
3669                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3670                         e_flags & EF_IA_64_VMS_COMCOD);
3671                   strcat (buf, ", <unknown>");
3672                 }
3673             }
3674           break;
3675
3676         case EM_VAX:
3677           if ((e_flags & EF_VAX_NONPIC))
3678             strcat (buf, ", non-PIC");
3679           if ((e_flags & EF_VAX_DFLOAT))
3680             strcat (buf, ", D-Float");
3681           if ((e_flags & EF_VAX_GFLOAT))
3682             strcat (buf, ", G-Float");
3683           break;
3684
3685         case EM_VISIUM:
3686           if (e_flags & EF_VISIUM_ARCH_MCM)
3687             strcat (buf, ", mcm");
3688           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3689             strcat (buf, ", mcm24");
3690           if (e_flags & EF_VISIUM_ARCH_GR6)
3691             strcat (buf, ", gr6");
3692           break;
3693
3694         case EM_RL78:
3695           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3696             {
3697             case E_FLAG_RL78_ANY_CPU: break;
3698             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3699             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3700             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3701             }
3702           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3703             strcat (buf, ", 64-bit doubles");
3704           break;
3705
3706         case EM_RX:
3707           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3708             strcat (buf, ", 64-bit doubles");
3709           if (e_flags & E_FLAG_RX_DSP)
3710             strcat (buf, ", dsp");
3711           if (e_flags & E_FLAG_RX_PID)
3712             strcat (buf, ", pid");
3713           if (e_flags & E_FLAG_RX_ABI)
3714             strcat (buf, ", RX ABI");
3715           if (e_flags & E_FLAG_RX_SINSNS_SET)
3716             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3717                     ? ", uses String instructions" : ", bans String instructions");
3718           if (e_flags & E_FLAG_RX_V2)
3719             strcat (buf, ", V2");
3720           if (e_flags & E_FLAG_RX_V3)
3721             strcat (buf, ", V3");
3722           break;
3723
3724         case EM_S390:
3725           if (e_flags & EF_S390_HIGH_GPRS)
3726             strcat (buf, ", highgprs");
3727           break;
3728
3729         case EM_TI_C6000:
3730           if ((e_flags & EF_C6000_REL))
3731             strcat (buf, ", relocatable module");
3732           break;
3733
3734         case EM_MSP430:
3735           strcat (buf, _(": architecture variant: "));
3736           switch (e_flags & EF_MSP430_MACH)
3737             {
3738             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3739             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3740             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3741             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3742             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3743             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3744             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3745             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3746             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3747             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3748             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3749             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3750             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3751             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3752             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3753             default:
3754               strcat (buf, _(": unknown")); break;
3755             }
3756
3757           if (e_flags & ~ EF_MSP430_MACH)
3758             strcat (buf, _(": unknown extra flag bits also present"));
3759         }
3760     }
3761
3762   return buf;
3763 }
3764
3765 static const char *
3766 get_osabi_name (Filedata * filedata, unsigned int osabi)
3767 {
3768   static char buff[32];
3769
3770   switch (osabi)
3771     {
3772     case ELFOSABI_NONE:         return "UNIX - System V";
3773     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3774     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3775     case ELFOSABI_GNU:          return "UNIX - GNU";
3776     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3777     case ELFOSABI_AIX:          return "UNIX - AIX";
3778     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3779     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3780     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3781     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3782     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3783     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3784     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3785     case ELFOSABI_AROS:         return "AROS";
3786     case ELFOSABI_FENIXOS:      return "FenixOS";
3787     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3788     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3789     default:
3790       if (osabi >= 64)
3791         switch (filedata->file_header.e_machine)
3792           {
3793           case EM_ARM:
3794             switch (osabi)
3795               {
3796               case ELFOSABI_ARM:        return "ARM";
3797               case ELFOSABI_ARM_FDPIC:  return "ARM FDPIC";
3798               default:
3799                 break;
3800               }
3801             break;
3802
3803           case EM_MSP430:
3804           case EM_MSP430_OLD:
3805           case EM_VISIUM:
3806             switch (osabi)
3807               {
3808               case ELFOSABI_STANDALONE: return _("Standalone App");
3809               default:
3810                 break;
3811               }
3812             break;
3813
3814           case EM_TI_C6000:
3815             switch (osabi)
3816               {
3817               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3818               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3819               default:
3820                 break;
3821               }
3822             break;
3823
3824           default:
3825             break;
3826           }
3827       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3828       return buff;
3829     }
3830 }
3831
3832 static const char *
3833 get_aarch64_segment_type (unsigned long type)
3834 {
3835   switch (type)
3836     {
3837     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3838     default:                  return NULL;
3839     }
3840 }
3841
3842 static const char *
3843 get_arm_segment_type (unsigned long type)
3844 {
3845   switch (type)
3846     {
3847     case PT_ARM_EXIDX: return "EXIDX";
3848     default:           return NULL;
3849     }
3850 }
3851
3852 static const char *
3853 get_s390_segment_type (unsigned long type)
3854 {
3855   switch (type)
3856     {
3857     case PT_S390_PGSTE: return "S390_PGSTE";
3858     default:            return NULL;
3859     }
3860 }
3861
3862 static const char *
3863 get_mips_segment_type (unsigned long type)
3864 {
3865   switch (type)
3866     {
3867     case PT_MIPS_REGINFO:   return "REGINFO";
3868     case PT_MIPS_RTPROC:    return "RTPROC";
3869     case PT_MIPS_OPTIONS:   return "OPTIONS";
3870     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3871     default:                return NULL;
3872     }
3873 }
3874
3875 static const char *
3876 get_parisc_segment_type (unsigned long type)
3877 {
3878   switch (type)
3879     {
3880     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3881     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3882     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3883     default:                    return NULL;
3884     }
3885 }
3886
3887 static const char *
3888 get_ia64_segment_type (unsigned long type)
3889 {
3890   switch (type)
3891     {
3892     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3893     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3894     default:                    return NULL;
3895     }
3896 }
3897
3898 static const char *
3899 get_tic6x_segment_type (unsigned long type)
3900 {
3901   switch (type)
3902     {
3903     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3904     default:               return NULL;
3905     }
3906 }
3907
3908 static const char *
3909 get_hpux_segment_type (unsigned long type, unsigned e_machine)
3910 {
3911   if (e_machine == EM_PARISC)
3912     switch (type)
3913       {
3914       case PT_HP_TLS:           return "HP_TLS";
3915       case PT_HP_CORE_NONE:     return "HP_CORE_NONE";
3916       case PT_HP_CORE_VERSION:  return "HP_CORE_VERSION";
3917       case PT_HP_CORE_KERNEL:   return "HP_CORE_KERNEL";
3918       case PT_HP_CORE_COMM:     return "HP_CORE_COMM";
3919       case PT_HP_CORE_PROC:     return "HP_CORE_PROC";
3920       case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3921       case PT_HP_CORE_STACK:    return "HP_CORE_STACK";
3922       case PT_HP_CORE_SHM:      return "HP_CORE_SHM";
3923       case PT_HP_CORE_MMF:      return "HP_CORE_MMF";
3924       case PT_HP_PARALLEL:      return "HP_PARALLEL";
3925       case PT_HP_FASTBIND:      return "HP_FASTBIND";
3926       case PT_HP_OPT_ANNOT:     return "HP_OPT_ANNOT";
3927       case PT_HP_HSL_ANNOT:     return "HP_HSL_ANNOT";
3928       case PT_HP_STACK:         return "HP_STACK";
3929       case PT_HP_CORE_UTSNAME:  return "HP_CORE_UTSNAME";
3930       default:                  return NULL;
3931       }
3932
3933   if (e_machine == EM_IA_64)
3934     switch (type)
3935       {
3936       case PT_HP_TLS:            return "HP_TLS";
3937       case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3938       case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3939       case PT_IA_64_HP_STACK:    return "HP_STACK";
3940       default:                   return NULL;
3941       }
3942
3943   return NULL;
3944 }
3945
3946 static const char *
3947 get_solaris_segment_type (unsigned long type)
3948 {
3949   switch (type)
3950     {
3951     case 0x6464e550: return "PT_SUNW_UNWIND";
3952     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3953     case 0x6ffffff7: return "PT_LOSUNW";
3954     case 0x6ffffffa: return "PT_SUNWBSS";
3955     case 0x6ffffffb: return "PT_SUNWSTACK";
3956     case 0x6ffffffc: return "PT_SUNWDTRACE";
3957     case 0x6ffffffd: return "PT_SUNWCAP";
3958     case 0x6fffffff: return "PT_HISUNW";
3959     default:         return NULL;
3960     }
3961 }
3962
3963 static const char *
3964 get_segment_type (Filedata * filedata, unsigned long p_type)
3965 {
3966   static char buff[32];
3967
3968   switch (p_type)
3969     {
3970     case PT_NULL:       return "NULL";
3971     case PT_LOAD:       return "LOAD";
3972     case PT_DYNAMIC:    return "DYNAMIC";
3973     case PT_INTERP:     return "INTERP";
3974     case PT_NOTE:       return "NOTE";
3975     case PT_SHLIB:      return "SHLIB";
3976     case PT_PHDR:       return "PHDR";
3977     case PT_TLS:        return "TLS";
3978     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3979     case PT_GNU_STACK:  return "GNU_STACK";
3980     case PT_GNU_RELRO:  return "GNU_RELRO";
3981     case PT_GNU_PROPERTY: return "GNU_PROPERTY";
3982
3983     default:
3984       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3985         {
3986           const char * result;
3987
3988           switch (filedata->file_header.e_machine)
3989             {
3990             case EM_AARCH64:
3991               result = get_aarch64_segment_type (p_type);
3992               break;
3993             case EM_ARM:
3994               result = get_arm_segment_type (p_type);
3995               break;
3996             case EM_MIPS:
3997             case EM_MIPS_RS3_LE:
3998               result = get_mips_segment_type (p_type);
3999               break;
4000             case EM_PARISC:
4001               result = get_parisc_segment_type (p_type);
4002               break;
4003             case EM_IA_64:
4004               result = get_ia64_segment_type (p_type);
4005               break;
4006             case EM_TI_C6000:
4007               result = get_tic6x_segment_type (p_type);
4008               break;
4009             case EM_S390:
4010             case EM_S390_OLD:
4011               result = get_s390_segment_type (p_type);
4012               break;
4013             default:
4014               result = NULL;
4015               break;
4016             }
4017
4018           if (result != NULL)
4019             return result;
4020
4021           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
4022         }
4023       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
4024         {
4025           const char * result = NULL;
4026
4027           switch (filedata->file_header.e_ident[EI_OSABI])
4028             {
4029             case ELFOSABI_GNU:
4030             case ELFOSABI_FREEBSD:
4031               if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
4032                 {
4033                   sprintf (buff, "GNU_MBIND+%#lx", p_type - PT_GNU_MBIND_LO);
4034                   result = buff;
4035                 }
4036               break;
4037             case ELFOSABI_HPUX:
4038               result = get_hpux_segment_type (p_type,
4039                                               filedata->file_header.e_machine);
4040               break;
4041             case ELFOSABI_SOLARIS:
4042               result = get_solaris_segment_type (p_type);
4043               break;
4044             default:
4045               break;
4046             }
4047           if (result != NULL)
4048             return result;
4049
4050           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4051         }
4052       else
4053         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4054
4055       return buff;
4056     }
4057 }
4058
4059 static const char *
4060 get_arc_section_type_name (unsigned int sh_type)
4061 {
4062   switch (sh_type)
4063     {
4064     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
4065     default:
4066       break;
4067     }
4068   return NULL;
4069 }
4070
4071 static const char *
4072 get_mips_section_type_name (unsigned int sh_type)
4073 {
4074   switch (sh_type)
4075     {
4076     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
4077     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
4078     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
4079     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
4080     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
4081     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
4082     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
4083     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
4084     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
4085     case SHT_MIPS_RELD:          return "MIPS_RELD";
4086     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
4087     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
4088     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
4089     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
4090     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
4091     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
4092     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
4093     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
4094     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
4095     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4096     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4097     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4098     case SHT_MIPS_LINE:          return "MIPS_LINE";
4099     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4100     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4101     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4102     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4103     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4104     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4105     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4106     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4107     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4108     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4109     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4110     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4111     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4112     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4113     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4114     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4115     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4116     default:
4117       break;
4118     }
4119   return NULL;
4120 }
4121
4122 static const char *
4123 get_parisc_section_type_name (unsigned int sh_type)
4124 {
4125   switch (sh_type)
4126     {
4127     case SHT_PARISC_EXT:        return "PARISC_EXT";
4128     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4129     case SHT_PARISC_DOC:        return "PARISC_DOC";
4130     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4131     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4132     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4133     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4134     default:                    return NULL;
4135     }
4136 }
4137
4138 static const char *
4139 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4140 {
4141   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4142   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4143     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4144
4145   switch (sh_type)
4146     {
4147     case SHT_IA_64_EXT:                return "IA_64_EXT";
4148     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4149     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4150     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4151     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4152     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4153     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4154     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4155     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4156     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4157     default:
4158       break;
4159     }
4160   return NULL;
4161 }
4162
4163 static const char *
4164 get_x86_64_section_type_name (unsigned int sh_type)
4165 {
4166   switch (sh_type)
4167     {
4168     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4169     default:                    return NULL;
4170     }
4171 }
4172
4173 static const char *
4174 get_aarch64_section_type_name (unsigned int sh_type)
4175 {
4176   switch (sh_type)
4177     {
4178     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4179     default:                     return NULL;
4180     }
4181 }
4182
4183 static const char *
4184 get_arm_section_type_name (unsigned int sh_type)
4185 {
4186   switch (sh_type)
4187     {
4188     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4189     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4190     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4191     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4192     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4193     default:                      return NULL;
4194     }
4195 }
4196
4197 static const char *
4198 get_tic6x_section_type_name (unsigned int sh_type)
4199 {
4200   switch (sh_type)
4201     {
4202     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4203     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4204     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4205     case SHT_TI_ICODE:          return "TI_ICODE";
4206     case SHT_TI_XREF:           return "TI_XREF";
4207     case SHT_TI_HANDLER:        return "TI_HANDLER";
4208     case SHT_TI_INITINFO:       return "TI_INITINFO";
4209     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4210     default:                    return NULL;
4211     }
4212 }
4213
4214 static const char *
4215 get_msp430x_section_type_name (unsigned int sh_type)
4216 {
4217   switch (sh_type)
4218     {
4219     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4220     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4221     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4222     default:                      return NULL;
4223     }
4224 }
4225
4226 static const char *
4227 get_nfp_section_type_name (unsigned int sh_type)
4228 {
4229   switch (sh_type)
4230     {
4231     case SHT_NFP_MECONFIG:      return "NFP_MECONFIG";
4232     case SHT_NFP_INITREG:       return "NFP_INITREG";
4233     case SHT_NFP_UDEBUG:        return "NFP_UDEBUG";
4234     default:                    return NULL;
4235     }
4236 }
4237
4238 static const char *
4239 get_v850_section_type_name (unsigned int sh_type)
4240 {
4241   switch (sh_type)
4242     {
4243     case SHT_V850_SCOMMON:  return "V850 Small Common";
4244     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4245     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4246     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4247     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4248     default:                return NULL;
4249     }
4250 }
4251
4252 static const char *
4253 get_riscv_section_type_name (unsigned int sh_type)
4254 {
4255   switch (sh_type)
4256     {
4257     case SHT_RISCV_ATTRIBUTES:  return "RISCV_ATTRIBUTES";
4258     default: return NULL;
4259     }
4260 }
4261
4262 static const char *
4263 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4264 {
4265   static char buff[32];
4266   const char * result;
4267
4268   switch (sh_type)
4269     {
4270     case SHT_NULL:              return "NULL";
4271     case SHT_PROGBITS:          return "PROGBITS";
4272     case SHT_SYMTAB:            return "SYMTAB";
4273     case SHT_STRTAB:            return "STRTAB";
4274     case SHT_RELA:              return "RELA";
4275     case SHT_HASH:              return "HASH";
4276     case SHT_DYNAMIC:           return "DYNAMIC";
4277     case SHT_NOTE:              return "NOTE";
4278     case SHT_NOBITS:            return "NOBITS";
4279     case SHT_REL:               return "REL";
4280     case SHT_SHLIB:             return "SHLIB";
4281     case SHT_DYNSYM:            return "DYNSYM";
4282     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4283     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4284     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4285     case SHT_GNU_HASH:          return "GNU_HASH";
4286     case SHT_GROUP:             return "GROUP";
4287     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICES";
4288     case SHT_GNU_verdef:        return "VERDEF";
4289     case SHT_GNU_verneed:       return "VERNEED";
4290     case SHT_GNU_versym:        return "VERSYM";
4291     case 0x6ffffff0:            return "VERSYM";
4292     case 0x6ffffffc:            return "VERDEF";
4293     case 0x7ffffffd:            return "AUXILIARY";
4294     case 0x7fffffff:            return "FILTER";
4295     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4296
4297     default:
4298       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4299         {
4300           switch (filedata->file_header.e_machine)
4301             {
4302             case EM_ARC:
4303             case EM_ARC_COMPACT:
4304             case EM_ARC_COMPACT2:
4305               result = get_arc_section_type_name (sh_type);
4306               break;
4307             case EM_MIPS:
4308             case EM_MIPS_RS3_LE:
4309               result = get_mips_section_type_name (sh_type);
4310               break;
4311             case EM_PARISC:
4312               result = get_parisc_section_type_name (sh_type);
4313               break;
4314             case EM_IA_64:
4315               result = get_ia64_section_type_name (filedata, sh_type);
4316               break;
4317             case EM_X86_64:
4318             case EM_L1OM:
4319             case EM_K1OM:
4320               result = get_x86_64_section_type_name (sh_type);
4321               break;
4322             case EM_AARCH64:
4323               result = get_aarch64_section_type_name (sh_type);
4324               break;
4325             case EM_ARM:
4326               result = get_arm_section_type_name (sh_type);
4327               break;
4328             case EM_TI_C6000:
4329               result = get_tic6x_section_type_name (sh_type);
4330               break;
4331             case EM_MSP430:
4332               result = get_msp430x_section_type_name (sh_type);
4333               break;
4334             case EM_NFP:
4335               result = get_nfp_section_type_name (sh_type);
4336               break;
4337             case EM_V800:
4338             case EM_V850:
4339             case EM_CYGNUS_V850:
4340               result = get_v850_section_type_name (sh_type);
4341               break;
4342             case EM_RISCV:
4343               result = get_riscv_section_type_name (sh_type);
4344               break;
4345             default:
4346               result = NULL;
4347               break;
4348             }
4349
4350           if (result != NULL)
4351             return result;
4352
4353           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4354         }
4355       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4356         {
4357           switch (filedata->file_header.e_machine)
4358             {
4359             case EM_IA_64:
4360               result = get_ia64_section_type_name (filedata, sh_type);
4361               break;
4362             default:
4363               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4364                 result = get_solaris_section_type (sh_type);
4365               else
4366                 {
4367                   switch (sh_type)
4368                     {
4369                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4370                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4371                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4372                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4373                     default:
4374                       result = NULL;
4375                       break;
4376                     }
4377                 }
4378               break;
4379             }
4380
4381           if (result != NULL)
4382             return result;
4383
4384           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4385         }
4386       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4387         {
4388           switch (filedata->file_header.e_machine)
4389             {
4390             case EM_V800:
4391             case EM_V850:
4392             case EM_CYGNUS_V850:
4393               result = get_v850_section_type_name (sh_type);
4394               break;
4395             default:
4396               result = NULL;
4397               break;
4398             }
4399
4400           if (result != NULL)
4401             return result;
4402
4403           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4404         }
4405       else
4406         /* This message is probably going to be displayed in a 15
4407            character wide field, so put the hex value first.  */
4408         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4409
4410       return buff;
4411     }
4412 }
4413
4414 #define OPTION_DEBUG_DUMP       512
4415 #define OPTION_DYN_SYMS         513
4416 #define OPTION_DWARF_DEPTH      514
4417 #define OPTION_DWARF_START      515
4418 #define OPTION_DWARF_CHECK      516
4419 #define OPTION_CTF_DUMP         517
4420 #define OPTION_CTF_PARENT       518
4421 #define OPTION_CTF_SYMBOLS      519
4422 #define OPTION_CTF_STRINGS      520
4423
4424 static struct option options[] =
4425 {
4426   {"all",              no_argument, 0, 'a'},
4427   {"file-header",      no_argument, 0, 'h'},
4428   {"program-headers",  no_argument, 0, 'l'},
4429   {"headers",          no_argument, 0, 'e'},
4430   {"histogram",        no_argument, 0, 'I'},
4431   {"segments",         no_argument, 0, 'l'},
4432   {"sections",         no_argument, 0, 'S'},
4433   {"section-headers",  no_argument, 0, 'S'},
4434   {"section-groups",   no_argument, 0, 'g'},
4435   {"section-details",  no_argument, 0, 't'},
4436   {"full-section-name",no_argument, 0, 'N'},
4437   {"symbols",          no_argument, 0, 's'},
4438   {"syms",             no_argument, 0, 's'},
4439   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4440   {"relocs",           no_argument, 0, 'r'},
4441   {"notes",            no_argument, 0, 'n'},
4442   {"dynamic",          no_argument, 0, 'd'},
4443   {"arch-specific",    no_argument, 0, 'A'},
4444   {"version-info",     no_argument, 0, 'V'},
4445   {"use-dynamic",      no_argument, 0, 'D'},
4446   {"unwind",           no_argument, 0, 'u'},
4447   {"archive-index",    no_argument, 0, 'c'},
4448   {"hex-dump",         required_argument, 0, 'x'},
4449   {"relocated-dump",   required_argument, 0, 'R'},
4450   {"string-dump",      required_argument, 0, 'p'},
4451   {"decompress",       no_argument, 0, 'z'},
4452 #ifdef SUPPORT_DISASSEMBLY
4453   {"instruction-dump", required_argument, 0, 'i'},
4454 #endif
4455   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4456
4457   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4458   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4459   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4460
4461   {"ctf",              required_argument, 0, OPTION_CTF_DUMP},
4462
4463   {"ctf-symbols",      required_argument, 0, OPTION_CTF_SYMBOLS},
4464   {"ctf-strings",      required_argument, 0, OPTION_CTF_STRINGS},
4465   {"ctf-parent",       required_argument, 0, OPTION_CTF_PARENT},
4466
4467   {"version",          no_argument, 0, 'v'},
4468   {"wide",             no_argument, 0, 'W'},
4469   {"help",             no_argument, 0, 'H'},
4470   {0,                  no_argument, 0, 0}
4471 };
4472
4473 static void
4474 usage (FILE * stream)
4475 {
4476   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4477   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4478   fprintf (stream, _(" Options are:\n\
4479   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4480   -h --file-header       Display the ELF file header\n\
4481   -l --program-headers   Display the program headers\n\
4482      --segments          An alias for --program-headers\n\
4483   -S --section-headers   Display the sections' header\n\
4484      --sections          An alias for --section-headers\n\
4485   -g --section-groups    Display the section groups\n\
4486   -t --section-details   Display the section details\n\
4487   -e --headers           Equivalent to: -h -l -S\n\
4488   -s --syms              Display the symbol table\n\
4489      --symbols           An alias for --syms\n\
4490   --dyn-syms             Display the dynamic symbol table\n\
4491   -n --notes             Display the core notes (if present)\n\
4492   -r --relocs            Display the relocations (if present)\n\
4493   -u --unwind            Display the unwind info (if present)\n\
4494   -d --dynamic           Display the dynamic section (if present)\n\
4495   -V --version-info      Display the version sections (if present)\n\
4496   -A --arch-specific     Display architecture specific information (if any)\n\
4497   -c --archive-index     Display the symbol/file index in an archive\n\
4498   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4499   -x --hex-dump=<number|name>\n\
4500                          Dump the contents of section <number|name> as bytes\n\
4501   -p --string-dump=<number|name>\n\
4502                          Dump the contents of section <number|name> as strings\n\
4503   -R --relocated-dump=<number|name>\n\
4504                          Dump the contents of section <number|name> as relocated bytes\n\
4505   -z --decompress        Decompress section before dumping it\n\
4506   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4507   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4508                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4509                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4510                =addr,=cu_index,=links,=follow-links]\n\
4511                          Display the contents of DWARF debug sections\n"));
4512   fprintf (stream, _("\
4513   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4514   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4515                          or deeper\n"));
4516   fprintf (stream, _("\
4517   --ctf=<number|name>    Display CTF info from section <number|name>\n\
4518   --ctf-parent=<number|name>\n\
4519                          Use section <number|name> as the CTF parent\n\n\
4520   --ctf-symbols=<number|name>\n\
4521                          Use section <number|name> as the CTF external symtab\n\n\
4522   --ctf-strings=<number|name>\n\
4523                          Use section <number|name> as the CTF external strtab\n\n"));
4524
4525 #ifdef SUPPORT_DISASSEMBLY
4526   fprintf (stream, _("\
4527   -i --instruction-dump=<number|name>\n\
4528                          Disassemble the contents of section <number|name>\n"));
4529 #endif
4530   fprintf (stream, _("\
4531   -I --histogram         Display histogram of bucket list lengths\n\
4532   -W --wide              Allow output width to exceed 80 characters\n\
4533   @<file>                Read options from <file>\n\
4534   -H --help              Display this information\n\
4535   -v --version           Display the version number of readelf\n"));
4536
4537   if (REPORT_BUGS_TO[0] && stream == stdout)
4538     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4539
4540   exit (stream == stdout ? 0 : 1);
4541 }
4542
4543 /* Record the fact that the user wants the contents of section number
4544    SECTION to be displayed using the method(s) encoded as flags bits
4545    in TYPE.  Note, TYPE can be zero if we are creating the array for
4546    the first time.  */
4547
4548 static void
4549 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4550 {
4551   if (section >= filedata->num_dump_sects)
4552     {
4553       dump_type * new_dump_sects;
4554
4555       new_dump_sects = (dump_type *) calloc (section + 1,
4556                                              sizeof (* new_dump_sects));
4557
4558       if (new_dump_sects == NULL)
4559         error (_("Out of memory allocating dump request table.\n"));
4560       else
4561         {
4562           if (filedata->dump_sects)
4563             {
4564               /* Copy current flag settings.  */
4565               memcpy (new_dump_sects, filedata->dump_sects,
4566                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4567
4568               free (filedata->dump_sects);
4569             }
4570
4571           filedata->dump_sects = new_dump_sects;
4572           filedata->num_dump_sects = section + 1;
4573         }
4574     }
4575
4576   if (filedata->dump_sects)
4577     filedata->dump_sects[section] |= type;
4578 }
4579
4580 /* Request a dump by section name.  */
4581
4582 static void
4583 request_dump_byname (const char * section, dump_type type)
4584 {
4585   struct dump_list_entry * new_request;
4586
4587   new_request = (struct dump_list_entry *)
4588       malloc (sizeof (struct dump_list_entry));
4589   if (!new_request)
4590     error (_("Out of memory allocating dump request table.\n"));
4591
4592   new_request->name = strdup (section);
4593   if (!new_request->name)
4594     error (_("Out of memory allocating dump request table.\n"));
4595
4596   new_request->type = type;
4597
4598   new_request->next = dump_sects_byname;
4599   dump_sects_byname = new_request;
4600 }
4601
4602 static inline void
4603 request_dump (Filedata * filedata, dump_type type)
4604 {
4605   int section;
4606   char * cp;
4607
4608   do_dump++;
4609   section = strtoul (optarg, & cp, 0);
4610
4611   if (! *cp && section >= 0)
4612     request_dump_bynumber (filedata, section, type);
4613   else
4614     request_dump_byname (optarg, type);
4615 }
4616
4617 static void
4618 parse_args (Filedata * filedata, int argc, char ** argv)
4619 {
4620   int c;
4621
4622   if (argc < 2)
4623     usage (stderr);
4624
4625   while ((c = getopt_long
4626           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4627     {
4628       switch (c)
4629         {
4630         case 0:
4631           /* Long options.  */
4632           break;
4633         case 'H':
4634           usage (stdout);
4635           break;
4636
4637         case 'a':
4638           do_syms = TRUE;
4639           do_reloc = TRUE;
4640           do_unwind = TRUE;
4641           do_dynamic = TRUE;
4642           do_header = TRUE;
4643           do_sections = TRUE;
4644           do_section_groups = TRUE;
4645           do_segments = TRUE;
4646           do_version = TRUE;
4647           do_histogram = TRUE;
4648           do_arch = TRUE;
4649           do_notes = TRUE;
4650           break;
4651         case 'g':
4652           do_section_groups = TRUE;
4653           break;
4654         case 't':
4655         case 'N':
4656           do_sections = TRUE;
4657           do_section_details = TRUE;
4658           break;
4659         case 'e':
4660           do_header = TRUE;
4661           do_sections = TRUE;
4662           do_segments = TRUE;
4663           break;
4664         case 'A':
4665           do_arch = TRUE;
4666           break;
4667         case 'D':
4668           do_using_dynamic = TRUE;
4669           break;
4670         case 'r':
4671           do_reloc = TRUE;
4672           break;
4673         case 'u':
4674           do_unwind = TRUE;
4675           break;
4676         case 'h':
4677           do_header = TRUE;
4678           break;
4679         case 'l':
4680           do_segments = TRUE;
4681           break;
4682         case 's':
4683           do_syms = TRUE;
4684           break;
4685         case 'S':
4686           do_sections = TRUE;
4687           break;
4688         case 'd':
4689           do_dynamic = TRUE;
4690           break;
4691         case 'I':
4692           do_histogram = TRUE;
4693           break;
4694         case 'n':
4695           do_notes = TRUE;
4696           break;
4697         case 'c':
4698           do_archive_index = TRUE;
4699           break;
4700         case 'x':
4701           request_dump (filedata, HEX_DUMP);
4702           break;
4703         case 'p':
4704           request_dump (filedata, STRING_DUMP);
4705           break;
4706         case 'R':
4707           request_dump (filedata, RELOC_DUMP);
4708           break;
4709         case 'z':
4710           decompress_dumps = TRUE;
4711           break;
4712         case 'w':
4713           do_dump = TRUE;
4714           if (optarg == 0)
4715             {
4716               do_debugging = TRUE;
4717               dwarf_select_sections_all ();
4718             }
4719           else
4720             {
4721               do_debugging = FALSE;
4722               dwarf_select_sections_by_letters (optarg);
4723             }
4724           break;
4725         case OPTION_DEBUG_DUMP:
4726           do_dump = TRUE;
4727           if (optarg == 0)
4728             do_debugging = TRUE;
4729           else
4730             {
4731               do_debugging = FALSE;
4732               dwarf_select_sections_by_names (optarg);
4733             }
4734           break;
4735         case OPTION_DWARF_DEPTH:
4736           {
4737             char *cp;
4738
4739             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4740           }
4741           break;
4742         case OPTION_DWARF_START:
4743           {
4744             char *cp;
4745
4746             dwarf_start_die = strtoul (optarg, & cp, 0);
4747           }
4748           break;
4749         case OPTION_DWARF_CHECK:
4750           dwarf_check = TRUE;
4751           break;
4752         case OPTION_CTF_DUMP:
4753           do_ctf = TRUE;
4754           request_dump (filedata, CTF_DUMP);
4755           break;
4756         case OPTION_CTF_SYMBOLS:
4757           dump_ctf_symtab_name = strdup (optarg);
4758           break;
4759         case OPTION_CTF_STRINGS:
4760           dump_ctf_strtab_name = strdup (optarg);
4761           break;
4762         case OPTION_CTF_PARENT:
4763           dump_ctf_parent_name = strdup (optarg);
4764           break;
4765         case OPTION_DYN_SYMS:
4766           do_dyn_syms = TRUE;
4767           break;
4768 #ifdef SUPPORT_DISASSEMBLY
4769         case 'i':
4770           request_dump (filedata, DISASS_DUMP);
4771           break;
4772 #endif
4773         case 'v':
4774           print_version (program_name);
4775           break;
4776         case 'V':
4777           do_version = TRUE;
4778           break;
4779         case 'W':
4780           do_wide = TRUE;
4781           break;
4782         default:
4783           /* xgettext:c-format */
4784           error (_("Invalid option '-%c'\n"), c);
4785           /* Fall through.  */
4786         case '?':
4787           usage (stderr);
4788         }
4789     }
4790
4791   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4792       && !do_segments && !do_header && !do_dump && !do_version
4793       && !do_histogram && !do_debugging && !do_arch && !do_notes
4794       && !do_section_groups && !do_archive_index
4795       && !do_dyn_syms)
4796     usage (stderr);
4797 }
4798
4799 static const char *
4800 get_elf_class (unsigned int elf_class)
4801 {
4802   static char buff[32];
4803
4804   switch (elf_class)
4805     {
4806     case ELFCLASSNONE: return _("none");
4807     case ELFCLASS32:   return "ELF32";
4808     case ELFCLASS64:   return "ELF64";
4809     default:
4810       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4811       return buff;
4812     }
4813 }
4814
4815 static const char *
4816 get_data_encoding (unsigned int encoding)
4817 {
4818   static char buff[32];
4819
4820   switch (encoding)
4821     {
4822     case ELFDATANONE: return _("none");
4823     case ELFDATA2LSB: return _("2's complement, little endian");
4824     case ELFDATA2MSB: return _("2's complement, big endian");
4825     default:
4826       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4827       return buff;
4828     }
4829 }
4830
4831 /* Decode the data held in 'filedata->file_header'.  */
4832
4833 static bfd_boolean
4834 process_file_header (Filedata * filedata)
4835 {
4836   Elf_Internal_Ehdr * header = & filedata->file_header;
4837
4838   if (   header->e_ident[EI_MAG0] != ELFMAG0
4839       || header->e_ident[EI_MAG1] != ELFMAG1
4840       || header->e_ident[EI_MAG2] != ELFMAG2
4841       || header->e_ident[EI_MAG3] != ELFMAG3)
4842     {
4843       error
4844         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4845       return FALSE;
4846     }
4847
4848   init_dwarf_regnames (header->e_machine);
4849
4850   if (do_header)
4851     {
4852       unsigned i;
4853
4854       printf (_("ELF Header:\n"));
4855       printf (_("  Magic:   "));
4856       for (i = 0; i < EI_NIDENT; i++)
4857         printf ("%2.2x ", header->e_ident[i]);
4858       printf ("\n");
4859       printf (_("  Class:                             %s\n"),
4860               get_elf_class (header->e_ident[EI_CLASS]));
4861       printf (_("  Data:                              %s\n"),
4862               get_data_encoding (header->e_ident[EI_DATA]));
4863       printf (_("  Version:                           %d%s\n"),
4864               header->e_ident[EI_VERSION],
4865               (header->e_ident[EI_VERSION] == EV_CURRENT
4866                ? _(" (current)")
4867                : (header->e_ident[EI_VERSION] != EV_NONE
4868                   ? _(" <unknown>")
4869                   : "")));
4870       printf (_("  OS/ABI:                            %s\n"),
4871               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4872       printf (_("  ABI Version:                       %d\n"),
4873               header->e_ident[EI_ABIVERSION]);
4874       printf (_("  Type:                              %s\n"),
4875               get_file_type (header->e_type));
4876       printf (_("  Machine:                           %s\n"),
4877               get_machine_name (header->e_machine));
4878       printf (_("  Version:                           0x%lx\n"),
4879               header->e_version);
4880
4881       printf (_("  Entry point address:               "));
4882       print_vma (header->e_entry, PREFIX_HEX);
4883       printf (_("\n  Start of program headers:          "));
4884       print_vma (header->e_phoff, DEC);
4885       printf (_(" (bytes into file)\n  Start of section headers:          "));
4886       print_vma (header->e_shoff, DEC);
4887       printf (_(" (bytes into file)\n"));
4888
4889       printf (_("  Flags:                             0x%lx%s\n"),
4890               header->e_flags,
4891               get_machine_flags (filedata, header->e_flags, header->e_machine));
4892       printf (_("  Size of this header:               %u (bytes)\n"),
4893               header->e_ehsize);
4894       printf (_("  Size of program headers:           %u (bytes)\n"),
4895               header->e_phentsize);
4896       printf (_("  Number of program headers:         %u"),
4897               header->e_phnum);
4898       if (filedata->section_headers != NULL
4899           && header->e_phnum == PN_XNUM
4900           && filedata->section_headers[0].sh_info != 0)
4901         {
4902           header->e_phnum = filedata->section_headers[0].sh_info;
4903           printf (" (%u)", header->e_phnum);
4904         }
4905       putc ('\n', stdout);
4906       printf (_("  Size of section headers:           %u (bytes)\n"),
4907               header->e_shentsize);
4908       printf (_("  Number of section headers:         %u"),
4909               header->e_shnum);
4910       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4911         {
4912           header->e_shnum = filedata->section_headers[0].sh_size;
4913           printf (" (%u)", header->e_shnum);
4914         }
4915       putc ('\n', stdout);
4916       printf (_("  Section header string table index: %u"),
4917               header->e_shstrndx);
4918       if (filedata->section_headers != NULL
4919           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4920         {
4921           header->e_shstrndx = filedata->section_headers[0].sh_link;
4922           printf (" (%u)", header->e_shstrndx);
4923         }
4924       if (header->e_shstrndx != SHN_UNDEF
4925           && header->e_shstrndx >= header->e_shnum)
4926         {
4927           header->e_shstrndx = SHN_UNDEF;
4928           printf (_(" <corrupt: out of range>"));
4929         }
4930       putc ('\n', stdout);
4931     }
4932
4933   if (filedata->section_headers != NULL)
4934     {
4935       if (header->e_phnum == PN_XNUM
4936           && filedata->section_headers[0].sh_info != 0)
4937         header->e_phnum = filedata->section_headers[0].sh_info;
4938       if (header->e_shnum == SHN_UNDEF)
4939         header->e_shnum = filedata->section_headers[0].sh_size;
4940       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4941         header->e_shstrndx = filedata->section_headers[0].sh_link;
4942       if (header->e_shstrndx >= header->e_shnum)
4943         header->e_shstrndx = SHN_UNDEF;
4944       free (filedata->section_headers);
4945       filedata->section_headers = NULL;
4946     }
4947
4948   return TRUE;
4949 }
4950
4951 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4952    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4953
4954 static bfd_boolean
4955 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4956 {
4957   Elf32_External_Phdr * phdrs;
4958   Elf32_External_Phdr * external;
4959   Elf_Internal_Phdr *   internal;
4960   unsigned int i;
4961   unsigned int size = filedata->file_header.e_phentsize;
4962   unsigned int num  = filedata->file_header.e_phnum;
4963
4964   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4965   if (size == 0 || num == 0)
4966     return FALSE;
4967   if (size < sizeof * phdrs)
4968     {
4969       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4970       return FALSE;
4971     }
4972   if (size > sizeof * phdrs)
4973     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4974
4975   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4976                                             size, num, _("program headers"));
4977   if (phdrs == NULL)
4978     return FALSE;
4979
4980   for (i = 0, internal = pheaders, external = phdrs;
4981        i < filedata->file_header.e_phnum;
4982        i++, internal++, external++)
4983     {
4984       internal->p_type   = BYTE_GET (external->p_type);
4985       internal->p_offset = BYTE_GET (external->p_offset);
4986       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4987       internal->p_paddr  = BYTE_GET (external->p_paddr);
4988       internal->p_filesz = BYTE_GET (external->p_filesz);
4989       internal->p_memsz  = BYTE_GET (external->p_memsz);
4990       internal->p_flags  = BYTE_GET (external->p_flags);
4991       internal->p_align  = BYTE_GET (external->p_align);
4992     }
4993
4994   free (phdrs);
4995   return TRUE;
4996 }
4997
4998 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4999    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
5000
5001 static bfd_boolean
5002 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
5003 {
5004   Elf64_External_Phdr * phdrs;
5005   Elf64_External_Phdr * external;
5006   Elf_Internal_Phdr *   internal;
5007   unsigned int i;
5008   unsigned int size = filedata->file_header.e_phentsize;
5009   unsigned int num  = filedata->file_header.e_phnum;
5010
5011   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5012   if (size == 0 || num == 0)
5013     return FALSE;
5014   if (size < sizeof * phdrs)
5015     {
5016       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5017       return FALSE;
5018     }
5019   if (size > sizeof * phdrs)
5020     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5021
5022   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5023                                             size, num, _("program headers"));
5024   if (!phdrs)
5025     return FALSE;
5026
5027   for (i = 0, internal = pheaders, external = phdrs;
5028        i < filedata->file_header.e_phnum;
5029        i++, internal++, external++)
5030     {
5031       internal->p_type   = BYTE_GET (external->p_type);
5032       internal->p_flags  = BYTE_GET (external->p_flags);
5033       internal->p_offset = BYTE_GET (external->p_offset);
5034       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
5035       internal->p_paddr  = BYTE_GET (external->p_paddr);
5036       internal->p_filesz = BYTE_GET (external->p_filesz);
5037       internal->p_memsz  = BYTE_GET (external->p_memsz);
5038       internal->p_align  = BYTE_GET (external->p_align);
5039     }
5040
5041   free (phdrs);
5042   return TRUE;
5043 }
5044
5045 /* Returns TRUE if the program headers were read into `program_headers'.  */
5046
5047 static bfd_boolean
5048 get_program_headers (Filedata * filedata)
5049 {
5050   Elf_Internal_Phdr * phdrs;
5051
5052   /* Check cache of prior read.  */
5053   if (filedata->program_headers != NULL)
5054     return TRUE;
5055
5056   /* Be kind to memory checkers by looking for
5057      e_phnum values which we know must be invalid.  */
5058   if (filedata->file_header.e_phnum
5059       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
5060       >= filedata->file_size)
5061     {
5062       error (_("Too many program headers - %#x - the file is not that big\n"),
5063              filedata->file_header.e_phnum);
5064       return FALSE;
5065     }
5066
5067   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
5068                                          sizeof (Elf_Internal_Phdr));
5069   if (phdrs == NULL)
5070     {
5071       error (_("Out of memory reading %u program headers\n"),
5072              filedata->file_header.e_phnum);
5073       return FALSE;
5074     }
5075
5076   if (is_32bit_elf
5077       ? get_32bit_program_headers (filedata, phdrs)
5078       : get_64bit_program_headers (filedata, phdrs))
5079     {
5080       filedata->program_headers = phdrs;
5081       return TRUE;
5082     }
5083
5084   free (phdrs);
5085   return FALSE;
5086 }
5087
5088 /* Returns TRUE if the program headers were loaded.  */
5089
5090 static bfd_boolean
5091 process_program_headers (Filedata * filedata)
5092 {
5093   Elf_Internal_Phdr * segment;
5094   unsigned int i;
5095   Elf_Internal_Phdr * previous_load = NULL;
5096
5097   if (filedata->file_header.e_phnum == 0)
5098     {
5099       /* PR binutils/12467.  */
5100       if (filedata->file_header.e_phoff != 0)
5101         {
5102           warn (_("possibly corrupt ELF header - it has a non-zero program"
5103                   " header offset, but no program headers\n"));
5104           return FALSE;
5105         }
5106       else if (do_segments)
5107         printf (_("\nThere are no program headers in this file.\n"));
5108       return TRUE;
5109     }
5110
5111   if (do_segments && !do_header)
5112     {
5113       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5114       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5115       printf (ngettext ("There is %d program header, starting at offset %s\n",
5116                         "There are %d program headers, starting at offset %s\n",
5117                         filedata->file_header.e_phnum),
5118               filedata->file_header.e_phnum,
5119               bfd_vmatoa ("u", filedata->file_header.e_phoff));
5120     }
5121
5122   if (! get_program_headers (filedata))
5123     return TRUE;
5124
5125   if (do_segments)
5126     {
5127       if (filedata->file_header.e_phnum > 1)
5128         printf (_("\nProgram Headers:\n"));
5129       else
5130         printf (_("\nProgram Headers:\n"));
5131
5132       if (is_32bit_elf)
5133         printf
5134           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
5135       else if (do_wide)
5136         printf
5137           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
5138       else
5139         {
5140           printf
5141             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
5142           printf
5143             (_("                 FileSiz            MemSiz              Flags  Align\n"));
5144         }
5145     }
5146
5147   dynamic_addr = 0;
5148   dynamic_size = 0;
5149
5150   for (i = 0, segment = filedata->program_headers;
5151        i < filedata->file_header.e_phnum;
5152        i++, segment++)
5153     {
5154       if (do_segments)
5155         {
5156           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
5157
5158           if (is_32bit_elf)
5159             {
5160               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5161               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5162               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5163               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5164               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5165               printf ("%c%c%c ",
5166                       (segment->p_flags & PF_R ? 'R' : ' '),
5167                       (segment->p_flags & PF_W ? 'W' : ' '),
5168                       (segment->p_flags & PF_X ? 'E' : ' '));
5169               printf ("%#lx", (unsigned long) segment->p_align);
5170             }
5171           else if (do_wide)
5172             {
5173               if ((unsigned long) segment->p_offset == segment->p_offset)
5174                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5175               else
5176                 {
5177                   print_vma (segment->p_offset, FULL_HEX);
5178                   putchar (' ');
5179                 }
5180
5181               print_vma (segment->p_vaddr, FULL_HEX);
5182               putchar (' ');
5183               print_vma (segment->p_paddr, FULL_HEX);
5184               putchar (' ');
5185
5186               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5187                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5188               else
5189                 {
5190                   print_vma (segment->p_filesz, FULL_HEX);
5191                   putchar (' ');
5192                 }
5193
5194               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5195                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5196               else
5197                 {
5198                   print_vma (segment->p_memsz, FULL_HEX);
5199                 }
5200
5201               printf (" %c%c%c ",
5202                       (segment->p_flags & PF_R ? 'R' : ' '),
5203                       (segment->p_flags & PF_W ? 'W' : ' '),
5204                       (segment->p_flags & PF_X ? 'E' : ' '));
5205
5206               if ((unsigned long) segment->p_align == segment->p_align)
5207                 printf ("%#lx", (unsigned long) segment->p_align);
5208               else
5209                 {
5210                   print_vma (segment->p_align, PREFIX_HEX);
5211                 }
5212             }
5213           else
5214             {
5215               print_vma (segment->p_offset, FULL_HEX);
5216               putchar (' ');
5217               print_vma (segment->p_vaddr, FULL_HEX);
5218               putchar (' ');
5219               print_vma (segment->p_paddr, FULL_HEX);
5220               printf ("\n                 ");
5221               print_vma (segment->p_filesz, FULL_HEX);
5222               putchar (' ');
5223               print_vma (segment->p_memsz, FULL_HEX);
5224               printf ("  %c%c%c    ",
5225                       (segment->p_flags & PF_R ? 'R' : ' '),
5226                       (segment->p_flags & PF_W ? 'W' : ' '),
5227                       (segment->p_flags & PF_X ? 'E' : ' '));
5228               print_vma (segment->p_align, PREFIX_HEX);
5229             }
5230
5231           putc ('\n', stdout);
5232         }
5233
5234       switch (segment->p_type)
5235         {
5236         case PT_LOAD:
5237 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5238          required by the ELF standard, several programs, including the Linux
5239          kernel, make use of non-ordered segments.  */
5240           if (previous_load
5241               && previous_load->p_vaddr > segment->p_vaddr)
5242             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5243 #endif
5244           if (segment->p_memsz < segment->p_filesz)
5245             error (_("the segment's file size is larger than its memory size\n"));
5246           previous_load = segment;
5247           break;
5248
5249         case PT_PHDR:
5250           /* PR 20815 - Verify that the program header is loaded into memory.  */
5251           if (i > 0 && previous_load != NULL)
5252             error (_("the PHDR segment must occur before any LOAD segment\n"));
5253           if (filedata->file_header.e_machine != EM_PARISC)
5254             {
5255               unsigned int j;
5256
5257               for (j = 1; j < filedata->file_header.e_phnum; j++)
5258                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5259                     && (filedata->program_headers[j].p_vaddr
5260                         + filedata->program_headers[j].p_memsz)
5261                     >= (segment->p_vaddr + segment->p_filesz))
5262                   break;
5263               if (j == filedata->file_header.e_phnum)
5264                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5265             }
5266           break;
5267
5268         case PT_DYNAMIC:
5269           if (dynamic_addr)
5270             error (_("more than one dynamic segment\n"));
5271
5272           /* By default, assume that the .dynamic section is the first
5273              section in the DYNAMIC segment.  */
5274           dynamic_addr = segment->p_offset;
5275           dynamic_size = segment->p_filesz;
5276
5277           /* Try to locate the .dynamic section. If there is
5278              a section header table, we can easily locate it.  */
5279           if (filedata->section_headers != NULL)
5280             {
5281               Elf_Internal_Shdr * sec;
5282
5283               sec = find_section (filedata, ".dynamic");
5284               if (sec == NULL || sec->sh_size == 0)
5285                 {
5286                   /* A corresponding .dynamic section is expected, but on
5287                      IA-64/OpenVMS it is OK for it to be missing.  */
5288                   if (!is_ia64_vms (filedata))
5289                     error (_("no .dynamic section in the dynamic segment\n"));
5290                   break;
5291                 }
5292
5293               if (sec->sh_type == SHT_NOBITS)
5294                 {
5295                   dynamic_size = 0;
5296                   break;
5297                 }
5298
5299               dynamic_addr = sec->sh_offset;
5300               dynamic_size = sec->sh_size;
5301
5302               if (dynamic_addr < segment->p_offset
5303                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5304                 warn (_("the .dynamic section is not contained"
5305                         " within the dynamic segment\n"));
5306               else if (dynamic_addr > segment->p_offset)
5307                 warn (_("the .dynamic section is not the first section"
5308                         " in the dynamic segment.\n"));
5309             }
5310
5311           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5312              segment.  Check this after matching against the section headers
5313              so we don't warn on debuginfo file (which have NOBITS .dynamic
5314              sections).  */
5315           if (dynamic_addr > filedata->file_size
5316               || dynamic_size > filedata->file_size - dynamic_addr)
5317             {
5318               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5319               dynamic_addr = dynamic_size = 0;
5320             }
5321           break;
5322
5323         case PT_INTERP:
5324           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5325                      SEEK_SET))
5326             error (_("Unable to find program interpreter name\n"));
5327           else
5328             {
5329               char fmt [32];
5330               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5331
5332               if (ret >= (int) sizeof (fmt) || ret < 0)
5333                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5334
5335               program_interpreter[0] = 0;
5336               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5337                 error (_("Unable to read program interpreter name\n"));
5338
5339               if (do_segments)
5340                 printf (_("      [Requesting program interpreter: %s]\n"),
5341                     program_interpreter);
5342             }
5343           break;
5344         }
5345     }
5346
5347   if (do_segments
5348       && filedata->section_headers != NULL
5349       && filedata->string_table != NULL)
5350     {
5351       printf (_("\n Section to Segment mapping:\n"));
5352       printf (_("  Segment Sections...\n"));
5353
5354       for (i = 0; i < filedata->file_header.e_phnum; i++)
5355         {
5356           unsigned int j;
5357           Elf_Internal_Shdr * section;
5358
5359           segment = filedata->program_headers + i;
5360           section = filedata->section_headers + 1;
5361
5362           printf ("   %2.2d     ", i);
5363
5364           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5365             {
5366               if (!ELF_TBSS_SPECIAL (section, segment)
5367                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5368                 printf ("%s ", printable_section_name (filedata, section));
5369             }
5370
5371           putc ('\n',stdout);
5372         }
5373     }
5374
5375   return TRUE;
5376 }
5377
5378
5379 /* Find the file offset corresponding to VMA by using the program headers.  */
5380
5381 static long
5382 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5383 {
5384   Elf_Internal_Phdr * seg;
5385
5386   if (! get_program_headers (filedata))
5387     {
5388       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5389       return (long) vma;
5390     }
5391
5392   for (seg = filedata->program_headers;
5393        seg < filedata->program_headers + filedata->file_header.e_phnum;
5394        ++seg)
5395     {
5396       if (seg->p_type != PT_LOAD)
5397         continue;
5398
5399       if (vma >= (seg->p_vaddr & -seg->p_align)
5400           && vma + size <= seg->p_vaddr + seg->p_filesz)
5401         return vma - seg->p_vaddr + seg->p_offset;
5402     }
5403
5404   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5405         (unsigned long) vma);
5406   return (long) vma;
5407 }
5408
5409
5410 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5411    If PROBE is true, this is just a probe and we do not generate any error
5412    messages if the load fails.  */
5413
5414 static bfd_boolean
5415 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5416 {
5417   Elf32_External_Shdr * shdrs;
5418   Elf_Internal_Shdr *   internal;
5419   unsigned int          i;
5420   unsigned int          size = filedata->file_header.e_shentsize;
5421   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5422
5423   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5424   if (size == 0 || num == 0)
5425     return FALSE;
5426   if (size < sizeof * shdrs)
5427     {
5428       if (! probe)
5429         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5430       return FALSE;
5431     }
5432   if (!probe && size > sizeof * shdrs)
5433     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5434
5435   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5436                                             size, num,
5437                                             probe ? NULL : _("section headers"));
5438   if (shdrs == NULL)
5439     return FALSE;
5440
5441   free (filedata->section_headers);
5442   filedata->section_headers = (Elf_Internal_Shdr *)
5443     cmalloc (num, sizeof (Elf_Internal_Shdr));
5444   if (filedata->section_headers == NULL)
5445     {
5446       if (!probe)
5447         error (_("Out of memory reading %u section headers\n"), num);
5448       free (shdrs);
5449       return FALSE;
5450     }
5451
5452   for (i = 0, internal = filedata->section_headers;
5453        i < num;
5454        i++, internal++)
5455     {
5456       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5457       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5458       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5459       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5460       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5461       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5462       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5463       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5464       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5465       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5466       if (!probe && internal->sh_link > num)
5467         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5468       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5469         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5470     }
5471
5472   free (shdrs);
5473   return TRUE;
5474 }
5475
5476 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5477
5478 static bfd_boolean
5479 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5480 {
5481   Elf64_External_Shdr *  shdrs;
5482   Elf_Internal_Shdr *    internal;
5483   unsigned int           i;
5484   unsigned int           size = filedata->file_header.e_shentsize;
5485   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5486
5487   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5488   if (size == 0 || num == 0)
5489     return FALSE;
5490
5491   if (size < sizeof * shdrs)
5492     {
5493       if (! probe)
5494         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5495       return FALSE;
5496     }
5497
5498   if (! probe && size > sizeof * shdrs)
5499     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5500
5501   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5502                                             filedata->file_header.e_shoff,
5503                                             size, num,
5504                                             probe ? NULL : _("section headers"));
5505   if (shdrs == NULL)
5506     return FALSE;
5507
5508   free (filedata->section_headers);
5509   filedata->section_headers = (Elf_Internal_Shdr *)
5510     cmalloc (num, sizeof (Elf_Internal_Shdr));
5511   if (filedata->section_headers == NULL)
5512     {
5513       if (! probe)
5514         error (_("Out of memory reading %u section headers\n"), num);
5515       free (shdrs);
5516       return FALSE;
5517     }
5518
5519   for (i = 0, internal = filedata->section_headers;
5520        i < num;
5521        i++, internal++)
5522     {
5523       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5524       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5525       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5526       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5527       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5528       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5529       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5530       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5531       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5532       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5533       if (!probe && internal->sh_link > num)
5534         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5535       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5536         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5537     }
5538
5539   free (shdrs);
5540   return TRUE;
5541 }
5542
5543 static Elf_Internal_Sym *
5544 get_32bit_elf_symbols (Filedata *           filedata,
5545                        Elf_Internal_Shdr *  section,
5546                        unsigned long *      num_syms_return)
5547 {
5548   unsigned long number = 0;
5549   Elf32_External_Sym * esyms = NULL;
5550   Elf_External_Sym_Shndx * shndx = NULL;
5551   Elf_Internal_Sym * isyms = NULL;
5552   Elf_Internal_Sym * psym;
5553   unsigned int j;
5554   elf_section_list * entry;
5555
5556   if (section->sh_size == 0)
5557     {
5558       if (num_syms_return != NULL)
5559         * num_syms_return = 0;
5560       return NULL;
5561     }
5562
5563   /* Run some sanity checks first.  */
5564   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5565     {
5566       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5567              printable_section_name (filedata, section),
5568              (unsigned long) section->sh_entsize);
5569       goto exit_point;
5570     }
5571
5572   if (section->sh_size > filedata->file_size)
5573     {
5574       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5575              printable_section_name (filedata, section),
5576              (unsigned long) section->sh_size);
5577       goto exit_point;
5578     }
5579
5580   number = section->sh_size / section->sh_entsize;
5581
5582   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5583     {
5584       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5585              (unsigned long) section->sh_size,
5586              printable_section_name (filedata, section),
5587              (unsigned long) section->sh_entsize);
5588       goto exit_point;
5589     }
5590
5591   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5592                                            section->sh_size, _("symbols"));
5593   if (esyms == NULL)
5594     goto exit_point;
5595
5596   shndx = NULL;
5597   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5598     {
5599       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5600         continue;
5601
5602       if (shndx != NULL)
5603         {
5604           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5605           free (shndx);
5606         }
5607
5608       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5609                                                    entry->hdr->sh_offset,
5610                                                    1, entry->hdr->sh_size,
5611                                                    _("symbol table section indices"));
5612       if (shndx == NULL)
5613         goto exit_point;
5614
5615       /* PR17531: file: heap-buffer-overflow */
5616       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5617         {
5618           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5619                  printable_section_name (filedata, entry->hdr),
5620                  (unsigned long) entry->hdr->sh_size,
5621                  (unsigned long) section->sh_size);
5622           goto exit_point;
5623         }
5624     }
5625
5626   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5627
5628   if (isyms == NULL)
5629     {
5630       error (_("Out of memory reading %lu symbols\n"),
5631              (unsigned long) number);
5632       goto exit_point;
5633     }
5634
5635   for (j = 0, psym = isyms; j < number; j++, psym++)
5636     {
5637       psym->st_name  = BYTE_GET (esyms[j].st_name);
5638       psym->st_value = BYTE_GET (esyms[j].st_value);
5639       psym->st_size  = BYTE_GET (esyms[j].st_size);
5640       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5641       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5642         psym->st_shndx
5643           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5644       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5645         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5646       psym->st_info  = BYTE_GET (esyms[j].st_info);
5647       psym->st_other = BYTE_GET (esyms[j].st_other);
5648     }
5649
5650  exit_point:
5651   free (shndx);
5652   free (esyms);
5653
5654   if (num_syms_return != NULL)
5655     * num_syms_return = isyms == NULL ? 0 : number;
5656
5657   return isyms;
5658 }
5659
5660 static Elf_Internal_Sym *
5661 get_64bit_elf_symbols (Filedata *           filedata,
5662                        Elf_Internal_Shdr *  section,
5663                        unsigned long *      num_syms_return)
5664 {
5665   unsigned long number = 0;
5666   Elf64_External_Sym * esyms = NULL;
5667   Elf_External_Sym_Shndx * shndx = NULL;
5668   Elf_Internal_Sym * isyms = NULL;
5669   Elf_Internal_Sym * psym;
5670   unsigned int j;
5671   elf_section_list * entry;
5672
5673   if (section->sh_size == 0)
5674     {
5675       if (num_syms_return != NULL)
5676         * num_syms_return = 0;
5677       return NULL;
5678     }
5679
5680   /* Run some sanity checks first.  */
5681   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5682     {
5683       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5684              printable_section_name (filedata, section),
5685              (unsigned long) section->sh_entsize);
5686       goto exit_point;
5687     }
5688
5689   if (section->sh_size > filedata->file_size)
5690     {
5691       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5692              printable_section_name (filedata, section),
5693              (unsigned long) section->sh_size);
5694       goto exit_point;
5695     }
5696
5697   number = section->sh_size / section->sh_entsize;
5698
5699   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5700     {
5701       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5702              (unsigned long) section->sh_size,
5703              printable_section_name (filedata, section),
5704              (unsigned long) section->sh_entsize);
5705       goto exit_point;
5706     }
5707
5708   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5709                                            section->sh_size, _("symbols"));
5710   if (!esyms)
5711     goto exit_point;
5712
5713   shndx = NULL;
5714   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5715     {
5716       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5717         continue;
5718
5719       if (shndx != NULL)
5720         {
5721           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5722           free (shndx);
5723         }
5724
5725       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5726                                                    entry->hdr->sh_offset,
5727                                                    1, entry->hdr->sh_size,
5728                                                    _("symbol table section indices"));
5729       if (shndx == NULL)
5730         goto exit_point;
5731
5732       /* PR17531: file: heap-buffer-overflow */
5733       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5734         {
5735           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5736                  printable_section_name (filedata, entry->hdr),
5737                  (unsigned long) entry->hdr->sh_size,
5738                  (unsigned long) section->sh_size);
5739           goto exit_point;
5740         }
5741     }
5742
5743   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5744
5745   if (isyms == NULL)
5746     {
5747       error (_("Out of memory reading %lu symbols\n"),
5748              (unsigned long) number);
5749       goto exit_point;
5750     }
5751
5752   for (j = 0, psym = isyms; j < number; j++, psym++)
5753     {
5754       psym->st_name  = BYTE_GET (esyms[j].st_name);
5755       psym->st_info  = BYTE_GET (esyms[j].st_info);
5756       psym->st_other = BYTE_GET (esyms[j].st_other);
5757       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5758
5759       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5760         psym->st_shndx
5761           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5762       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5763         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5764
5765       psym->st_value = BYTE_GET (esyms[j].st_value);
5766       psym->st_size  = BYTE_GET (esyms[j].st_size);
5767     }
5768
5769  exit_point:
5770   free (shndx);
5771   free (esyms);
5772
5773   if (num_syms_return != NULL)
5774     * num_syms_return = isyms == NULL ? 0 : number;
5775
5776   return isyms;
5777 }
5778
5779 static const char *
5780 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5781 {
5782   static char buff[1024];
5783   char * p = buff;
5784   unsigned int field_size = is_32bit_elf ? 8 : 16;
5785   signed int sindex;
5786   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5787   bfd_vma os_flags = 0;
5788   bfd_vma proc_flags = 0;
5789   bfd_vma unknown_flags = 0;
5790   static const struct
5791     {
5792       const char * str;
5793       unsigned int len;
5794     }
5795   flags [] =
5796     {
5797       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5798       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5799       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5800       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5801       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5802       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5803       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5804       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5805       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5806       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5807       /* IA-64 specific.  */
5808       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5809       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5810       /* IA-64 OpenVMS specific.  */
5811       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5812       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5813       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5814       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5815       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5816       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5817       /* Generic.  */
5818       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5819       /* SPARC specific.  */
5820       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5821       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5822       /* ARM specific.  */
5823       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5824       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5825       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5826       /* GNU specific.  */
5827       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5828       /* VLE specific.  */
5829       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5830     };
5831
5832   if (do_section_details)
5833     {
5834       sprintf (buff, "[%*.*lx]: ",
5835                field_size, field_size, (unsigned long) sh_flags);
5836       p += field_size + 4;
5837     }
5838
5839   while (sh_flags)
5840     {
5841       bfd_vma flag;
5842
5843       flag = sh_flags & - sh_flags;
5844       sh_flags &= ~ flag;
5845
5846       if (do_section_details)
5847         {
5848           switch (flag)
5849             {
5850             case SHF_WRITE:             sindex = 0; break;
5851             case SHF_ALLOC:             sindex = 1; break;
5852             case SHF_EXECINSTR:         sindex = 2; break;
5853             case SHF_MERGE:             sindex = 3; break;
5854             case SHF_STRINGS:           sindex = 4; break;
5855             case SHF_INFO_LINK:         sindex = 5; break;
5856             case SHF_LINK_ORDER:        sindex = 6; break;
5857             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5858             case SHF_GROUP:             sindex = 8; break;
5859             case SHF_TLS:               sindex = 9; break;
5860             case SHF_EXCLUDE:           sindex = 18; break;
5861             case SHF_COMPRESSED:        sindex = 20; break;
5862             case SHF_GNU_MBIND:         sindex = 24; break;
5863
5864             default:
5865               sindex = -1;
5866               switch (filedata->file_header.e_machine)
5867                 {
5868                 case EM_IA_64:
5869                   if (flag == SHF_IA_64_SHORT)
5870                     sindex = 10;
5871                   else if (flag == SHF_IA_64_NORECOV)
5872                     sindex = 11;
5873 #ifdef BFD64
5874                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5875                     switch (flag)
5876                       {
5877                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5878                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5879                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5880                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5881                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5882                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5883                       default:                        break;
5884                       }
5885 #endif
5886                   break;
5887
5888                 case EM_386:
5889                 case EM_IAMCU:
5890                 case EM_X86_64:
5891                 case EM_L1OM:
5892                 case EM_K1OM:
5893                 case EM_OLD_SPARCV9:
5894                 case EM_SPARC32PLUS:
5895                 case EM_SPARCV9:
5896                 case EM_SPARC:
5897                   if (flag == SHF_ORDERED)
5898                     sindex = 19;
5899                   break;
5900
5901                 case EM_ARM:
5902                   switch (flag)
5903                     {
5904                     case SHF_ENTRYSECT: sindex = 21; break;
5905                     case SHF_ARM_PURECODE: sindex = 22; break;
5906                     case SHF_COMDEF: sindex = 23; break;
5907                     default: break;
5908                     }
5909                   break;
5910                 case EM_PPC:
5911                   if (flag == SHF_PPC_VLE)
5912                     sindex = 25;
5913                   break;
5914
5915                 default:
5916                   break;
5917                 }
5918             }
5919
5920           if (sindex != -1)
5921             {
5922               if (p != buff + field_size + 4)
5923                 {
5924                   if (size < (10 + 2))
5925                     {
5926                       warn (_("Internal error: not enough buffer room for section flag info"));
5927                       return _("<unknown>");
5928                     }
5929                   size -= 2;
5930                   *p++ = ',';
5931                   *p++ = ' ';
5932                 }
5933
5934               size -= flags [sindex].len;
5935               p = stpcpy (p, flags [sindex].str);
5936             }
5937           else if (flag & SHF_MASKOS)
5938             os_flags |= flag;
5939           else if (flag & SHF_MASKPROC)
5940             proc_flags |= flag;
5941           else
5942             unknown_flags |= flag;
5943         }
5944       else
5945         {
5946           switch (flag)
5947             {
5948             case SHF_WRITE:             *p = 'W'; break;
5949             case SHF_ALLOC:             *p = 'A'; break;
5950             case SHF_EXECINSTR:         *p = 'X'; break;
5951             case SHF_MERGE:             *p = 'M'; break;
5952             case SHF_STRINGS:           *p = 'S'; break;
5953             case SHF_INFO_LINK:         *p = 'I'; break;
5954             case SHF_LINK_ORDER:        *p = 'L'; break;
5955             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5956             case SHF_GROUP:             *p = 'G'; break;
5957             case SHF_TLS:               *p = 'T'; break;
5958             case SHF_EXCLUDE:           *p = 'E'; break;
5959             case SHF_COMPRESSED:        *p = 'C'; break;
5960             case SHF_GNU_MBIND:         *p = 'D'; break;
5961
5962             default:
5963               if ((filedata->file_header.e_machine == EM_X86_64
5964                    || filedata->file_header.e_machine == EM_L1OM
5965                    || filedata->file_header.e_machine == EM_K1OM)
5966                   && flag == SHF_X86_64_LARGE)
5967                 *p = 'l';
5968               else if (filedata->file_header.e_machine == EM_ARM
5969                        && flag == SHF_ARM_PURECODE)
5970                   *p = 'y';
5971               else if (filedata->file_header.e_machine == EM_PPC
5972                        && flag == SHF_PPC_VLE)
5973                   *p = 'v';
5974               else if (flag & SHF_MASKOS)
5975                 {
5976                   *p = 'o';
5977                   sh_flags &= ~ SHF_MASKOS;
5978                 }
5979               else if (flag & SHF_MASKPROC)
5980                 {
5981                   *p = 'p';
5982                   sh_flags &= ~ SHF_MASKPROC;
5983                 }
5984               else
5985                 *p = 'x';
5986               break;
5987             }
5988           p++;
5989         }
5990     }
5991
5992   if (do_section_details)
5993     {
5994       if (os_flags)
5995         {
5996           size -= 5 + field_size;
5997           if (p != buff + field_size + 4)
5998             {
5999               if (size < (2 + 1))
6000                 {
6001                   warn (_("Internal error: not enough buffer room for section flag info"));
6002                   return _("<unknown>");
6003                 }
6004               size -= 2;
6005               *p++ = ',';
6006               *p++ = ' ';
6007             }
6008           sprintf (p, "OS (%*.*lx)", field_size, field_size,
6009                    (unsigned long) os_flags);
6010           p += 5 + field_size;
6011         }
6012       if (proc_flags)
6013         {
6014           size -= 7 + field_size;
6015           if (p != buff + field_size + 4)
6016             {
6017               if (size < (2 + 1))
6018                 {
6019                   warn (_("Internal error: not enough buffer room for section flag info"));
6020                   return _("<unknown>");
6021                 }
6022               size -= 2;
6023               *p++ = ',';
6024               *p++ = ' ';
6025             }
6026           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
6027                    (unsigned long) proc_flags);
6028           p += 7 + field_size;
6029         }
6030       if (unknown_flags)
6031         {
6032           size -= 10 + field_size;
6033           if (p != buff + field_size + 4)
6034             {
6035               if (size < (2 + 1))
6036                 {
6037                   warn (_("Internal error: not enough buffer room for section flag info"));
6038                   return _("<unknown>");
6039                 }
6040               size -= 2;
6041               *p++ = ',';
6042               *p++ = ' ';
6043             }
6044           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
6045                    (unsigned long) unknown_flags);
6046           p += 10 + field_size;
6047         }
6048     }
6049
6050   *p = '\0';
6051   return buff;
6052 }
6053
6054 static unsigned int
6055 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
6056 {
6057   if (is_32bit_elf)
6058     {
6059       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
6060
6061       if (size < sizeof (* echdr))
6062         {
6063           error (_("Compressed section is too small even for a compression header\n"));
6064           return 0;
6065         }
6066
6067       chdr->ch_type = BYTE_GET (echdr->ch_type);
6068       chdr->ch_size = BYTE_GET (echdr->ch_size);
6069       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6070       return sizeof (*echdr);
6071     }
6072   else
6073     {
6074       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
6075
6076       if (size < sizeof (* echdr))
6077         {
6078           error (_("Compressed section is too small even for a compression header\n"));
6079           return 0;
6080         }
6081
6082       chdr->ch_type = BYTE_GET (echdr->ch_type);
6083       chdr->ch_size = BYTE_GET (echdr->ch_size);
6084       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6085       return sizeof (*echdr);
6086     }
6087 }
6088
6089 static bfd_boolean
6090 process_section_headers (Filedata * filedata)
6091 {
6092   Elf_Internal_Shdr * section;
6093   unsigned int i;
6094
6095   filedata->section_headers = NULL;
6096
6097   if (filedata->file_header.e_shnum == 0)
6098     {
6099       /* PR binutils/12467.  */
6100       if (filedata->file_header.e_shoff != 0)
6101         {
6102           warn (_("possibly corrupt ELF file header - it has a non-zero"
6103                   " section header offset, but no section headers\n"));
6104           return FALSE;
6105         }
6106       else if (do_sections)
6107         printf (_("\nThere are no sections in this file.\n"));
6108
6109       return TRUE;
6110     }
6111
6112   if (do_sections && !do_header)
6113     printf (ngettext ("There is %d section header, "
6114                       "starting at offset 0x%lx:\n",
6115                       "There are %d section headers, "
6116                       "starting at offset 0x%lx:\n",
6117                       filedata->file_header.e_shnum),
6118             filedata->file_header.e_shnum,
6119             (unsigned long) filedata->file_header.e_shoff);
6120
6121   if (is_32bit_elf)
6122     {
6123       if (! get_32bit_section_headers (filedata, FALSE))
6124         return FALSE;
6125     }
6126   else
6127     {
6128       if (! get_64bit_section_headers (filedata, FALSE))
6129         return FALSE;
6130     }
6131
6132   /* Read in the string table, so that we have names to display.  */
6133   if (filedata->file_header.e_shstrndx != SHN_UNDEF
6134        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6135     {
6136       section = filedata->section_headers + filedata->file_header.e_shstrndx;
6137
6138       if (section->sh_size != 0)
6139         {
6140           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6141                                                       1, section->sh_size,
6142                                                       _("string table"));
6143
6144           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6145         }
6146     }
6147
6148   /* Scan the sections for the dynamic symbol table
6149      and dynamic string table and debug sections.  */
6150   dynamic_symbols = NULL;
6151   dynamic_strings = NULL;
6152   dynamic_syminfo = NULL;
6153   symtab_shndx_list = NULL;
6154
6155   eh_addr_size = is_32bit_elf ? 4 : 8;
6156   switch (filedata->file_header.e_machine)
6157     {
6158     case EM_MIPS:
6159     case EM_MIPS_RS3_LE:
6160       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6161          FDE addresses.  However, the ABI also has a semi-official ILP32
6162          variant for which the normal FDE address size rules apply.
6163
6164          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6165          section, where XX is the size of longs in bits.  Unfortunately,
6166          earlier compilers provided no way of distinguishing ILP32 objects
6167          from LP64 objects, so if there's any doubt, we should assume that
6168          the official LP64 form is being used.  */
6169       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6170           && find_section (filedata, ".gcc_compiled_long32") == NULL)
6171         eh_addr_size = 8;
6172       break;
6173
6174     case EM_H8_300:
6175     case EM_H8_300H:
6176       switch (filedata->file_header.e_flags & EF_H8_MACH)
6177         {
6178         case E_H8_MACH_H8300:
6179         case E_H8_MACH_H8300HN:
6180         case E_H8_MACH_H8300SN:
6181         case E_H8_MACH_H8300SXN:
6182           eh_addr_size = 2;
6183           break;
6184         case E_H8_MACH_H8300H:
6185         case E_H8_MACH_H8300S:
6186         case E_H8_MACH_H8300SX:
6187           eh_addr_size = 4;
6188           break;
6189         }
6190       break;
6191
6192     case EM_M32C_OLD:
6193     case EM_M32C:
6194       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6195         {
6196         case EF_M32C_CPU_M16C:
6197           eh_addr_size = 2;
6198           break;
6199         }
6200       break;
6201     }
6202
6203 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6204   do                                                                    \
6205     {                                                                   \
6206       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6207       if (section->sh_entsize != expected_entsize)                      \
6208         {                                                               \
6209           char buf[40];                                                 \
6210           sprintf_vma (buf, section->sh_entsize);                       \
6211           /* Note: coded this way so that there is a single string for  \
6212              translation.  */ \
6213           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6214           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6215                    (unsigned) expected_entsize);                        \
6216           section->sh_entsize = expected_entsize;                       \
6217         }                                                               \
6218     }                                                                   \
6219   while (0)
6220
6221 #define CHECK_ENTSIZE(section, i, type)                                 \
6222   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6223                         sizeof (Elf64_External_##type))
6224
6225   for (i = 0, section = filedata->section_headers;
6226        i < filedata->file_header.e_shnum;
6227        i++, section++)
6228     {
6229       char * name = SECTION_NAME (section);
6230
6231       if (section->sh_type == SHT_DYNSYM)
6232         {
6233           if (dynamic_symbols != NULL)
6234             {
6235               error (_("File contains multiple dynamic symbol tables\n"));
6236               continue;
6237             }
6238
6239           CHECK_ENTSIZE (section, i, Sym);
6240           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6241         }
6242       else if (section->sh_type == SHT_STRTAB
6243                && streq (name, ".dynstr"))
6244         {
6245           if (dynamic_strings != NULL)
6246             {
6247               error (_("File contains multiple dynamic string tables\n"));
6248               continue;
6249             }
6250
6251           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6252                                                1, section->sh_size,
6253                                                _("dynamic strings"));
6254           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6255         }
6256       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6257         {
6258           elf_section_list * entry = xmalloc (sizeof * entry);
6259
6260           entry->hdr = section;
6261           entry->next = symtab_shndx_list;
6262           symtab_shndx_list = entry;
6263         }
6264       else if (section->sh_type == SHT_SYMTAB)
6265         CHECK_ENTSIZE (section, i, Sym);
6266       else if (section->sh_type == SHT_GROUP)
6267         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6268       else if (section->sh_type == SHT_REL)
6269         CHECK_ENTSIZE (section, i, Rel);
6270       else if (section->sh_type == SHT_RELA)
6271         CHECK_ENTSIZE (section, i, Rela);
6272       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6273                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6274                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6275                 || do_debug_str || do_debug_loc || do_debug_ranges
6276                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6277                && (const_strneq (name, ".debug_")
6278                    || const_strneq (name, ".zdebug_")))
6279         {
6280           if (name[1] == 'z')
6281             name += sizeof (".zdebug_") - 1;
6282           else
6283             name += sizeof (".debug_") - 1;
6284
6285           if (do_debugging
6286               || (do_debug_info     && const_strneq (name, "info"))
6287               || (do_debug_info     && const_strneq (name, "types"))
6288               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6289               || (do_debug_lines    && strcmp (name, "line") == 0)
6290               || (do_debug_lines    && const_strneq (name, "line."))
6291               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6292               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6293               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6294               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6295               || (do_debug_aranges  && const_strneq (name, "aranges"))
6296               || (do_debug_ranges   && const_strneq (name, "ranges"))
6297               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6298               || (do_debug_frames   && const_strneq (name, "frame"))
6299               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6300               || (do_debug_macinfo  && const_strneq (name, "macro"))
6301               || (do_debug_str      && const_strneq (name, "str"))
6302               || (do_debug_loc      && const_strneq (name, "loc"))
6303               || (do_debug_loc      && const_strneq (name, "loclists"))
6304               || (do_debug_addr     && const_strneq (name, "addr"))
6305               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6306               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6307               )
6308             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6309         }
6310       /* Linkonce section to be combined with .debug_info at link time.  */
6311       else if ((do_debugging || do_debug_info)
6312                && const_strneq (name, ".gnu.linkonce.wi."))
6313         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6314       else if (do_debug_frames && streq (name, ".eh_frame"))
6315         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6316       else if (do_gdb_index && (streq (name, ".gdb_index")
6317                                 || streq (name, ".debug_names")))
6318         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6319       /* Trace sections for Itanium VMS.  */
6320       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6321                 || do_trace_aranges)
6322                && const_strneq (name, ".trace_"))
6323         {
6324           name += sizeof (".trace_") - 1;
6325
6326           if (do_debugging
6327               || (do_trace_info     && streq (name, "info"))
6328               || (do_trace_abbrevs  && streq (name, "abbrev"))
6329               || (do_trace_aranges  && streq (name, "aranges"))
6330               )
6331             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6332         }
6333       else if ((do_debugging || do_debug_links)
6334                && (const_strneq (name, ".gnu_debuglink")
6335                    || const_strneq (name, ".gnu_debugaltlink")))
6336         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6337     }
6338
6339   if (! do_sections)
6340     return TRUE;
6341
6342   if (filedata->file_header.e_shnum > 1)
6343     printf (_("\nSection Headers:\n"));
6344   else
6345     printf (_("\nSection Header:\n"));
6346
6347   if (is_32bit_elf)
6348     {
6349       if (do_section_details)
6350         {
6351           printf (_("  [Nr] Name\n"));
6352           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6353         }
6354       else
6355         printf
6356           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6357     }
6358   else if (do_wide)
6359     {
6360       if (do_section_details)
6361         {
6362           printf (_("  [Nr] Name\n"));
6363           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6364         }
6365       else
6366         printf
6367           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6368     }
6369   else
6370     {
6371       if (do_section_details)
6372         {
6373           printf (_("  [Nr] Name\n"));
6374           printf (_("       Type              Address          Offset            Link\n"));
6375           printf (_("       Size              EntSize          Info              Align\n"));
6376         }
6377       else
6378         {
6379           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6380           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6381         }
6382     }
6383
6384   if (do_section_details)
6385     printf (_("       Flags\n"));
6386
6387   for (i = 0, section = filedata->section_headers;
6388        i < filedata->file_header.e_shnum;
6389        i++, section++)
6390     {
6391       /* Run some sanity checks on the section header.  */
6392
6393       /* Check the sh_link field.  */
6394       switch (section->sh_type)
6395         {
6396         case SHT_REL:
6397         case SHT_RELA:
6398           if (section->sh_link == 0
6399               && (filedata->file_header.e_type == ET_EXEC
6400                   || filedata->file_header.e_type == ET_DYN))
6401             /* A dynamic relocation section where all entries use a
6402                zero symbol index need not specify a symtab section.  */
6403             break;
6404           /* Fall through.  */
6405         case SHT_SYMTAB_SHNDX:
6406         case SHT_GROUP:
6407         case SHT_HASH:
6408         case SHT_GNU_HASH:
6409         case SHT_GNU_versym:
6410           if (section->sh_link == 0
6411               || section->sh_link >= filedata->file_header.e_shnum
6412               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6413                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6414             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6415                   i, section->sh_link);
6416           break;
6417
6418         case SHT_DYNAMIC:
6419         case SHT_SYMTAB:
6420         case SHT_DYNSYM:
6421         case SHT_GNU_verneed:
6422         case SHT_GNU_verdef:
6423         case SHT_GNU_LIBLIST:
6424           if (section->sh_link == 0
6425               || section->sh_link >= filedata->file_header.e_shnum
6426               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6427             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6428                   i, section->sh_link);
6429           break;
6430
6431         case SHT_INIT_ARRAY:
6432         case SHT_FINI_ARRAY:
6433         case SHT_PREINIT_ARRAY:
6434           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6435             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6436                   i, section->sh_link);
6437           break;
6438
6439         default:
6440           /* FIXME: Add support for target specific section types.  */
6441 #if 0     /* Currently we do not check other section types as there are too
6442              many special cases.  Stab sections for example have a type
6443              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6444              section.  */
6445           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6446             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6447                   i, section->sh_link);
6448 #endif
6449           break;
6450         }
6451
6452       /* Check the sh_info field.  */
6453       switch (section->sh_type)
6454         {
6455         case SHT_REL:
6456         case SHT_RELA:
6457           if (section->sh_info == 0
6458               && (filedata->file_header.e_type == ET_EXEC
6459                   || filedata->file_header.e_type == ET_DYN))
6460             /* Dynamic relocations apply to segments, so they do not
6461                need to specify the section they relocate.  */
6462             break;
6463           if (section->sh_info == 0
6464               || section->sh_info >= filedata->file_header.e_shnum
6465               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6466                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6467                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6468                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6469                   && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6470                   && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6471                   /* FIXME: Are other section types valid ?  */
6472                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6473             warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6474                   i, section->sh_info);
6475           break;
6476
6477         case SHT_DYNAMIC:
6478         case SHT_HASH:
6479         case SHT_SYMTAB_SHNDX:
6480         case SHT_INIT_ARRAY:
6481         case SHT_FINI_ARRAY:
6482         case SHT_PREINIT_ARRAY:
6483           if (section->sh_info != 0)
6484             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6485                   i, section->sh_info);
6486           break;
6487
6488         case SHT_GROUP:
6489         case SHT_SYMTAB:
6490         case SHT_DYNSYM:
6491           /* A symbol index - we assume that it is valid.  */
6492           break;
6493
6494         default:
6495           /* FIXME: Add support for target specific section types.  */
6496           if (section->sh_type == SHT_NOBITS)
6497             /* NOBITS section headers with non-zero sh_info fields can be
6498                created when a binary is stripped of everything but its debug
6499                information.  The stripped sections have their headers
6500                preserved but their types set to SHT_NOBITS.  So do not check
6501                this type of section.  */
6502             ;
6503           else if (section->sh_flags & SHF_INFO_LINK)
6504             {
6505               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6506                 warn (_("[%2u]: Expected link to another section in info field"), i);
6507             }
6508           else if (section->sh_type < SHT_LOOS
6509                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6510                    && section->sh_info != 0)
6511             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6512                   i, section->sh_info);
6513           break;
6514         }
6515
6516       /* Check the sh_size field.  */
6517       if (section->sh_size > filedata->file_size
6518           && section->sh_type != SHT_NOBITS
6519           && section->sh_type != SHT_NULL
6520           && section->sh_type < SHT_LOOS)
6521         warn (_("Size of section %u is larger than the entire file!\n"), i);
6522
6523       printf ("  [%2u] ", i);
6524       if (do_section_details)
6525         printf ("%s\n      ", printable_section_name (filedata, section));
6526       else
6527         print_symbol (-17, SECTION_NAME (section));
6528
6529       printf (do_wide ? " %-15s " : " %-15.15s ",
6530               get_section_type_name (filedata, section->sh_type));
6531
6532       if (is_32bit_elf)
6533         {
6534           const char * link_too_big = NULL;
6535
6536           print_vma (section->sh_addr, LONG_HEX);
6537
6538           printf ( " %6.6lx %6.6lx %2.2lx",
6539                    (unsigned long) section->sh_offset,
6540                    (unsigned long) section->sh_size,
6541                    (unsigned long) section->sh_entsize);
6542
6543           if (do_section_details)
6544             fputs ("  ", stdout);
6545           else
6546             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6547
6548           if (section->sh_link >= filedata->file_header.e_shnum)
6549             {
6550               link_too_big = "";
6551               /* The sh_link value is out of range.  Normally this indicates
6552                  an error but it can have special values in Solaris binaries.  */
6553               switch (filedata->file_header.e_machine)
6554                 {
6555                 case EM_386:
6556                 case EM_IAMCU:
6557                 case EM_X86_64:
6558                 case EM_L1OM:
6559                 case EM_K1OM:
6560                 case EM_OLD_SPARCV9:
6561                 case EM_SPARC32PLUS:
6562                 case EM_SPARCV9:
6563                 case EM_SPARC:
6564                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6565                     link_too_big = "BEFORE";
6566                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6567                     link_too_big = "AFTER";
6568                   break;
6569                 default:
6570                   break;
6571                 }
6572             }
6573
6574           if (do_section_details)
6575             {
6576               if (link_too_big != NULL && * link_too_big)
6577                 printf ("<%s> ", link_too_big);
6578               else
6579                 printf ("%2u ", section->sh_link);
6580               printf ("%3u %2lu\n", section->sh_info,
6581                       (unsigned long) section->sh_addralign);
6582             }
6583           else
6584             printf ("%2u %3u %2lu\n",
6585                     section->sh_link,
6586                     section->sh_info,
6587                     (unsigned long) section->sh_addralign);
6588
6589           if (link_too_big && ! * link_too_big)
6590             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6591                   i, section->sh_link);
6592         }
6593       else if (do_wide)
6594         {
6595           print_vma (section->sh_addr, LONG_HEX);
6596
6597           if ((long) section->sh_offset == section->sh_offset)
6598             printf (" %6.6lx", (unsigned long) section->sh_offset);
6599           else
6600             {
6601               putchar (' ');
6602               print_vma (section->sh_offset, LONG_HEX);
6603             }
6604
6605           if ((unsigned long) section->sh_size == section->sh_size)
6606             printf (" %6.6lx", (unsigned long) section->sh_size);
6607           else
6608             {
6609               putchar (' ');
6610               print_vma (section->sh_size, LONG_HEX);
6611             }
6612
6613           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6614             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6615           else
6616             {
6617               putchar (' ');
6618               print_vma (section->sh_entsize, LONG_HEX);
6619             }
6620
6621           if (do_section_details)
6622             fputs ("  ", stdout);
6623           else
6624             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6625
6626           printf ("%2u %3u ", section->sh_link, section->sh_info);
6627
6628           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6629             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6630           else
6631             {
6632               print_vma (section->sh_addralign, DEC);
6633               putchar ('\n');
6634             }
6635         }
6636       else if (do_section_details)
6637         {
6638           putchar (' ');
6639           print_vma (section->sh_addr, LONG_HEX);
6640           if ((long) section->sh_offset == section->sh_offset)
6641             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6642           else
6643             {
6644               printf ("  ");
6645               print_vma (section->sh_offset, LONG_HEX);
6646             }
6647           printf ("  %u\n       ", section->sh_link);
6648           print_vma (section->sh_size, LONG_HEX);
6649           putchar (' ');
6650           print_vma (section->sh_entsize, LONG_HEX);
6651
6652           printf ("  %-16u  %lu\n",
6653                   section->sh_info,
6654                   (unsigned long) section->sh_addralign);
6655         }
6656       else
6657         {
6658           putchar (' ');
6659           print_vma (section->sh_addr, LONG_HEX);
6660           if ((long) section->sh_offset == section->sh_offset)
6661             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6662           else
6663             {
6664               printf ("  ");
6665               print_vma (section->sh_offset, LONG_HEX);
6666             }
6667           printf ("\n       ");
6668           print_vma (section->sh_size, LONG_HEX);
6669           printf ("  ");
6670           print_vma (section->sh_entsize, LONG_HEX);
6671
6672           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6673
6674           printf ("     %2u   %3u     %lu\n",
6675                   section->sh_link,
6676                   section->sh_info,
6677                   (unsigned long) section->sh_addralign);
6678         }
6679
6680       if (do_section_details)
6681         {
6682           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6683           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6684             {
6685               /* Minimum section size is 12 bytes for 32-bit compression
6686                  header + 12 bytes for compressed data header.  */
6687               unsigned char buf[24];
6688
6689               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6690               if (get_data (&buf, filedata, section->sh_offset, 1,
6691                             sizeof (buf), _("compression header")))
6692                 {
6693                   Elf_Internal_Chdr chdr;
6694
6695                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6696
6697                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6698                     printf ("       ZLIB, ");
6699                   else
6700                     printf (_("       [<unknown>: 0x%x], "),
6701                             chdr.ch_type);
6702                   print_vma (chdr.ch_size, LONG_HEX);
6703                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6704                 }
6705             }
6706         }
6707     }
6708
6709   if (!do_section_details)
6710     {
6711       /* The ordering of the letters shown here matches the ordering of the
6712          corresponding SHF_xxx values, and hence the order in which these
6713          letters will be displayed to the user.  */
6714       printf (_("Key to Flags:\n\
6715   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6716   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6717   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6718       if (filedata->file_header.e_machine == EM_X86_64
6719           || filedata->file_header.e_machine == EM_L1OM
6720           || filedata->file_header.e_machine == EM_K1OM)
6721         printf (_("l (large), "));
6722       else if (filedata->file_header.e_machine == EM_ARM)
6723         printf (_("y (purecode), "));
6724       else if (filedata->file_header.e_machine == EM_PPC)
6725         printf (_("v (VLE), "));
6726       printf ("p (processor specific)\n");
6727     }
6728
6729   return TRUE;
6730 }
6731
6732 static const char *
6733 get_group_flags (unsigned int flags)
6734 {
6735   static char buff[128];
6736
6737   if (flags == 0)
6738     return "";
6739   else if (flags == GRP_COMDAT)
6740     return "COMDAT ";
6741
6742   snprintf (buff, 14, _("[0x%x: "), flags);
6743
6744   flags &= ~ GRP_COMDAT;
6745   if (flags & GRP_MASKOS)
6746     {
6747       strcat (buff, "<OS specific>");
6748       flags &= ~ GRP_MASKOS;
6749     }
6750
6751   if (flags & GRP_MASKPROC)
6752     {
6753       strcat (buff, "<PROC specific>");
6754       flags &= ~ GRP_MASKPROC;
6755     }
6756
6757   if (flags)
6758     strcat (buff, "<unknown>");
6759
6760   strcat (buff, "]");
6761   return buff;
6762 }
6763
6764 static bfd_boolean
6765 process_section_groups (Filedata * filedata)
6766 {
6767   Elf_Internal_Shdr * section;
6768   unsigned int i;
6769   struct group * group;
6770   Elf_Internal_Shdr * symtab_sec;
6771   Elf_Internal_Shdr * strtab_sec;
6772   Elf_Internal_Sym * symtab;
6773   unsigned long num_syms;
6774   char * strtab;
6775   size_t strtab_size;
6776
6777   /* Don't process section groups unless needed.  */
6778   if (!do_unwind && !do_section_groups)
6779     return TRUE;
6780
6781   if (filedata->file_header.e_shnum == 0)
6782     {
6783       if (do_section_groups)
6784         printf (_("\nThere are no sections to group in this file.\n"));
6785
6786       return TRUE;
6787     }
6788
6789   if (filedata->section_headers == NULL)
6790     {
6791       error (_("Section headers are not available!\n"));
6792       /* PR 13622: This can happen with a corrupt ELF header.  */
6793       return FALSE;
6794     }
6795
6796   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6797                                                      sizeof (struct group *));
6798
6799   if (section_headers_groups == NULL)
6800     {
6801       error (_("Out of memory reading %u section group headers\n"),
6802              filedata->file_header.e_shnum);
6803       return FALSE;
6804     }
6805
6806   /* Scan the sections for the group section.  */
6807   group_count = 0;
6808   for (i = 0, section = filedata->section_headers;
6809        i < filedata->file_header.e_shnum;
6810        i++, section++)
6811     if (section->sh_type == SHT_GROUP)
6812       group_count++;
6813
6814   if (group_count == 0)
6815     {
6816       if (do_section_groups)
6817         printf (_("\nThere are no section groups in this file.\n"));
6818
6819       return TRUE;
6820     }
6821
6822   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6823
6824   if (section_groups == NULL)
6825     {
6826       error (_("Out of memory reading %lu groups\n"),
6827              (unsigned long) group_count);
6828       return FALSE;
6829     }
6830
6831   symtab_sec = NULL;
6832   strtab_sec = NULL;
6833   symtab = NULL;
6834   num_syms = 0;
6835   strtab = NULL;
6836   strtab_size = 0;
6837   for (i = 0, section = filedata->section_headers, group = section_groups;
6838        i < filedata->file_header.e_shnum;
6839        i++, section++)
6840     {
6841       if (section->sh_type == SHT_GROUP)
6842         {
6843           const char * name = printable_section_name (filedata, section);
6844           const char * group_name;
6845           unsigned char * start;
6846           unsigned char * indices;
6847           unsigned int entry, j, size;
6848           Elf_Internal_Shdr * sec;
6849           Elf_Internal_Sym * sym;
6850
6851           /* Get the symbol table.  */
6852           if (section->sh_link >= filedata->file_header.e_shnum
6853               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6854                   != SHT_SYMTAB))
6855             {
6856               error (_("Bad sh_link in group section `%s'\n"), name);
6857               continue;
6858             }
6859
6860           if (symtab_sec != sec)
6861             {
6862               symtab_sec = sec;
6863               if (symtab)
6864                 free (symtab);
6865               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6866             }
6867
6868           if (symtab == NULL)
6869             {
6870               error (_("Corrupt header in group section `%s'\n"), name);
6871               continue;
6872             }
6873
6874           if (section->sh_info >= num_syms)
6875             {
6876               error (_("Bad sh_info in group section `%s'\n"), name);
6877               continue;
6878             }
6879
6880           sym = symtab + section->sh_info;
6881
6882           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6883             {
6884               if (sym->st_shndx == 0
6885                   || sym->st_shndx >= filedata->file_header.e_shnum)
6886                 {
6887                   error (_("Bad sh_info in group section `%s'\n"), name);
6888                   continue;
6889                 }
6890
6891               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6892               strtab_sec = NULL;
6893               if (strtab)
6894                 free (strtab);
6895               strtab = NULL;
6896               strtab_size = 0;
6897             }
6898           else
6899             {
6900               /* Get the string table.  */
6901               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6902                 {
6903                   strtab_sec = NULL;
6904                   if (strtab)
6905                     free (strtab);
6906                   strtab = NULL;
6907                   strtab_size = 0;
6908                 }
6909               else if (strtab_sec
6910                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6911                 {
6912                   strtab_sec = sec;
6913                   if (strtab)
6914                     free (strtab);
6915
6916                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6917                                               1, strtab_sec->sh_size,
6918                                               _("string table"));
6919                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6920                 }
6921               group_name = sym->st_name < strtab_size
6922                 ? strtab + sym->st_name : _("<corrupt>");
6923             }
6924
6925           /* PR 17531: file: loop.  */
6926           if (section->sh_entsize > section->sh_size)
6927             {
6928               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6929                      printable_section_name (filedata, section),
6930                      (unsigned long) section->sh_entsize,
6931                      (unsigned long) section->sh_size);
6932               continue;
6933             }
6934
6935           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6936                                               1, section->sh_size,
6937                                               _("section data"));
6938           if (start == NULL)
6939             continue;
6940
6941           indices = start;
6942           size = (section->sh_size / section->sh_entsize) - 1;
6943           entry = byte_get (indices, 4);
6944           indices += 4;
6945
6946           if (do_section_groups)
6947             {
6948               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6949                       get_group_flags (entry), i, name, group_name, size);
6950
6951               printf (_("   [Index]    Name\n"));
6952             }
6953
6954           group->group_index = i;
6955
6956           for (j = 0; j < size; j++)
6957             {
6958               struct group_list * g;
6959
6960               entry = byte_get (indices, 4);
6961               indices += 4;
6962
6963               if (entry >= filedata->file_header.e_shnum)
6964                 {
6965                   static unsigned num_group_errors = 0;
6966
6967                   if (num_group_errors ++ < 10)
6968                     {
6969                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6970                              entry, i, filedata->file_header.e_shnum - 1);
6971                       if (num_group_errors == 10)
6972                         warn (_("Further error messages about overlarge group section indices suppressed\n"));
6973                     }
6974                   continue;
6975                 }
6976
6977               if (section_headers_groups [entry] != NULL)
6978                 {
6979                   if (entry)
6980                     {
6981                       static unsigned num_errs = 0;
6982
6983                       if (num_errs ++ < 10)
6984                         {
6985                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6986                                  entry, i,
6987                                  section_headers_groups [entry]->group_index);
6988                           if (num_errs == 10)
6989                             warn (_("Further error messages about already contained group sections suppressed\n"));
6990                         }
6991                       continue;
6992                     }
6993                   else
6994                     {
6995                       /* Intel C/C++ compiler may put section 0 in a
6996                          section group.  We just warn it the first time
6997                          and ignore it afterwards.  */
6998                       static bfd_boolean warned = FALSE;
6999                       if (!warned)
7000                         {
7001                           error (_("section 0 in group section [%5u]\n"),
7002                                  section_headers_groups [entry]->group_index);
7003                           warned = TRUE;
7004                         }
7005                     }
7006                 }
7007
7008               section_headers_groups [entry] = group;
7009
7010               if (do_section_groups)
7011                 {
7012                   sec = filedata->section_headers + entry;
7013                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
7014                 }
7015
7016               g = (struct group_list *) xmalloc (sizeof (struct group_list));
7017               g->section_index = entry;
7018               g->next = group->root;
7019               group->root = g;
7020             }
7021
7022           if (start)
7023             free (start);
7024
7025           group++;
7026         }
7027     }
7028
7029   if (symtab)
7030     free (symtab);
7031   if (strtab)
7032     free (strtab);
7033   return TRUE;
7034 }
7035
7036 /* Data used to display dynamic fixups.  */
7037
7038 struct ia64_vms_dynfixup
7039 {
7040   bfd_vma needed_ident;         /* Library ident number.  */
7041   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
7042   bfd_vma fixup_needed;         /* Index of the library.  */
7043   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
7044   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
7045 };
7046
7047 /* Data used to display dynamic relocations.  */
7048
7049 struct ia64_vms_dynimgrela
7050 {
7051   bfd_vma img_rela_cnt;         /* Number of relocations.  */
7052   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
7053 };
7054
7055 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7056    library).  */
7057
7058 static bfd_boolean
7059 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
7060                               struct ia64_vms_dynfixup *  fixup,
7061                               const char *                strtab,
7062                               unsigned int                strtab_sz)
7063 {
7064   Elf64_External_VMS_IMAGE_FIXUP * imfs;
7065   long i;
7066   const char * lib_name;
7067
7068   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
7069                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
7070                    _("dynamic section image fixups"));
7071   if (!imfs)
7072     return FALSE;
7073
7074   if (fixup->needed < strtab_sz)
7075     lib_name = strtab + fixup->needed;
7076   else
7077     {
7078       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7079             (unsigned long) fixup->needed);
7080       lib_name = "???";
7081     }
7082   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7083           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
7084   printf
7085     (_("Seg Offset           Type                             SymVec DataType\n"));
7086
7087   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
7088     {
7089       unsigned int type;
7090       const char *rtype;
7091
7092       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
7093       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7094       type = BYTE_GET (imfs [i].type);
7095       rtype = elf_ia64_reloc_type (type);
7096       if (rtype == NULL)
7097         printf (" 0x%08x                       ", type);
7098       else
7099         printf (" %-32s ", rtype);
7100       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7101       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7102     }
7103
7104   free (imfs);
7105   return TRUE;
7106 }
7107
7108 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
7109
7110 static bfd_boolean
7111 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7112 {
7113   Elf64_External_VMS_IMAGE_RELA *imrs;
7114   long i;
7115
7116   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7117                    1, imgrela->img_rela_cnt * sizeof (*imrs),
7118                    _("dynamic section image relocations"));
7119   if (!imrs)
7120     return FALSE;
7121
7122   printf (_("\nImage relocs\n"));
7123   printf
7124     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
7125
7126   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7127     {
7128       unsigned int type;
7129       const char *rtype;
7130
7131       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7132       printf ("%08" BFD_VMA_FMT "x ",
7133               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7134       type = BYTE_GET (imrs [i].type);
7135       rtype = elf_ia64_reloc_type (type);
7136       if (rtype == NULL)
7137         printf ("0x%08x                      ", type);
7138       else
7139         printf ("%-31s ", rtype);
7140       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7141       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7142       printf ("%08" BFD_VMA_FMT "x\n",
7143               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7144     }
7145
7146   free (imrs);
7147   return TRUE;
7148 }
7149
7150 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
7151
7152 static bfd_boolean
7153 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7154 {
7155   struct ia64_vms_dynfixup fixup;
7156   struct ia64_vms_dynimgrela imgrela;
7157   Elf_Internal_Dyn *entry;
7158   bfd_vma strtab_off = 0;
7159   bfd_vma strtab_sz = 0;
7160   char *strtab = NULL;
7161   bfd_boolean res = TRUE;
7162
7163   memset (&fixup, 0, sizeof (fixup));
7164   memset (&imgrela, 0, sizeof (imgrela));
7165
7166   /* Note: the order of the entries is specified by the OpenVMS specs.  */
7167   for (entry = dynamic_section;
7168        entry < dynamic_section + dynamic_nent;
7169        entry++)
7170     {
7171       switch (entry->d_tag)
7172         {
7173         case DT_IA_64_VMS_STRTAB_OFFSET:
7174           strtab_off = entry->d_un.d_val;
7175           break;
7176         case DT_STRSZ:
7177           strtab_sz = entry->d_un.d_val;
7178           if (strtab == NULL)
7179             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7180                                1, strtab_sz, _("dynamic string section"));
7181           break;
7182
7183         case DT_IA_64_VMS_NEEDED_IDENT:
7184           fixup.needed_ident = entry->d_un.d_val;
7185           break;
7186         case DT_NEEDED:
7187           fixup.needed = entry->d_un.d_val;
7188           break;
7189         case DT_IA_64_VMS_FIXUP_NEEDED:
7190           fixup.fixup_needed = entry->d_un.d_val;
7191           break;
7192         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7193           fixup.fixup_rela_cnt = entry->d_un.d_val;
7194           break;
7195         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7196           fixup.fixup_rela_off = entry->d_un.d_val;
7197           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7198             res = FALSE;
7199           break;
7200         case DT_IA_64_VMS_IMG_RELA_CNT:
7201           imgrela.img_rela_cnt = entry->d_un.d_val;
7202           break;
7203         case DT_IA_64_VMS_IMG_RELA_OFF:
7204           imgrela.img_rela_off = entry->d_un.d_val;
7205           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7206             res = FALSE;
7207           break;
7208
7209         default:
7210           break;
7211         }
7212     }
7213
7214   if (strtab != NULL)
7215     free (strtab);
7216
7217   return res;
7218 }
7219
7220 static struct
7221 {
7222   const char * name;
7223   int reloc;
7224   int size;
7225   int rela;
7226 }
7227   dynamic_relocations [] =
7228 {
7229   { "REL", DT_REL, DT_RELSZ, FALSE },
7230   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7231   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7232 };
7233
7234 /* Process the reloc section.  */
7235
7236 static bfd_boolean
7237 process_relocs (Filedata * filedata)
7238 {
7239   unsigned long rel_size;
7240   unsigned long rel_offset;
7241
7242   if (!do_reloc)
7243     return TRUE;
7244
7245   if (do_using_dynamic)
7246     {
7247       int          is_rela;
7248       const char * name;
7249       bfd_boolean  has_dynamic_reloc;
7250       unsigned int i;
7251
7252       has_dynamic_reloc = FALSE;
7253
7254       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7255         {
7256           is_rela = dynamic_relocations [i].rela;
7257           name = dynamic_relocations [i].name;
7258           rel_size = dynamic_info [dynamic_relocations [i].size];
7259           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7260
7261           if (rel_size)
7262             has_dynamic_reloc = TRUE;
7263
7264           if (is_rela == UNKNOWN)
7265             {
7266               if (dynamic_relocations [i].reloc == DT_JMPREL)
7267                 switch (dynamic_info[DT_PLTREL])
7268                   {
7269                   case DT_REL:
7270                     is_rela = FALSE;
7271                     break;
7272                   case DT_RELA:
7273                     is_rela = TRUE;
7274                     break;
7275                   }
7276             }
7277
7278           if (rel_size)
7279             {
7280               printf
7281                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7282                  name, rel_offset, rel_size);
7283
7284               dump_relocations (filedata,
7285                                 offset_from_vma (filedata, rel_offset, rel_size),
7286                                 rel_size,
7287                                 dynamic_symbols, num_dynamic_syms,
7288                                 dynamic_strings, dynamic_strings_length,
7289                                 is_rela, TRUE /* is_dynamic */);
7290             }
7291         }
7292
7293       if (is_ia64_vms (filedata))
7294         if (process_ia64_vms_dynamic_relocs (filedata))
7295           has_dynamic_reloc = TRUE;
7296
7297       if (! has_dynamic_reloc)
7298         printf (_("\nThere are no dynamic relocations in this file.\n"));
7299     }
7300   else
7301     {
7302       Elf_Internal_Shdr * section;
7303       unsigned long i;
7304       bfd_boolean found = FALSE;
7305
7306       for (i = 0, section = filedata->section_headers;
7307            i < filedata->file_header.e_shnum;
7308            i++, section++)
7309         {
7310           if (   section->sh_type != SHT_RELA
7311               && section->sh_type != SHT_REL)
7312             continue;
7313
7314           rel_offset = section->sh_offset;
7315           rel_size   = section->sh_size;
7316
7317           if (rel_size)
7318             {
7319               Elf_Internal_Shdr * strsec;
7320               int is_rela;
7321               unsigned long num_rela;
7322
7323               printf (_("\nRelocation section "));
7324
7325               if (filedata->string_table == NULL)
7326                 printf ("%d", section->sh_name);
7327               else
7328                 printf ("'%s'", printable_section_name (filedata, section));
7329
7330               num_rela = rel_size / section->sh_entsize;
7331               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7332                                 " at offset 0x%lx contains %lu entries:\n",
7333                                 num_rela),
7334                       rel_offset, num_rela);
7335
7336               is_rela = section->sh_type == SHT_RELA;
7337
7338               if (section->sh_link != 0
7339                   && section->sh_link < filedata->file_header.e_shnum)
7340                 {
7341                   Elf_Internal_Shdr * symsec;
7342                   Elf_Internal_Sym *  symtab;
7343                   unsigned long nsyms;
7344                   unsigned long strtablen = 0;
7345                   char * strtab = NULL;
7346
7347                   symsec = filedata->section_headers + section->sh_link;
7348                   if (symsec->sh_type != SHT_SYMTAB
7349                       && symsec->sh_type != SHT_DYNSYM)
7350                     continue;
7351
7352                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7353
7354                   if (symtab == NULL)
7355                     continue;
7356
7357                   if (symsec->sh_link != 0
7358                       && symsec->sh_link < filedata->file_header.e_shnum)
7359                     {
7360                       strsec = filedata->section_headers + symsec->sh_link;
7361
7362                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7363                                                   1, strsec->sh_size,
7364                                                   _("string table"));
7365                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7366                     }
7367
7368                   dump_relocations (filedata, rel_offset, rel_size,
7369                                     symtab, nsyms, strtab, strtablen,
7370                                     is_rela,
7371                                     symsec->sh_type == SHT_DYNSYM);
7372                   if (strtab)
7373                     free (strtab);
7374                   free (symtab);
7375                 }
7376               else
7377                 dump_relocations (filedata, rel_offset, rel_size,
7378                                   NULL, 0, NULL, 0, is_rela,
7379                                   FALSE /* is_dynamic */);
7380
7381               found = TRUE;
7382             }
7383         }
7384
7385       if (! found)
7386         {
7387           /* Users sometimes forget the -D option, so try to be helpful.  */
7388           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7389             {
7390               if (dynamic_info [dynamic_relocations [i].size])
7391                 {
7392                   printf (_("\nThere are no static relocations in this file."));
7393                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7394
7395                   break;
7396                 }
7397             }
7398           if (i == ARRAY_SIZE (dynamic_relocations))
7399             printf (_("\nThere are no relocations in this file.\n"));
7400         }
7401     }
7402
7403   return TRUE;
7404 }
7405
7406 /* An absolute address consists of a section and an offset.  If the
7407    section is NULL, the offset itself is the address, otherwise, the
7408    address equals to LOAD_ADDRESS(section) + offset.  */
7409
7410 struct absaddr
7411 {
7412   unsigned short section;
7413   bfd_vma offset;
7414 };
7415
7416 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7417    name, if found, and the offset from the symbol to ADDR.  */
7418
7419 static void
7420 find_symbol_for_address (Filedata *          filedata,
7421                          Elf_Internal_Sym *  symtab,
7422                          unsigned long       nsyms,
7423                          const char *        strtab,
7424                          unsigned long       strtab_size,
7425                          struct absaddr      addr,
7426                          const char **       symname,
7427                          bfd_vma *           offset)
7428 {
7429   bfd_vma dist = 0x100000;
7430   Elf_Internal_Sym * sym;
7431   Elf_Internal_Sym * beg;
7432   Elf_Internal_Sym * end;
7433   Elf_Internal_Sym * best = NULL;
7434
7435   REMOVE_ARCH_BITS (addr.offset);
7436   beg = symtab;
7437   end = symtab + nsyms;
7438
7439   while (beg < end)
7440     {
7441       bfd_vma value;
7442
7443       sym = beg + (end - beg) / 2;
7444
7445       value = sym->st_value;
7446       REMOVE_ARCH_BITS (value);
7447
7448       if (sym->st_name != 0
7449           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7450           && addr.offset >= value
7451           && addr.offset - value < dist)
7452         {
7453           best = sym;
7454           dist = addr.offset - value;
7455           if (!dist)
7456             break;
7457         }
7458
7459       if (addr.offset < value)
7460         end = sym;
7461       else
7462         beg = sym + 1;
7463     }
7464
7465   if (best)
7466     {
7467       *symname = (best->st_name >= strtab_size
7468                   ? _("<corrupt>") : strtab + best->st_name);
7469       *offset = dist;
7470       return;
7471     }
7472
7473   *symname = NULL;
7474   *offset = addr.offset;
7475 }
7476
7477 static /* signed */ int
7478 symcmp (const void *p, const void *q)
7479 {
7480   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7481   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7482
7483   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7484 }
7485
7486 /* Process the unwind section.  */
7487
7488 #include "unwind-ia64.h"
7489
7490 struct ia64_unw_table_entry
7491 {
7492   struct absaddr start;
7493   struct absaddr end;
7494   struct absaddr info;
7495 };
7496
7497 struct ia64_unw_aux_info
7498 {
7499   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7500   unsigned long                 table_len;      /* Length of unwind table.  */
7501   unsigned char *               info;           /* Unwind info.  */
7502   unsigned long                 info_size;      /* Size of unwind info.  */
7503   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7504   bfd_vma                       seg_base;       /* Starting address of segment.  */
7505   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7506   unsigned long                 nsyms;          /* Number of symbols.  */
7507   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7508   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7509   char *                        strtab;         /* The string table.  */
7510   unsigned long                 strtab_size;    /* Size of string table.  */
7511 };
7512
7513 static bfd_boolean
7514 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7515 {
7516   struct ia64_unw_table_entry * tp;
7517   unsigned long j, nfuns;
7518   int in_body;
7519   bfd_boolean res = TRUE;
7520
7521   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7522   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7523     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7524       aux->funtab[nfuns++] = aux->symtab[j];
7525   aux->nfuns = nfuns;
7526   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7527
7528   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7529     {
7530       bfd_vma stamp;
7531       bfd_vma offset;
7532       const unsigned char * dp;
7533       const unsigned char * head;
7534       const unsigned char * end;
7535       const char * procname;
7536
7537       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7538                                aux->strtab_size, tp->start, &procname, &offset);
7539
7540       fputs ("\n<", stdout);
7541
7542       if (procname)
7543         {
7544           fputs (procname, stdout);
7545
7546           if (offset)
7547             printf ("+%lx", (unsigned long) offset);
7548         }
7549
7550       fputs (">: [", stdout);
7551       print_vma (tp->start.offset, PREFIX_HEX);
7552       fputc ('-', stdout);
7553       print_vma (tp->end.offset, PREFIX_HEX);
7554       printf ("], info at +0x%lx\n",
7555               (unsigned long) (tp->info.offset - aux->seg_base));
7556
7557       /* PR 17531: file: 86232b32.  */
7558       if (aux->info == NULL)
7559         continue;
7560
7561       offset = tp->info.offset;
7562       if (tp->info.section)
7563         {
7564           if (tp->info.section >= filedata->file_header.e_shnum)
7565             {
7566               warn (_("Invalid section %u in table entry %ld\n"),
7567                     tp->info.section, (long) (tp - aux->table));
7568               res = FALSE;
7569               continue;
7570             }
7571           offset += filedata->section_headers[tp->info.section].sh_addr;
7572         }
7573       offset -= aux->info_addr;
7574       /* PR 17531: file: 0997b4d1.  */
7575       if (offset >= aux->info_size
7576           || aux->info_size - offset < 8)
7577         {
7578           warn (_("Invalid offset %lx in table entry %ld\n"),
7579                 (long) tp->info.offset, (long) (tp - aux->table));
7580           res = FALSE;
7581           continue;
7582         }
7583
7584       head = aux->info + offset;
7585       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7586
7587       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7588               (unsigned) UNW_VER (stamp),
7589               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7590               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7591               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7592               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7593
7594       if (UNW_VER (stamp) != 1)
7595         {
7596           printf (_("\tUnknown version.\n"));
7597           continue;
7598         }
7599
7600       in_body = 0;
7601       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7602       /* PR 17531: file: 16ceda89.  */
7603       if (end > aux->info + aux->info_size)
7604         end = aux->info + aux->info_size;
7605       for (dp = head + 8; dp < end;)
7606         dp = unw_decode (dp, in_body, & in_body, end);
7607     }
7608
7609   free (aux->funtab);
7610
7611   return res;
7612 }
7613
7614 static bfd_boolean
7615 slurp_ia64_unwind_table (Filedata *                  filedata,
7616                          struct ia64_unw_aux_info *  aux,
7617                          Elf_Internal_Shdr *         sec)
7618 {
7619   unsigned long size, nrelas, i;
7620   Elf_Internal_Phdr * seg;
7621   struct ia64_unw_table_entry * tep;
7622   Elf_Internal_Shdr * relsec;
7623   Elf_Internal_Rela * rela;
7624   Elf_Internal_Rela * rp;
7625   unsigned char * table;
7626   unsigned char * tp;
7627   Elf_Internal_Sym * sym;
7628   const char * relname;
7629
7630   aux->table_len = 0;
7631
7632   /* First, find the starting address of the segment that includes
7633      this section: */
7634
7635   if (filedata->file_header.e_phnum)
7636     {
7637       if (! get_program_headers (filedata))
7638           return FALSE;
7639
7640       for (seg = filedata->program_headers;
7641            seg < filedata->program_headers + filedata->file_header.e_phnum;
7642            ++seg)
7643         {
7644           if (seg->p_type != PT_LOAD)
7645             continue;
7646
7647           if (sec->sh_addr >= seg->p_vaddr
7648               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7649             {
7650               aux->seg_base = seg->p_vaddr;
7651               break;
7652             }
7653         }
7654     }
7655
7656   /* Second, build the unwind table from the contents of the unwind section:  */
7657   size = sec->sh_size;
7658   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7659                                       _("unwind table"));
7660   if (!table)
7661     return FALSE;
7662
7663   aux->table_len = size / (3 * eh_addr_size);
7664   aux->table = (struct ia64_unw_table_entry *)
7665     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7666   tep = aux->table;
7667
7668   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7669     {
7670       tep->start.section = SHN_UNDEF;
7671       tep->end.section   = SHN_UNDEF;
7672       tep->info.section  = SHN_UNDEF;
7673       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7674       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7675       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7676       tep->start.offset += aux->seg_base;
7677       tep->end.offset   += aux->seg_base;
7678       tep->info.offset  += aux->seg_base;
7679     }
7680   free (table);
7681
7682   /* Third, apply any relocations to the unwind table:  */
7683   for (relsec = filedata->section_headers;
7684        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7685        ++relsec)
7686     {
7687       if (relsec->sh_type != SHT_RELA
7688           || relsec->sh_info >= filedata->file_header.e_shnum
7689           || filedata->section_headers + relsec->sh_info != sec)
7690         continue;
7691
7692       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7693                               & rela, & nrelas))
7694         {
7695           free (aux->table);
7696           aux->table = NULL;
7697           aux->table_len = 0;
7698           return FALSE;
7699         }
7700
7701       for (rp = rela; rp < rela + nrelas; ++rp)
7702         {
7703           unsigned int sym_ndx;
7704           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7705           relname = elf_ia64_reloc_type (r_type);
7706
7707           /* PR 17531: file: 9fa67536.  */
7708           if (relname == NULL)
7709             {
7710               warn (_("Skipping unknown relocation type: %u\n"), r_type);
7711               continue;
7712             }
7713
7714           if (! const_strneq (relname, "R_IA64_SEGREL"))
7715             {
7716               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7717               continue;
7718             }
7719
7720           i = rp->r_offset / (3 * eh_addr_size);
7721
7722           /* PR 17531: file: 5bc8d9bf.  */
7723           if (i >= aux->table_len)
7724             {
7725               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7726               continue;
7727             }
7728
7729           sym_ndx = get_reloc_symindex (rp->r_info);
7730           if (sym_ndx >= aux->nsyms)
7731             {
7732               warn (_("Skipping reloc with invalid symbol index: %u\n"),
7733                     sym_ndx);
7734               continue;
7735             }
7736           sym = aux->symtab + sym_ndx;
7737
7738           switch (rp->r_offset / eh_addr_size % 3)
7739             {
7740             case 0:
7741               aux->table[i].start.section = sym->st_shndx;
7742               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7743               break;
7744             case 1:
7745               aux->table[i].end.section   = sym->st_shndx;
7746               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7747               break;
7748             case 2:
7749               aux->table[i].info.section  = sym->st_shndx;
7750               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7751               break;
7752             default:
7753               break;
7754             }
7755         }
7756
7757       free (rela);
7758     }
7759
7760   return TRUE;
7761 }
7762
7763 static bfd_boolean
7764 ia64_process_unwind (Filedata * filedata)
7765 {
7766   Elf_Internal_Shdr * sec;
7767   Elf_Internal_Shdr * unwsec = NULL;
7768   Elf_Internal_Shdr * strsec;
7769   unsigned long i, unwcount = 0, unwstart = 0;
7770   struct ia64_unw_aux_info aux;
7771   bfd_boolean res = TRUE;
7772
7773   memset (& aux, 0, sizeof (aux));
7774
7775   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7776     {
7777       if (sec->sh_type == SHT_SYMTAB
7778           && sec->sh_link < filedata->file_header.e_shnum)
7779         {
7780           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7781
7782           strsec = filedata->section_headers + sec->sh_link;
7783           if (aux.strtab != NULL)
7784             {
7785               error (_("Multiple auxillary string tables encountered\n"));
7786               free (aux.strtab);
7787               res = FALSE;
7788             }
7789           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7790                                           1, strsec->sh_size,
7791                                           _("string table"));
7792           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7793         }
7794       else if (sec->sh_type == SHT_IA_64_UNWIND)
7795         unwcount++;
7796     }
7797
7798   if (!unwcount)
7799     printf (_("\nThere are no unwind sections in this file.\n"));
7800
7801   while (unwcount-- > 0)
7802     {
7803       char * suffix;
7804       size_t len, len2;
7805
7806       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7807            i < filedata->file_header.e_shnum; ++i, ++sec)
7808         if (sec->sh_type == SHT_IA_64_UNWIND)
7809           {
7810             unwsec = sec;
7811             break;
7812           }
7813       /* We have already counted the number of SHT_IA64_UNWIND
7814          sections so the loop above should never fail.  */
7815       assert (unwsec != NULL);
7816
7817       unwstart = i + 1;
7818       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7819
7820       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7821         {
7822           /* We need to find which section group it is in.  */
7823           struct group_list * g;
7824
7825           if (section_headers_groups == NULL
7826               || section_headers_groups [i] == NULL)
7827             i = filedata->file_header.e_shnum;
7828           else
7829             {
7830               g = section_headers_groups [i]->root;
7831
7832               for (; g != NULL; g = g->next)
7833                 {
7834                   sec = filedata->section_headers + g->section_index;
7835
7836                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7837                     break;
7838                 }
7839
7840               if (g == NULL)
7841                 i = filedata->file_header.e_shnum;
7842             }
7843         }
7844       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7845         {
7846           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7847           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7848           suffix = SECTION_NAME (unwsec) + len;
7849           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7850                ++i, ++sec)
7851             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7852                 && streq (SECTION_NAME (sec) + len2, suffix))
7853               break;
7854         }
7855       else
7856         {
7857           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7858              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7859           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7860           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7861           suffix = "";
7862           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7863             suffix = SECTION_NAME (unwsec) + len;
7864           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7865                ++i, ++sec)
7866             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7867                 && streq (SECTION_NAME (sec) + len2, suffix))
7868               break;
7869         }
7870
7871       if (i == filedata->file_header.e_shnum)
7872         {
7873           printf (_("\nCould not find unwind info section for "));
7874
7875           if (filedata->string_table == NULL)
7876             printf ("%d", unwsec->sh_name);
7877           else
7878             printf ("'%s'", printable_section_name (filedata, unwsec));
7879         }
7880       else
7881         {
7882           aux.info_addr = sec->sh_addr;
7883           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7884                                                  sec->sh_size,
7885                                                  _("unwind info"));
7886           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7887
7888           printf (_("\nUnwind section "));
7889
7890           if (filedata->string_table == NULL)
7891             printf ("%d", unwsec->sh_name);
7892           else
7893             printf ("'%s'", printable_section_name (filedata, unwsec));
7894
7895           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7896                   (unsigned long) unwsec->sh_offset,
7897                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7898
7899           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7900               && aux.table_len > 0)
7901             dump_ia64_unwind (filedata, & aux);
7902
7903           if (aux.table)
7904             free ((char *) aux.table);
7905           if (aux.info)
7906             free ((char *) aux.info);
7907           aux.table = NULL;
7908           aux.info = NULL;
7909         }
7910     }
7911
7912   if (aux.symtab)
7913     free (aux.symtab);
7914   if (aux.strtab)
7915     free ((char *) aux.strtab);
7916
7917   return res;
7918 }
7919
7920 struct hppa_unw_table_entry
7921 {
7922   struct absaddr start;
7923   struct absaddr end;
7924   unsigned int Cannot_unwind:1;                 /* 0 */
7925   unsigned int Millicode:1;                     /* 1 */
7926   unsigned int Millicode_save_sr0:1;            /* 2 */
7927   unsigned int Region_description:2;            /* 3..4 */
7928   unsigned int reserved1:1;                     /* 5 */
7929   unsigned int Entry_SR:1;                      /* 6 */
7930   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7931   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7932   unsigned int Args_stored:1;                   /* 16 */
7933   unsigned int Variable_Frame:1;                /* 17 */
7934   unsigned int Separate_Package_Body:1;         /* 18 */
7935   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7936   unsigned int Stack_Overflow_Check:1;          /* 20 */
7937   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7938   unsigned int Ada_Region:1;                    /* 22 */
7939   unsigned int cxx_info:1;                      /* 23 */
7940   unsigned int cxx_try_catch:1;                 /* 24 */
7941   unsigned int sched_entry_seq:1;               /* 25 */
7942   unsigned int reserved2:1;                     /* 26 */
7943   unsigned int Save_SP:1;                       /* 27 */
7944   unsigned int Save_RP:1;                       /* 28 */
7945   unsigned int Save_MRP_in_frame:1;             /* 29 */
7946   unsigned int extn_ptr_defined:1;              /* 30 */
7947   unsigned int Cleanup_defined:1;               /* 31 */
7948
7949   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7950   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7951   unsigned int Large_frame:1;                   /* 2 */
7952   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7953   unsigned int reserved4:1;                     /* 4 */
7954   unsigned int Total_frame_size:27;             /* 5..31 */
7955 };
7956
7957 struct hppa_unw_aux_info
7958 {
7959   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7960   unsigned long                  table_len;     /* Length of unwind table.  */
7961   bfd_vma                        seg_base;      /* Starting address of segment.  */
7962   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7963   unsigned long                  nsyms;         /* Number of symbols.  */
7964   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7965   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7966   char *                         strtab;        /* The string table.  */
7967   unsigned long                  strtab_size;   /* Size of string table.  */
7968 };
7969
7970 static bfd_boolean
7971 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7972 {
7973   struct hppa_unw_table_entry * tp;
7974   unsigned long j, nfuns;
7975   bfd_boolean res = TRUE;
7976
7977   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7978   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7979     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7980       aux->funtab[nfuns++] = aux->symtab[j];
7981   aux->nfuns = nfuns;
7982   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7983
7984   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7985     {
7986       bfd_vma offset;
7987       const char * procname;
7988
7989       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7990                                aux->strtab_size, tp->start, &procname,
7991                                &offset);
7992
7993       fputs ("\n<", stdout);
7994
7995       if (procname)
7996         {
7997           fputs (procname, stdout);
7998
7999           if (offset)
8000             printf ("+%lx", (unsigned long) offset);
8001         }
8002
8003       fputs (">: [", stdout);
8004       print_vma (tp->start.offset, PREFIX_HEX);
8005       fputc ('-', stdout);
8006       print_vma (tp->end.offset, PREFIX_HEX);
8007       printf ("]\n\t");
8008
8009 #define PF(_m) if (tp->_m) printf (#_m " ");
8010 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8011       PF(Cannot_unwind);
8012       PF(Millicode);
8013       PF(Millicode_save_sr0);
8014       /* PV(Region_description);  */
8015       PF(Entry_SR);
8016       PV(Entry_FR);
8017       PV(Entry_GR);
8018       PF(Args_stored);
8019       PF(Variable_Frame);
8020       PF(Separate_Package_Body);
8021       PF(Frame_Extension_Millicode);
8022       PF(Stack_Overflow_Check);
8023       PF(Two_Instruction_SP_Increment);
8024       PF(Ada_Region);
8025       PF(cxx_info);
8026       PF(cxx_try_catch);
8027       PF(sched_entry_seq);
8028       PF(Save_SP);
8029       PF(Save_RP);
8030       PF(Save_MRP_in_frame);
8031       PF(extn_ptr_defined);
8032       PF(Cleanup_defined);
8033       PF(MPE_XL_interrupt_marker);
8034       PF(HP_UX_interrupt_marker);
8035       PF(Large_frame);
8036       PF(Pseudo_SP_Set);
8037       PV(Total_frame_size);
8038 #undef PF
8039 #undef PV
8040     }
8041
8042   printf ("\n");
8043
8044   free (aux->funtab);
8045
8046   return res;
8047 }
8048
8049 static bfd_boolean
8050 slurp_hppa_unwind_table (Filedata *                  filedata,
8051                          struct hppa_unw_aux_info *  aux,
8052                          Elf_Internal_Shdr *         sec)
8053 {
8054   unsigned long size, unw_ent_size, nentries, nrelas, i;
8055   Elf_Internal_Phdr * seg;
8056   struct hppa_unw_table_entry * tep;
8057   Elf_Internal_Shdr * relsec;
8058   Elf_Internal_Rela * rela;
8059   Elf_Internal_Rela * rp;
8060   unsigned char * table;
8061   unsigned char * tp;
8062   Elf_Internal_Sym * sym;
8063   const char * relname;
8064
8065   /* First, find the starting address of the segment that includes
8066      this section.  */
8067   if (filedata->file_header.e_phnum)
8068     {
8069       if (! get_program_headers (filedata))
8070         return FALSE;
8071
8072       for (seg = filedata->program_headers;
8073            seg < filedata->program_headers + filedata->file_header.e_phnum;
8074            ++seg)
8075         {
8076           if (seg->p_type != PT_LOAD)
8077             continue;
8078
8079           if (sec->sh_addr >= seg->p_vaddr
8080               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
8081             {
8082               aux->seg_base = seg->p_vaddr;
8083               break;
8084             }
8085         }
8086     }
8087
8088   /* Second, build the unwind table from the contents of the unwind
8089      section.  */
8090   size = sec->sh_size;
8091   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
8092                                       _("unwind table"));
8093   if (!table)
8094     return FALSE;
8095
8096   unw_ent_size = 16;
8097   nentries = size / unw_ent_size;
8098   size = unw_ent_size * nentries;
8099
8100   tep = aux->table = (struct hppa_unw_table_entry *)
8101       xcmalloc (nentries, sizeof (aux->table[0]));
8102
8103   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8104     {
8105       unsigned int tmp1, tmp2;
8106
8107       tep->start.section = SHN_UNDEF;
8108       tep->end.section   = SHN_UNDEF;
8109
8110       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8111       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8112       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8113       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8114
8115       tep->start.offset += aux->seg_base;
8116       tep->end.offset   += aux->seg_base;
8117
8118       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8119       tep->Millicode = (tmp1 >> 30) & 0x1;
8120       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8121       tep->Region_description = (tmp1 >> 27) & 0x3;
8122       tep->reserved1 = (tmp1 >> 26) & 0x1;
8123       tep->Entry_SR = (tmp1 >> 25) & 0x1;
8124       tep->Entry_FR = (tmp1 >> 21) & 0xf;
8125       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8126       tep->Args_stored = (tmp1 >> 15) & 0x1;
8127       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8128       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8129       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8130       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8131       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8132       tep->Ada_Region = (tmp1 >> 9) & 0x1;
8133       tep->cxx_info = (tmp1 >> 8) & 0x1;
8134       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8135       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8136       tep->reserved2 = (tmp1 >> 5) & 0x1;
8137       tep->Save_SP = (tmp1 >> 4) & 0x1;
8138       tep->Save_RP = (tmp1 >> 3) & 0x1;
8139       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8140       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8141       tep->Cleanup_defined = tmp1 & 0x1;
8142
8143       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8144       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8145       tep->Large_frame = (tmp2 >> 29) & 0x1;
8146       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8147       tep->reserved4 = (tmp2 >> 27) & 0x1;
8148       tep->Total_frame_size = tmp2 & 0x7ffffff;
8149     }
8150   free (table);
8151
8152   /* Third, apply any relocations to the unwind table.  */
8153   for (relsec = filedata->section_headers;
8154        relsec < filedata->section_headers + filedata->file_header.e_shnum;
8155        ++relsec)
8156     {
8157       if (relsec->sh_type != SHT_RELA
8158           || relsec->sh_info >= filedata->file_header.e_shnum
8159           || filedata->section_headers + relsec->sh_info != sec)
8160         continue;
8161
8162       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8163                               & rela, & nrelas))
8164         return FALSE;
8165
8166       for (rp = rela; rp < rela + nrelas; ++rp)
8167         {
8168           unsigned int sym_ndx;
8169           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8170           relname = elf_hppa_reloc_type (r_type);
8171
8172           if (relname == NULL)
8173             {
8174               warn (_("Skipping unknown relocation type: %u\n"), r_type);
8175               continue;
8176             }
8177
8178           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
8179           if (! const_strneq (relname, "R_PARISC_SEGREL"))
8180             {
8181               warn (_("Skipping unexpected relocation type: %s\n"), relname);
8182               continue;
8183             }
8184
8185           i = rp->r_offset / unw_ent_size;
8186           if (i >= aux->table_len)
8187             {
8188               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8189               continue;
8190             }
8191
8192           sym_ndx = get_reloc_symindex (rp->r_info);
8193           if (sym_ndx >= aux->nsyms)
8194             {
8195               warn (_("Skipping reloc with invalid symbol index: %u\n"),
8196                     sym_ndx);
8197               continue;
8198             }
8199           sym = aux->symtab + sym_ndx;
8200
8201           switch ((rp->r_offset % unw_ent_size) / 4)
8202             {
8203             case 0:
8204               aux->table[i].start.section = sym->st_shndx;
8205               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
8206               break;
8207             case 1:
8208               aux->table[i].end.section   = sym->st_shndx;
8209               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
8210               break;
8211             default:
8212               break;
8213             }
8214         }
8215
8216       free (rela);
8217     }
8218
8219   aux->table_len = nentries;
8220
8221   return TRUE;
8222 }
8223
8224 static bfd_boolean
8225 hppa_process_unwind (Filedata * filedata)
8226 {
8227   struct hppa_unw_aux_info aux;
8228   Elf_Internal_Shdr * unwsec = NULL;
8229   Elf_Internal_Shdr * strsec;
8230   Elf_Internal_Shdr * sec;
8231   unsigned long i;
8232   bfd_boolean res = TRUE;
8233
8234   if (filedata->string_table == NULL)
8235     return FALSE;
8236
8237   memset (& aux, 0, sizeof (aux));
8238
8239   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8240     {
8241       if (sec->sh_type == SHT_SYMTAB
8242           && sec->sh_link < filedata->file_header.e_shnum)
8243         {
8244           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8245
8246           strsec = filedata->section_headers + sec->sh_link;
8247           if (aux.strtab != NULL)
8248             {
8249               error (_("Multiple auxillary string tables encountered\n"));
8250               free (aux.strtab);
8251               res = FALSE;
8252             }
8253           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8254                                           1, strsec->sh_size,
8255                                           _("string table"));
8256           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8257         }
8258       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8259         unwsec = sec;
8260     }
8261
8262   if (!unwsec)
8263     printf (_("\nThere are no unwind sections in this file.\n"));
8264
8265   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8266     {
8267       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8268         {
8269           unsigned long num_unwind = sec->sh_size / 16;
8270
8271           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8272                             "contains %lu entry:\n",
8273                             "\nUnwind section '%s' at offset 0x%lx "
8274                             "contains %lu entries:\n",
8275                             num_unwind),
8276                   printable_section_name (filedata, sec),
8277                   (unsigned long) sec->sh_offset,
8278                   num_unwind);
8279
8280           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8281             res = FALSE;
8282
8283           if (res && aux.table_len > 0)
8284             {
8285               if (! dump_hppa_unwind (filedata, &aux))
8286                 res = FALSE;
8287             }
8288
8289           if (aux.table)
8290             free ((char *) aux.table);
8291           aux.table = NULL;
8292         }
8293     }
8294
8295   if (aux.symtab)
8296     free (aux.symtab);
8297   if (aux.strtab)
8298     free ((char *) aux.strtab);
8299
8300   return res;
8301 }
8302
8303 struct arm_section
8304 {
8305   unsigned char *      data;            /* The unwind data.  */
8306   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8307   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8308   unsigned long        nrelas;          /* The number of relocations.  */
8309   unsigned int         rel_type;        /* REL or RELA ?  */
8310   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8311 };
8312
8313 struct arm_unw_aux_info
8314 {
8315   Filedata *          filedata;         /* The file containing the unwind sections.  */
8316   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8317   unsigned long       nsyms;            /* Number of symbols.  */
8318   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8319   unsigned long       nfuns;            /* Number of these symbols.  */
8320   char *              strtab;           /* The file's string table.  */
8321   unsigned long       strtab_size;      /* Size of string table.  */
8322 };
8323
8324 static const char *
8325 arm_print_vma_and_name (Filedata *                 filedata,
8326                         struct arm_unw_aux_info *  aux,
8327                         bfd_vma                    fn,
8328                         struct absaddr             addr)
8329 {
8330   const char *procname;
8331   bfd_vma sym_offset;
8332
8333   if (addr.section == SHN_UNDEF)
8334     addr.offset = fn;
8335
8336   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8337                            aux->strtab_size, addr, &procname,
8338                            &sym_offset);
8339
8340   print_vma (fn, PREFIX_HEX);
8341
8342   if (procname)
8343     {
8344       fputs (" <", stdout);
8345       fputs (procname, stdout);
8346
8347       if (sym_offset)
8348         printf ("+0x%lx", (unsigned long) sym_offset);
8349       fputc ('>', stdout);
8350     }
8351
8352   return procname;
8353 }
8354
8355 static void
8356 arm_free_section (struct arm_section *arm_sec)
8357 {
8358   if (arm_sec->data != NULL)
8359     free (arm_sec->data);
8360
8361   if (arm_sec->rela != NULL)
8362     free (arm_sec->rela);
8363 }
8364
8365 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8366       cached section and install SEC instead.
8367    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8368       and return its valued in * WORDP, relocating if necessary.
8369    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8370       relocation's offset in ADDR.
8371    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8372       into the string table of the symbol associated with the reloc.  If no
8373       reloc was applied store -1 there.
8374    5) Return TRUE upon success, FALSE otherwise.  */
8375
8376 static bfd_boolean
8377 get_unwind_section_word (Filedata *                 filedata,
8378                          struct arm_unw_aux_info *  aux,
8379                          struct arm_section *       arm_sec,
8380                          Elf_Internal_Shdr *        sec,
8381                          bfd_vma                    word_offset,
8382                          unsigned int *             wordp,
8383                          struct absaddr *           addr,
8384                          bfd_vma *                  sym_name)
8385 {
8386   Elf_Internal_Rela *rp;
8387   Elf_Internal_Sym *sym;
8388   const char * relname;
8389   unsigned int word;
8390   bfd_boolean wrapped;
8391
8392   if (sec == NULL || arm_sec == NULL)
8393     return FALSE;
8394
8395   addr->section = SHN_UNDEF;
8396   addr->offset = 0;
8397
8398   if (sym_name != NULL)
8399     *sym_name = (bfd_vma) -1;
8400
8401   /* If necessary, update the section cache.  */
8402   if (sec != arm_sec->sec)
8403     {
8404       Elf_Internal_Shdr *relsec;
8405
8406       arm_free_section (arm_sec);
8407
8408       arm_sec->sec = sec;
8409       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8410                                 sec->sh_size, _("unwind data"));
8411       arm_sec->rela = NULL;
8412       arm_sec->nrelas = 0;
8413
8414       for (relsec = filedata->section_headers;
8415            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8416            ++relsec)
8417         {
8418           if (relsec->sh_info >= filedata->file_header.e_shnum
8419               || filedata->section_headers + relsec->sh_info != sec
8420               /* PR 15745: Check the section type as well.  */
8421               || (relsec->sh_type != SHT_REL
8422                   && relsec->sh_type != SHT_RELA))
8423             continue;
8424
8425           arm_sec->rel_type = relsec->sh_type;
8426           if (relsec->sh_type == SHT_REL)
8427             {
8428               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8429                                      relsec->sh_size,
8430                                      & arm_sec->rela, & arm_sec->nrelas))
8431                 return FALSE;
8432             }
8433           else /* relsec->sh_type == SHT_RELA */
8434             {
8435               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8436                                       relsec->sh_size,
8437                                       & arm_sec->rela, & arm_sec->nrelas))
8438                 return FALSE;
8439             }
8440           break;
8441         }
8442
8443       arm_sec->next_rela = arm_sec->rela;
8444     }
8445
8446   /* If there is no unwind data we can do nothing.  */
8447   if (arm_sec->data == NULL)
8448     return FALSE;
8449
8450   /* If the offset is invalid then fail.  */
8451   if (/* PR 21343 *//* PR 18879 */
8452       sec->sh_size < 4
8453       || word_offset > (sec->sh_size - 4)
8454       || ((bfd_signed_vma) word_offset) < 0)
8455     return FALSE;
8456
8457   /* Get the word at the required offset.  */
8458   word = byte_get (arm_sec->data + word_offset, 4);
8459
8460   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8461   if (arm_sec->rela == NULL)
8462     {
8463       * wordp = word;
8464       return TRUE;
8465     }
8466
8467   /* Look through the relocs to find the one that applies to the provided offset.  */
8468   wrapped = FALSE;
8469   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8470     {
8471       bfd_vma prelval, offset;
8472
8473       if (rp->r_offset > word_offset && !wrapped)
8474         {
8475           rp = arm_sec->rela;
8476           wrapped = TRUE;
8477         }
8478       if (rp->r_offset > word_offset)
8479         break;
8480
8481       if (rp->r_offset & 3)
8482         {
8483           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8484                 (unsigned long) rp->r_offset);
8485           continue;
8486         }
8487
8488       if (rp->r_offset < word_offset)
8489         continue;
8490
8491       /* PR 17531: file: 027-161405-0.004  */
8492       if (aux->symtab == NULL)
8493         continue;
8494
8495       if (arm_sec->rel_type == SHT_REL)
8496         {
8497           offset = word & 0x7fffffff;
8498           if (offset & 0x40000000)
8499             offset |= ~ (bfd_vma) 0x7fffffff;
8500         }
8501       else if (arm_sec->rel_type == SHT_RELA)
8502         offset = rp->r_addend;
8503       else
8504         {
8505           error (_("Unknown section relocation type %d encountered\n"),
8506                  arm_sec->rel_type);
8507           break;
8508         }
8509
8510       /* PR 17531 file: 027-1241568-0.004.  */
8511       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8512         {
8513           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8514                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8515           break;
8516         }
8517
8518       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8519       offset += sym->st_value;
8520       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8521
8522       /* Check that we are processing the expected reloc type.  */
8523       if (filedata->file_header.e_machine == EM_ARM)
8524         {
8525           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8526           if (relname == NULL)
8527             {
8528               warn (_("Skipping unknown ARM relocation type: %d\n"),
8529                     (int) ELF32_R_TYPE (rp->r_info));
8530               continue;
8531             }
8532
8533           if (streq (relname, "R_ARM_NONE"))
8534               continue;
8535
8536           if (! streq (relname, "R_ARM_PREL31"))
8537             {
8538               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8539               continue;
8540             }
8541         }
8542       else if (filedata->file_header.e_machine == EM_TI_C6000)
8543         {
8544           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8545           if (relname == NULL)
8546             {
8547               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8548                     (int) ELF32_R_TYPE (rp->r_info));
8549               continue;
8550             }
8551
8552           if (streq (relname, "R_C6000_NONE"))
8553             continue;
8554
8555           if (! streq (relname, "R_C6000_PREL31"))
8556             {
8557               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8558               continue;
8559             }
8560
8561           prelval >>= 1;
8562         }
8563       else
8564         {
8565           /* This function currently only supports ARM and TI unwinders.  */
8566           warn (_("Only TI and ARM unwinders are currently supported\n"));
8567           break;
8568         }
8569
8570       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8571       addr->section = sym->st_shndx;
8572       addr->offset = offset;
8573
8574       if (sym_name)
8575         * sym_name = sym->st_name;
8576       break;
8577     }
8578
8579   *wordp = word;
8580   arm_sec->next_rela = rp;
8581
8582   return TRUE;
8583 }
8584
8585 static const char *tic6x_unwind_regnames[16] =
8586 {
8587   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8588   "A14", "A13", "A12", "A11", "A10",
8589   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8590 };
8591
8592 static void
8593 decode_tic6x_unwind_regmask (unsigned int mask)
8594 {
8595   int i;
8596
8597   for (i = 12; mask; mask >>= 1, i--)
8598     {
8599       if (mask & 1)
8600         {
8601           fputs (tic6x_unwind_regnames[i], stdout);
8602           if (mask > 1)
8603             fputs (", ", stdout);
8604         }
8605     }
8606 }
8607
8608 #define ADVANCE                                                 \
8609   if (remaining == 0 && more_words)                             \
8610     {                                                           \
8611       data_offset += 4;                                         \
8612       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8613                                      data_offset, & word, & addr, NULL))        \
8614         return FALSE;                                           \
8615       remaining = 4;                                            \
8616       more_words--;                                             \
8617     }                                                           \
8618
8619 #define GET_OP(OP)                      \
8620   ADVANCE;                              \
8621   if (remaining)                        \
8622     {                                   \
8623       remaining--;                      \
8624       (OP) = word >> 24;                \
8625       word <<= 8;                       \
8626     }                                   \
8627   else                                  \
8628     {                                   \
8629       printf (_("[Truncated opcode]\n"));       \
8630       return FALSE;                     \
8631     }                                   \
8632   printf ("0x%02x ", OP)
8633
8634 static bfd_boolean
8635 decode_arm_unwind_bytecode (Filedata *                 filedata,
8636                             struct arm_unw_aux_info *  aux,
8637                             unsigned int               word,
8638                             unsigned int               remaining,
8639                             unsigned int               more_words,
8640                             bfd_vma                    data_offset,
8641                             Elf_Internal_Shdr *        data_sec,
8642                             struct arm_section *       data_arm_sec)
8643 {
8644   struct absaddr addr;
8645   bfd_boolean res = TRUE;
8646
8647   /* Decode the unwinding instructions.  */
8648   while (1)
8649     {
8650       unsigned int op, op2;
8651
8652       ADVANCE;
8653       if (remaining == 0)
8654         break;
8655       remaining--;
8656       op = word >> 24;
8657       word <<= 8;
8658
8659       printf ("  0x%02x ", op);
8660
8661       if ((op & 0xc0) == 0x00)
8662         {
8663           int offset = ((op & 0x3f) << 2) + 4;
8664
8665           printf ("     vsp = vsp + %d", offset);
8666         }
8667       else if ((op & 0xc0) == 0x40)
8668         {
8669           int offset = ((op & 0x3f) << 2) + 4;
8670
8671           printf ("     vsp = vsp - %d", offset);
8672         }
8673       else if ((op & 0xf0) == 0x80)
8674         {
8675           GET_OP (op2);
8676           if (op == 0x80 && op2 == 0)
8677             printf (_("Refuse to unwind"));
8678           else
8679             {
8680               unsigned int mask = ((op & 0x0f) << 8) | op2;
8681               bfd_boolean first = TRUE;
8682               int i;
8683
8684               printf ("pop {");
8685               for (i = 0; i < 12; i++)
8686                 if (mask & (1 << i))
8687                   {
8688                     if (first)
8689                       first = FALSE;
8690                     else
8691                       printf (", ");
8692                     printf ("r%d", 4 + i);
8693                   }
8694               printf ("}");
8695             }
8696         }
8697       else if ((op & 0xf0) == 0x90)
8698         {
8699           if (op == 0x9d || op == 0x9f)
8700             printf (_("     [Reserved]"));
8701           else
8702             printf ("     vsp = r%d", op & 0x0f);
8703         }
8704       else if ((op & 0xf0) == 0xa0)
8705         {
8706           int end = 4 + (op & 0x07);
8707           bfd_boolean first = TRUE;
8708           int i;
8709
8710           printf ("     pop {");
8711           for (i = 4; i <= end; i++)
8712             {
8713               if (first)
8714                 first = FALSE;
8715               else
8716                 printf (", ");
8717               printf ("r%d", i);
8718             }
8719           if (op & 0x08)
8720             {
8721               if (!first)
8722                 printf (", ");
8723               printf ("r14");
8724             }
8725           printf ("}");
8726         }
8727       else if (op == 0xb0)
8728         printf (_("     finish"));
8729       else if (op == 0xb1)
8730         {
8731           GET_OP (op2);
8732           if (op2 == 0 || (op2 & 0xf0) != 0)
8733             printf (_("[Spare]"));
8734           else
8735             {
8736               unsigned int mask = op2 & 0x0f;
8737               bfd_boolean first = TRUE;
8738               int i;
8739
8740               printf ("pop {");
8741               for (i = 0; i < 12; i++)
8742                 if (mask & (1 << i))
8743                   {
8744                     if (first)
8745                       first = FALSE;
8746                     else
8747                       printf (", ");
8748                     printf ("r%d", i);
8749                   }
8750               printf ("}");
8751             }
8752         }
8753       else if (op == 0xb2)
8754         {
8755           unsigned char buf[9];
8756           unsigned int i, len;
8757           unsigned long offset;
8758
8759           for (i = 0; i < sizeof (buf); i++)
8760             {
8761               GET_OP (buf[i]);
8762               if ((buf[i] & 0x80) == 0)
8763                 break;
8764             }
8765           if (i == sizeof (buf))
8766             {
8767               error (_("corrupt change to vsp"));
8768               res = FALSE;
8769             }
8770           else
8771             {
8772               offset = read_uleb128 (buf, &len, buf + i + 1);
8773               assert (len == i + 1);
8774               offset = offset * 4 + 0x204;
8775               printf ("vsp = vsp + %ld", offset);
8776             }
8777         }
8778       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8779         {
8780           unsigned int first, last;
8781
8782           GET_OP (op2);
8783           first = op2 >> 4;
8784           last = op2 & 0x0f;
8785           if (op == 0xc8)
8786             first = first + 16;
8787           printf ("pop {D%d", first);
8788           if (last)
8789             printf ("-D%d", first + last);
8790           printf ("}");
8791         }
8792       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8793         {
8794           unsigned int count = op & 0x07;
8795
8796           printf ("pop {D8");
8797           if (count)
8798             printf ("-D%d", 8 + count);
8799           printf ("}");
8800         }
8801       else if (op >= 0xc0 && op <= 0xc5)
8802         {
8803           unsigned int count = op & 0x07;
8804
8805           printf ("     pop {wR10");
8806           if (count)
8807             printf ("-wR%d", 10 + count);
8808           printf ("}");
8809         }
8810       else if (op == 0xc6)
8811         {
8812           unsigned int first, last;
8813
8814           GET_OP (op2);
8815           first = op2 >> 4;
8816           last = op2 & 0x0f;
8817           printf ("pop {wR%d", first);
8818           if (last)
8819             printf ("-wR%d", first + last);
8820           printf ("}");
8821         }
8822       else if (op == 0xc7)
8823         {
8824           GET_OP (op2);
8825           if (op2 == 0 || (op2 & 0xf0) != 0)
8826             printf (_("[Spare]"));
8827           else
8828             {
8829               unsigned int mask = op2 & 0x0f;
8830               bfd_boolean first = TRUE;
8831               int i;
8832
8833               printf ("pop {");
8834               for (i = 0; i < 4; i++)
8835                 if (mask & (1 << i))
8836                   {
8837                     if (first)
8838                       first = FALSE;
8839                     else
8840                       printf (", ");
8841                     printf ("wCGR%d", i);
8842                   }
8843               printf ("}");
8844             }
8845         }
8846       else
8847         {
8848           printf (_("     [unsupported opcode]"));
8849           res = FALSE;
8850         }
8851
8852       printf ("\n");
8853     }
8854
8855   return res;
8856 }
8857
8858 static bfd_boolean
8859 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8860                               struct arm_unw_aux_info *  aux,
8861                               unsigned int               word,
8862                               unsigned int               remaining,
8863                               unsigned int               more_words,
8864                               bfd_vma                    data_offset,
8865                               Elf_Internal_Shdr *        data_sec,
8866                               struct arm_section *       data_arm_sec)
8867 {
8868   struct absaddr addr;
8869
8870   /* Decode the unwinding instructions.  */
8871   while (1)
8872     {
8873       unsigned int op, op2;
8874
8875       ADVANCE;
8876       if (remaining == 0)
8877         break;
8878       remaining--;
8879       op = word >> 24;
8880       word <<= 8;
8881
8882       printf ("  0x%02x ", op);
8883
8884       if ((op & 0xc0) == 0x00)
8885         {
8886           int offset = ((op & 0x3f) << 3) + 8;
8887           printf ("     sp = sp + %d", offset);
8888         }
8889       else if ((op & 0xc0) == 0x80)
8890         {
8891           GET_OP (op2);
8892           if (op == 0x80 && op2 == 0)
8893             printf (_("Refuse to unwind"));
8894           else
8895             {
8896               unsigned int mask = ((op & 0x1f) << 8) | op2;
8897               if (op & 0x20)
8898                 printf ("pop compact {");
8899               else
8900                 printf ("pop {");
8901
8902               decode_tic6x_unwind_regmask (mask);
8903               printf("}");
8904             }
8905         }
8906       else if ((op & 0xf0) == 0xc0)
8907         {
8908           unsigned int reg;
8909           unsigned int nregs;
8910           unsigned int i;
8911           const char *name;
8912           struct
8913           {
8914             unsigned int offset;
8915             unsigned int reg;
8916           } regpos[16];
8917
8918           /* Scan entire instruction first so that GET_OP output is not
8919              interleaved with disassembly.  */
8920           nregs = 0;
8921           for (i = 0; nregs < (op & 0xf); i++)
8922             {
8923               GET_OP (op2);
8924               reg = op2 >> 4;
8925               if (reg != 0xf)
8926                 {
8927                   regpos[nregs].offset = i * 2;
8928                   regpos[nregs].reg = reg;
8929                   nregs++;
8930                 }
8931
8932               reg = op2 & 0xf;
8933               if (reg != 0xf)
8934                 {
8935                   regpos[nregs].offset = i * 2 + 1;
8936                   regpos[nregs].reg = reg;
8937                   nregs++;
8938                 }
8939             }
8940
8941           printf (_("pop frame {"));
8942           if (nregs == 0)
8943             {
8944               printf (_("*corrupt* - no registers specified"));
8945             }
8946           else
8947             {
8948               reg = nregs - 1;
8949               for (i = i * 2; i > 0; i--)
8950                 {
8951                   if (regpos[reg].offset == i - 1)
8952                     {
8953                       name = tic6x_unwind_regnames[regpos[reg].reg];
8954                       if (reg > 0)
8955                         reg--;
8956                     }
8957                   else
8958                     name = _("[pad]");
8959
8960                   fputs (name, stdout);
8961                   if (i > 1)
8962                     printf (", ");
8963                 }
8964             }
8965
8966           printf ("}");
8967         }
8968       else if (op == 0xd0)
8969         printf ("     MOV FP, SP");
8970       else if (op == 0xd1)
8971         printf ("     __c6xabi_pop_rts");
8972       else if (op == 0xd2)
8973         {
8974           unsigned char buf[9];
8975           unsigned int i, len;
8976           unsigned long offset;
8977
8978           for (i = 0; i < sizeof (buf); i++)
8979             {
8980               GET_OP (buf[i]);
8981               if ((buf[i] & 0x80) == 0)
8982                 break;
8983             }
8984           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8985           if (i == sizeof (buf))
8986             {
8987               warn (_("Corrupt stack pointer adjustment detected\n"));
8988               return FALSE;
8989             }
8990
8991           offset = read_uleb128 (buf, &len, buf + i + 1);
8992           assert (len == i + 1);
8993           offset = offset * 8 + 0x408;
8994           printf (_("sp = sp + %ld"), offset);
8995         }
8996       else if ((op & 0xf0) == 0xe0)
8997         {
8998           if ((op & 0x0f) == 7)
8999             printf ("     RETURN");
9000           else
9001             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
9002         }
9003       else
9004         {
9005           printf (_("     [unsupported opcode]"));
9006         }
9007       putchar ('\n');
9008     }
9009
9010   return TRUE;
9011 }
9012
9013 static bfd_vma
9014 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
9015 {
9016   bfd_vma offset;
9017
9018   offset = word & 0x7fffffff;
9019   if (offset & 0x40000000)
9020     offset |= ~ (bfd_vma) 0x7fffffff;
9021
9022   if (filedata->file_header.e_machine == EM_TI_C6000)
9023     offset <<= 1;
9024
9025   return offset + where;
9026 }
9027
9028 static bfd_boolean
9029 decode_arm_unwind (Filedata *                 filedata,
9030                    struct arm_unw_aux_info *  aux,
9031                    unsigned int               word,
9032                    unsigned int               remaining,
9033                    bfd_vma                    data_offset,
9034                    Elf_Internal_Shdr *        data_sec,
9035                    struct arm_section *       data_arm_sec)
9036 {
9037   int per_index;
9038   unsigned int more_words = 0;
9039   struct absaddr addr;
9040   bfd_vma sym_name = (bfd_vma) -1;
9041   bfd_boolean res = TRUE;
9042
9043   if (remaining == 0)
9044     {
9045       /* Fetch the first word.
9046          Note - when decoding an object file the address extracted
9047          here will always be 0.  So we also pass in the sym_name
9048          parameter so that we can find the symbol associated with
9049          the personality routine.  */
9050       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
9051                                      & word, & addr, & sym_name))
9052         return FALSE;
9053
9054       remaining = 4;
9055     }
9056   else
9057     {
9058       addr.section = SHN_UNDEF;
9059       addr.offset = 0;
9060     }
9061
9062   if ((word & 0x80000000) == 0)
9063     {
9064       /* Expand prel31 for personality routine.  */
9065       bfd_vma fn;
9066       const char *procname;
9067
9068       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
9069       printf (_("  Personality routine: "));
9070       if (fn == 0
9071           && addr.section == SHN_UNDEF && addr.offset == 0
9072           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
9073         {
9074           procname = aux->strtab + sym_name;
9075           print_vma (fn, PREFIX_HEX);
9076           if (procname)
9077             {
9078               fputs (" <", stdout);
9079               fputs (procname, stdout);
9080               fputc ('>', stdout);
9081             }
9082         }
9083       else
9084         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
9085       fputc ('\n', stdout);
9086
9087       /* The GCC personality routines use the standard compact
9088          encoding, starting with one byte giving the number of
9089          words.  */
9090       if (procname != NULL
9091           && (const_strneq (procname, "__gcc_personality_v0")
9092               || const_strneq (procname, "__gxx_personality_v0")
9093               || const_strneq (procname, "__gcj_personality_v0")
9094               || const_strneq (procname, "__gnu_objc_personality_v0")))
9095         {
9096           remaining = 0;
9097           more_words = 1;
9098           ADVANCE;
9099           if (!remaining)
9100             {
9101               printf (_("  [Truncated data]\n"));
9102               return FALSE;
9103             }
9104           more_words = word >> 24;
9105           word <<= 8;
9106           remaining--;
9107           per_index = -1;
9108         }
9109       else
9110         return TRUE;
9111     }
9112   else
9113     {
9114       /* ARM EHABI Section 6.3:
9115
9116          An exception-handling table entry for the compact model looks like:
9117
9118            31 30-28 27-24 23-0
9119            -- ----- ----- ----
9120             1   0   index Data for personalityRoutine[index]    */
9121
9122       if (filedata->file_header.e_machine == EM_ARM
9123           && (word & 0x70000000))
9124         {
9125           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9126           res = FALSE;
9127         }
9128
9129       per_index = (word >> 24) & 0x7f;
9130       printf (_("  Compact model index: %d\n"), per_index);
9131       if (per_index == 0)
9132         {
9133           more_words = 0;
9134           word <<= 8;
9135           remaining--;
9136         }
9137       else if (per_index < 3)
9138         {
9139           more_words = (word >> 16) & 0xff;
9140           word <<= 16;
9141           remaining -= 2;
9142         }
9143     }
9144
9145   switch (filedata->file_header.e_machine)
9146     {
9147     case EM_ARM:
9148       if (per_index < 3)
9149         {
9150           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9151                                             data_offset, data_sec, data_arm_sec))
9152             res = FALSE;
9153         }
9154       else
9155         {
9156           warn (_("Unknown ARM compact model index encountered\n"));
9157           printf (_("  [reserved]\n"));
9158           res = FALSE;
9159         }
9160       break;
9161
9162     case EM_TI_C6000:
9163       if (per_index < 3)
9164         {
9165           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9166                                               data_offset, data_sec, data_arm_sec))
9167             res = FALSE;
9168         }
9169       else if (per_index < 5)
9170         {
9171           if (((word >> 17) & 0x7f) == 0x7f)
9172             printf (_("  Restore stack from frame pointer\n"));
9173           else
9174             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
9175           printf (_("  Registers restored: "));
9176           if (per_index == 4)
9177             printf (" (compact) ");
9178           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9179           putchar ('\n');
9180           printf (_("  Return register: %s\n"),
9181                   tic6x_unwind_regnames[word & 0xf]);
9182         }
9183       else
9184         printf (_("  [reserved (%d)]\n"), per_index);
9185       break;
9186
9187     default:
9188       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9189              filedata->file_header.e_machine);
9190       res = FALSE;
9191     }
9192
9193   /* Decode the descriptors.  Not implemented.  */
9194
9195   return res;
9196 }
9197
9198 static bfd_boolean
9199 dump_arm_unwind (Filedata *                 filedata,
9200                  struct arm_unw_aux_info *  aux,
9201                  Elf_Internal_Shdr *        exidx_sec)
9202 {
9203   struct arm_section exidx_arm_sec, extab_arm_sec;
9204   unsigned int i, exidx_len;
9205   unsigned long j, nfuns;
9206   bfd_boolean res = TRUE;
9207
9208   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9209   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9210   exidx_len = exidx_sec->sh_size / 8;
9211
9212   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9213   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9214     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9215       aux->funtab[nfuns++] = aux->symtab[j];
9216   aux->nfuns = nfuns;
9217   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9218
9219   for (i = 0; i < exidx_len; i++)
9220     {
9221       unsigned int exidx_fn, exidx_entry;
9222       struct absaddr fn_addr, entry_addr;
9223       bfd_vma fn;
9224
9225       fputc ('\n', stdout);
9226
9227       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9228                                      8 * i, & exidx_fn, & fn_addr, NULL)
9229           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9230                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9231         {
9232           free (aux->funtab);
9233           arm_free_section (& exidx_arm_sec);
9234           arm_free_section (& extab_arm_sec);
9235           return FALSE;
9236         }
9237
9238       /* ARM EHABI, Section 5:
9239          An index table entry consists of 2 words.
9240          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9241       if (exidx_fn & 0x80000000)
9242         {
9243           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9244           res = FALSE;
9245         }
9246
9247       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9248
9249       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9250       fputs (": ", stdout);
9251
9252       if (exidx_entry == 1)
9253         {
9254           print_vma (exidx_entry, PREFIX_HEX);
9255           fputs (" [cantunwind]\n", stdout);
9256         }
9257       else if (exidx_entry & 0x80000000)
9258         {
9259           print_vma (exidx_entry, PREFIX_HEX);
9260           fputc ('\n', stdout);
9261           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9262         }
9263       else
9264         {
9265           bfd_vma table, table_offset = 0;
9266           Elf_Internal_Shdr *table_sec;
9267
9268           fputs ("@", stdout);
9269           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9270           print_vma (table, PREFIX_HEX);
9271           printf ("\n");
9272
9273           /* Locate the matching .ARM.extab.  */
9274           if (entry_addr.section != SHN_UNDEF
9275               && entry_addr.section < filedata->file_header.e_shnum)
9276             {
9277               table_sec = filedata->section_headers + entry_addr.section;
9278               table_offset = entry_addr.offset;
9279               /* PR 18879 */
9280               if (table_offset > table_sec->sh_size
9281                   || ((bfd_signed_vma) table_offset) < 0)
9282                 {
9283                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9284                         (unsigned long) table_offset,
9285                         printable_section_name (filedata, table_sec));
9286                   res = FALSE;
9287                   continue;
9288                 }
9289             }
9290           else
9291             {
9292               table_sec = find_section_by_address (filedata, table);
9293               if (table_sec != NULL)
9294                 table_offset = table - table_sec->sh_addr;
9295             }
9296
9297           if (table_sec == NULL)
9298             {
9299               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9300                     (unsigned long) table);
9301               res = FALSE;
9302               continue;
9303             }
9304
9305           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9306                                    &extab_arm_sec))
9307             res = FALSE;
9308         }
9309     }
9310
9311   printf ("\n");
9312
9313   free (aux->funtab);
9314   arm_free_section (&exidx_arm_sec);
9315   arm_free_section (&extab_arm_sec);
9316
9317   return res;
9318 }
9319
9320 /* Used for both ARM and C6X unwinding tables.  */
9321
9322 static bfd_boolean
9323 arm_process_unwind (Filedata * filedata)
9324 {
9325   struct arm_unw_aux_info aux;
9326   Elf_Internal_Shdr *unwsec = NULL;
9327   Elf_Internal_Shdr *strsec;
9328   Elf_Internal_Shdr *sec;
9329   unsigned long i;
9330   unsigned int sec_type;
9331   bfd_boolean res = TRUE;
9332
9333   switch (filedata->file_header.e_machine)
9334     {
9335     case EM_ARM:
9336       sec_type = SHT_ARM_EXIDX;
9337       break;
9338
9339     case EM_TI_C6000:
9340       sec_type = SHT_C6000_UNWIND;
9341       break;
9342
9343     default:
9344       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9345              filedata->file_header.e_machine);
9346       return FALSE;
9347     }
9348
9349   if (filedata->string_table == NULL)
9350     return FALSE;
9351
9352   memset (& aux, 0, sizeof (aux));
9353   aux.filedata = filedata;
9354
9355   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9356     {
9357       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9358         {
9359           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9360
9361           strsec = filedata->section_headers + sec->sh_link;
9362
9363           /* PR binutils/17531 file: 011-12666-0.004.  */
9364           if (aux.strtab != NULL)
9365             {
9366               error (_("Multiple string tables found in file.\n"));
9367               free (aux.strtab);
9368               res = FALSE;
9369             }
9370           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9371                                  1, strsec->sh_size, _("string table"));
9372           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9373         }
9374       else if (sec->sh_type == sec_type)
9375         unwsec = sec;
9376     }
9377
9378   if (unwsec == NULL)
9379     printf (_("\nThere are no unwind sections in this file.\n"));
9380   else
9381     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9382       {
9383         if (sec->sh_type == sec_type)
9384           {
9385             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9386             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9387                               "contains %lu entry:\n",
9388                               "\nUnwind section '%s' at offset 0x%lx "
9389                               "contains %lu entries:\n",
9390                               num_unwind),
9391                     printable_section_name (filedata, sec),
9392                     (unsigned long) sec->sh_offset,
9393                     num_unwind);
9394
9395             if (! dump_arm_unwind (filedata, &aux, sec))
9396               res = FALSE;
9397           }
9398       }
9399
9400   if (aux.symtab)
9401     free (aux.symtab);
9402   if (aux.strtab)
9403     free ((char *) aux.strtab);
9404
9405   return res;
9406 }
9407
9408 static bfd_boolean
9409 process_unwind (Filedata * filedata)
9410 {
9411   struct unwind_handler
9412   {
9413     unsigned int machtype;
9414     bfd_boolean (* handler)(Filedata *);
9415   } handlers[] =
9416   {
9417     { EM_ARM, arm_process_unwind },
9418     { EM_IA_64, ia64_process_unwind },
9419     { EM_PARISC, hppa_process_unwind },
9420     { EM_TI_C6000, arm_process_unwind },
9421     { 0, NULL }
9422   };
9423   int i;
9424
9425   if (!do_unwind)
9426     return TRUE;
9427
9428   for (i = 0; handlers[i].handler != NULL; i++)
9429     if (filedata->file_header.e_machine == handlers[i].machtype)
9430       return handlers[i].handler (filedata);
9431
9432   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9433           get_machine_name (filedata->file_header.e_machine));
9434   return TRUE;
9435 }
9436
9437 static void
9438 dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
9439 {
9440   switch (entry->d_tag)
9441     {
9442     case DT_AARCH64_BTI_PLT:
9443     case DT_AARCH64_PAC_PLT:
9444       break;
9445     default:
9446       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9447       break;
9448     }
9449   putchar ('\n');
9450 }
9451
9452 static void
9453 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9454 {
9455   switch (entry->d_tag)
9456     {
9457     case DT_MIPS_FLAGS:
9458       if (entry->d_un.d_val == 0)
9459         printf (_("NONE"));
9460       else
9461         {
9462           static const char * opts[] =
9463           {
9464             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9465             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9466             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9467             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9468             "RLD_ORDER_SAFE"
9469           };
9470           unsigned int cnt;
9471           bfd_boolean first = TRUE;
9472
9473           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9474             if (entry->d_un.d_val & (1 << cnt))
9475               {
9476                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9477                 first = FALSE;
9478               }
9479         }
9480       break;
9481
9482     case DT_MIPS_IVERSION:
9483       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9484         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9485       else
9486         {
9487           char buf[40];
9488           sprintf_vma (buf, entry->d_un.d_ptr);
9489           /* Note: coded this way so that there is a single string for translation.  */
9490           printf (_("<corrupt: %s>"), buf);
9491         }
9492       break;
9493
9494     case DT_MIPS_TIME_STAMP:
9495       {
9496         char timebuf[128];
9497         struct tm * tmp;
9498         time_t atime = entry->d_un.d_val;
9499
9500         tmp = gmtime (&atime);
9501         /* PR 17531: file: 6accc532.  */
9502         if (tmp == NULL)
9503           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9504         else
9505           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9506                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9507                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9508         printf (_("Time Stamp: %s"), timebuf);
9509       }
9510       break;
9511
9512     case DT_MIPS_RLD_VERSION:
9513     case DT_MIPS_LOCAL_GOTNO:
9514     case DT_MIPS_CONFLICTNO:
9515     case DT_MIPS_LIBLISTNO:
9516     case DT_MIPS_SYMTABNO:
9517     case DT_MIPS_UNREFEXTNO:
9518     case DT_MIPS_HIPAGENO:
9519     case DT_MIPS_DELTA_CLASS_NO:
9520     case DT_MIPS_DELTA_INSTANCE_NO:
9521     case DT_MIPS_DELTA_RELOC_NO:
9522     case DT_MIPS_DELTA_SYM_NO:
9523     case DT_MIPS_DELTA_CLASSSYM_NO:
9524     case DT_MIPS_COMPACT_SIZE:
9525       print_vma (entry->d_un.d_val, DEC);
9526       break;
9527
9528     default:
9529       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9530     }
9531     putchar ('\n');
9532 }
9533
9534 static void
9535 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9536 {
9537   switch (entry->d_tag)
9538     {
9539     case DT_HP_DLD_FLAGS:
9540       {
9541         static struct
9542         {
9543           long int bit;
9544           const char * str;
9545         }
9546         flags[] =
9547         {
9548           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9549           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9550           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9551           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9552           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9553           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9554           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9555           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9556           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9557           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9558           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9559           { DT_HP_GST, "HP_GST" },
9560           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9561           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9562           { DT_HP_NODELETE, "HP_NODELETE" },
9563           { DT_HP_GROUP, "HP_GROUP" },
9564           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9565         };
9566         bfd_boolean first = TRUE;
9567         size_t cnt;
9568         bfd_vma val = entry->d_un.d_val;
9569
9570         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9571           if (val & flags[cnt].bit)
9572             {
9573               if (! first)
9574                 putchar (' ');
9575               fputs (flags[cnt].str, stdout);
9576               first = FALSE;
9577               val ^= flags[cnt].bit;
9578             }
9579
9580         if (val != 0 || first)
9581           {
9582             if (! first)
9583               putchar (' ');
9584             print_vma (val, HEX);
9585           }
9586       }
9587       break;
9588
9589     default:
9590       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9591       break;
9592     }
9593   putchar ('\n');
9594 }
9595
9596 #ifdef BFD64
9597
9598 /* VMS vs Unix time offset and factor.  */
9599
9600 #define VMS_EPOCH_OFFSET 35067168000000000LL
9601 #define VMS_GRANULARITY_FACTOR 10000000
9602
9603 /* Display a VMS time in a human readable format.  */
9604
9605 static void
9606 print_vms_time (bfd_int64_t vmstime)
9607 {
9608   struct tm *tm;
9609   time_t unxtime;
9610
9611   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9612   tm = gmtime (&unxtime);
9613   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9614           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9615           tm->tm_hour, tm->tm_min, tm->tm_sec);
9616 }
9617 #endif /* BFD64 */
9618
9619 static void
9620 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9621 {
9622   switch (entry->d_tag)
9623     {
9624     case DT_IA_64_PLT_RESERVE:
9625       /* First 3 slots reserved.  */
9626       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9627       printf (" -- ");
9628       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9629       break;
9630
9631     case DT_IA_64_VMS_LINKTIME:
9632 #ifdef BFD64
9633       print_vms_time (entry->d_un.d_val);
9634 #endif
9635       break;
9636
9637     case DT_IA_64_VMS_LNKFLAGS:
9638       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9639       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9640         printf (" CALL_DEBUG");
9641       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9642         printf (" NOP0BUFS");
9643       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9644         printf (" P0IMAGE");
9645       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9646         printf (" MKTHREADS");
9647       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9648         printf (" UPCALLS");
9649       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9650         printf (" IMGSTA");
9651       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9652         printf (" INITIALIZE");
9653       if (entry->d_un.d_val & VMS_LF_MAIN)
9654         printf (" MAIN");
9655       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9656         printf (" EXE_INIT");
9657       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9658         printf (" TBK_IN_IMG");
9659       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9660         printf (" DBG_IN_IMG");
9661       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9662         printf (" TBK_IN_DSF");
9663       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9664         printf (" DBG_IN_DSF");
9665       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9666         printf (" SIGNATURES");
9667       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9668         printf (" REL_SEG_OFF");
9669       break;
9670
9671     default:
9672       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9673       break;
9674     }
9675   putchar ('\n');
9676 }
9677
9678 static bfd_boolean
9679 get_32bit_dynamic_section (Filedata * filedata)
9680 {
9681   Elf32_External_Dyn * edyn;
9682   Elf32_External_Dyn * ext;
9683   Elf_Internal_Dyn * entry;
9684
9685   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9686                                           dynamic_size, _("dynamic section"));
9687   if (!edyn)
9688     return FALSE;
9689
9690   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9691      might not have the luxury of section headers.  Look for the DT_NULL
9692      terminator to determine the number of entries.  */
9693   for (ext = edyn, dynamic_nent = 0;
9694        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9695        ext++)
9696     {
9697       dynamic_nent++;
9698       if (BYTE_GET (ext->d_tag) == DT_NULL)
9699         break;
9700     }
9701
9702   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9703                                                   sizeof (* entry));
9704   if (dynamic_section == NULL)
9705     {
9706       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9707              (unsigned long) dynamic_nent);
9708       free (edyn);
9709       return FALSE;
9710     }
9711
9712   for (ext = edyn, entry = dynamic_section;
9713        entry < dynamic_section + dynamic_nent;
9714        ext++, entry++)
9715     {
9716       entry->d_tag      = BYTE_GET (ext->d_tag);
9717       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9718     }
9719
9720   free (edyn);
9721
9722   return TRUE;
9723 }
9724
9725 static bfd_boolean
9726 get_64bit_dynamic_section (Filedata * filedata)
9727 {
9728   Elf64_External_Dyn * edyn;
9729   Elf64_External_Dyn * ext;
9730   Elf_Internal_Dyn * entry;
9731
9732   /* Read in the data.  */
9733   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9734                                           dynamic_size, _("dynamic section"));
9735   if (!edyn)
9736     return FALSE;
9737
9738   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9739      might not have the luxury of section headers.  Look for the DT_NULL
9740      terminator to determine the number of entries.  */
9741   for (ext = edyn, dynamic_nent = 0;
9742        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9743        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9744        ext++)
9745     {
9746       dynamic_nent++;
9747       if (BYTE_GET (ext->d_tag) == DT_NULL)
9748         break;
9749     }
9750
9751   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9752                                                   sizeof (* entry));
9753   if (dynamic_section == NULL)
9754     {
9755       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9756              (unsigned long) dynamic_nent);
9757       free (edyn);
9758       return FALSE;
9759     }
9760
9761   /* Convert from external to internal formats.  */
9762   for (ext = edyn, entry = dynamic_section;
9763        entry < dynamic_section + dynamic_nent;
9764        ext++, entry++)
9765     {
9766       entry->d_tag      = BYTE_GET (ext->d_tag);
9767       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9768     }
9769
9770   free (edyn);
9771
9772   return TRUE;
9773 }
9774
9775 static void
9776 print_dynamic_flags (bfd_vma flags)
9777 {
9778   bfd_boolean first = TRUE;
9779
9780   while (flags)
9781     {
9782       bfd_vma flag;
9783
9784       flag = flags & - flags;
9785       flags &= ~ flag;
9786
9787       if (first)
9788         first = FALSE;
9789       else
9790         putc (' ', stdout);
9791
9792       switch (flag)
9793         {
9794         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9795         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9796         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9797         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9798         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9799         default:                fputs (_("unknown"), stdout); break;
9800         }
9801     }
9802   puts ("");
9803 }
9804
9805 /* Parse and display the contents of the dynamic section.  */
9806
9807 static bfd_boolean
9808 process_dynamic_section (Filedata * filedata)
9809 {
9810   Elf_Internal_Dyn * entry;
9811
9812   if (dynamic_size == 0)
9813     {
9814       if (do_dynamic)
9815         printf (_("\nThere is no dynamic section in this file.\n"));
9816
9817       return TRUE;
9818     }
9819
9820   if (is_32bit_elf)
9821     {
9822       if (! get_32bit_dynamic_section (filedata))
9823         return FALSE;
9824     }
9825   else
9826     {
9827       if (! get_64bit_dynamic_section (filedata))
9828         return FALSE;
9829     }
9830
9831   /* Find the appropriate symbol table.  */
9832   if (dynamic_symbols == NULL)
9833     {
9834       for (entry = dynamic_section;
9835            entry < dynamic_section + dynamic_nent;
9836            ++entry)
9837         {
9838           Elf_Internal_Shdr section;
9839
9840           if (entry->d_tag != DT_SYMTAB)
9841             continue;
9842
9843           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9844
9845           /* Since we do not know how big the symbol table is,
9846              we default to reading in the entire file (!) and
9847              processing that.  This is overkill, I know, but it
9848              should work.  */
9849           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9850           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9851             {
9852               /* See PR 21379 for a reproducer.  */
9853               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9854               return FALSE;
9855             }
9856
9857           if (archive_file_offset != 0)
9858             section.sh_size = archive_file_size - section.sh_offset;
9859           else
9860             section.sh_size = filedata->file_size - section.sh_offset;
9861
9862           if (is_32bit_elf)
9863             section.sh_entsize = sizeof (Elf32_External_Sym);
9864           else
9865             section.sh_entsize = sizeof (Elf64_External_Sym);
9866           section.sh_name = filedata->string_table_length;
9867
9868           if (dynamic_symbols != NULL)
9869             {
9870               error (_("Multiple dynamic symbol table sections found\n"));
9871               free (dynamic_symbols);
9872             }
9873           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9874           if (num_dynamic_syms < 1)
9875             {
9876               error (_("Unable to determine the number of symbols to load\n"));
9877               continue;
9878             }
9879         }
9880     }
9881
9882   /* Similarly find a string table.  */
9883   if (dynamic_strings == NULL)
9884     {
9885       for (entry = dynamic_section;
9886            entry < dynamic_section + dynamic_nent;
9887            ++entry)
9888         {
9889           unsigned long offset;
9890           long str_tab_len;
9891
9892           if (entry->d_tag != DT_STRTAB)
9893             continue;
9894
9895           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9896
9897           /* Since we do not know how big the string table is,
9898              we default to reading in the entire file (!) and
9899              processing that.  This is overkill, I know, but it
9900              should work.  */
9901
9902           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9903
9904           if (archive_file_offset != 0)
9905             str_tab_len = archive_file_size - offset;
9906           else
9907             str_tab_len = filedata->file_size - offset;
9908
9909           if (str_tab_len < 1)
9910             {
9911               error
9912                 (_("Unable to determine the length of the dynamic string table\n"));
9913               continue;
9914             }
9915
9916           if (dynamic_strings != NULL)
9917             {
9918               error (_("Multiple dynamic string tables found\n"));
9919               free (dynamic_strings);
9920             }
9921
9922           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9923                                                str_tab_len,
9924                                                _("dynamic string table"));
9925           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9926         }
9927     }
9928
9929   /* And find the syminfo section if available.  */
9930   if (dynamic_syminfo == NULL)
9931     {
9932       unsigned long syminsz = 0;
9933
9934       for (entry = dynamic_section;
9935            entry < dynamic_section + dynamic_nent;
9936            ++entry)
9937         {
9938           if (entry->d_tag == DT_SYMINENT)
9939             {
9940               /* Note: these braces are necessary to avoid a syntax
9941                  error from the SunOS4 C compiler.  */
9942               /* PR binutils/17531: A corrupt file can trigger this test.
9943                  So do not use an assert, instead generate an error message.  */
9944               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9945                 error (_("Bad value (%d) for SYMINENT entry\n"),
9946                        (int) entry->d_un.d_val);
9947             }
9948           else if (entry->d_tag == DT_SYMINSZ)
9949             syminsz = entry->d_un.d_val;
9950           else if (entry->d_tag == DT_SYMINFO)
9951             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9952                                                       syminsz);
9953         }
9954
9955       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9956         {
9957           Elf_External_Syminfo * extsyminfo;
9958           Elf_External_Syminfo * extsym;
9959           Elf_Internal_Syminfo * syminfo;
9960
9961           /* There is a syminfo section.  Read the data.  */
9962           extsyminfo = (Elf_External_Syminfo *)
9963               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9964                         _("symbol information"));
9965           if (!extsyminfo)
9966             return FALSE;
9967
9968           if (dynamic_syminfo != NULL)
9969             {
9970               error (_("Multiple dynamic symbol information sections found\n"));
9971               free (dynamic_syminfo);
9972             }
9973           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9974           if (dynamic_syminfo == NULL)
9975             {
9976               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9977                      (unsigned long) syminsz);
9978               return FALSE;
9979             }
9980
9981           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9982           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9983                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9984                ++syminfo, ++extsym)
9985             {
9986               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9987               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9988             }
9989
9990           free (extsyminfo);
9991         }
9992     }
9993
9994   if (do_dynamic && dynamic_addr)
9995     printf (ngettext ("\nDynamic section at offset 0x%lx "
9996                       "contains %lu entry:\n",
9997                       "\nDynamic section at offset 0x%lx "
9998                       "contains %lu entries:\n",
9999                       dynamic_nent),
10000             dynamic_addr, (unsigned long) dynamic_nent);
10001   if (do_dynamic)
10002     printf (_("  Tag        Type                         Name/Value\n"));
10003
10004   for (entry = dynamic_section;
10005        entry < dynamic_section + dynamic_nent;
10006        entry++)
10007     {
10008       if (do_dynamic)
10009         {
10010           const char * dtype;
10011
10012           putchar (' ');
10013           print_vma (entry->d_tag, FULL_HEX);
10014           dtype = get_dynamic_type (filedata, entry->d_tag);
10015           printf (" (%s)%*s", dtype,
10016                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
10017         }
10018
10019       switch (entry->d_tag)
10020         {
10021         case DT_FLAGS:
10022           if (do_dynamic)
10023             print_dynamic_flags (entry->d_un.d_val);
10024           break;
10025
10026         case DT_AUXILIARY:
10027         case DT_FILTER:
10028         case DT_CONFIG:
10029         case DT_DEPAUDIT:
10030         case DT_AUDIT:
10031           if (do_dynamic)
10032             {
10033               switch (entry->d_tag)
10034                 {
10035                 case DT_AUXILIARY:
10036                   printf (_("Auxiliary library"));
10037                   break;
10038
10039                 case DT_FILTER:
10040                   printf (_("Filter library"));
10041                   break;
10042
10043                 case DT_CONFIG:
10044                   printf (_("Configuration file"));
10045                   break;
10046
10047                 case DT_DEPAUDIT:
10048                   printf (_("Dependency audit library"));
10049                   break;
10050
10051                 case DT_AUDIT:
10052                   printf (_("Audit library"));
10053                   break;
10054                 }
10055
10056               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10057                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
10058               else
10059                 {
10060                   printf (": ");
10061                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10062                   putchar ('\n');
10063                 }
10064             }
10065           break;
10066
10067         case DT_FEATURE:
10068           if (do_dynamic)
10069             {
10070               printf (_("Flags:"));
10071
10072               if (entry->d_un.d_val == 0)
10073                 printf (_(" None\n"));
10074               else
10075                 {
10076                   unsigned long int val = entry->d_un.d_val;
10077
10078                   if (val & DTF_1_PARINIT)
10079                     {
10080                       printf (" PARINIT");
10081                       val ^= DTF_1_PARINIT;
10082                     }
10083                   if (val & DTF_1_CONFEXP)
10084                     {
10085                       printf (" CONFEXP");
10086                       val ^= DTF_1_CONFEXP;
10087                     }
10088                   if (val != 0)
10089                     printf (" %lx", val);
10090                   puts ("");
10091                 }
10092             }
10093           break;
10094
10095         case DT_POSFLAG_1:
10096           if (do_dynamic)
10097             {
10098               printf (_("Flags:"));
10099
10100               if (entry->d_un.d_val == 0)
10101                 printf (_(" None\n"));
10102               else
10103                 {
10104                   unsigned long int val = entry->d_un.d_val;
10105
10106                   if (val & DF_P1_LAZYLOAD)
10107                     {
10108                       printf (" LAZYLOAD");
10109                       val ^= DF_P1_LAZYLOAD;
10110                     }
10111                   if (val & DF_P1_GROUPPERM)
10112                     {
10113                       printf (" GROUPPERM");
10114                       val ^= DF_P1_GROUPPERM;
10115                     }
10116                   if (val != 0)
10117                     printf (" %lx", val);
10118                   puts ("");
10119                 }
10120             }
10121           break;
10122
10123         case DT_FLAGS_1:
10124           if (do_dynamic)
10125             {
10126               printf (_("Flags:"));
10127               if (entry->d_un.d_val == 0)
10128                 printf (_(" None\n"));
10129               else
10130                 {
10131                   unsigned long int val = entry->d_un.d_val;
10132
10133                   if (val & DF_1_NOW)
10134                     {
10135                       printf (" NOW");
10136                       val ^= DF_1_NOW;
10137                     }
10138                   if (val & DF_1_GLOBAL)
10139                     {
10140                       printf (" GLOBAL");
10141                       val ^= DF_1_GLOBAL;
10142                     }
10143                   if (val & DF_1_GROUP)
10144                     {
10145                       printf (" GROUP");
10146                       val ^= DF_1_GROUP;
10147                     }
10148                   if (val & DF_1_NODELETE)
10149                     {
10150                       printf (" NODELETE");
10151                       val ^= DF_1_NODELETE;
10152                     }
10153                   if (val & DF_1_LOADFLTR)
10154                     {
10155                       printf (" LOADFLTR");
10156                       val ^= DF_1_LOADFLTR;
10157                     }
10158                   if (val & DF_1_INITFIRST)
10159                     {
10160                       printf (" INITFIRST");
10161                       val ^= DF_1_INITFIRST;
10162                     }
10163                   if (val & DF_1_NOOPEN)
10164                     {
10165                       printf (" NOOPEN");
10166                       val ^= DF_1_NOOPEN;
10167                     }
10168                   if (val & DF_1_ORIGIN)
10169                     {
10170                       printf (" ORIGIN");
10171                       val ^= DF_1_ORIGIN;
10172                     }
10173                   if (val & DF_1_DIRECT)
10174                     {
10175                       printf (" DIRECT");
10176                       val ^= DF_1_DIRECT;
10177                     }
10178                   if (val & DF_1_TRANS)
10179                     {
10180                       printf (" TRANS");
10181                       val ^= DF_1_TRANS;
10182                     }
10183                   if (val & DF_1_INTERPOSE)
10184                     {
10185                       printf (" INTERPOSE");
10186                       val ^= DF_1_INTERPOSE;
10187                     }
10188                   if (val & DF_1_NODEFLIB)
10189                     {
10190                       printf (" NODEFLIB");
10191                       val ^= DF_1_NODEFLIB;
10192                     }
10193                   if (val & DF_1_NODUMP)
10194                     {
10195                       printf (" NODUMP");
10196                       val ^= DF_1_NODUMP;
10197                     }
10198                   if (val & DF_1_CONFALT)
10199                     {
10200                       printf (" CONFALT");
10201                       val ^= DF_1_CONFALT;
10202                     }
10203                   if (val & DF_1_ENDFILTEE)
10204                     {
10205                       printf (" ENDFILTEE");
10206                       val ^= DF_1_ENDFILTEE;
10207                     }
10208                   if (val & DF_1_DISPRELDNE)
10209                     {
10210                       printf (" DISPRELDNE");
10211                       val ^= DF_1_DISPRELDNE;
10212                     }
10213                   if (val & DF_1_DISPRELPND)
10214                     {
10215                       printf (" DISPRELPND");
10216                       val ^= DF_1_DISPRELPND;
10217                     }
10218                   if (val & DF_1_NODIRECT)
10219                     {
10220                       printf (" NODIRECT");
10221                       val ^= DF_1_NODIRECT;
10222                     }
10223                   if (val & DF_1_IGNMULDEF)
10224                     {
10225                       printf (" IGNMULDEF");
10226                       val ^= DF_1_IGNMULDEF;
10227                     }
10228                   if (val & DF_1_NOKSYMS)
10229                     {
10230                       printf (" NOKSYMS");
10231                       val ^= DF_1_NOKSYMS;
10232                     }
10233                   if (val & DF_1_NOHDR)
10234                     {
10235                       printf (" NOHDR");
10236                       val ^= DF_1_NOHDR;
10237                     }
10238                   if (val & DF_1_EDITED)
10239                     {
10240                       printf (" EDITED");
10241                       val ^= DF_1_EDITED;
10242                     }
10243                   if (val & DF_1_NORELOC)
10244                     {
10245                       printf (" NORELOC");
10246                       val ^= DF_1_NORELOC;
10247                     }
10248                   if (val & DF_1_SYMINTPOSE)
10249                     {
10250                       printf (" SYMINTPOSE");
10251                       val ^= DF_1_SYMINTPOSE;
10252                     }
10253                   if (val & DF_1_GLOBAUDIT)
10254                     {
10255                       printf (" GLOBAUDIT");
10256                       val ^= DF_1_GLOBAUDIT;
10257                     }
10258                   if (val & DF_1_SINGLETON)
10259                     {
10260                       printf (" SINGLETON");
10261                       val ^= DF_1_SINGLETON;
10262                     }
10263                   if (val & DF_1_STUB)
10264                     {
10265                       printf (" STUB");
10266                       val ^= DF_1_STUB;
10267                     }
10268                   if (val & DF_1_PIE)
10269                     {
10270                       printf (" PIE");
10271                       val ^= DF_1_PIE;
10272                     }
10273                   if (val & DF_1_KMOD)
10274                     {
10275                       printf (" KMOD");
10276                       val ^= DF_1_KMOD;
10277                     }
10278                   if (val & DF_1_WEAKFILTER)
10279                     {
10280                       printf (" WEAKFILTER");
10281                       val ^= DF_1_WEAKFILTER;
10282                     }
10283                   if (val & DF_1_NOCOMMON)
10284                     {
10285                       printf (" NOCOMMON");
10286                       val ^= DF_1_NOCOMMON;
10287                     }
10288                   if (val != 0)
10289                     printf (" %lx", val);
10290                   puts ("");
10291                 }
10292             }
10293           break;
10294
10295         case DT_PLTREL:
10296           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10297           if (do_dynamic)
10298             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10299           break;
10300
10301         case DT_NULL    :
10302         case DT_NEEDED  :
10303         case DT_PLTGOT  :
10304         case DT_HASH    :
10305         case DT_STRTAB  :
10306         case DT_SYMTAB  :
10307         case DT_RELA    :
10308         case DT_INIT    :
10309         case DT_FINI    :
10310         case DT_SONAME  :
10311         case DT_RPATH   :
10312         case DT_SYMBOLIC:
10313         case DT_REL     :
10314         case DT_DEBUG   :
10315         case DT_TEXTREL :
10316         case DT_JMPREL  :
10317         case DT_RUNPATH :
10318           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10319
10320           if (do_dynamic)
10321             {
10322               char * name;
10323
10324               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10325                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10326               else
10327                 name = NULL;
10328
10329               if (name)
10330                 {
10331                   switch (entry->d_tag)
10332                     {
10333                     case DT_NEEDED:
10334                       printf (_("Shared library: [%s]"), name);
10335
10336                       if (streq (name, program_interpreter))
10337                         printf (_(" program interpreter"));
10338                       break;
10339
10340                     case DT_SONAME:
10341                       printf (_("Library soname: [%s]"), name);
10342                       break;
10343
10344                     case DT_RPATH:
10345                       printf (_("Library rpath: [%s]"), name);
10346                       break;
10347
10348                     case DT_RUNPATH:
10349                       printf (_("Library runpath: [%s]"), name);
10350                       break;
10351
10352                     default:
10353                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10354                       break;
10355                     }
10356                 }
10357               else
10358                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10359
10360               putchar ('\n');
10361             }
10362           break;
10363
10364         case DT_PLTRELSZ:
10365         case DT_RELASZ  :
10366         case DT_STRSZ   :
10367         case DT_RELSZ   :
10368         case DT_RELAENT :
10369         case DT_SYMENT  :
10370         case DT_RELENT  :
10371           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10372           /* Fall through.  */
10373         case DT_PLTPADSZ:
10374         case DT_MOVEENT :
10375         case DT_MOVESZ  :
10376         case DT_INIT_ARRAYSZ:
10377         case DT_FINI_ARRAYSZ:
10378         case DT_GNU_CONFLICTSZ:
10379         case DT_GNU_LIBLISTSZ:
10380           if (do_dynamic)
10381             {
10382               print_vma (entry->d_un.d_val, UNSIGNED);
10383               printf (_(" (bytes)\n"));
10384             }
10385           break;
10386
10387         case DT_VERDEFNUM:
10388         case DT_VERNEEDNUM:
10389         case DT_RELACOUNT:
10390         case DT_RELCOUNT:
10391           if (do_dynamic)
10392             {
10393               print_vma (entry->d_un.d_val, UNSIGNED);
10394               putchar ('\n');
10395             }
10396           break;
10397
10398         case DT_SYMINSZ:
10399         case DT_SYMINENT:
10400         case DT_SYMINFO:
10401         case DT_USED:
10402         case DT_INIT_ARRAY:
10403         case DT_FINI_ARRAY:
10404           if (do_dynamic)
10405             {
10406               if (entry->d_tag == DT_USED
10407                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10408                 {
10409                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10410
10411                   if (*name)
10412                     {
10413                       printf (_("Not needed object: [%s]\n"), name);
10414                       break;
10415                     }
10416                 }
10417
10418               print_vma (entry->d_un.d_val, PREFIX_HEX);
10419               putchar ('\n');
10420             }
10421           break;
10422
10423         case DT_BIND_NOW:
10424           /* The value of this entry is ignored.  */
10425           if (do_dynamic)
10426             putchar ('\n');
10427           break;
10428
10429         case DT_GNU_PRELINKED:
10430           if (do_dynamic)
10431             {
10432               struct tm * tmp;
10433               time_t atime = entry->d_un.d_val;
10434
10435               tmp = gmtime (&atime);
10436               /* PR 17533 file: 041-1244816-0.004.  */
10437               if (tmp == NULL)
10438                 printf (_("<corrupt time val: %lx"),
10439                         (unsigned long) atime);
10440               else
10441                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10442                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10443                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10444
10445             }
10446           break;
10447
10448         case DT_GNU_HASH:
10449           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10450           if (do_dynamic)
10451             {
10452               print_vma (entry->d_un.d_val, PREFIX_HEX);
10453               putchar ('\n');
10454             }
10455           break;
10456
10457         default:
10458           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10459             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10460               entry->d_un.d_val;
10461
10462           if (do_dynamic)
10463             {
10464               switch (filedata->file_header.e_machine)
10465                 {
10466                 case EM_AARCH64:
10467                   dynamic_section_aarch64_val (entry);
10468                   break;
10469                 case EM_MIPS:
10470                 case EM_MIPS_RS3_LE:
10471                   dynamic_section_mips_val (entry);
10472                   break;
10473                 case EM_PARISC:
10474                   dynamic_section_parisc_val (entry);
10475                   break;
10476                 case EM_IA_64:
10477                   dynamic_section_ia64_val (entry);
10478                   break;
10479                 default:
10480                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10481                   putchar ('\n');
10482                 }
10483             }
10484           break;
10485         }
10486     }
10487
10488   return TRUE;
10489 }
10490
10491 static char *
10492 get_ver_flags (unsigned int flags)
10493 {
10494   static char buff[128];
10495
10496   buff[0] = 0;
10497
10498   if (flags == 0)
10499     return _("none");
10500
10501   if (flags & VER_FLG_BASE)
10502     strcat (buff, "BASE");
10503
10504   if (flags & VER_FLG_WEAK)
10505     {
10506       if (flags & VER_FLG_BASE)
10507         strcat (buff, " | ");
10508
10509       strcat (buff, "WEAK");
10510     }
10511
10512   if (flags & VER_FLG_INFO)
10513     {
10514       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10515         strcat (buff, " | ");
10516
10517       strcat (buff, "INFO");
10518     }
10519
10520   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10521     {
10522       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10523         strcat (buff, " | ");
10524
10525       strcat (buff, _("<unknown>"));
10526     }
10527
10528   return buff;
10529 }
10530
10531 /* Display the contents of the version sections.  */
10532
10533 static bfd_boolean
10534 process_version_sections (Filedata * filedata)
10535 {
10536   Elf_Internal_Shdr * section;
10537   unsigned i;
10538   bfd_boolean found = FALSE;
10539
10540   if (! do_version)
10541     return TRUE;
10542
10543   for (i = 0, section = filedata->section_headers;
10544        i < filedata->file_header.e_shnum;
10545        i++, section++)
10546     {
10547       switch (section->sh_type)
10548         {
10549         case SHT_GNU_verdef:
10550           {
10551             Elf_External_Verdef * edefs;
10552             unsigned long idx;
10553             unsigned long cnt;
10554             char * endbuf;
10555
10556             found = TRUE;
10557
10558             printf (ngettext ("\nVersion definition section '%s' "
10559                               "contains %u entry:\n",
10560                               "\nVersion definition section '%s' "
10561                               "contains %u entries:\n",
10562                               section->sh_info),
10563                     printable_section_name (filedata, section),
10564                     section->sh_info);
10565
10566             printf (_(" Addr: 0x"));
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_from_index (filedata, section->sh_link));
10571
10572             edefs = (Elf_External_Verdef *)
10573                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10574                           _("version definition section"));
10575             if (!edefs)
10576               break;
10577             endbuf = (char *) edefs + section->sh_size;
10578
10579             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10580               {
10581                 char * vstart;
10582                 Elf_External_Verdef * edef;
10583                 Elf_Internal_Verdef ent;
10584                 Elf_External_Verdaux * eaux;
10585                 Elf_Internal_Verdaux aux;
10586                 unsigned long isum;
10587                 int j;
10588
10589                 vstart = ((char *) edefs) + idx;
10590                 if (vstart + sizeof (*edef) > endbuf)
10591                   break;
10592
10593                 edef = (Elf_External_Verdef *) vstart;
10594
10595                 ent.vd_version = BYTE_GET (edef->vd_version);
10596                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10597                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10598                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10599                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10600                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10601                 ent.vd_next    = BYTE_GET (edef->vd_next);
10602
10603                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10604                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10605
10606                 printf (_("  Index: %d  Cnt: %d  "),
10607                         ent.vd_ndx, ent.vd_cnt);
10608
10609                 /* Check for overflow.  */
10610                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10611                   break;
10612
10613                 vstart += ent.vd_aux;
10614
10615                 if (vstart + sizeof (*eaux) > endbuf)
10616                   break;
10617                 eaux = (Elf_External_Verdaux *) vstart;
10618
10619                 aux.vda_name = BYTE_GET (eaux->vda_name);
10620                 aux.vda_next = BYTE_GET (eaux->vda_next);
10621
10622                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10623                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10624                 else
10625                   printf (_("Name index: %ld\n"), aux.vda_name);
10626
10627                 isum = idx + ent.vd_aux;
10628
10629                 for (j = 1; j < ent.vd_cnt; j++)
10630                   {
10631                     if (aux.vda_next < sizeof (*eaux)
10632                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10633                       {
10634                         warn (_("Invalid vda_next field of %lx\n"),
10635                               aux.vda_next);
10636                         j = ent.vd_cnt;
10637                         break;
10638                       }
10639                     /* Check for overflow.  */
10640                     if (aux.vda_next > (size_t) (endbuf - vstart))
10641                       break;
10642
10643                     isum   += aux.vda_next;
10644                     vstart += aux.vda_next;
10645
10646                     if (vstart + sizeof (*eaux) > endbuf)
10647                       break;
10648                     eaux = (Elf_External_Verdaux *) vstart;
10649
10650                     aux.vda_name = BYTE_GET (eaux->vda_name);
10651                     aux.vda_next = BYTE_GET (eaux->vda_next);
10652
10653                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10654                       printf (_("  %#06lx: Parent %d: %s\n"),
10655                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10656                     else
10657                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10658                               isum, j, aux.vda_name);
10659                   }
10660
10661                 if (j < ent.vd_cnt)
10662                   printf (_("  Version def aux past end of section\n"));
10663
10664                 /* PR 17531:
10665                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10666                 if (ent.vd_next < sizeof (*edef)
10667                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10668                   {
10669                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10670                     cnt = section->sh_info;
10671                     break;
10672                   }
10673                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10674                   break;
10675
10676                 idx += ent.vd_next;
10677               }
10678
10679             if (cnt < section->sh_info)
10680               printf (_("  Version definition past end of section\n"));
10681
10682             free (edefs);
10683           }
10684           break;
10685
10686         case SHT_GNU_verneed:
10687           {
10688             Elf_External_Verneed * eneed;
10689             unsigned long idx;
10690             unsigned long cnt;
10691             char * endbuf;
10692
10693             found = TRUE;
10694
10695             printf (ngettext ("\nVersion needs section '%s' "
10696                               "contains %u entry:\n",
10697                               "\nVersion needs section '%s' "
10698                               "contains %u entries:\n",
10699                               section->sh_info),
10700                     printable_section_name (filedata, section), section->sh_info);
10701
10702             printf (_(" Addr: 0x"));
10703             printf_vma (section->sh_addr);
10704             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10705                     (unsigned long) section->sh_offset, section->sh_link,
10706                     printable_section_name_from_index (filedata, section->sh_link));
10707
10708             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10709                                                        section->sh_offset, 1,
10710                                                        section->sh_size,
10711                                                        _("Version Needs section"));
10712             if (!eneed)
10713               break;
10714             endbuf = (char *) eneed + section->sh_size;
10715
10716             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10717               {
10718                 Elf_External_Verneed * entry;
10719                 Elf_Internal_Verneed ent;
10720                 unsigned long isum;
10721                 int j;
10722                 char * vstart;
10723
10724                 vstart = ((char *) eneed) + idx;
10725                 if (vstart + sizeof (*entry) > endbuf)
10726                   break;
10727
10728                 entry = (Elf_External_Verneed *) vstart;
10729
10730                 ent.vn_version = BYTE_GET (entry->vn_version);
10731                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10732                 ent.vn_file    = BYTE_GET (entry->vn_file);
10733                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10734                 ent.vn_next    = BYTE_GET (entry->vn_next);
10735
10736                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10737
10738                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10739                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10740                 else
10741                   printf (_("  File: %lx"), ent.vn_file);
10742
10743                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10744
10745                 /* Check for overflow.  */
10746                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10747                   break;
10748                 vstart += ent.vn_aux;
10749
10750                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10751                   {
10752                     Elf_External_Vernaux * eaux;
10753                     Elf_Internal_Vernaux aux;
10754
10755                     if (vstart + sizeof (*eaux) > endbuf)
10756                       break;
10757                     eaux = (Elf_External_Vernaux *) vstart;
10758
10759                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10760                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10761                     aux.vna_other = BYTE_GET (eaux->vna_other);
10762                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10763                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10764
10765                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10766                       printf (_("  %#06lx:   Name: %s"),
10767                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10768                     else
10769                       printf (_("  %#06lx:   Name index: %lx"),
10770                               isum, aux.vna_name);
10771
10772                     printf (_("  Flags: %s  Version: %d\n"),
10773                             get_ver_flags (aux.vna_flags), aux.vna_other);
10774
10775                     if (aux.vna_next < sizeof (*eaux)
10776                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10777                       {
10778                         warn (_("Invalid vna_next field of %lx\n"),
10779                               aux.vna_next);
10780                         j = ent.vn_cnt;
10781                         break;
10782                       }
10783                     /* Check for overflow.  */
10784                     if (aux.vna_next > (size_t) (endbuf - vstart))
10785                       break;
10786                     isum   += aux.vna_next;
10787                     vstart += aux.vna_next;
10788                   }
10789
10790                 if (j < ent.vn_cnt)
10791                   warn (_("Missing Version Needs auxillary information\n"));
10792
10793                 if (ent.vn_next < sizeof (*entry)
10794                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10795                   {
10796                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10797                     cnt = section->sh_info;
10798                     break;
10799                   }
10800                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10801                   break;
10802                 idx += ent.vn_next;
10803               }
10804
10805             if (cnt < section->sh_info)
10806               warn (_("Missing Version Needs information\n"));
10807
10808             free (eneed);
10809           }
10810           break;
10811
10812         case SHT_GNU_versym:
10813           {
10814             Elf_Internal_Shdr * link_section;
10815             size_t total;
10816             unsigned int cnt;
10817             unsigned char * edata;
10818             unsigned short * data;
10819             char * strtab;
10820             Elf_Internal_Sym * symbols;
10821             Elf_Internal_Shdr * string_sec;
10822             unsigned long num_syms;
10823             long off;
10824
10825             if (section->sh_link >= filedata->file_header.e_shnum)
10826               break;
10827
10828             link_section = filedata->section_headers + section->sh_link;
10829             total = section->sh_size / sizeof (Elf_External_Versym);
10830
10831             if (link_section->sh_link >= filedata->file_header.e_shnum)
10832               break;
10833
10834             found = TRUE;
10835
10836             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10837             if (symbols == NULL)
10838               break;
10839
10840             string_sec = filedata->section_headers + link_section->sh_link;
10841
10842             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10843                                         string_sec->sh_size,
10844                                         _("version string table"));
10845             if (!strtab)
10846               {
10847                 free (symbols);
10848                 break;
10849               }
10850
10851             printf (ngettext ("\nVersion symbols section '%s' "
10852                               "contains %lu entry:\n",
10853                               "\nVersion symbols section '%s' "
10854                               "contains %lu entries:\n",
10855                               total),
10856                     printable_section_name (filedata, section), (unsigned long) total);
10857
10858             printf (_(" Addr: 0x"));
10859             printf_vma (section->sh_addr);
10860             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10861                     (unsigned long) section->sh_offset, section->sh_link,
10862                     printable_section_name (filedata, link_section));
10863
10864             off = offset_from_vma (filedata,
10865                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10866                                    total * sizeof (short));
10867             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10868                                                 sizeof (short),
10869                                                 _("version symbol data"));
10870             if (!edata)
10871               {
10872                 free (strtab);
10873                 free (symbols);
10874                 break;
10875               }
10876
10877             data = (short unsigned int *) cmalloc (total, sizeof (short));
10878
10879             for (cnt = total; cnt --;)
10880               data[cnt] = byte_get (edata + cnt * sizeof (short),
10881                                     sizeof (short));
10882
10883             free (edata);
10884
10885             for (cnt = 0; cnt < total; cnt += 4)
10886               {
10887                 int j, nn;
10888                 char *name;
10889                 char *invalid = _("*invalid*");
10890
10891                 printf ("  %03x:", cnt);
10892
10893                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10894                   switch (data[cnt + j])
10895                     {
10896                     case 0:
10897                       fputs (_("   0 (*local*)    "), stdout);
10898                       break;
10899
10900                     case 1:
10901                       fputs (_("   1 (*global*)   "), stdout);
10902                       break;
10903
10904                     default:
10905                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10906                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10907
10908                       /* If this index value is greater than the size of the symbols
10909                          array, break to avoid an out-of-bounds read.  */
10910                       if ((unsigned long)(cnt + j) >= num_syms)
10911                         {
10912                           warn (_("invalid index into symbol array\n"));
10913                           break;
10914                         }
10915
10916                       name = NULL;
10917                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10918                         {
10919                           Elf_Internal_Verneed ivn;
10920                           unsigned long offset;
10921
10922                           offset = offset_from_vma
10923                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10924                              sizeof (Elf_External_Verneed));
10925
10926                           do
10927                             {
10928                               Elf_Internal_Vernaux ivna;
10929                               Elf_External_Verneed evn;
10930                               Elf_External_Vernaux evna;
10931                               unsigned long a_off;
10932
10933                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10934                                             _("version need")) == NULL)
10935                                 break;
10936
10937                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10938                               ivn.vn_next = BYTE_GET (evn.vn_next);
10939
10940                               a_off = offset + ivn.vn_aux;
10941
10942                               do
10943                                 {
10944                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10945                                                 1, _("version need aux (2)")) == NULL)
10946                                     {
10947                                       ivna.vna_next  = 0;
10948                                       ivna.vna_other = 0;
10949                                     }
10950                                   else
10951                                     {
10952                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10953                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10954                                     }
10955
10956                                   a_off += ivna.vna_next;
10957                                 }
10958                               while (ivna.vna_other != data[cnt + j]
10959                                      && ivna.vna_next != 0);
10960
10961                               if (ivna.vna_other == data[cnt + j])
10962                                 {
10963                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10964
10965                                   if (ivna.vna_name >= string_sec->sh_size)
10966                                     name = invalid;
10967                                   else
10968                                     name = strtab + ivna.vna_name;
10969                                   break;
10970                                 }
10971
10972                               offset += ivn.vn_next;
10973                             }
10974                           while (ivn.vn_next);
10975                         }
10976
10977                       if (data[cnt + j] != 0x8001
10978                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10979                         {
10980                           Elf_Internal_Verdef ivd;
10981                           Elf_External_Verdef evd;
10982                           unsigned long offset;
10983
10984                           offset = offset_from_vma
10985                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10986                              sizeof evd);
10987
10988                           do
10989                             {
10990                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10991                                             _("version def")) == NULL)
10992                                 {
10993                                   ivd.vd_next = 0;
10994                                   /* PR 17531: file: 046-1082287-0.004.  */
10995                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10996                                   break;
10997                                 }
10998                               else
10999                                 {
11000                                   ivd.vd_next = BYTE_GET (evd.vd_next);
11001                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
11002                                 }
11003
11004                               offset += ivd.vd_next;
11005                             }
11006                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
11007                                  && ivd.vd_next != 0);
11008
11009                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
11010                             {
11011                               Elf_External_Verdaux evda;
11012                               Elf_Internal_Verdaux ivda;
11013
11014                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11015
11016                               if (get_data (&evda, filedata,
11017                                             offset - ivd.vd_next + ivd.vd_aux,
11018                                             sizeof (evda), 1,
11019                                             _("version def aux")) == NULL)
11020                                 break;
11021
11022                               ivda.vda_name = BYTE_GET (evda.vda_name);
11023
11024                               if (ivda.vda_name >= string_sec->sh_size)
11025                                 name = invalid;
11026                               else if (name != NULL && name != invalid)
11027                                 name = _("*both*");
11028                               else
11029                                 name = strtab + ivda.vda_name;
11030                             }
11031                         }
11032                       if (name != NULL)
11033                         nn += printf ("(%s%-*s",
11034                                       name,
11035                                       12 - (int) strlen (name),
11036                                       ")");
11037
11038                       if (nn < 18)
11039                         printf ("%*c", 18 - nn, ' ');
11040                     }
11041
11042                 putchar ('\n');
11043               }
11044
11045             free (data);
11046             free (strtab);
11047             free (symbols);
11048           }
11049           break;
11050
11051         default:
11052           break;
11053         }
11054     }
11055
11056   if (! found)
11057     printf (_("\nNo version information found in this file.\n"));
11058
11059   return TRUE;
11060 }
11061
11062 static const char *
11063 get_symbol_binding (Filedata * filedata, unsigned int binding)
11064 {
11065   static char buff[32];
11066
11067   switch (binding)
11068     {
11069     case STB_LOCAL:     return "LOCAL";
11070     case STB_GLOBAL:    return "GLOBAL";
11071     case STB_WEAK:      return "WEAK";
11072     default:
11073       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
11074         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
11075                   binding);
11076       else if (binding >= STB_LOOS && binding <= STB_HIOS)
11077         {
11078           if (binding == STB_GNU_UNIQUE
11079               && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU)
11080             return "UNIQUE";
11081           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
11082         }
11083       else
11084         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
11085       return buff;
11086     }
11087 }
11088
11089 static const char *
11090 get_symbol_type (Filedata * filedata, unsigned int type)
11091 {
11092   static char buff[32];
11093
11094   switch (type)
11095     {
11096     case STT_NOTYPE:    return "NOTYPE";
11097     case STT_OBJECT:    return "OBJECT";
11098     case STT_FUNC:      return "FUNC";
11099     case STT_SECTION:   return "SECTION";
11100     case STT_FILE:      return "FILE";
11101     case STT_COMMON:    return "COMMON";
11102     case STT_TLS:       return "TLS";
11103     case STT_RELC:      return "RELC";
11104     case STT_SRELC:     return "SRELC";
11105     default:
11106       if (type >= STT_LOPROC && type <= STT_HIPROC)
11107         {
11108           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
11109             return "THUMB_FUNC";
11110
11111           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
11112             return "REGISTER";
11113
11114           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
11115             return "PARISC_MILLI";
11116
11117           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
11118         }
11119       else if (type >= STT_LOOS && type <= STT_HIOS)
11120         {
11121           if (filedata->file_header.e_machine == EM_PARISC)
11122             {
11123               if (type == STT_HP_OPAQUE)
11124                 return "HP_OPAQUE";
11125               if (type == STT_HP_STUB)
11126                 return "HP_STUB";
11127             }
11128
11129           if (type == STT_GNU_IFUNC
11130               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11131                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD))
11132             return "IFUNC";
11133
11134           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11135         }
11136       else
11137         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11138       return buff;
11139     }
11140 }
11141
11142 static const char *
11143 get_symbol_visibility (unsigned int visibility)
11144 {
11145   switch (visibility)
11146     {
11147     case STV_DEFAULT:   return "DEFAULT";
11148     case STV_INTERNAL:  return "INTERNAL";
11149     case STV_HIDDEN:    return "HIDDEN";
11150     case STV_PROTECTED: return "PROTECTED";
11151     default:
11152       error (_("Unrecognized visibility value: %u"), visibility);
11153       return _("<unknown>");
11154     }
11155 }
11156
11157 static const char *
11158 get_alpha_symbol_other (unsigned int other)
11159 {
11160   switch (other)
11161     {
11162     case STO_ALPHA_NOPV:       return "NOPV";
11163     case STO_ALPHA_STD_GPLOAD: return "STD GPLOAD";
11164     default:
11165       error (_("Unrecognized alpah specific other value: %u"), other);
11166       return _("<unknown>");
11167     }
11168 }
11169
11170 static const char *
11171 get_solaris_symbol_visibility (unsigned int visibility)
11172 {
11173   switch (visibility)
11174     {
11175     case 4: return "EXPORTED";
11176     case 5: return "SINGLETON";
11177     case 6: return "ELIMINATE";
11178     default: return get_symbol_visibility (visibility);
11179     }
11180 }
11181
11182 static const char *
11183 get_aarch64_symbol_other (unsigned int other)
11184 {
11185   static char buf[32];
11186
11187   if (other & STO_AARCH64_VARIANT_PCS)
11188     {
11189       other &= ~STO_AARCH64_VARIANT_PCS;
11190       if (other == 0)
11191         return "VARIANT_PCS";
11192       snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other);
11193       return buf;
11194     }
11195   return NULL;
11196 }
11197
11198 static const char *
11199 get_mips_symbol_other (unsigned int other)
11200 {
11201   switch (other)
11202     {
11203     case STO_OPTIONAL:      return "OPTIONAL";
11204     case STO_MIPS_PLT:      return "MIPS PLT";
11205     case STO_MIPS_PIC:      return "MIPS PIC";
11206     case STO_MICROMIPS:     return "MICROMIPS";
11207     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
11208     case STO_MIPS16:        return "MIPS16";
11209     default:                return NULL;
11210     }
11211 }
11212
11213 static const char *
11214 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11215 {
11216   if (is_ia64_vms (filedata))
11217     {
11218       static char res[32];
11219
11220       res[0] = 0;
11221
11222       /* Function types is for images and .STB files only.  */
11223       switch (filedata->file_header.e_type)
11224         {
11225         case ET_DYN:
11226         case ET_EXEC:
11227           switch (VMS_ST_FUNC_TYPE (other))
11228             {
11229             case VMS_SFT_CODE_ADDR:
11230               strcat (res, " CA");
11231               break;
11232             case VMS_SFT_SYMV_IDX:
11233               strcat (res, " VEC");
11234               break;
11235             case VMS_SFT_FD:
11236               strcat (res, " FD");
11237               break;
11238             case VMS_SFT_RESERVE:
11239               strcat (res, " RSV");
11240               break;
11241             default:
11242               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11243                     VMS_ST_FUNC_TYPE (other));
11244               strcat (res, " <unknown>");
11245               break;
11246             }
11247           break;
11248         default:
11249           break;
11250         }
11251       switch (VMS_ST_LINKAGE (other))
11252         {
11253         case VMS_STL_IGNORE:
11254           strcat (res, " IGN");
11255           break;
11256         case VMS_STL_RESERVE:
11257           strcat (res, " RSV");
11258           break;
11259         case VMS_STL_STD:
11260           strcat (res, " STD");
11261           break;
11262         case VMS_STL_LNK:
11263           strcat (res, " LNK");
11264           break;
11265         default:
11266           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11267                 VMS_ST_LINKAGE (other));
11268           strcat (res, " <unknown>");
11269           break;
11270         }
11271
11272       if (res[0] != 0)
11273         return res + 1;
11274       else
11275         return res;
11276     }
11277   return NULL;
11278 }
11279
11280 static const char *
11281 get_ppc64_symbol_other (unsigned int other)
11282 {
11283   if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11284     return NULL;
11285
11286   other >>= STO_PPC64_LOCAL_BIT;
11287   if (other <= 6)
11288     {
11289       static char buf[32];
11290       if (other >= 2)
11291         other = ppc64_decode_local_entry (other);
11292       snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11293       return buf;
11294     }
11295   return NULL;
11296 }
11297
11298 static const char *
11299 get_symbol_other (Filedata * filedata, unsigned int other)
11300 {
11301   const char * result = NULL;
11302   static char buff [32];
11303
11304   if (other == 0)
11305     return "";
11306
11307   switch (filedata->file_header.e_machine)
11308     {
11309     case EM_ALPHA:
11310       result = get_alpha_symbol_other (other);
11311       break;
11312     case EM_AARCH64:
11313       result = get_aarch64_symbol_other (other);
11314       break;
11315     case EM_MIPS:
11316       result = get_mips_symbol_other (other);
11317       break;
11318     case EM_IA_64:
11319       result = get_ia64_symbol_other (filedata, other);
11320       break;
11321     case EM_PPC64:
11322       result = get_ppc64_symbol_other (other);
11323       break;
11324     default:
11325       result = NULL;
11326       break;
11327     }
11328
11329   if (result)
11330     return result;
11331
11332   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11333   return buff;
11334 }
11335
11336 static const char *
11337 get_symbol_index_type (Filedata * filedata, unsigned int type)
11338 {
11339   static char buff[32];
11340
11341   switch (type)
11342     {
11343     case SHN_UNDEF:     return "UND";
11344     case SHN_ABS:       return "ABS";
11345     case SHN_COMMON:    return "COM";
11346     default:
11347       if (type == SHN_IA_64_ANSI_COMMON
11348           && filedata->file_header.e_machine == EM_IA_64
11349           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11350         return "ANSI_COM";
11351       else if ((filedata->file_header.e_machine == EM_X86_64
11352                 || filedata->file_header.e_machine == EM_L1OM
11353                 || filedata->file_header.e_machine == EM_K1OM)
11354                && type == SHN_X86_64_LCOMMON)
11355         return "LARGE_COM";
11356       else if ((type == SHN_MIPS_SCOMMON
11357                 && filedata->file_header.e_machine == EM_MIPS)
11358                || (type == SHN_TIC6X_SCOMMON
11359                    && filedata->file_header.e_machine == EM_TI_C6000))
11360         return "SCOM";
11361       else if (type == SHN_MIPS_SUNDEFINED
11362                && filedata->file_header.e_machine == EM_MIPS)
11363         return "SUND";
11364       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11365         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11366       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11367         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11368       else if (type >= SHN_LORESERVE)
11369         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11370       else if (type >= filedata->file_header.e_shnum)
11371         sprintf (buff, _("bad section index[%3d]"), type);
11372       else
11373         sprintf (buff, "%3d", type);
11374       break;
11375     }
11376
11377   return buff;
11378 }
11379
11380 static bfd_vma *
11381 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11382 {
11383   unsigned char * e_data;
11384   bfd_vma * i_data;
11385
11386   /* If the size_t type is smaller than the bfd_size_type, eg because
11387      you are building a 32-bit tool on a 64-bit host, then make sure
11388      that when (number) is cast to (size_t) no information is lost.  */
11389   if (sizeof (size_t) < sizeof (bfd_size_type)
11390       && (bfd_size_type) ((size_t) number) != number)
11391     {
11392       error (_("Size truncation prevents reading %s elements of size %u\n"),
11393              bfd_vmatoa ("u", number), ent_size);
11394       return NULL;
11395     }
11396
11397   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11398      attempting to allocate memory when the read is bound to fail.  */
11399   if (ent_size * number > filedata->file_size)
11400     {
11401       error (_("Invalid number of dynamic entries: %s\n"),
11402              bfd_vmatoa ("u", number));
11403       return NULL;
11404     }
11405
11406   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11407   if (e_data == NULL)
11408     {
11409       error (_("Out of memory reading %s dynamic entries\n"),
11410              bfd_vmatoa ("u", number));
11411       return NULL;
11412     }
11413
11414   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11415     {
11416       error (_("Unable to read in %s bytes of dynamic data\n"),
11417              bfd_vmatoa ("u", number * ent_size));
11418       free (e_data);
11419       return NULL;
11420     }
11421
11422   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11423   if (i_data == NULL)
11424     {
11425       error (_("Out of memory allocating space for %s dynamic entries\n"),
11426              bfd_vmatoa ("u", number));
11427       free (e_data);
11428       return NULL;
11429     }
11430
11431   while (number--)
11432     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11433
11434   free (e_data);
11435
11436   return i_data;
11437 }
11438
11439 static void
11440 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11441 {
11442   Elf_Internal_Sym * psym;
11443   int n;
11444
11445   n = print_vma (si, DEC_5);
11446   if (n < 5)
11447     fputs (&"     "[n], stdout);
11448   printf (" %3lu: ", hn);
11449
11450   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11451     {
11452       printf (_("<No info available for dynamic symbol number %lu>\n"),
11453               (unsigned long) si);
11454       return;
11455     }
11456
11457   psym = dynamic_symbols + si;
11458   print_vma (psym->st_value, LONG_HEX);
11459   putchar (' ');
11460   print_vma (psym->st_size, DEC_5);
11461
11462   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11463   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11464
11465   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11466     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11467   else
11468     {
11469       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11470
11471       printf (" %-7s",  get_symbol_visibility (vis));
11472       /* Check to see if any other bits in the st_other field are set.
11473          Note - displaying this information disrupts the layout of the
11474          table being generated, but for the moment this case is very
11475          rare.  */
11476       if (psym->st_other ^ vis)
11477         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11478     }
11479
11480   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11481   if (VALID_DYNAMIC_NAME (psym->st_name))
11482     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11483   else
11484     printf (_(" <corrupt: %14ld>"), psym->st_name);
11485   putchar ('\n');
11486 }
11487
11488 static const char *
11489 get_symbol_version_string (Filedata *                   filedata,
11490                            bfd_boolean                  is_dynsym,
11491                            const char *                 strtab,
11492                            unsigned long int            strtab_size,
11493                            unsigned int                 si,
11494                            Elf_Internal_Sym *           psym,
11495                            enum versioned_symbol_info * sym_info,
11496                            unsigned short *             vna_other)
11497 {
11498   unsigned char data[2];
11499   unsigned short vers_data;
11500   unsigned long offset;
11501   unsigned short max_vd_ndx;
11502
11503   if (!is_dynsym
11504       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11505     return NULL;
11506
11507   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11508                             sizeof data + si * sizeof (vers_data));
11509
11510   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11511                 sizeof (data), 1, _("version data")) == NULL)
11512     return NULL;
11513
11514   vers_data = byte_get (data, 2);
11515
11516   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11517     return NULL;
11518
11519   max_vd_ndx = 0;
11520
11521   /* Usually we'd only see verdef for defined symbols, and verneed for
11522      undefined symbols.  However, symbols defined by the linker in
11523      .dynbss for variables copied from a shared library in order to
11524      avoid text relocations are defined yet have verneed.  We could
11525      use a heuristic to detect the special case, for example, check
11526      for verneed first on symbols defined in SHT_NOBITS sections, but
11527      it is simpler and more reliable to just look for both verdef and
11528      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11529
11530   if (psym->st_shndx != SHN_UNDEF
11531       && vers_data != 0x8001
11532       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11533     {
11534       Elf_Internal_Verdef ivd;
11535       Elf_Internal_Verdaux ivda;
11536       Elf_External_Verdaux evda;
11537       unsigned long off;
11538
11539       off = offset_from_vma (filedata,
11540                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11541                              sizeof (Elf_External_Verdef));
11542
11543       do
11544         {
11545           Elf_External_Verdef evd;
11546
11547           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11548                         _("version def")) == NULL)
11549             {
11550               ivd.vd_ndx = 0;
11551               ivd.vd_aux = 0;
11552               ivd.vd_next = 0;
11553               ivd.vd_flags = 0;
11554             }
11555           else
11556             {
11557               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11558               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11559               ivd.vd_next = BYTE_GET (evd.vd_next);
11560               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11561             }
11562
11563           if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11564             max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11565
11566           off += ivd.vd_next;
11567         }
11568       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11569
11570       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11571         {
11572           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11573             return NULL;
11574
11575           off -= ivd.vd_next;
11576           off += ivd.vd_aux;
11577
11578           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11579                         _("version def aux")) != NULL)
11580             {
11581               ivda.vda_name = BYTE_GET (evda.vda_name);
11582
11583               if (psym->st_name != ivda.vda_name)
11584                 {
11585                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11586                                ? symbol_hidden : symbol_public);
11587                   return (ivda.vda_name < strtab_size
11588                           ? strtab + ivda.vda_name : _("<corrupt>"));
11589                 }
11590             }
11591         }
11592     }
11593
11594   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11595     {
11596       Elf_External_Verneed evn;
11597       Elf_Internal_Verneed ivn;
11598       Elf_Internal_Vernaux ivna;
11599
11600       offset = offset_from_vma (filedata,
11601                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11602                                 sizeof evn);
11603       do
11604         {
11605           unsigned long vna_off;
11606
11607           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11608                         _("version need")) == NULL)
11609             {
11610               ivna.vna_next = 0;
11611               ivna.vna_other = 0;
11612               ivna.vna_name = 0;
11613               break;
11614             }
11615
11616           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11617           ivn.vn_next = BYTE_GET (evn.vn_next);
11618
11619           vna_off = offset + ivn.vn_aux;
11620
11621           do
11622             {
11623               Elf_External_Vernaux evna;
11624
11625               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11626                             _("version need aux (3)")) == NULL)
11627                 {
11628                   ivna.vna_next = 0;
11629                   ivna.vna_other = 0;
11630                   ivna.vna_name = 0;
11631                 }
11632               else
11633                 {
11634                   ivna.vna_other = BYTE_GET (evna.vna_other);
11635                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11636                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11637                 }
11638
11639               vna_off += ivna.vna_next;
11640             }
11641           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11642
11643           if (ivna.vna_other == vers_data)
11644             break;
11645
11646           offset += ivn.vn_next;
11647         }
11648       while (ivn.vn_next != 0);
11649
11650       if (ivna.vna_other == vers_data)
11651         {
11652           *sym_info = symbol_undefined;
11653           *vna_other = ivna.vna_other;
11654           return (ivna.vna_name < strtab_size
11655                   ? strtab + ivna.vna_name : _("<corrupt>"));
11656         }
11657       else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11658                && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11659         return _("<corrupt>");
11660     }
11661   return NULL;
11662 }
11663
11664 /* Dump the symbol table.  */
11665 static bfd_boolean
11666 process_symbol_table (Filedata * filedata)
11667 {
11668   Elf_Internal_Shdr * section;
11669   bfd_size_type nbuckets = 0;
11670   bfd_size_type nchains = 0;
11671   bfd_vma * buckets = NULL;
11672   bfd_vma * chains = NULL;
11673   bfd_vma ngnubuckets = 0;
11674   bfd_vma * gnubuckets = NULL;
11675   bfd_vma * gnuchains = NULL;
11676   bfd_vma gnusymidx = 0;
11677   bfd_size_type ngnuchains = 0;
11678
11679   if (!do_syms && !do_dyn_syms && !do_histogram)
11680     return TRUE;
11681
11682   if (dynamic_info[DT_HASH]
11683       && (do_histogram
11684           || (do_using_dynamic
11685               && !do_dyn_syms
11686               && dynamic_strings != NULL)))
11687     {
11688       unsigned char nb[8];
11689       unsigned char nc[8];
11690       unsigned int hash_ent_size = 4;
11691
11692       if ((filedata->file_header.e_machine == EM_ALPHA
11693            || filedata->file_header.e_machine == EM_S390
11694            || filedata->file_header.e_machine == EM_S390_OLD)
11695           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11696         hash_ent_size = 8;
11697
11698       if (fseek (filedata->handle,
11699                  (archive_file_offset
11700                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11701                                      sizeof nb + sizeof nc)),
11702                  SEEK_SET))
11703         {
11704           error (_("Unable to seek to start of dynamic information\n"));
11705           goto no_hash;
11706         }
11707
11708       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11709         {
11710           error (_("Failed to read in number of buckets\n"));
11711           goto no_hash;
11712         }
11713
11714       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11715         {
11716           error (_("Failed to read in number of chains\n"));
11717           goto no_hash;
11718         }
11719
11720       nbuckets = byte_get (nb, hash_ent_size);
11721       nchains  = byte_get (nc, hash_ent_size);
11722
11723       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11724       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11725
11726     no_hash:
11727       if (buckets == NULL || chains == NULL)
11728         {
11729           if (do_using_dynamic)
11730             return FALSE;
11731           free (buckets);
11732           free (chains);
11733           buckets = NULL;
11734           chains = NULL;
11735           nbuckets = 0;
11736           nchains = 0;
11737         }
11738     }
11739
11740   if (dynamic_info_DT_GNU_HASH
11741       && (do_histogram
11742           || (do_using_dynamic
11743               && !do_dyn_syms
11744               && dynamic_strings != NULL)))
11745     {
11746       unsigned char nb[16];
11747       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11748       bfd_vma buckets_vma;
11749
11750       if (fseek (filedata->handle,
11751                  (archive_file_offset
11752                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11753                                      sizeof nb)),
11754                  SEEK_SET))
11755         {
11756           error (_("Unable to seek to start of dynamic information\n"));
11757           goto no_gnu_hash;
11758         }
11759
11760       if (fread (nb, 16, 1, filedata->handle) != 1)
11761         {
11762           error (_("Failed to read in number of buckets\n"));
11763           goto no_gnu_hash;
11764         }
11765
11766       ngnubuckets = byte_get (nb, 4);
11767       gnusymidx = byte_get (nb + 4, 4);
11768       bitmaskwords = byte_get (nb + 8, 4);
11769       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11770       if (is_32bit_elf)
11771         buckets_vma += bitmaskwords * 4;
11772       else
11773         buckets_vma += bitmaskwords * 8;
11774
11775       if (fseek (filedata->handle,
11776                  (archive_file_offset
11777                   + offset_from_vma (filedata, buckets_vma, 4)),
11778                  SEEK_SET))
11779         {
11780           error (_("Unable to seek to start of dynamic information\n"));
11781           goto no_gnu_hash;
11782         }
11783
11784       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11785
11786       if (gnubuckets == NULL)
11787         goto no_gnu_hash;
11788
11789       for (i = 0; i < ngnubuckets; i++)
11790         if (gnubuckets[i] != 0)
11791           {
11792             if (gnubuckets[i] < gnusymidx)
11793               return FALSE;
11794
11795             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11796               maxchain = gnubuckets[i];
11797           }
11798
11799       if (maxchain == 0xffffffff)
11800         goto no_gnu_hash;
11801
11802       maxchain -= gnusymidx;
11803
11804       if (fseek (filedata->handle,
11805                  (archive_file_offset
11806                   + offset_from_vma (filedata, buckets_vma
11807                                            + 4 * (ngnubuckets + maxchain), 4)),
11808                  SEEK_SET))
11809         {
11810           error (_("Unable to seek to start of dynamic information\n"));
11811           goto no_gnu_hash;
11812         }
11813
11814       do
11815         {
11816           if (fread (nb, 4, 1, filedata->handle) != 1)
11817             {
11818               error (_("Failed to determine last chain length\n"));
11819               goto no_gnu_hash;
11820             }
11821
11822           if (maxchain + 1 == 0)
11823             goto no_gnu_hash;
11824
11825           ++maxchain;
11826         }
11827       while ((byte_get (nb, 4) & 1) == 0);
11828
11829       if (fseek (filedata->handle,
11830                  (archive_file_offset
11831                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11832                  SEEK_SET))
11833         {
11834           error (_("Unable to seek to start of dynamic information\n"));
11835           goto no_gnu_hash;
11836         }
11837
11838       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11839       ngnuchains = maxchain;
11840
11841     no_gnu_hash:
11842       if (gnuchains == NULL)
11843         {
11844           free (gnubuckets);
11845           gnubuckets = NULL;
11846           ngnubuckets = 0;
11847           if (do_using_dynamic)
11848             return FALSE;
11849         }
11850     }
11851
11852   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11853       && do_syms
11854       && do_using_dynamic
11855       && dynamic_strings != NULL
11856       && dynamic_symbols != NULL)
11857     {
11858       unsigned long hn;
11859
11860       if (dynamic_info[DT_HASH])
11861         {
11862           bfd_vma si;
11863           char *visited;
11864
11865           printf (_("\nSymbol table for image:\n"));
11866           if (is_32bit_elf)
11867             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11868           else
11869             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11870
11871           visited = xcmalloc (nchains, 1);
11872           memset (visited, 0, nchains);
11873           for (hn = 0; hn < nbuckets; hn++)
11874             {
11875               for (si = buckets[hn]; si > 0; si = chains[si])
11876                 {
11877                   print_dynamic_symbol (filedata, si, hn);
11878                   if (si >= nchains || visited[si])
11879                     {
11880                       error (_("histogram chain is corrupt\n"));
11881                       break;
11882                     }
11883                   visited[si] = 1;
11884                 }
11885             }
11886           free (visited);
11887         }
11888
11889       if (dynamic_info_DT_GNU_HASH)
11890         {
11891           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11892           if (is_32bit_elf)
11893             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11894           else
11895             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11896
11897           for (hn = 0; hn < ngnubuckets; ++hn)
11898             if (gnubuckets[hn] != 0)
11899               {
11900                 bfd_vma si = gnubuckets[hn];
11901                 bfd_vma off = si - gnusymidx;
11902
11903                 do
11904                   {
11905                     print_dynamic_symbol (filedata, si, hn);
11906                     si++;
11907                   }
11908                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11909               }
11910         }
11911     }
11912   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11913            && filedata->section_headers != NULL)
11914     {
11915       unsigned int i;
11916
11917       for (i = 0, section = filedata->section_headers;
11918            i < filedata->file_header.e_shnum;
11919            i++, section++)
11920         {
11921           unsigned int si;
11922           char * strtab = NULL;
11923           unsigned long int strtab_size = 0;
11924           Elf_Internal_Sym * symtab;
11925           Elf_Internal_Sym * psym;
11926           unsigned long num_syms;
11927
11928           if ((section->sh_type != SHT_SYMTAB
11929                && section->sh_type != SHT_DYNSYM)
11930               || (!do_syms
11931                   && section->sh_type == SHT_SYMTAB))
11932             continue;
11933
11934           if (section->sh_entsize == 0)
11935             {
11936               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11937                       printable_section_name (filedata, section));
11938               continue;
11939             }
11940
11941           num_syms = section->sh_size / section->sh_entsize;
11942           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11943                             "\nSymbol table '%s' contains %lu entries:\n",
11944                             num_syms),
11945                   printable_section_name (filedata, section),
11946                   num_syms);
11947
11948           if (is_32bit_elf)
11949             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11950           else
11951             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11952
11953           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11954           if (symtab == NULL)
11955             continue;
11956
11957           if (section->sh_link == filedata->file_header.e_shstrndx)
11958             {
11959               strtab = filedata->string_table;
11960               strtab_size = filedata->string_table_length;
11961             }
11962           else if (section->sh_link < filedata->file_header.e_shnum)
11963             {
11964               Elf_Internal_Shdr * string_sec;
11965
11966               string_sec = filedata->section_headers + section->sh_link;
11967
11968               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11969                                           1, string_sec->sh_size,
11970                                           _("string table"));
11971               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11972             }
11973
11974           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11975             {
11976               const char *version_string;
11977               enum versioned_symbol_info sym_info;
11978               unsigned short vna_other;
11979
11980               printf ("%6d: ", si);
11981               print_vma (psym->st_value, LONG_HEX);
11982               putchar (' ');
11983               print_vma (psym->st_size, DEC_5);
11984               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11985               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11986               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11987                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11988               else
11989                 {
11990                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11991
11992                   printf (" %-7s", get_symbol_visibility (vis));
11993                   /* Check to see if any other bits in the st_other field are set.
11994                      Note - displaying this information disrupts the layout of the
11995                      table being generated, but for the moment this case is very rare.  */
11996                   if (psym->st_other ^ vis)
11997                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11998                 }
11999               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
12000               print_symbol (25, psym->st_name < strtab_size
12001                             ? strtab + psym->st_name : _("<corrupt>"));
12002
12003               version_string
12004                 = get_symbol_version_string (filedata,
12005                                              section->sh_type == SHT_DYNSYM,
12006                                              strtab, strtab_size, si,
12007                                              psym, &sym_info, &vna_other);
12008               if (version_string)
12009                 {
12010                   if (sym_info == symbol_undefined)
12011                     printf ("@%s (%d)", version_string, vna_other);
12012                   else
12013                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
12014                             version_string);
12015                 }
12016
12017               putchar ('\n');
12018
12019               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
12020                   && si >= section->sh_info
12021                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
12022                   && filedata->file_header.e_machine != EM_MIPS
12023                   /* Solaris binaries have been found to violate this requirement as
12024                      well.  Not sure if this is a bug or an ABI requirement.  */
12025                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
12026                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12027                       si, printable_section_name (filedata, section), section->sh_info);
12028             }
12029
12030           free (symtab);
12031           if (strtab != filedata->string_table)
12032             free (strtab);
12033         }
12034     }
12035   else if (do_syms)
12036     printf
12037       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12038
12039   if (do_histogram && buckets != NULL)
12040     {
12041       unsigned long * lengths;
12042       unsigned long * counts;
12043       unsigned long hn;
12044       bfd_vma si;
12045       unsigned long maxlength = 0;
12046       unsigned long nzero_counts = 0;
12047       unsigned long nsyms = 0;
12048       char *visited;
12049
12050       printf (ngettext ("\nHistogram for bucket list length "
12051                         "(total of %lu bucket):\n",
12052                         "\nHistogram for bucket list length "
12053                         "(total of %lu buckets):\n",
12054                         (unsigned long) nbuckets),
12055               (unsigned long) nbuckets);
12056
12057       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
12058       if (lengths == NULL)
12059         {
12060           error (_("Out of memory allocating space for histogram buckets\n"));
12061           return FALSE;
12062         }
12063       visited = xcmalloc (nchains, 1);
12064       memset (visited, 0, nchains);
12065
12066       printf (_(" Length  Number     %% of total  Coverage\n"));
12067       for (hn = 0; hn < nbuckets; ++hn)
12068         {
12069           for (si = buckets[hn]; si > 0; si = chains[si])
12070             {
12071               ++nsyms;
12072               if (maxlength < ++lengths[hn])
12073                 ++maxlength;
12074               if (si >= nchains || visited[si])
12075                 {
12076                   error (_("histogram chain is corrupt\n"));
12077                   break;
12078                 }
12079               visited[si] = 1;
12080             }
12081         }
12082       free (visited);
12083
12084       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12085       if (counts == NULL)
12086         {
12087           free (lengths);
12088           error (_("Out of memory allocating space for histogram counts\n"));
12089           return FALSE;
12090         }
12091
12092       for (hn = 0; hn < nbuckets; ++hn)
12093         ++counts[lengths[hn]];
12094
12095       if (nbuckets > 0)
12096         {
12097           unsigned long i;
12098           printf ("      0  %-10lu (%5.1f%%)\n",
12099                   counts[0], (counts[0] * 100.0) / nbuckets);
12100           for (i = 1; i <= maxlength; ++i)
12101             {
12102               nzero_counts += counts[i] * i;
12103               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
12104                       i, counts[i], (counts[i] * 100.0) / nbuckets,
12105                       (nzero_counts * 100.0) / nsyms);
12106             }
12107         }
12108
12109       free (counts);
12110       free (lengths);
12111     }
12112
12113   if (buckets != NULL)
12114     {
12115       free (buckets);
12116       free (chains);
12117     }
12118
12119   if (do_histogram && gnubuckets != NULL)
12120     {
12121       unsigned long * lengths;
12122       unsigned long * counts;
12123       unsigned long hn;
12124       unsigned long maxlength = 0;
12125       unsigned long nzero_counts = 0;
12126       unsigned long nsyms = 0;
12127
12128       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
12129                         "(total of %lu bucket):\n",
12130                         "\nHistogram for `.gnu.hash' bucket list length "
12131                         "(total of %lu buckets):\n",
12132                         (unsigned long) ngnubuckets),
12133               (unsigned long) ngnubuckets);
12134
12135       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
12136       if (lengths == NULL)
12137         {
12138           error (_("Out of memory allocating space for gnu histogram buckets\n"));
12139           return FALSE;
12140         }
12141
12142       printf (_(" Length  Number     %% of total  Coverage\n"));
12143
12144       for (hn = 0; hn < ngnubuckets; ++hn)
12145         if (gnubuckets[hn] != 0)
12146           {
12147             bfd_vma off, length = 1;
12148
12149             for (off = gnubuckets[hn] - gnusymidx;
12150                  /* PR 17531 file: 010-77222-0.004.  */
12151                  off < ngnuchains && (gnuchains[off] & 1) == 0;
12152                  ++off)
12153               ++length;
12154             lengths[hn] = length;
12155             if (length > maxlength)
12156               maxlength = length;
12157             nsyms += length;
12158           }
12159
12160       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12161       if (counts == NULL)
12162         {
12163           free (lengths);
12164           error (_("Out of memory allocating space for gnu histogram counts\n"));
12165           return FALSE;
12166         }
12167
12168       for (hn = 0; hn < ngnubuckets; ++hn)
12169         ++counts[lengths[hn]];
12170
12171       if (ngnubuckets > 0)
12172         {
12173           unsigned long j;
12174           printf ("      0  %-10lu (%5.1f%%)\n",
12175                   counts[0], (counts[0] * 100.0) / ngnubuckets);
12176           for (j = 1; j <= maxlength; ++j)
12177             {
12178               nzero_counts += counts[j] * j;
12179               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
12180                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
12181                       (nzero_counts * 100.0) / nsyms);
12182             }
12183         }
12184
12185       free (counts);
12186       free (lengths);
12187       free (gnubuckets);
12188       free (gnuchains);
12189     }
12190
12191   return TRUE;
12192 }
12193
12194 static bfd_boolean
12195 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12196 {
12197   unsigned int i;
12198
12199   if (dynamic_syminfo == NULL
12200       || !do_dynamic)
12201     /* No syminfo, this is ok.  */
12202     return TRUE;
12203
12204   /* There better should be a dynamic symbol section.  */
12205   if (dynamic_symbols == NULL || dynamic_strings == NULL)
12206     return FALSE;
12207
12208   if (dynamic_addr)
12209     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12210                       "contains %d entry:\n",
12211                       "\nDynamic info segment at offset 0x%lx "
12212                       "contains %d entries:\n",
12213                       dynamic_syminfo_nent),
12214             dynamic_syminfo_offset, dynamic_syminfo_nent);
12215
12216   printf (_(" Num: Name                           BoundTo     Flags\n"));
12217   for (i = 0; i < dynamic_syminfo_nent; ++i)
12218     {
12219       unsigned short int flags = dynamic_syminfo[i].si_flags;
12220
12221       printf ("%4d: ", i);
12222       if (i >= num_dynamic_syms)
12223         printf (_("<corrupt index>"));
12224       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12225         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12226       else
12227         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12228       putchar (' ');
12229
12230       switch (dynamic_syminfo[i].si_boundto)
12231         {
12232         case SYMINFO_BT_SELF:
12233           fputs ("SELF       ", stdout);
12234           break;
12235         case SYMINFO_BT_PARENT:
12236           fputs ("PARENT     ", stdout);
12237           break;
12238         default:
12239           if (dynamic_syminfo[i].si_boundto > 0
12240               && dynamic_syminfo[i].si_boundto < dynamic_nent
12241               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12242             {
12243               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12244               putchar (' ' );
12245             }
12246           else
12247             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12248           break;
12249         }
12250
12251       if (flags & SYMINFO_FLG_DIRECT)
12252         printf (" DIRECT");
12253       if (flags & SYMINFO_FLG_PASSTHRU)
12254         printf (" PASSTHRU");
12255       if (flags & SYMINFO_FLG_COPY)
12256         printf (" COPY");
12257       if (flags & SYMINFO_FLG_LAZYLOAD)
12258         printf (" LAZYLOAD");
12259
12260       puts ("");
12261     }
12262
12263   return TRUE;
12264 }
12265
12266 #define IN_RANGE(START,END,ADDR,OFF)            \
12267   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12268
12269 /* Check to see if the given reloc needs to be handled in a target specific
12270    manner.  If so then process the reloc and return TRUE otherwise return
12271    FALSE.
12272
12273    If called with reloc == NULL, then this is a signal that reloc processing
12274    for the current section has finished, and any saved state should be
12275    discarded.  */
12276
12277 static bfd_boolean
12278 target_specific_reloc_handling (Filedata *           filedata,
12279                                 Elf_Internal_Rela *  reloc,
12280                                 unsigned char *      start,
12281                                 unsigned char *      end,
12282                                 Elf_Internal_Sym *   symtab,
12283                                 unsigned long        num_syms)
12284 {
12285   unsigned int reloc_type = 0;
12286   unsigned long sym_index = 0;
12287
12288   if (reloc)
12289     {
12290       reloc_type = get_reloc_type (filedata, reloc->r_info);
12291       sym_index = get_reloc_symindex (reloc->r_info);
12292     }
12293
12294   switch (filedata->file_header.e_machine)
12295     {
12296     case EM_MSP430:
12297     case EM_MSP430_OLD:
12298       {
12299         static Elf_Internal_Sym * saved_sym = NULL;
12300
12301         if (reloc == NULL)
12302           {
12303             saved_sym = NULL;
12304             return TRUE;
12305           }
12306
12307         switch (reloc_type)
12308           {
12309           case 10: /* R_MSP430_SYM_DIFF */
12310             if (uses_msp430x_relocs (filedata))
12311               break;
12312             /* Fall through.  */
12313           case 21: /* R_MSP430X_SYM_DIFF */
12314             /* PR 21139.  */
12315             if (sym_index >= num_syms)
12316               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12317                      sym_index);
12318             else
12319               saved_sym = symtab + sym_index;
12320             return TRUE;
12321
12322           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12323           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12324             goto handle_sym_diff;
12325
12326           case 5: /* R_MSP430_16_BYTE */
12327           case 9: /* R_MSP430_8 */
12328             if (uses_msp430x_relocs (filedata))
12329               break;
12330             goto handle_sym_diff;
12331
12332           case 2: /* R_MSP430_ABS16 */
12333           case 15: /* R_MSP430X_ABS16 */
12334             if (! uses_msp430x_relocs (filedata))
12335               break;
12336             goto handle_sym_diff;
12337
12338           handle_sym_diff:
12339             if (saved_sym != NULL)
12340               {
12341                 int reloc_size = reloc_type == 1 ? 4 : 2;
12342                 bfd_vma value;
12343
12344                 if (sym_index >= num_syms)
12345                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12346                          sym_index);
12347                 else
12348                   {
12349                     value = reloc->r_addend + (symtab[sym_index].st_value
12350                                                - saved_sym->st_value);
12351
12352                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12353                       byte_put (start + reloc->r_offset, value, reloc_size);
12354                     else
12355                       /* PR 21137 */
12356                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12357                              (long) reloc->r_offset);
12358                   }
12359
12360                 saved_sym = NULL;
12361                 return TRUE;
12362               }
12363             break;
12364
12365           default:
12366             if (saved_sym != NULL)
12367               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12368             break;
12369           }
12370         break;
12371       }
12372
12373     case EM_MN10300:
12374     case EM_CYGNUS_MN10300:
12375       {
12376         static Elf_Internal_Sym * saved_sym = NULL;
12377
12378         if (reloc == NULL)
12379           {
12380             saved_sym = NULL;
12381             return TRUE;
12382           }
12383
12384         switch (reloc_type)
12385           {
12386           case 34: /* R_MN10300_ALIGN */
12387             return TRUE;
12388           case 33: /* R_MN10300_SYM_DIFF */
12389             if (sym_index >= num_syms)
12390               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12391                      sym_index);
12392             else
12393               saved_sym = symtab + sym_index;
12394             return TRUE;
12395
12396           case 1: /* R_MN10300_32 */
12397           case 2: /* R_MN10300_16 */
12398             if (saved_sym != NULL)
12399               {
12400                 int reloc_size = reloc_type == 1 ? 4 : 2;
12401                 bfd_vma value;
12402
12403                 if (sym_index >= num_syms)
12404                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12405                          sym_index);
12406                 else
12407                   {
12408                     value = reloc->r_addend + (symtab[sym_index].st_value
12409                                                - saved_sym->st_value);
12410
12411                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12412                       byte_put (start + reloc->r_offset, value, reloc_size);
12413                     else
12414                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12415                              (long) reloc->r_offset);
12416                   }
12417
12418                 saved_sym = NULL;
12419                 return TRUE;
12420               }
12421             break;
12422           default:
12423             if (saved_sym != NULL)
12424               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12425             break;
12426           }
12427         break;
12428       }
12429
12430     case EM_RL78:
12431       {
12432         static bfd_vma saved_sym1 = 0;
12433         static bfd_vma saved_sym2 = 0;
12434         static bfd_vma value;
12435
12436         if (reloc == NULL)
12437           {
12438             saved_sym1 = saved_sym2 = 0;
12439             return TRUE;
12440           }
12441
12442         switch (reloc_type)
12443           {
12444           case 0x80: /* R_RL78_SYM.  */
12445             saved_sym1 = saved_sym2;
12446             if (sym_index >= num_syms)
12447               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12448                      sym_index);
12449             else
12450               {
12451                 saved_sym2 = symtab[sym_index].st_value;
12452                 saved_sym2 += reloc->r_addend;
12453               }
12454             return TRUE;
12455
12456           case 0x83: /* R_RL78_OPsub.  */
12457             value = saved_sym1 - saved_sym2;
12458             saved_sym2 = saved_sym1 = 0;
12459             return TRUE;
12460             break;
12461
12462           case 0x41: /* R_RL78_ABS32.  */
12463             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12464               byte_put (start + reloc->r_offset, value, 4);
12465             else
12466               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12467                      (long) reloc->r_offset);
12468             value = 0;
12469             return TRUE;
12470
12471           case 0x43: /* R_RL78_ABS16.  */
12472             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12473               byte_put (start + reloc->r_offset, value, 2);
12474             else
12475               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12476                      (long) reloc->r_offset);
12477             value = 0;
12478             return TRUE;
12479
12480           default:
12481             break;
12482           }
12483         break;
12484       }
12485     }
12486
12487   return FALSE;
12488 }
12489
12490 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12491    DWARF debug sections.  This is a target specific test.  Note - we do not
12492    go through the whole including-target-headers-multiple-times route, (as
12493    we have already done with <elf/h8.h>) because this would become very
12494    messy and even then this function would have to contain target specific
12495    information (the names of the relocs instead of their numeric values).
12496    FIXME: This is not the correct way to solve this problem.  The proper way
12497    is to have target specific reloc sizing and typing functions created by
12498    the reloc-macros.h header, in the same way that it already creates the
12499    reloc naming functions.  */
12500
12501 static bfd_boolean
12502 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12503 {
12504   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12505   switch (filedata->file_header.e_machine)
12506     {
12507     case EM_386:
12508     case EM_IAMCU:
12509       return reloc_type == 1; /* R_386_32.  */
12510     case EM_68K:
12511       return reloc_type == 1; /* R_68K_32.  */
12512     case EM_860:
12513       return reloc_type == 1; /* R_860_32.  */
12514     case EM_960:
12515       return reloc_type == 2; /* R_960_32.  */
12516     case EM_AARCH64:
12517       return (reloc_type == 258
12518               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12519     case EM_BPF:
12520       return reloc_type == 11; /* R_BPF_DATA_32 */
12521     case EM_ADAPTEVA_EPIPHANY:
12522       return reloc_type == 3;
12523     case EM_ALPHA:
12524       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12525     case EM_ARC:
12526       return reloc_type == 1; /* R_ARC_32.  */
12527     case EM_ARC_COMPACT:
12528     case EM_ARC_COMPACT2:
12529       return reloc_type == 4; /* R_ARC_32.  */
12530     case EM_ARM:
12531       return reloc_type == 2; /* R_ARM_ABS32 */
12532     case EM_AVR_OLD:
12533     case EM_AVR:
12534       return reloc_type == 1;
12535     case EM_BLACKFIN:
12536       return reloc_type == 0x12; /* R_byte4_data.  */
12537     case EM_CRIS:
12538       return reloc_type == 3; /* R_CRIS_32.  */
12539     case EM_CR16:
12540       return reloc_type == 3; /* R_CR16_NUM32.  */
12541     case EM_CRX:
12542       return reloc_type == 15; /* R_CRX_NUM32.  */
12543     case EM_CSKY:
12544       return reloc_type == 1; /* R_CKCORE_ADDR32.  */
12545     case EM_CYGNUS_FRV:
12546       return reloc_type == 1;
12547     case EM_CYGNUS_D10V:
12548     case EM_D10V:
12549       return reloc_type == 6; /* R_D10V_32.  */
12550     case EM_CYGNUS_D30V:
12551     case EM_D30V:
12552       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12553     case EM_DLX:
12554       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12555     case EM_CYGNUS_FR30:
12556     case EM_FR30:
12557       return reloc_type == 3; /* R_FR30_32.  */
12558     case EM_FT32:
12559       return reloc_type == 1; /* R_FT32_32.  */
12560     case EM_H8S:
12561     case EM_H8_300:
12562     case EM_H8_300H:
12563       return reloc_type == 1; /* R_H8_DIR32.  */
12564     case EM_IA_64:
12565       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12566               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12567               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12568               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12569     case EM_IP2K_OLD:
12570     case EM_IP2K:
12571       return reloc_type == 2; /* R_IP2K_32.  */
12572     case EM_IQ2000:
12573       return reloc_type == 2; /* R_IQ2000_32.  */
12574     case EM_LATTICEMICO32:
12575       return reloc_type == 3; /* R_LM32_32.  */
12576     case EM_M32C_OLD:
12577     case EM_M32C:
12578       return reloc_type == 3; /* R_M32C_32.  */
12579     case EM_M32R:
12580       return reloc_type == 34; /* R_M32R_32_RELA.  */
12581     case EM_68HC11:
12582     case EM_68HC12:
12583       return reloc_type == 6; /* R_M68HC11_32.  */
12584     case EM_S12Z:
12585       return reloc_type == 7 || /* R_S12Z_EXT32 */
12586         reloc_type == 6;        /* R_S12Z_CW32.  */
12587     case EM_MCORE:
12588       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12589     case EM_CYGNUS_MEP:
12590       return reloc_type == 4; /* R_MEP_32.  */
12591     case EM_METAG:
12592       return reloc_type == 2; /* R_METAG_ADDR32.  */
12593     case EM_MICROBLAZE:
12594       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12595     case EM_MIPS:
12596       return reloc_type == 2; /* R_MIPS_32.  */
12597     case EM_MMIX:
12598       return reloc_type == 4; /* R_MMIX_32.  */
12599     case EM_CYGNUS_MN10200:
12600     case EM_MN10200:
12601       return reloc_type == 1; /* R_MN10200_32.  */
12602     case EM_CYGNUS_MN10300:
12603     case EM_MN10300:
12604       return reloc_type == 1; /* R_MN10300_32.  */
12605     case EM_MOXIE:
12606       return reloc_type == 1; /* R_MOXIE_32.  */
12607     case EM_MSP430_OLD:
12608     case EM_MSP430:
12609       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12610     case EM_MT:
12611       return reloc_type == 2; /* R_MT_32.  */
12612     case EM_NDS32:
12613       return reloc_type == 20; /* R_NDS32_RELA.  */
12614     case EM_ALTERA_NIOS2:
12615       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12616     case EM_NIOS32:
12617       return reloc_type == 1; /* R_NIOS_32.  */
12618     case EM_OR1K:
12619       return reloc_type == 1; /* R_OR1K_32.  */
12620     case EM_PARISC:
12621       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12622               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12623               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12624     case EM_PJ:
12625     case EM_PJ_OLD:
12626       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12627     case EM_PPC64:
12628       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12629     case EM_PPC:
12630       return reloc_type == 1; /* R_PPC_ADDR32.  */
12631     case EM_TI_PRU:
12632       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12633     case EM_RISCV:
12634       return reloc_type == 1; /* R_RISCV_32.  */
12635     case EM_RL78:
12636       return reloc_type == 1; /* R_RL78_DIR32.  */
12637     case EM_RX:
12638       return reloc_type == 1; /* R_RX_DIR32.  */
12639     case EM_S370:
12640       return reloc_type == 1; /* R_I370_ADDR31.  */
12641     case EM_S390_OLD:
12642     case EM_S390:
12643       return reloc_type == 4; /* R_S390_32.  */
12644     case EM_SCORE:
12645       return reloc_type == 8; /* R_SCORE_ABS32.  */
12646     case EM_SH:
12647       return reloc_type == 1; /* R_SH_DIR32.  */
12648     case EM_SPARC32PLUS:
12649     case EM_SPARCV9:
12650     case EM_SPARC:
12651       return reloc_type == 3 /* R_SPARC_32.  */
12652         || reloc_type == 23; /* R_SPARC_UA32.  */
12653     case EM_SPU:
12654       return reloc_type == 6; /* R_SPU_ADDR32 */
12655     case EM_TI_C6000:
12656       return reloc_type == 1; /* R_C6000_ABS32.  */
12657     case EM_TILEGX:
12658       return reloc_type == 2; /* R_TILEGX_32.  */
12659     case EM_TILEPRO:
12660       return reloc_type == 1; /* R_TILEPRO_32.  */
12661     case EM_CYGNUS_V850:
12662     case EM_V850:
12663       return reloc_type == 6; /* R_V850_ABS32.  */
12664     case EM_V800:
12665       return reloc_type == 0x33; /* R_V810_WORD.  */
12666     case EM_VAX:
12667       return reloc_type == 1; /* R_VAX_32.  */
12668     case EM_VISIUM:
12669       return reloc_type == 3;  /* R_VISIUM_32. */
12670     case EM_WEBASSEMBLY:
12671       return reloc_type == 1;  /* R_WASM32_32.  */
12672     case EM_X86_64:
12673     case EM_L1OM:
12674     case EM_K1OM:
12675       return reloc_type == 10; /* R_X86_64_32.  */
12676     case EM_XC16X:
12677     case EM_C166:
12678       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12679     case EM_XGATE:
12680       return reloc_type == 4; /* R_XGATE_32.  */
12681     case EM_XSTORMY16:
12682       return reloc_type == 1; /* R_XSTROMY16_32.  */
12683     case EM_XTENSA_OLD:
12684     case EM_XTENSA:
12685       return reloc_type == 1; /* R_XTENSA_32.  */
12686     default:
12687       {
12688         static unsigned int prev_warn = 0;
12689
12690         /* Avoid repeating the same warning multiple times.  */
12691         if (prev_warn != filedata->file_header.e_machine)
12692           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12693                  filedata->file_header.e_machine);
12694         prev_warn = filedata->file_header.e_machine;
12695         return FALSE;
12696       }
12697     }
12698 }
12699
12700 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12701    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12702
12703 static bfd_boolean
12704 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12705 {
12706   switch (filedata->file_header.e_machine)
12707   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12708     {
12709     case EM_386:
12710     case EM_IAMCU:
12711       return reloc_type == 2;  /* R_386_PC32.  */
12712     case EM_68K:
12713       return reloc_type == 4;  /* R_68K_PC32.  */
12714     case EM_AARCH64:
12715       return reloc_type == 261; /* R_AARCH64_PREL32 */
12716     case EM_ADAPTEVA_EPIPHANY:
12717       return reloc_type == 6;
12718     case EM_ALPHA:
12719       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12720     case EM_ARC_COMPACT:
12721     case EM_ARC_COMPACT2:
12722       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12723     case EM_ARM:
12724       return reloc_type == 3;  /* R_ARM_REL32 */
12725     case EM_AVR_OLD:
12726     case EM_AVR:
12727       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12728     case EM_MICROBLAZE:
12729       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12730     case EM_OR1K:
12731       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12732     case EM_PARISC:
12733       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12734     case EM_PPC:
12735       return reloc_type == 26; /* R_PPC_REL32.  */
12736     case EM_PPC64:
12737       return reloc_type == 26; /* R_PPC64_REL32.  */
12738     case EM_RISCV:
12739       return reloc_type == 57;  /* R_RISCV_32_PCREL.  */
12740     case EM_S390_OLD:
12741     case EM_S390:
12742       return reloc_type == 5;  /* R_390_PC32.  */
12743     case EM_SH:
12744       return reloc_type == 2;  /* R_SH_REL32.  */
12745     case EM_SPARC32PLUS:
12746     case EM_SPARCV9:
12747     case EM_SPARC:
12748       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12749     case EM_SPU:
12750       return reloc_type == 13; /* R_SPU_REL32.  */
12751     case EM_TILEGX:
12752       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12753     case EM_TILEPRO:
12754       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12755     case EM_VISIUM:
12756       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12757     case EM_X86_64:
12758     case EM_L1OM:
12759     case EM_K1OM:
12760       return reloc_type == 2;  /* R_X86_64_PC32.  */
12761     case EM_VAX:
12762       return reloc_type == 4;  /* R_VAX_PCREL32.  */
12763     case EM_XTENSA_OLD:
12764     case EM_XTENSA:
12765       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12766     default:
12767       /* Do not abort or issue an error message here.  Not all targets use
12768          pc-relative 32-bit relocs in their DWARF debug information and we
12769          have already tested for target coverage in is_32bit_abs_reloc.  A
12770          more helpful warning message will be generated by apply_relocations
12771          anyway, so just return.  */
12772       return FALSE;
12773     }
12774 }
12775
12776 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12777    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12778
12779 static bfd_boolean
12780 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12781 {
12782   switch (filedata->file_header.e_machine)
12783     {
12784     case EM_AARCH64:
12785       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12786     case EM_ALPHA:
12787       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12788     case EM_IA_64:
12789       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12790               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12791     case EM_PARISC:
12792       return reloc_type == 80; /* R_PARISC_DIR64.  */
12793     case EM_PPC64:
12794       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12795     case EM_RISCV:
12796       return reloc_type == 2; /* R_RISCV_64.  */
12797     case EM_SPARC32PLUS:
12798     case EM_SPARCV9:
12799     case EM_SPARC:
12800       return reloc_type == 32 /* R_SPARC_64.  */
12801         || reloc_type == 54; /* R_SPARC_UA64.  */
12802     case EM_X86_64:
12803     case EM_L1OM:
12804     case EM_K1OM:
12805       return reloc_type == 1; /* R_X86_64_64.  */
12806     case EM_S390_OLD:
12807     case EM_S390:
12808       return reloc_type == 22;  /* R_S390_64.  */
12809     case EM_TILEGX:
12810       return reloc_type == 1; /* R_TILEGX_64.  */
12811     case EM_MIPS:
12812       return reloc_type == 18;  /* R_MIPS_64.  */
12813     default:
12814       return FALSE;
12815     }
12816 }
12817
12818 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12819    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12820
12821 static bfd_boolean
12822 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12823 {
12824   switch (filedata->file_header.e_machine)
12825     {
12826     case EM_AARCH64:
12827       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12828     case EM_ALPHA:
12829       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12830     case EM_IA_64:
12831       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12832               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12833     case EM_PARISC:
12834       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12835     case EM_PPC64:
12836       return reloc_type == 44; /* R_PPC64_REL64.  */
12837     case EM_SPARC32PLUS:
12838     case EM_SPARCV9:
12839     case EM_SPARC:
12840       return reloc_type == 46; /* R_SPARC_DISP64.  */
12841     case EM_X86_64:
12842     case EM_L1OM:
12843     case EM_K1OM:
12844       return reloc_type == 24; /* R_X86_64_PC64.  */
12845     case EM_S390_OLD:
12846     case EM_S390:
12847       return reloc_type == 23;  /* R_S390_PC64.  */
12848     case EM_TILEGX:
12849       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12850     default:
12851       return FALSE;
12852     }
12853 }
12854
12855 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12856    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12857
12858 static bfd_boolean
12859 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12860 {
12861   switch (filedata->file_header.e_machine)
12862     {
12863     case EM_CYGNUS_MN10200:
12864     case EM_MN10200:
12865       return reloc_type == 4; /* R_MN10200_24.  */
12866     case EM_FT32:
12867       return reloc_type == 5; /* R_FT32_20.  */
12868     default:
12869       return FALSE;
12870     }
12871 }
12872
12873 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12874    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12875
12876 static bfd_boolean
12877 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12878 {
12879   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12880   switch (filedata->file_header.e_machine)
12881     {
12882     case EM_ARC:
12883     case EM_ARC_COMPACT:
12884     case EM_ARC_COMPACT2:
12885       return reloc_type == 2; /* R_ARC_16.  */
12886     case EM_ADAPTEVA_EPIPHANY:
12887       return reloc_type == 5;
12888     case EM_AVR_OLD:
12889     case EM_AVR:
12890       return reloc_type == 4; /* R_AVR_16.  */
12891     case EM_CYGNUS_D10V:
12892     case EM_D10V:
12893       return reloc_type == 3; /* R_D10V_16.  */
12894     case EM_FT32:
12895       return reloc_type == 2; /* R_FT32_16.  */
12896     case EM_H8S:
12897     case EM_H8_300:
12898     case EM_H8_300H:
12899       return reloc_type == R_H8_DIR16;
12900     case EM_IP2K_OLD:
12901     case EM_IP2K:
12902       return reloc_type == 1; /* R_IP2K_16.  */
12903     case EM_M32C_OLD:
12904     case EM_M32C:
12905       return reloc_type == 1; /* R_M32C_16 */
12906     case EM_CYGNUS_MN10200:
12907     case EM_MN10200:
12908       return reloc_type == 2; /* R_MN10200_16.  */
12909     case EM_CYGNUS_MN10300:
12910     case EM_MN10300:
12911       return reloc_type == 2; /* R_MN10300_16.  */
12912     case EM_MSP430:
12913       if (uses_msp430x_relocs (filedata))
12914         return reloc_type == 2; /* R_MSP430_ABS16.  */
12915       /* Fall through.  */
12916     case EM_MSP430_OLD:
12917       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12918     case EM_NDS32:
12919       return reloc_type == 19; /* R_NDS32_RELA.  */
12920     case EM_ALTERA_NIOS2:
12921       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12922     case EM_NIOS32:
12923       return reloc_type == 9; /* R_NIOS_16.  */
12924     case EM_OR1K:
12925       return reloc_type == 2; /* R_OR1K_16.  */
12926     case EM_RISCV:
12927       return reloc_type == 55; /* R_RISCV_SET16.  */
12928     case EM_TI_PRU:
12929       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12930     case EM_TI_C6000:
12931       return reloc_type == 2; /* R_C6000_ABS16.  */
12932     case EM_VISIUM:
12933       return reloc_type == 2; /* R_VISIUM_16. */
12934     case EM_XC16X:
12935     case EM_C166:
12936       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12937     case EM_XGATE:
12938       return reloc_type == 3; /* R_XGATE_16.  */
12939     default:
12940       return FALSE;
12941     }
12942 }
12943
12944 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12945    a 8-bit absolute RELA relocation used in DWARF debug sections.  */
12946
12947 static bfd_boolean
12948 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12949 {
12950   switch (filedata->file_header.e_machine)
12951     {
12952     case EM_RISCV:
12953       return reloc_type == 54; /* R_RISCV_SET8.  */
12954     default:
12955       return FALSE;
12956     }
12957 }
12958
12959 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12960    a 6-bit absolute RELA relocation used in DWARF debug sections.  */
12961
12962 static bfd_boolean
12963 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12964 {
12965   switch (filedata->file_header.e_machine)
12966     {
12967     case EM_RISCV:
12968       return reloc_type == 53; /* R_RISCV_SET6.  */
12969     default:
12970       return FALSE;
12971     }
12972 }
12973
12974 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12975    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12976
12977 static bfd_boolean
12978 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12979 {
12980   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12981   switch (filedata->file_header.e_machine)
12982     {
12983     case EM_RISCV:
12984       return reloc_type == 35; /* R_RISCV_ADD32.  */
12985     default:
12986       return FALSE;
12987     }
12988 }
12989
12990 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12991    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12992
12993 static bfd_boolean
12994 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12995 {
12996   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12997   switch (filedata->file_header.e_machine)
12998     {
12999     case EM_RISCV:
13000       return reloc_type == 39; /* R_RISCV_SUB32.  */
13001     default:
13002       return FALSE;
13003     }
13004 }
13005
13006 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13007    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
13008
13009 static bfd_boolean
13010 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13011 {
13012   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13013   switch (filedata->file_header.e_machine)
13014     {
13015     case EM_RISCV:
13016       return reloc_type == 36; /* R_RISCV_ADD64.  */
13017     default:
13018       return FALSE;
13019     }
13020 }
13021
13022 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13023    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
13024
13025 static bfd_boolean
13026 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13027 {
13028   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13029   switch (filedata->file_header.e_machine)
13030     {
13031     case EM_RISCV:
13032       return reloc_type == 40; /* R_RISCV_SUB64.  */
13033     default:
13034       return FALSE;
13035     }
13036 }
13037
13038 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13039    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
13040
13041 static bfd_boolean
13042 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13043 {
13044   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13045   switch (filedata->file_header.e_machine)
13046     {
13047     case EM_RISCV:
13048       return reloc_type == 34; /* R_RISCV_ADD16.  */
13049     default:
13050       return FALSE;
13051     }
13052 }
13053
13054 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13055    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
13056
13057 static bfd_boolean
13058 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13059 {
13060   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13061   switch (filedata->file_header.e_machine)
13062     {
13063     case EM_RISCV:
13064       return reloc_type == 38; /* R_RISCV_SUB16.  */
13065     default:
13066       return FALSE;
13067     }
13068 }
13069
13070 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13071    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
13072
13073 static bfd_boolean
13074 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13075 {
13076   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13077   switch (filedata->file_header.e_machine)
13078     {
13079     case EM_RISCV:
13080       return reloc_type == 33; /* R_RISCV_ADD8.  */
13081     default:
13082       return FALSE;
13083     }
13084 }
13085
13086 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13087    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
13088
13089 static bfd_boolean
13090 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13091 {
13092   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13093   switch (filedata->file_header.e_machine)
13094     {
13095     case EM_RISCV:
13096       return reloc_type == 37; /* R_RISCV_SUB8.  */
13097     default:
13098       return FALSE;
13099     }
13100 }
13101
13102 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13103    a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
13104
13105 static bfd_boolean
13106 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13107 {
13108   switch (filedata->file_header.e_machine)
13109     {
13110     case EM_RISCV:
13111       return reloc_type == 52; /* R_RISCV_SUB6.  */
13112     default:
13113       return FALSE;
13114     }
13115 }
13116
13117 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13118    relocation entries (possibly formerly used for SHT_GROUP sections).  */
13119
13120 static bfd_boolean
13121 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
13122 {
13123   switch (filedata->file_header.e_machine)
13124     {
13125     case EM_386:     /* R_386_NONE.  */
13126     case EM_68K:     /* R_68K_NONE.  */
13127     case EM_ADAPTEVA_EPIPHANY:
13128     case EM_ALPHA:   /* R_ALPHA_NONE.  */
13129     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
13130     case EM_ARC:     /* R_ARC_NONE.  */
13131     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
13132     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
13133     case EM_ARM:     /* R_ARM_NONE.  */
13134     case EM_C166:    /* R_XC16X_NONE.  */
13135     case EM_CRIS:    /* R_CRIS_NONE.  */
13136     case EM_FT32:    /* R_FT32_NONE.  */
13137     case EM_IA_64:   /* R_IA64_NONE.  */
13138     case EM_K1OM:    /* R_X86_64_NONE.  */
13139     case EM_L1OM:    /* R_X86_64_NONE.  */
13140     case EM_M32R:    /* R_M32R_NONE.  */
13141     case EM_MIPS:    /* R_MIPS_NONE.  */
13142     case EM_MN10300: /* R_MN10300_NONE.  */
13143     case EM_MOXIE:   /* R_MOXIE_NONE.  */
13144     case EM_NIOS32:  /* R_NIOS_NONE.  */
13145     case EM_OR1K:    /* R_OR1K_NONE. */
13146     case EM_PARISC:  /* R_PARISC_NONE.  */
13147     case EM_PPC64:   /* R_PPC64_NONE.  */
13148     case EM_PPC:     /* R_PPC_NONE.  */
13149     case EM_RISCV:   /* R_RISCV_NONE.  */
13150     case EM_S390:    /* R_390_NONE.  */
13151     case EM_S390_OLD:
13152     case EM_SH:      /* R_SH_NONE.  */
13153     case EM_SPARC32PLUS:
13154     case EM_SPARC:   /* R_SPARC_NONE.  */
13155     case EM_SPARCV9:
13156     case EM_TILEGX:  /* R_TILEGX_NONE.  */
13157     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
13158     case EM_TI_C6000:/* R_C6000_NONE.  */
13159     case EM_X86_64:  /* R_X86_64_NONE.  */
13160     case EM_XC16X:
13161     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
13162       return reloc_type == 0;
13163
13164     case EM_AARCH64:
13165       return reloc_type == 0 || reloc_type == 256;
13166     case EM_AVR_OLD:
13167     case EM_AVR:
13168       return (reloc_type == 0 /* R_AVR_NONE.  */
13169               || reloc_type == 30 /* R_AVR_DIFF8.  */
13170               || reloc_type == 31 /* R_AVR_DIFF16.  */
13171               || reloc_type == 32 /* R_AVR_DIFF32.  */);
13172     case EM_METAG:
13173       return reloc_type == 3; /* R_METAG_NONE.  */
13174     case EM_NDS32:
13175       return (reloc_type == 0       /* R_XTENSA_NONE.  */
13176               || reloc_type == 204  /* R_NDS32_DIFF8.  */
13177               || reloc_type == 205  /* R_NDS32_DIFF16.  */
13178               || reloc_type == 206  /* R_NDS32_DIFF32.  */
13179               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
13180     case EM_TI_PRU:
13181       return (reloc_type == 0       /* R_PRU_NONE.  */
13182               || reloc_type == 65   /* R_PRU_DIFF8.  */
13183               || reloc_type == 66   /* R_PRU_DIFF16.  */
13184               || reloc_type == 67   /* R_PRU_DIFF32.  */);
13185     case EM_XTENSA_OLD:
13186     case EM_XTENSA:
13187       return (reloc_type == 0      /* R_XTENSA_NONE.  */
13188               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
13189               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
13190               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
13191     }
13192   return FALSE;
13193 }
13194
13195 /* Returns TRUE if there is a relocation against
13196    section NAME at OFFSET bytes.  */
13197
13198 bfd_boolean
13199 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13200 {
13201   Elf_Internal_Rela * relocs;
13202   Elf_Internal_Rela * rp;
13203
13204   if (dsec == NULL || dsec->reloc_info == NULL)
13205     return FALSE;
13206
13207   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13208
13209   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13210     if (rp->r_offset == offset)
13211       return TRUE;
13212
13213    return FALSE;
13214 }
13215
13216 /* Apply relocations to a section.
13217    Returns TRUE upon success, FALSE otherwise.
13218    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13219    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
13220    will be set to the number of relocs loaded.
13221
13222    Note: So far support has been added only for those relocations
13223    which can be found in debug sections. FIXME: Add support for
13224    more relocations ?  */
13225
13226 static bfd_boolean
13227 apply_relocations (Filedata *                 filedata,
13228                    const Elf_Internal_Shdr *  section,
13229                    unsigned char *            start,
13230                    bfd_size_type              size,
13231                    void **                    relocs_return,
13232                    unsigned long *            num_relocs_return)
13233 {
13234   Elf_Internal_Shdr * relsec;
13235   unsigned char * end = start + size;
13236
13237   if (relocs_return != NULL)
13238     {
13239       * (Elf_Internal_Rela **) relocs_return = NULL;
13240       * num_relocs_return = 0;
13241     }
13242
13243   if (filedata->file_header.e_type != ET_REL)
13244     /* No relocs to apply.  */
13245     return TRUE;
13246
13247   /* Find the reloc section associated with the section.  */
13248   for (relsec = filedata->section_headers;
13249        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13250        ++relsec)
13251     {
13252       bfd_boolean is_rela;
13253       unsigned long num_relocs;
13254       Elf_Internal_Rela * relocs;
13255       Elf_Internal_Rela * rp;
13256       Elf_Internal_Shdr * symsec;
13257       Elf_Internal_Sym * symtab;
13258       unsigned long num_syms;
13259       Elf_Internal_Sym * sym;
13260
13261       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13262           || relsec->sh_info >= filedata->file_header.e_shnum
13263           || filedata->section_headers + relsec->sh_info != section
13264           || relsec->sh_size == 0
13265           || relsec->sh_link >= filedata->file_header.e_shnum)
13266         continue;
13267
13268       is_rela = relsec->sh_type == SHT_RELA;
13269
13270       if (is_rela)
13271         {
13272           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13273                                   relsec->sh_size, & relocs, & num_relocs))
13274             return FALSE;
13275         }
13276       else
13277         {
13278           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13279                                  relsec->sh_size, & relocs, & num_relocs))
13280             return FALSE;
13281         }
13282
13283       /* SH uses RELA but uses in place value instead of the addend field.  */
13284       if (filedata->file_header.e_machine == EM_SH)
13285         is_rela = FALSE;
13286
13287       symsec = filedata->section_headers + relsec->sh_link;
13288       if (symsec->sh_type != SHT_SYMTAB
13289           && symsec->sh_type != SHT_DYNSYM)
13290         return FALSE;
13291       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13292
13293       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13294         {
13295           bfd_vma         addend;
13296           unsigned int    reloc_type;
13297           unsigned int    reloc_size;
13298           bfd_boolean     reloc_inplace = FALSE;
13299           bfd_boolean     reloc_subtract = FALSE;
13300           unsigned char * rloc;
13301           unsigned long   sym_index;
13302
13303           reloc_type = get_reloc_type (filedata, rp->r_info);
13304
13305           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13306             continue;
13307           else if (is_none_reloc (filedata, reloc_type))
13308             continue;
13309           else if (is_32bit_abs_reloc (filedata, reloc_type)
13310                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13311             reloc_size = 4;
13312           else if (is_64bit_abs_reloc (filedata, reloc_type)
13313                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13314             reloc_size = 8;
13315           else if (is_24bit_abs_reloc (filedata, reloc_type))
13316             reloc_size = 3;
13317           else if (is_16bit_abs_reloc (filedata, reloc_type))
13318             reloc_size = 2;
13319           else if (is_8bit_abs_reloc (filedata, reloc_type)
13320                    || is_6bit_abs_reloc (filedata, reloc_type))
13321             reloc_size = 1;
13322           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13323                                                                  reloc_type))
13324                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13325             {
13326               reloc_size = 4;
13327               reloc_inplace = TRUE;
13328             }
13329           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13330                                                                  reloc_type))
13331                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13332             {
13333               reloc_size = 8;
13334               reloc_inplace = TRUE;
13335             }
13336           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13337                                                                  reloc_type))
13338                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13339             {
13340               reloc_size = 2;
13341               reloc_inplace = TRUE;
13342             }
13343           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13344                                                                 reloc_type))
13345                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13346             {
13347               reloc_size = 1;
13348               reloc_inplace = TRUE;
13349             }
13350           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13351                                                                 reloc_type)))
13352             {
13353               reloc_size = 1;
13354               reloc_inplace = TRUE;
13355             }
13356           else
13357             {
13358               static unsigned int prev_reloc = 0;
13359
13360               if (reloc_type != prev_reloc)
13361                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13362                       reloc_type, printable_section_name (filedata, section));
13363               prev_reloc = reloc_type;
13364               continue;
13365             }
13366
13367           rloc = start + rp->r_offset;
13368           if (rloc >= end || (rloc + reloc_size) > end || (rloc < start))
13369             {
13370               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13371                     (unsigned long) rp->r_offset,
13372                     printable_section_name (filedata, section));
13373               continue;
13374             }
13375
13376           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13377           if (sym_index >= num_syms)
13378             {
13379               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13380                     sym_index, printable_section_name (filedata, section));
13381               continue;
13382             }
13383           sym = symtab + sym_index;
13384
13385           /* If the reloc has a symbol associated with it,
13386              make sure that it is of an appropriate type.
13387
13388              Relocations against symbols without type can happen.
13389              Gcc -feliminate-dwarf2-dups may generate symbols
13390              without type for debug info.
13391
13392              Icc generates relocations against function symbols
13393              instead of local labels.
13394
13395              Relocations against object symbols can happen, eg when
13396              referencing a global array.  For an example of this see
13397              the _clz.o binary in libgcc.a.  */
13398           if (sym != symtab
13399               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13400               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13401             {
13402               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13403                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13404                     printable_section_name (filedata, relsec),
13405                     (long int)(rp - relocs));
13406               continue;
13407             }
13408
13409           addend = 0;
13410           if (is_rela)
13411             addend += rp->r_addend;
13412           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13413              partial_inplace.  */
13414           if (!is_rela
13415               || (filedata->file_header.e_machine == EM_XTENSA
13416                   && reloc_type == 1)
13417               || ((filedata->file_header.e_machine == EM_PJ
13418                    || filedata->file_header.e_machine == EM_PJ_OLD)
13419                   && reloc_type == 1)
13420               || ((filedata->file_header.e_machine == EM_D30V
13421                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13422                   && reloc_type == 12)
13423               || reloc_inplace)
13424             {
13425               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13426                 addend += byte_get (rloc, reloc_size) & 0x3f;
13427               else
13428                 addend += byte_get (rloc, reloc_size);
13429             }
13430
13431           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13432               || is_64bit_pcrel_reloc (filedata, reloc_type))
13433             {
13434               /* On HPPA, all pc-relative relocations are biased by 8.  */
13435               if (filedata->file_header.e_machine == EM_PARISC)
13436                 addend -= 8;
13437               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13438                         reloc_size);
13439             }
13440           else if (is_6bit_abs_reloc (filedata, reloc_type)
13441                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13442             {
13443               if (reloc_subtract)
13444                 addend -= sym->st_value;
13445               else
13446                 addend += sym->st_value;
13447               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13448               byte_put (rloc, addend, reloc_size);
13449             }
13450           else if (reloc_subtract)
13451             byte_put (rloc, addend - sym->st_value, reloc_size);
13452           else
13453             byte_put (rloc, addend + sym->st_value, reloc_size);
13454         }
13455
13456       free (symtab);
13457       /* Let the target specific reloc processing code know that
13458          we have finished with these relocs.  */
13459       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13460
13461       if (relocs_return)
13462         {
13463           * (Elf_Internal_Rela **) relocs_return = relocs;
13464           * num_relocs_return = num_relocs;
13465         }
13466       else
13467         free (relocs);
13468
13469       break;
13470     }
13471
13472   return TRUE;
13473 }
13474
13475 #ifdef SUPPORT_DISASSEMBLY
13476 static bfd_boolean
13477 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13478 {
13479   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13480
13481   /* FIXME: XXX -- to be done --- XXX */
13482
13483   return TRUE;
13484 }
13485 #endif
13486
13487 /* Reads in the contents of SECTION from FILE, returning a pointer
13488    to a malloc'ed buffer or NULL if something went wrong.  */
13489
13490 static char *
13491 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13492 {
13493   bfd_size_type num_bytes = section->sh_size;
13494
13495   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13496     {
13497       printf (_("Section '%s' has no data to dump.\n"),
13498               printable_section_name (filedata, section));
13499       return NULL;
13500     }
13501
13502   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13503                              _("section contents"));
13504 }
13505
13506 /* Uncompresses a section that was compressed using zlib, in place.  */
13507
13508 static bfd_boolean
13509 uncompress_section_contents (unsigned char **   buffer,
13510                              dwarf_size_type    uncompressed_size,
13511                              dwarf_size_type *  size)
13512 {
13513   dwarf_size_type compressed_size = *size;
13514   unsigned char * compressed_buffer = *buffer;
13515   unsigned char * uncompressed_buffer;
13516   z_stream strm;
13517   int rc;
13518
13519   /* It is possible the section consists of several compressed
13520      buffers concatenated together, so we uncompress in a loop.  */
13521   /* PR 18313: The state field in the z_stream structure is supposed
13522      to be invisible to the user (ie us), but some compilers will
13523      still complain about it being used without initialisation.  So
13524      we first zero the entire z_stream structure and then set the fields
13525      that we need.  */
13526   memset (& strm, 0, sizeof strm);
13527   strm.avail_in = compressed_size;
13528   strm.next_in = (Bytef *) compressed_buffer;
13529   strm.avail_out = uncompressed_size;
13530   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13531
13532   rc = inflateInit (& strm);
13533   while (strm.avail_in > 0)
13534     {
13535       if (rc != Z_OK)
13536         goto fail;
13537       strm.next_out = ((Bytef *) uncompressed_buffer
13538                        + (uncompressed_size - strm.avail_out));
13539       rc = inflate (&strm, Z_FINISH);
13540       if (rc != Z_STREAM_END)
13541         goto fail;
13542       rc = inflateReset (& strm);
13543     }
13544   rc = inflateEnd (& strm);
13545   if (rc != Z_OK
13546       || strm.avail_out != 0)
13547     goto fail;
13548
13549   *buffer = uncompressed_buffer;
13550   *size = uncompressed_size;
13551   return TRUE;
13552
13553  fail:
13554   free (uncompressed_buffer);
13555   /* Indicate decompression failure.  */
13556   *buffer = NULL;
13557   return FALSE;
13558 }
13559
13560 static bfd_boolean
13561 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13562 {
13563   Elf_Internal_Shdr *  relsec;
13564   bfd_size_type        num_bytes;
13565   unsigned char *      data;
13566   unsigned char *      end;
13567   unsigned char *      real_start;
13568   unsigned char *      start;
13569   bfd_boolean          some_strings_shown;
13570
13571   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13572   if (start == NULL)
13573     /* PR 21820: Do not fail if the section was empty.  */
13574     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13575
13576   num_bytes = section->sh_size;
13577
13578   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13579
13580   if (decompress_dumps)
13581     {
13582       dwarf_size_type new_size = num_bytes;
13583       dwarf_size_type uncompressed_size = 0;
13584
13585       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13586         {
13587           Elf_Internal_Chdr chdr;
13588           unsigned int compression_header_size
13589             = get_compression_header (& chdr, (unsigned char *) start,
13590                                       num_bytes);
13591
13592           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13593             {
13594               warn (_("section '%s' has unsupported compress type: %d\n"),
13595                     printable_section_name (filedata, section), chdr.ch_type);
13596               return FALSE;
13597             }
13598           uncompressed_size = chdr.ch_size;
13599           start += compression_header_size;
13600           new_size -= compression_header_size;
13601         }
13602       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13603         {
13604           /* Read the zlib header.  In this case, it should be "ZLIB"
13605              followed by the uncompressed section size, 8 bytes in
13606              big-endian order.  */
13607           uncompressed_size = start[4]; uncompressed_size <<= 8;
13608           uncompressed_size += start[5]; uncompressed_size <<= 8;
13609           uncompressed_size += start[6]; uncompressed_size <<= 8;
13610           uncompressed_size += start[7]; uncompressed_size <<= 8;
13611           uncompressed_size += start[8]; uncompressed_size <<= 8;
13612           uncompressed_size += start[9]; uncompressed_size <<= 8;
13613           uncompressed_size += start[10]; uncompressed_size <<= 8;
13614           uncompressed_size += start[11];
13615           start += 12;
13616           new_size -= 12;
13617         }
13618
13619       if (uncompressed_size)
13620         {
13621           if (uncompress_section_contents (& start,
13622                                            uncompressed_size, & new_size))
13623             num_bytes = new_size;
13624           else
13625             {
13626               error (_("Unable to decompress section %s\n"),
13627                      printable_section_name (filedata, section));
13628               return FALSE;
13629             }
13630         }
13631       else
13632         start = real_start;
13633     }
13634
13635   /* If the section being dumped has relocations against it the user might
13636      be expecting these relocations to have been applied.  Check for this
13637      case and issue a warning message in order to avoid confusion.
13638      FIXME: Maybe we ought to have an option that dumps a section with
13639      relocs applied ?  */
13640   for (relsec = filedata->section_headers;
13641        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13642        ++relsec)
13643     {
13644       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13645           || relsec->sh_info >= filedata->file_header.e_shnum
13646           || filedata->section_headers + relsec->sh_info != section
13647           || relsec->sh_size == 0
13648           || relsec->sh_link >= filedata->file_header.e_shnum)
13649         continue;
13650
13651       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13652       break;
13653     }
13654
13655   data = start;
13656   end  = start + num_bytes;
13657   some_strings_shown = FALSE;
13658
13659   while (data < end)
13660     {
13661       while (!ISPRINT (* data))
13662         if (++ data >= end)
13663           break;
13664
13665       if (data < end)
13666         {
13667           size_t maxlen = end - data;
13668
13669 #ifndef __MSVCRT__
13670           /* PR 11128: Use two separate invocations in order to work
13671              around bugs in the Solaris 8 implementation of printf.  */
13672           printf ("  [%6tx]  ", data - start);
13673 #else
13674           printf ("  [%6Ix]  ", (size_t) (data - start));
13675 #endif
13676           if (maxlen > 0)
13677             {
13678               print_symbol ((int) maxlen, (const char *) data);
13679               putchar ('\n');
13680               data += strnlen ((const char *) data, maxlen);
13681             }
13682           else
13683             {
13684               printf (_("<corrupt>\n"));
13685               data = end;
13686             }
13687           some_strings_shown = TRUE;
13688         }
13689     }
13690
13691   if (! some_strings_shown)
13692     printf (_("  No strings found in this section."));
13693
13694   free (real_start);
13695
13696   putchar ('\n');
13697   return TRUE;
13698 }
13699
13700 static bfd_boolean
13701 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13702                        Filedata *           filedata,
13703                        bfd_boolean          relocate)
13704 {
13705   Elf_Internal_Shdr * relsec;
13706   bfd_size_type       bytes;
13707   bfd_size_type       section_size;
13708   bfd_vma             addr;
13709   unsigned char *     data;
13710   unsigned char *     real_start;
13711   unsigned char *     start;
13712
13713   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13714   if (start == NULL)
13715     /* PR 21820: Do not fail if the section was empty.  */
13716     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13717
13718   section_size = section->sh_size;
13719
13720   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13721
13722   if (decompress_dumps)
13723     {
13724       dwarf_size_type new_size = section_size;
13725       dwarf_size_type uncompressed_size = 0;
13726
13727       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13728         {
13729           Elf_Internal_Chdr chdr;
13730           unsigned int compression_header_size
13731             = get_compression_header (& chdr, start, section_size);
13732
13733           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13734             {
13735               warn (_("section '%s' has unsupported compress type: %d\n"),
13736                     printable_section_name (filedata, section), chdr.ch_type);
13737               return FALSE;
13738             }
13739           uncompressed_size = chdr.ch_size;
13740           start += compression_header_size;
13741           new_size -= compression_header_size;
13742         }
13743       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13744         {
13745           /* Read the zlib header.  In this case, it should be "ZLIB"
13746              followed by the uncompressed section size, 8 bytes in
13747              big-endian order.  */
13748           uncompressed_size = start[4]; uncompressed_size <<= 8;
13749           uncompressed_size += start[5]; uncompressed_size <<= 8;
13750           uncompressed_size += start[6]; uncompressed_size <<= 8;
13751           uncompressed_size += start[7]; uncompressed_size <<= 8;
13752           uncompressed_size += start[8]; uncompressed_size <<= 8;
13753           uncompressed_size += start[9]; uncompressed_size <<= 8;
13754           uncompressed_size += start[10]; uncompressed_size <<= 8;
13755           uncompressed_size += start[11];
13756           start += 12;
13757           new_size -= 12;
13758         }
13759
13760       if (uncompressed_size)
13761         {
13762           if (uncompress_section_contents (& start, uncompressed_size,
13763                                            & new_size))
13764             {
13765               section_size = new_size;
13766             }
13767           else
13768             {
13769               error (_("Unable to decompress section %s\n"),
13770                      printable_section_name (filedata, section));
13771               /* FIXME: Print the section anyway ?  */
13772               return FALSE;
13773             }
13774         }
13775       else
13776         start = real_start;
13777     }
13778
13779   if (relocate)
13780     {
13781       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13782         return FALSE;
13783     }
13784   else
13785     {
13786       /* If the section being dumped has relocations against it the user might
13787          be expecting these relocations to have been applied.  Check for this
13788          case and issue a warning message in order to avoid confusion.
13789          FIXME: Maybe we ought to have an option that dumps a section with
13790          relocs applied ?  */
13791       for (relsec = filedata->section_headers;
13792            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13793            ++relsec)
13794         {
13795           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13796               || relsec->sh_info >= filedata->file_header.e_shnum
13797               || filedata->section_headers + relsec->sh_info != section
13798               || relsec->sh_size == 0
13799               || relsec->sh_link >= filedata->file_header.e_shnum)
13800             continue;
13801
13802           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13803           break;
13804         }
13805     }
13806
13807   addr = section->sh_addr;
13808   bytes = section_size;
13809   data = start;
13810
13811   while (bytes)
13812     {
13813       int j;
13814       int k;
13815       int lbytes;
13816
13817       lbytes = (bytes > 16 ? 16 : bytes);
13818
13819       printf ("  0x%8.8lx ", (unsigned long) addr);
13820
13821       for (j = 0; j < 16; j++)
13822         {
13823           if (j < lbytes)
13824             printf ("%2.2x", data[j]);
13825           else
13826             printf ("  ");
13827
13828           if ((j & 3) == 3)
13829             printf (" ");
13830         }
13831
13832       for (j = 0; j < lbytes; j++)
13833         {
13834           k = data[j];
13835           if (k >= ' ' && k < 0x7f)
13836             printf ("%c", k);
13837           else
13838             printf (".");
13839         }
13840
13841       putchar ('\n');
13842
13843       data  += lbytes;
13844       addr  += lbytes;
13845       bytes -= lbytes;
13846     }
13847
13848   free (real_start);
13849
13850   putchar ('\n');
13851   return TRUE;
13852 }
13853
13854 static ctf_sect_t *
13855 shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata)
13856 {
13857   buf->cts_name = SECTION_NAME (shdr);
13858   buf->cts_size = shdr->sh_size;
13859   buf->cts_entsize = shdr->sh_entsize;
13860
13861   return buf;
13862 }
13863
13864 /* Formatting callback function passed to ctf_dump.  Returns either the pointer
13865    it is passed, or a pointer to newly-allocated storage, in which case
13866    dump_ctf() will free it when it no longer needs it.  */
13867
13868 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
13869                                     char *s, void *arg)
13870 {
13871   const char *blanks = arg;
13872   char *new_s;
13873
13874   if (asprintf (&new_s, "%s%s", blanks, s) < 0)
13875     return s;
13876   return new_s;
13877 }
13878
13879 static bfd_boolean
13880 dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
13881 {
13882   Elf_Internal_Shdr *  parent_sec = NULL;
13883   Elf_Internal_Shdr *  symtab_sec = NULL;
13884   Elf_Internal_Shdr *  strtab_sec = NULL;
13885   void *               data = NULL;
13886   void *               symdata = NULL;
13887   void *               strdata = NULL;
13888   void *               parentdata = NULL;
13889   ctf_sect_t           ctfsect, symsect, strsect, parentsect;
13890   ctf_sect_t *         symsectp = NULL;
13891   ctf_sect_t *         strsectp = NULL;
13892   ctf_file_t *         ctf = NULL;
13893   ctf_file_t *         parent = NULL;
13894
13895   const char *things[] = {"Labels", "Data objects", "Function objects",
13896                           "Variables", "Types", "Strings", ""};
13897   const char **thing;
13898   int err;
13899   bfd_boolean ret = FALSE;
13900   size_t i;
13901
13902   shdr_to_ctf_sect (&ctfsect, section, filedata);
13903   data = get_section_contents (section, filedata);
13904   ctfsect.cts_data = data;
13905
13906   if (dump_ctf_symtab_name)
13907     {
13908       if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL)
13909         {
13910           error (_("No symbol section named %s\n"), dump_ctf_symtab_name);
13911           goto fail;
13912         }
13913       if ((symdata = (void *) get_data (NULL, filedata,
13914                                         symtab_sec->sh_offset, 1,
13915                                         symtab_sec->sh_size,
13916                                         _("symbols"))) == NULL)
13917         goto fail;
13918       symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
13919       symsect.cts_data = symdata;
13920     }
13921   if (dump_ctf_strtab_name)
13922     {
13923       if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
13924         {
13925           error (_("No string table section named %s\n"),
13926                  dump_ctf_strtab_name);
13927           goto fail;
13928         }
13929       if ((strdata = (void *) get_data (NULL, filedata,
13930                                         strtab_sec->sh_offset, 1,
13931                                         strtab_sec->sh_size,
13932                                         _("strings"))) == NULL)
13933         goto fail;
13934       strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata);
13935       strsect.cts_data = strdata;
13936     }
13937   if (dump_ctf_parent_name)
13938     {
13939       if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL)
13940         {
13941           error (_("No CTF parent section named %s\n"), dump_ctf_parent_name);
13942           goto fail;
13943         }
13944       if ((parentdata = (void *) get_data (NULL, filedata,
13945                                            parent_sec->sh_offset, 1,
13946                                            parent_sec->sh_size,
13947                                            _("CTF parent"))) == NULL)
13948         goto fail;
13949       shdr_to_ctf_sect (&parentsect, parent_sec, filedata);
13950       parentsect.cts_data = parentdata;
13951     }
13952
13953   /* Load the CTF file and dump it.  */
13954
13955   if ((ctf = ctf_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL)
13956     {
13957       error (_("CTF open failure: %s\n"), ctf_errmsg (err));
13958       goto fail;
13959     }
13960
13961   if (parentdata)
13962     {
13963       if ((parent = ctf_bufopen (&parentsect, symsectp, strsectp, &err)) == NULL)
13964         {
13965           error (_("CTF open failure: %s\n"), ctf_errmsg (err));
13966           goto fail;
13967         }
13968
13969       ctf_import (ctf, parent);
13970     }
13971
13972   ret = TRUE;
13973
13974   printf (_("\nDump of CTF section '%s':\n"),
13975           printable_section_name (filedata, section));
13976
13977   for (i = 1, thing = things; *thing[0]; thing++, i++)
13978     {
13979       ctf_dump_state_t *s = NULL;
13980       char *item;
13981
13982       printf ("\n  %s:\n", *thing);
13983       while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
13984                                (void *) "    ")) != NULL)
13985         {
13986           printf ("%s\n", item);
13987           free (item);
13988         }
13989
13990       if (ctf_errno (ctf))
13991         {
13992           error (_("Iteration failed: %s, %s\n"), *thing,
13993                    ctf_errmsg (ctf_errno (ctf)));
13994           ret = FALSE;
13995         }
13996     }
13997
13998  fail:
13999   ctf_file_close (ctf);
14000   ctf_file_close (parent);
14001   free (parentdata);
14002   free (data);
14003   free (symdata);
14004   free (strdata);
14005   return ret;
14006 }
14007
14008 static bfd_boolean
14009 load_specific_debug_section (enum dwarf_section_display_enum  debug,
14010                              const Elf_Internal_Shdr *        sec,
14011                              void *                           data)
14012 {
14013   struct dwarf_section * section = &debug_displays [debug].section;
14014   char buf [64];
14015   Filedata * filedata = (Filedata *) data;
14016
14017   if (section->start != NULL)
14018     {
14019       /* If it is already loaded, do nothing.  */
14020       if (streq (section->filename, filedata->file_name))
14021         return TRUE;
14022       free (section->start);
14023     }
14024
14025   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
14026   section->address = sec->sh_addr;
14027   section->user_data = NULL;
14028   section->filename = filedata->file_name;
14029   section->start = (unsigned char *) get_data (NULL, filedata,
14030                                                sec->sh_offset, 1,
14031                                                sec->sh_size, buf);
14032   if (section->start == NULL)
14033     section->size = 0;
14034   else
14035     {
14036       unsigned char *start = section->start;
14037       dwarf_size_type size = sec->sh_size;
14038       dwarf_size_type uncompressed_size = 0;
14039
14040       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
14041         {
14042           Elf_Internal_Chdr chdr;
14043           unsigned int compression_header_size;
14044
14045           if (size < (is_32bit_elf
14046                       ? sizeof (Elf32_External_Chdr)
14047                       : sizeof (Elf64_External_Chdr)))
14048             {
14049               warn (_("compressed section %s is too small to contain a compression header"),
14050                     section->name);
14051               return FALSE;
14052             }
14053
14054           compression_header_size = get_compression_header (&chdr, start, size);
14055
14056           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
14057             {
14058               warn (_("section '%s' has unsupported compress type: %d\n"),
14059                     section->name, chdr.ch_type);
14060               return FALSE;
14061             }
14062           uncompressed_size = chdr.ch_size;
14063           start += compression_header_size;
14064           size -= compression_header_size;
14065         }
14066       else if (size > 12 && streq ((char *) start, "ZLIB"))
14067         {
14068           /* Read the zlib header.  In this case, it should be "ZLIB"
14069              followed by the uncompressed section size, 8 bytes in
14070              big-endian order.  */
14071           uncompressed_size = start[4]; uncompressed_size <<= 8;
14072           uncompressed_size += start[5]; uncompressed_size <<= 8;
14073           uncompressed_size += start[6]; uncompressed_size <<= 8;
14074           uncompressed_size += start[7]; uncompressed_size <<= 8;
14075           uncompressed_size += start[8]; uncompressed_size <<= 8;
14076           uncompressed_size += start[9]; uncompressed_size <<= 8;
14077           uncompressed_size += start[10]; uncompressed_size <<= 8;
14078           uncompressed_size += start[11];
14079           start += 12;
14080           size -= 12;
14081         }
14082
14083       if (uncompressed_size)
14084         {
14085           if (uncompress_section_contents (&start, uncompressed_size,
14086                                            &size))
14087             {
14088               /* Free the compressed buffer, update the section buffer
14089                  and the section size if uncompress is successful.  */
14090               free (section->start);
14091               section->start = start;
14092             }
14093           else
14094             {
14095               error (_("Unable to decompress section %s\n"),
14096                      printable_section_name (filedata, sec));
14097               return FALSE;
14098             }
14099         }
14100
14101       section->size = size;
14102     }
14103
14104   if (section->start == NULL)
14105     return FALSE;
14106
14107   if (debug_displays [debug].relocate)
14108     {
14109       if (! apply_relocations (filedata, sec, section->start, section->size,
14110                                & section->reloc_info, & section->num_relocs))
14111         return FALSE;
14112     }
14113   else
14114     {
14115       section->reloc_info = NULL;
14116       section->num_relocs = 0;
14117     }
14118
14119   return TRUE;
14120 }
14121
14122 /* If this is not NULL, load_debug_section will only look for sections
14123    within the list of sections given here.  */
14124 static unsigned int * section_subset = NULL;
14125
14126 bfd_boolean
14127 load_debug_section (enum dwarf_section_display_enum debug, void * data)
14128 {
14129   struct dwarf_section * section = &debug_displays [debug].section;
14130   Elf_Internal_Shdr * sec;
14131   Filedata * filedata = (Filedata *) data;
14132
14133   /* Without section headers we cannot find any sections.  */
14134   if (filedata->section_headers == NULL)
14135     return FALSE;
14136
14137   if (filedata->string_table == NULL
14138       && filedata->file_header.e_shstrndx != SHN_UNDEF
14139       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
14140     {
14141       Elf_Internal_Shdr * strs;
14142
14143       /* Read in the string table, so that we have section names to scan.  */
14144       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
14145
14146       if (strs != NULL && strs->sh_size != 0)
14147         {
14148           filedata->string_table
14149             = (char *) get_data (NULL, filedata, strs->sh_offset,
14150                                  1, strs->sh_size, _("string table"));
14151
14152           filedata->string_table_length
14153             = filedata->string_table != NULL ? strs->sh_size : 0;
14154         }
14155     }
14156
14157   /* Locate the debug section.  */
14158   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
14159   if (sec != NULL)
14160     section->name = section->uncompressed_name;
14161   else
14162     {
14163       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
14164       if (sec != NULL)
14165         section->name = section->compressed_name;
14166     }
14167   if (sec == NULL)
14168     return FALSE;
14169
14170   /* If we're loading from a subset of sections, and we've loaded
14171      a section matching this name before, it's likely that it's a
14172      different one.  */
14173   if (section_subset != NULL)
14174     free_debug_section (debug);
14175
14176   return load_specific_debug_section (debug, sec, data);
14177 }
14178
14179 void
14180 free_debug_section (enum dwarf_section_display_enum debug)
14181 {
14182   struct dwarf_section * section = &debug_displays [debug].section;
14183
14184   if (section->start == NULL)
14185     return;
14186
14187   free ((char *) section->start);
14188   section->start = NULL;
14189   section->address = 0;
14190   section->size = 0;
14191 }
14192
14193 static bfd_boolean
14194 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
14195 {
14196   char * name = SECTION_NAME (section);
14197   const char * print_name = printable_section_name (filedata, section);
14198   bfd_size_type length;
14199   bfd_boolean result = TRUE;
14200   int i;
14201
14202   length = section->sh_size;
14203   if (length == 0)
14204     {
14205       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
14206       return TRUE;
14207     }
14208   if (section->sh_type == SHT_NOBITS)
14209     {
14210       /* There is no point in dumping the contents of a debugging section
14211          which has the NOBITS type - the bits in the file will be random.
14212          This can happen when a file containing a .eh_frame section is
14213          stripped with the --only-keep-debug command line option.  */
14214       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14215               print_name);
14216       return FALSE;
14217     }
14218
14219   if (const_strneq (name, ".gnu.linkonce.wi."))
14220     name = ".debug_info";
14221
14222   /* See if we know how to display the contents of this section.  */
14223   for (i = 0; i < max; i++)
14224     {
14225       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
14226       struct dwarf_section_display *   display = debug_displays + i;
14227       struct dwarf_section *           sec = & display->section;
14228
14229       if (streq (sec->uncompressed_name, name)
14230           || (id == line && const_strneq (name, ".debug_line."))
14231           || streq (sec->compressed_name, name))
14232         {
14233           bfd_boolean secondary = (section != find_section (filedata, name));
14234
14235           if (secondary)
14236             free_debug_section (id);
14237
14238           if (i == line && const_strneq (name, ".debug_line."))
14239             sec->name = name;
14240           else if (streq (sec->uncompressed_name, name))
14241             sec->name = sec->uncompressed_name;
14242           else
14243             sec->name = sec->compressed_name;
14244
14245           if (load_specific_debug_section (id, section, filedata))
14246             {
14247               /* If this debug section is part of a CU/TU set in a .dwp file,
14248                  restrict load_debug_section to the sections in that set.  */
14249               section_subset = find_cu_tu_set (filedata, shndx);
14250
14251               result &= display->display (sec, filedata);
14252
14253               section_subset = NULL;
14254
14255               if (secondary || (id != info && id != abbrev))
14256                 free_debug_section (id);
14257             }
14258           break;
14259         }
14260     }
14261
14262   if (i == max)
14263     {
14264       printf (_("Unrecognized debug section: %s\n"), print_name);
14265       result = FALSE;
14266     }
14267
14268   return result;
14269 }
14270
14271 /* Set DUMP_SECTS for all sections where dumps were requested
14272    based on section name.  */
14273
14274 static void
14275 initialise_dumps_byname (Filedata * filedata)
14276 {
14277   struct dump_list_entry * cur;
14278
14279   for (cur = dump_sects_byname; cur; cur = cur->next)
14280     {
14281       unsigned int i;
14282       bfd_boolean any = FALSE;
14283
14284       for (i = 0; i < filedata->file_header.e_shnum; i++)
14285         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
14286           {
14287             request_dump_bynumber (filedata, i, cur->type);
14288             any = TRUE;
14289           }
14290
14291       if (!any)
14292         warn (_("Section '%s' was not dumped because it does not exist!\n"),
14293               cur->name);
14294     }
14295 }
14296
14297 static bfd_boolean
14298 process_section_contents (Filedata * filedata)
14299 {
14300   Elf_Internal_Shdr * section;
14301   unsigned int i;
14302   bfd_boolean res = TRUE;
14303
14304   if (! do_dump)
14305     return TRUE;
14306
14307   initialise_dumps_byname (filedata);
14308
14309   for (i = 0, section = filedata->section_headers;
14310        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
14311        i++, section++)
14312     {
14313       dump_type dump = filedata->dump_sects[i];
14314
14315 #ifdef SUPPORT_DISASSEMBLY
14316       if (dump & DISASS_DUMP)
14317         {
14318           if (! disassemble_section (section, filedata))
14319             res = FALSE;
14320         }
14321 #endif
14322       if (dump & HEX_DUMP)
14323         {
14324           if (! dump_section_as_bytes (section, filedata, FALSE))
14325             res = FALSE;
14326         }
14327
14328       if (dump & RELOC_DUMP)
14329         {
14330           if (! dump_section_as_bytes (section, filedata, TRUE))
14331             res = FALSE;
14332         }
14333
14334       if (dump & STRING_DUMP)
14335         {
14336           if (! dump_section_as_strings (section, filedata))
14337             res = FALSE;
14338         }
14339
14340       if (dump & DEBUG_DUMP)
14341         {
14342           if (! display_debug_section (i, section, filedata))
14343             res = FALSE;
14344         }
14345
14346       if (dump & CTF_DUMP)
14347         {
14348           if (! dump_section_as_ctf (section, filedata))
14349             res = FALSE;
14350         }
14351     }
14352
14353   /* Check to see if the user requested a
14354      dump of a section that does not exist.  */
14355   while (i < filedata->num_dump_sects)
14356     {
14357       if (filedata->dump_sects[i])
14358         {
14359           warn (_("Section %d was not dumped because it does not exist!\n"), i);
14360           res = FALSE;
14361         }
14362       i++;
14363     }
14364
14365   return res;
14366 }
14367
14368 static void
14369 process_mips_fpe_exception (int mask)
14370 {
14371   if (mask)
14372     {
14373       bfd_boolean first = TRUE;
14374
14375       if (mask & OEX_FPU_INEX)
14376         fputs ("INEX", stdout), first = FALSE;
14377       if (mask & OEX_FPU_UFLO)
14378         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14379       if (mask & OEX_FPU_OFLO)
14380         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14381       if (mask & OEX_FPU_DIV0)
14382         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14383       if (mask & OEX_FPU_INVAL)
14384         printf ("%sINVAL", first ? "" : "|");
14385     }
14386   else
14387     fputs ("0", stdout);
14388 }
14389
14390 /* Display's the value of TAG at location P.  If TAG is
14391    greater than 0 it is assumed to be an unknown tag, and
14392    a message is printed to this effect.  Otherwise it is
14393    assumed that a message has already been printed.
14394
14395    If the bottom bit of TAG is set it assumed to have a
14396    string value, otherwise it is assumed to have an integer
14397    value.
14398
14399    Returns an updated P pointing to the first unread byte
14400    beyond the end of TAG's value.
14401
14402    Reads at or beyond END will not be made.  */
14403
14404 static unsigned char *
14405 display_tag_value (signed int tag,
14406                    unsigned char * p,
14407                    const unsigned char * const end)
14408 {
14409   unsigned long val;
14410
14411   if (tag > 0)
14412     printf ("  Tag_unknown_%d: ", tag);
14413
14414   if (p >= end)
14415     {
14416       warn (_("<corrupt tag>\n"));
14417     }
14418   else if (tag & 1)
14419     {
14420       /* PR 17531 file: 027-19978-0.004.  */
14421       size_t maxlen = (end - p) - 1;
14422
14423       putchar ('"');
14424       if (maxlen > 0)
14425         {
14426           print_symbol ((int) maxlen, (const char *) p);
14427           p += strnlen ((char *) p, maxlen) + 1;
14428         }
14429       else
14430         {
14431           printf (_("<corrupt string tag>"));
14432           p = (unsigned char *) end;
14433         }
14434       printf ("\"\n");
14435     }
14436   else
14437     {
14438       unsigned int len;
14439
14440       val = read_uleb128 (p, &len, end);
14441       p += len;
14442       printf ("%ld (0x%lx)\n", val, val);
14443     }
14444
14445   assert (p <= end);
14446   return p;
14447 }
14448
14449 /* ARC ABI attributes section.  */
14450
14451 static unsigned char *
14452 display_arc_attribute (unsigned char * p,
14453                        const unsigned char * const end)
14454 {
14455   unsigned int tag;
14456   unsigned int len;
14457   unsigned int val;
14458
14459   tag = read_uleb128 (p, &len, end);
14460   p += len;
14461
14462   switch (tag)
14463     {
14464     case Tag_ARC_PCS_config:
14465       val = read_uleb128 (p, &len, end);
14466       p += len;
14467       printf ("  Tag_ARC_PCS_config: ");
14468       switch (val)
14469         {
14470         case 0:
14471           printf (_("Absent/Non standard\n"));
14472           break;
14473         case 1:
14474           printf (_("Bare metal/mwdt\n"));
14475           break;
14476         case 2:
14477           printf (_("Bare metal/newlib\n"));
14478           break;
14479         case 3:
14480           printf (_("Linux/uclibc\n"));
14481           break;
14482         case 4:
14483           printf (_("Linux/glibc\n"));
14484           break;
14485         default:
14486           printf (_("Unknown\n"));
14487           break;
14488         }
14489       break;
14490
14491     case Tag_ARC_CPU_base:
14492       val = read_uleb128 (p, &len, end);
14493       p += len;
14494       printf ("  Tag_ARC_CPU_base: ");
14495       switch (val)
14496         {
14497         default:
14498         case TAG_CPU_NONE:
14499           printf (_("Absent\n"));
14500           break;
14501         case TAG_CPU_ARC6xx:
14502           printf ("ARC6xx\n");
14503           break;
14504         case TAG_CPU_ARC7xx:
14505           printf ("ARC7xx\n");
14506           break;
14507         case TAG_CPU_ARCEM:
14508           printf ("ARCEM\n");
14509           break;
14510         case TAG_CPU_ARCHS:
14511           printf ("ARCHS\n");
14512           break;
14513         }
14514       break;
14515
14516     case Tag_ARC_CPU_variation:
14517       val = read_uleb128 (p, &len, end);
14518       p += len;
14519       printf ("  Tag_ARC_CPU_variation: ");
14520       switch (val)
14521         {
14522         default:
14523           if (val > 0 && val < 16)
14524               printf ("Core%d\n", val);
14525           else
14526               printf ("Unknown\n");
14527           break;
14528
14529         case 0:
14530           printf (_("Absent\n"));
14531           break;
14532         }
14533       break;
14534
14535     case Tag_ARC_CPU_name:
14536       printf ("  Tag_ARC_CPU_name: ");
14537       p = display_tag_value (-1, p, end);
14538       break;
14539
14540     case Tag_ARC_ABI_rf16:
14541       val = read_uleb128 (p, &len, end);
14542       p += len;
14543       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14544       break;
14545
14546     case Tag_ARC_ABI_osver:
14547       val = read_uleb128 (p, &len, end);
14548       p += len;
14549       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14550       break;
14551
14552     case Tag_ARC_ABI_pic:
14553     case Tag_ARC_ABI_sda:
14554       val = read_uleb128 (p, &len, end);
14555       p += len;
14556       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14557               : "  Tag_ARC_ABI_pic: ");
14558       switch (val)
14559         {
14560         case 0:
14561           printf (_("Absent\n"));
14562           break;
14563         case 1:
14564           printf ("MWDT\n");
14565           break;
14566         case 2:
14567           printf ("GNU\n");
14568           break;
14569         default:
14570           printf (_("Unknown\n"));
14571           break;
14572         }
14573       break;
14574
14575     case Tag_ARC_ABI_tls:
14576       val = read_uleb128 (p, &len, end);
14577       p += len;
14578       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14579       break;
14580
14581     case Tag_ARC_ABI_enumsize:
14582       val = read_uleb128 (p, &len, end);
14583       p += len;
14584       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14585               _("smallest"));
14586       break;
14587
14588     case Tag_ARC_ABI_exceptions:
14589       val = read_uleb128 (p, &len, end);
14590       p += len;
14591       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14592               : _("default"));
14593       break;
14594
14595     case Tag_ARC_ABI_double_size:
14596       val = read_uleb128 (p, &len, end);
14597       p += len;
14598       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14599       break;
14600
14601     case Tag_ARC_ISA_config:
14602       printf ("  Tag_ARC_ISA_config: ");
14603       p = display_tag_value (-1, p, end);
14604       break;
14605
14606     case Tag_ARC_ISA_apex:
14607       printf ("  Tag_ARC_ISA_apex: ");
14608       p = display_tag_value (-1, p, end);
14609       break;
14610
14611     case Tag_ARC_ISA_mpy_option:
14612       val = read_uleb128 (p, &len, end);
14613       p += len;
14614       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14615       break;
14616
14617     case Tag_ARC_ATR_version:
14618       val = read_uleb128 (p, &len, end);
14619       p += len;
14620       printf ("  Tag_ARC_ATR_version: %d\n", val);
14621       break;
14622
14623     default:
14624       return display_tag_value (tag & 1, p, end);
14625     }
14626
14627   return p;
14628 }
14629
14630 /* ARM EABI attributes section.  */
14631 typedef struct
14632 {
14633   unsigned int tag;
14634   const char * name;
14635   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14636   unsigned int type;
14637   const char ** table;
14638 } arm_attr_public_tag;
14639
14640 static const char * arm_attr_tag_CPU_arch[] =
14641   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14642    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14643    "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14644 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14645 static const char * arm_attr_tag_THUMB_ISA_use[] =
14646   {"No", "Thumb-1", "Thumb-2", "Yes"};
14647 static const char * arm_attr_tag_FP_arch[] =
14648   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14649    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14650 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14651 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14652   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14653    "NEON for ARMv8.1"};
14654 static const char * arm_attr_tag_PCS_config[] =
14655   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14656    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14657 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14658   {"V6", "SB", "TLS", "Unused"};
14659 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14660   {"Absolute", "PC-relative", "SB-relative", "None"};
14661 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14662   {"Absolute", "PC-relative", "None"};
14663 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14664   {"None", "direct", "GOT-indirect"};
14665 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14666   {"None", "??? 1", "2", "??? 3", "4"};
14667 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14668 static const char * arm_attr_tag_ABI_FP_denormal[] =
14669   {"Unused", "Needed", "Sign only"};
14670 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14671 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14672 static const char * arm_attr_tag_ABI_FP_number_model[] =
14673   {"Unused", "Finite", "RTABI", "IEEE 754"};
14674 static const char * arm_attr_tag_ABI_enum_size[] =
14675   {"Unused", "small", "int", "forced to int"};
14676 static const char * arm_attr_tag_ABI_HardFP_use[] =
14677   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14678 static const char * arm_attr_tag_ABI_VFP_args[] =
14679   {"AAPCS", "VFP registers", "custom", "compatible"};
14680 static const char * arm_attr_tag_ABI_WMMX_args[] =
14681   {"AAPCS", "WMMX registers", "custom"};
14682 static const char * arm_attr_tag_ABI_optimization_goals[] =
14683   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14684     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14685 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14686   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14687     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14688 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14689 static const char * arm_attr_tag_FP_HP_extension[] =
14690   {"Not Allowed", "Allowed"};
14691 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14692   {"None", "IEEE 754", "Alternative Format"};
14693 static const char * arm_attr_tag_DSP_extension[] =
14694   {"Follow architecture", "Allowed"};
14695 static const char * arm_attr_tag_MPextension_use[] =
14696   {"Not Allowed", "Allowed"};
14697 static const char * arm_attr_tag_DIV_use[] =
14698   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14699     "Allowed in v7-A with integer division extension"};
14700 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14701 static const char * arm_attr_tag_Virtualization_use[] =
14702   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14703     "TrustZone and Virtualization Extensions"};
14704 static const char * arm_attr_tag_MPextension_use_legacy[] =
14705   {"Not Allowed", "Allowed"};
14706
14707 static const char * arm_attr_tag_MVE_arch[] =
14708   {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14709
14710 #define LOOKUP(id, name) \
14711   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14712 static arm_attr_public_tag arm_attr_public_tags[] =
14713 {
14714   {4, "CPU_raw_name", 1, NULL},
14715   {5, "CPU_name", 1, NULL},
14716   LOOKUP(6, CPU_arch),
14717   {7, "CPU_arch_profile", 0, NULL},
14718   LOOKUP(8, ARM_ISA_use),
14719   LOOKUP(9, THUMB_ISA_use),
14720   LOOKUP(10, FP_arch),
14721   LOOKUP(11, WMMX_arch),
14722   LOOKUP(12, Advanced_SIMD_arch),
14723   LOOKUP(13, PCS_config),
14724   LOOKUP(14, ABI_PCS_R9_use),
14725   LOOKUP(15, ABI_PCS_RW_data),
14726   LOOKUP(16, ABI_PCS_RO_data),
14727   LOOKUP(17, ABI_PCS_GOT_use),
14728   LOOKUP(18, ABI_PCS_wchar_t),
14729   LOOKUP(19, ABI_FP_rounding),
14730   LOOKUP(20, ABI_FP_denormal),
14731   LOOKUP(21, ABI_FP_exceptions),
14732   LOOKUP(22, ABI_FP_user_exceptions),
14733   LOOKUP(23, ABI_FP_number_model),
14734   {24, "ABI_align_needed", 0, NULL},
14735   {25, "ABI_align_preserved", 0, NULL},
14736   LOOKUP(26, ABI_enum_size),
14737   LOOKUP(27, ABI_HardFP_use),
14738   LOOKUP(28, ABI_VFP_args),
14739   LOOKUP(29, ABI_WMMX_args),
14740   LOOKUP(30, ABI_optimization_goals),
14741   LOOKUP(31, ABI_FP_optimization_goals),
14742   {32, "compatibility", 0, NULL},
14743   LOOKUP(34, CPU_unaligned_access),
14744   LOOKUP(36, FP_HP_extension),
14745   LOOKUP(38, ABI_FP_16bit_format),
14746   LOOKUP(42, MPextension_use),
14747   LOOKUP(44, DIV_use),
14748   LOOKUP(46, DSP_extension),
14749   LOOKUP(48, MVE_arch),
14750   {64, "nodefaults", 0, NULL},
14751   {65, "also_compatible_with", 0, NULL},
14752   LOOKUP(66, T2EE_use),
14753   {67, "conformance", 1, NULL},
14754   LOOKUP(68, Virtualization_use),
14755   LOOKUP(70, MPextension_use_legacy)
14756 };
14757 #undef LOOKUP
14758
14759 static unsigned char *
14760 display_arm_attribute (unsigned char * p,
14761                        const unsigned char * const end)
14762 {
14763   unsigned int tag;
14764   unsigned int len;
14765   unsigned int val;
14766   arm_attr_public_tag * attr;
14767   unsigned i;
14768   unsigned int type;
14769
14770   tag = read_uleb128 (p, &len, end);
14771   p += len;
14772   attr = NULL;
14773   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14774     {
14775       if (arm_attr_public_tags[i].tag == tag)
14776         {
14777           attr = &arm_attr_public_tags[i];
14778           break;
14779         }
14780     }
14781
14782   if (attr)
14783     {
14784       printf ("  Tag_%s: ", attr->name);
14785       switch (attr->type)
14786         {
14787         case 0:
14788           switch (tag)
14789             {
14790             case 7: /* Tag_CPU_arch_profile.  */
14791               val = read_uleb128 (p, &len, end);
14792               p += len;
14793               switch (val)
14794                 {
14795                 case 0: printf (_("None\n")); break;
14796                 case 'A': printf (_("Application\n")); break;
14797                 case 'R': printf (_("Realtime\n")); break;
14798                 case 'M': printf (_("Microcontroller\n")); break;
14799                 case 'S': printf (_("Application or Realtime\n")); break;
14800                 default: printf ("??? (%d)\n", val); break;
14801                 }
14802               break;
14803
14804             case 24: /* Tag_align_needed.  */
14805               val = read_uleb128 (p, &len, end);
14806               p += len;
14807               switch (val)
14808                 {
14809                 case 0: printf (_("None\n")); break;
14810                 case 1: printf (_("8-byte\n")); break;
14811                 case 2: printf (_("4-byte\n")); break;
14812                 case 3: printf ("??? 3\n"); break;
14813                 default:
14814                   if (val <= 12)
14815                     printf (_("8-byte and up to %d-byte extended\n"),
14816                             1 << val);
14817                   else
14818                     printf ("??? (%d)\n", val);
14819                   break;
14820                 }
14821               break;
14822
14823             case 25: /* Tag_align_preserved.  */
14824               val = read_uleb128 (p, &len, end);
14825               p += len;
14826               switch (val)
14827                 {
14828                 case 0: printf (_("None\n")); break;
14829                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14830                 case 2: printf (_("8-byte\n")); break;
14831                 case 3: printf ("??? 3\n"); break;
14832                 default:
14833                   if (val <= 12)
14834                     printf (_("8-byte and up to %d-byte extended\n"),
14835                             1 << val);
14836                   else
14837                     printf ("??? (%d)\n", val);
14838                   break;
14839                 }
14840               break;
14841
14842             case 32: /* Tag_compatibility.  */
14843               {
14844                 val = read_uleb128 (p, &len, end);
14845                 p += len;
14846                 printf (_("flag = %d, vendor = "), val);
14847                 if (p < end - 1)
14848                   {
14849                     size_t maxlen = (end - p) - 1;
14850
14851                     print_symbol ((int) maxlen, (const char *) p);
14852                     p += strnlen ((char *) p, maxlen) + 1;
14853                   }
14854                 else
14855                   {
14856                     printf (_("<corrupt>"));
14857                     p = (unsigned char *) end;
14858                   }
14859                 putchar ('\n');
14860               }
14861               break;
14862
14863             case 64: /* Tag_nodefaults.  */
14864               /* PR 17531: file: 001-505008-0.01.  */
14865               if (p < end)
14866                 p++;
14867               printf (_("True\n"));
14868               break;
14869
14870             case 65: /* Tag_also_compatible_with.  */
14871               val = read_uleb128 (p, &len, end);
14872               p += len;
14873               if (val == 6 /* Tag_CPU_arch.  */)
14874                 {
14875                   val = read_uleb128 (p, &len, end);
14876                   p += len;
14877                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14878                     printf ("??? (%d)\n", val);
14879                   else
14880                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14881                 }
14882               else
14883                 printf ("???\n");
14884               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14885                 ;
14886               break;
14887
14888             default:
14889               printf (_("<unknown: %d>\n"), tag);
14890               break;
14891             }
14892           return p;
14893
14894         case 1:
14895           return display_tag_value (-1, p, end);
14896         case 2:
14897           return display_tag_value (0, p, end);
14898
14899         default:
14900           assert (attr->type & 0x80);
14901           val = read_uleb128 (p, &len, end);
14902           p += len;
14903           type = attr->type & 0x7f;
14904           if (val >= type)
14905             printf ("??? (%d)\n", val);
14906           else
14907             printf ("%s\n", attr->table[val]);
14908           return p;
14909         }
14910     }
14911
14912   return display_tag_value (tag, p, end);
14913 }
14914
14915 static unsigned char *
14916 display_gnu_attribute (unsigned char * p,
14917                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14918                        const unsigned char * const end)
14919 {
14920   int tag;
14921   unsigned int len;
14922   unsigned int val;
14923
14924   tag = read_uleb128 (p, &len, end);
14925   p += len;
14926
14927   /* Tag_compatibility is the only generic GNU attribute defined at
14928      present.  */
14929   if (tag == 32)
14930     {
14931       val = read_uleb128 (p, &len, end);
14932       p += len;
14933
14934       printf (_("flag = %d, vendor = "), val);
14935       if (p == end)
14936         {
14937           printf (_("<corrupt>\n"));
14938           warn (_("corrupt vendor attribute\n"));
14939         }
14940       else
14941         {
14942           if (p < end - 1)
14943             {
14944               size_t maxlen = (end - p) - 1;
14945
14946               print_symbol ((int) maxlen, (const char *) p);
14947               p += strnlen ((char *) p, maxlen) + 1;
14948             }
14949           else
14950             {
14951               printf (_("<corrupt>"));
14952               p = (unsigned char *) end;
14953             }
14954           putchar ('\n');
14955         }
14956       return p;
14957     }
14958
14959   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14960     return display_proc_gnu_attribute (p, tag, end);
14961
14962   return display_tag_value (tag, p, end);
14963 }
14964
14965 static unsigned char *
14966 display_power_gnu_attribute (unsigned char * p,
14967                              unsigned int tag,
14968                              const unsigned char * const end)
14969 {
14970   unsigned int len;
14971   unsigned int val;
14972
14973   if (tag == Tag_GNU_Power_ABI_FP)
14974     {
14975       val = read_uleb128 (p, &len, end);
14976       p += len;
14977       printf ("  Tag_GNU_Power_ABI_FP: ");
14978       if (len == 0)
14979         {
14980           printf (_("<corrupt>\n"));
14981           return p;
14982         }
14983
14984       if (val > 15)
14985         printf ("(%#x), ", val);
14986
14987       switch (val & 3)
14988         {
14989         case 0:
14990           printf (_("unspecified hard/soft float, "));
14991           break;
14992         case 1:
14993           printf (_("hard float, "));
14994           break;
14995         case 2:
14996           printf (_("soft float, "));
14997           break;
14998         case 3:
14999           printf (_("single-precision hard float, "));
15000           break;
15001         }
15002
15003       switch (val & 0xC)
15004         {
15005         case 0:
15006           printf (_("unspecified long double\n"));
15007           break;
15008         case 4:
15009           printf (_("128-bit IBM long double\n"));
15010           break;
15011         case 8:
15012           printf (_("64-bit long double\n"));
15013           break;
15014         case 12:
15015           printf (_("128-bit IEEE long double\n"));
15016           break;
15017         }
15018       return p;
15019     }
15020
15021   if (tag == Tag_GNU_Power_ABI_Vector)
15022     {
15023       val = read_uleb128 (p, &len, end);
15024       p += len;
15025       printf ("  Tag_GNU_Power_ABI_Vector: ");
15026       if (len == 0)
15027         {
15028           printf (_("<corrupt>\n"));
15029           return p;
15030         }
15031
15032       if (val > 3)
15033         printf ("(%#x), ", val);
15034
15035       switch (val & 3)
15036         {
15037         case 0:
15038           printf (_("unspecified\n"));
15039           break;
15040         case 1:
15041           printf (_("generic\n"));
15042           break;
15043         case 2:
15044           printf ("AltiVec\n");
15045           break;
15046         case 3:
15047           printf ("SPE\n");
15048           break;
15049         }
15050       return p;
15051     }
15052
15053   if (tag == Tag_GNU_Power_ABI_Struct_Return)
15054     {
15055       val = read_uleb128 (p, &len, end);
15056       p += len;
15057       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
15058       if (len == 0)
15059         {
15060           printf (_("<corrupt>\n"));
15061           return p;
15062         }
15063
15064       if (val > 2)
15065         printf ("(%#x), ", val);
15066
15067       switch (val & 3)
15068         {
15069         case 0:
15070           printf (_("unspecified\n"));
15071           break;
15072         case 1:
15073           printf ("r3/r4\n");
15074           break;
15075         case 2:
15076           printf (_("memory\n"));
15077           break;
15078         case 3:
15079           printf ("???\n");
15080           break;
15081         }
15082       return p;
15083     }
15084
15085   return display_tag_value (tag & 1, p, end);
15086 }
15087
15088 static unsigned char *
15089 display_s390_gnu_attribute (unsigned char * p,
15090                             unsigned int tag,
15091                             const unsigned char * const end)
15092 {
15093   unsigned int len;
15094   int val;
15095
15096   if (tag == Tag_GNU_S390_ABI_Vector)
15097     {
15098       val = read_uleb128 (p, &len, end);
15099       p += len;
15100       printf ("  Tag_GNU_S390_ABI_Vector: ");
15101
15102       switch (val)
15103         {
15104         case 0:
15105           printf (_("any\n"));
15106           break;
15107         case 1:
15108           printf (_("software\n"));
15109           break;
15110         case 2:
15111           printf (_("hardware\n"));
15112           break;
15113         default:
15114           printf ("??? (%d)\n", val);
15115           break;
15116         }
15117       return p;
15118    }
15119
15120   return display_tag_value (tag & 1, p, end);
15121 }
15122
15123 static void
15124 display_sparc_hwcaps (unsigned int mask)
15125 {
15126   if (mask)
15127     {
15128       bfd_boolean first = TRUE;
15129
15130       if (mask & ELF_SPARC_HWCAP_MUL32)
15131         fputs ("mul32", stdout), first = FALSE;
15132       if (mask & ELF_SPARC_HWCAP_DIV32)
15133         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
15134       if (mask & ELF_SPARC_HWCAP_FSMULD)
15135         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
15136       if (mask & ELF_SPARC_HWCAP_V8PLUS)
15137         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
15138       if (mask & ELF_SPARC_HWCAP_POPC)
15139         printf ("%spopc", first ? "" : "|"), first = FALSE;
15140       if (mask & ELF_SPARC_HWCAP_VIS)
15141         printf ("%svis", first ? "" : "|"), first = FALSE;
15142       if (mask & ELF_SPARC_HWCAP_VIS2)
15143         printf ("%svis2", first ? "" : "|"), first = FALSE;
15144       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
15145         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
15146       if (mask & ELF_SPARC_HWCAP_FMAF)
15147         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
15148       if (mask & ELF_SPARC_HWCAP_VIS3)
15149         printf ("%svis3", first ? "" : "|"), first = FALSE;
15150       if (mask & ELF_SPARC_HWCAP_HPC)
15151         printf ("%shpc", first ? "" : "|"), first = FALSE;
15152       if (mask & ELF_SPARC_HWCAP_RANDOM)
15153         printf ("%srandom", first ? "" : "|"), first = FALSE;
15154       if (mask & ELF_SPARC_HWCAP_TRANS)
15155         printf ("%strans", first ? "" : "|"), first = FALSE;
15156       if (mask & ELF_SPARC_HWCAP_FJFMAU)
15157         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
15158       if (mask & ELF_SPARC_HWCAP_IMA)
15159         printf ("%sima", first ? "" : "|"), first = FALSE;
15160       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
15161         printf ("%scspare", first ? "" : "|"), first = FALSE;
15162     }
15163   else
15164     fputc ('0', stdout);
15165   fputc ('\n', stdout);
15166 }
15167
15168 static void
15169 display_sparc_hwcaps2 (unsigned int mask)
15170 {
15171   if (mask)
15172     {
15173       bfd_boolean first = TRUE;
15174
15175       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
15176         fputs ("fjathplus", stdout), first = FALSE;
15177       if (mask & ELF_SPARC_HWCAP2_VIS3B)
15178         printf ("%svis3b", first ? "" : "|"), first = FALSE;
15179       if (mask & ELF_SPARC_HWCAP2_ADP)
15180         printf ("%sadp", first ? "" : "|"), first = FALSE;
15181       if (mask & ELF_SPARC_HWCAP2_SPARC5)
15182         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
15183       if (mask & ELF_SPARC_HWCAP2_MWAIT)
15184         printf ("%smwait", first ? "" : "|"), first = FALSE;
15185       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
15186         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
15187       if (mask & ELF_SPARC_HWCAP2_XMONT)
15188         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
15189       if (mask & ELF_SPARC_HWCAP2_NSEC)
15190         printf ("%snsec", first ? "" : "|"), first = FALSE;
15191       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
15192         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
15193       if (mask & ELF_SPARC_HWCAP2_FJDES)
15194         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
15195       if (mask & ELF_SPARC_HWCAP2_FJAES)
15196         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
15197     }
15198   else
15199     fputc ('0', stdout);
15200   fputc ('\n', stdout);
15201 }
15202
15203 static unsigned char *
15204 display_sparc_gnu_attribute (unsigned char * p,
15205                              unsigned int tag,
15206                              const unsigned char * const end)
15207 {
15208   unsigned int len;
15209   int val;
15210
15211   if (tag == Tag_GNU_Sparc_HWCAPS)
15212     {
15213       val = read_uleb128 (p, &len, end);
15214       p += len;
15215       printf ("  Tag_GNU_Sparc_HWCAPS: ");
15216       display_sparc_hwcaps (val);
15217       return p;
15218     }
15219   if (tag == Tag_GNU_Sparc_HWCAPS2)
15220     {
15221       val = read_uleb128 (p, &len, end);
15222       p += len;
15223       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
15224       display_sparc_hwcaps2 (val);
15225       return p;
15226     }
15227
15228   return display_tag_value (tag, p, end);
15229 }
15230
15231 static void
15232 print_mips_fp_abi_value (unsigned int val)
15233 {
15234   switch (val)
15235     {
15236     case Val_GNU_MIPS_ABI_FP_ANY:
15237       printf (_("Hard or soft float\n"));
15238       break;
15239     case Val_GNU_MIPS_ABI_FP_DOUBLE:
15240       printf (_("Hard float (double precision)\n"));
15241       break;
15242     case Val_GNU_MIPS_ABI_FP_SINGLE:
15243       printf (_("Hard float (single precision)\n"));
15244       break;
15245     case Val_GNU_MIPS_ABI_FP_SOFT:
15246       printf (_("Soft float\n"));
15247       break;
15248     case Val_GNU_MIPS_ABI_FP_OLD_64:
15249       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15250       break;
15251     case Val_GNU_MIPS_ABI_FP_XX:
15252       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15253       break;
15254     case Val_GNU_MIPS_ABI_FP_64:
15255       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15256       break;
15257     case Val_GNU_MIPS_ABI_FP_64A:
15258       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15259       break;
15260     case Val_GNU_MIPS_ABI_FP_NAN2008:
15261       printf (_("NaN 2008 compatibility\n"));
15262       break;
15263     default:
15264       printf ("??? (%d)\n", val);
15265       break;
15266     }
15267 }
15268
15269 static unsigned char *
15270 display_mips_gnu_attribute (unsigned char * p,
15271                             unsigned int tag,
15272                             const unsigned char * const end)
15273 {
15274   if (tag == Tag_GNU_MIPS_ABI_FP)
15275     {
15276       unsigned int len;
15277       unsigned int val;
15278
15279       val = read_uleb128 (p, &len, end);
15280       p += len;
15281       printf ("  Tag_GNU_MIPS_ABI_FP: ");
15282
15283       print_mips_fp_abi_value (val);
15284
15285       return p;
15286    }
15287
15288   if (tag == Tag_GNU_MIPS_ABI_MSA)
15289     {
15290       unsigned int len;
15291       unsigned int val;
15292
15293       val = read_uleb128 (p, &len, end);
15294       p += len;
15295       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
15296
15297       switch (val)
15298         {
15299         case Val_GNU_MIPS_ABI_MSA_ANY:
15300           printf (_("Any MSA or not\n"));
15301           break;
15302         case Val_GNU_MIPS_ABI_MSA_128:
15303           printf (_("128-bit MSA\n"));
15304           break;
15305         default:
15306           printf ("??? (%d)\n", val);
15307           break;
15308         }
15309       return p;
15310     }
15311
15312   return display_tag_value (tag & 1, p, end);
15313 }
15314
15315 static unsigned char *
15316 display_tic6x_attribute (unsigned char * p,
15317                          const unsigned char * const end)
15318 {
15319   unsigned int tag;
15320   unsigned int len;
15321   int val;
15322
15323   tag = read_uleb128 (p, &len, end);
15324   p += len;
15325
15326   switch (tag)
15327     {
15328     case Tag_ISA:
15329       val = read_uleb128 (p, &len, end);
15330       p += len;
15331       printf ("  Tag_ISA: ");
15332
15333       switch (val)
15334         {
15335         case C6XABI_Tag_ISA_none:
15336           printf (_("None\n"));
15337           break;
15338         case C6XABI_Tag_ISA_C62X:
15339           printf ("C62x\n");
15340           break;
15341         case C6XABI_Tag_ISA_C67X:
15342           printf ("C67x\n");
15343           break;
15344         case C6XABI_Tag_ISA_C67XP:
15345           printf ("C67x+\n");
15346           break;
15347         case C6XABI_Tag_ISA_C64X:
15348           printf ("C64x\n");
15349           break;
15350         case C6XABI_Tag_ISA_C64XP:
15351           printf ("C64x+\n");
15352           break;
15353         case C6XABI_Tag_ISA_C674X:
15354           printf ("C674x\n");
15355           break;
15356         default:
15357           printf ("??? (%d)\n", val);
15358           break;
15359         }
15360       return p;
15361
15362     case Tag_ABI_wchar_t:
15363       val = read_uleb128 (p, &len, end);
15364       p += len;
15365       printf ("  Tag_ABI_wchar_t: ");
15366       switch (val)
15367         {
15368         case 0:
15369           printf (_("Not used\n"));
15370           break;
15371         case 1:
15372           printf (_("2 bytes\n"));
15373           break;
15374         case 2:
15375           printf (_("4 bytes\n"));
15376           break;
15377         default:
15378           printf ("??? (%d)\n", val);
15379           break;
15380         }
15381       return p;
15382
15383     case Tag_ABI_stack_align_needed:
15384       val = read_uleb128 (p, &len, end);
15385       p += len;
15386       printf ("  Tag_ABI_stack_align_needed: ");
15387       switch (val)
15388         {
15389         case 0:
15390           printf (_("8-byte\n"));
15391           break;
15392         case 1:
15393           printf (_("16-byte\n"));
15394           break;
15395         default:
15396           printf ("??? (%d)\n", val);
15397           break;
15398         }
15399       return p;
15400
15401     case Tag_ABI_stack_align_preserved:
15402       val = read_uleb128 (p, &len, end);
15403       p += len;
15404       printf ("  Tag_ABI_stack_align_preserved: ");
15405       switch (val)
15406         {
15407         case 0:
15408           printf (_("8-byte\n"));
15409           break;
15410         case 1:
15411           printf (_("16-byte\n"));
15412           break;
15413         default:
15414           printf ("??? (%d)\n", val);
15415           break;
15416         }
15417       return p;
15418
15419     case Tag_ABI_DSBT:
15420       val = read_uleb128 (p, &len, end);
15421       p += len;
15422       printf ("  Tag_ABI_DSBT: ");
15423       switch (val)
15424         {
15425         case 0:
15426           printf (_("DSBT addressing not used\n"));
15427           break;
15428         case 1:
15429           printf (_("DSBT addressing used\n"));
15430           break;
15431         default:
15432           printf ("??? (%d)\n", val);
15433           break;
15434         }
15435       return p;
15436
15437     case Tag_ABI_PID:
15438       val = read_uleb128 (p, &len, end);
15439       p += len;
15440       printf ("  Tag_ABI_PID: ");
15441       switch (val)
15442         {
15443         case 0:
15444           printf (_("Data addressing position-dependent\n"));
15445           break;
15446         case 1:
15447           printf (_("Data addressing position-independent, GOT near DP\n"));
15448           break;
15449         case 2:
15450           printf (_("Data addressing position-independent, GOT far from DP\n"));
15451           break;
15452         default:
15453           printf ("??? (%d)\n", val);
15454           break;
15455         }
15456       return p;
15457
15458     case Tag_ABI_PIC:
15459       val = read_uleb128 (p, &len, end);
15460       p += len;
15461       printf ("  Tag_ABI_PIC: ");
15462       switch (val)
15463         {
15464         case 0:
15465           printf (_("Code addressing position-dependent\n"));
15466           break;
15467         case 1:
15468           printf (_("Code addressing position-independent\n"));
15469           break;
15470         default:
15471           printf ("??? (%d)\n", val);
15472           break;
15473         }
15474       return p;
15475
15476     case Tag_ABI_array_object_alignment:
15477       val = read_uleb128 (p, &len, end);
15478       p += len;
15479       printf ("  Tag_ABI_array_object_alignment: ");
15480       switch (val)
15481         {
15482         case 0:
15483           printf (_("8-byte\n"));
15484           break;
15485         case 1:
15486           printf (_("4-byte\n"));
15487           break;
15488         case 2:
15489           printf (_("16-byte\n"));
15490           break;
15491         default:
15492           printf ("??? (%d)\n", val);
15493           break;
15494         }
15495       return p;
15496
15497     case Tag_ABI_array_object_align_expected:
15498       val = read_uleb128 (p, &len, end);
15499       p += len;
15500       printf ("  Tag_ABI_array_object_align_expected: ");
15501       switch (val)
15502         {
15503         case 0:
15504           printf (_("8-byte\n"));
15505           break;
15506         case 1:
15507           printf (_("4-byte\n"));
15508           break;
15509         case 2:
15510           printf (_("16-byte\n"));
15511           break;
15512         default:
15513           printf ("??? (%d)\n", val);
15514           break;
15515         }
15516       return p;
15517
15518     case Tag_ABI_compatibility:
15519       {
15520         val = read_uleb128 (p, &len, end);
15521         p += len;
15522         printf ("  Tag_ABI_compatibility: ");
15523         printf (_("flag = %d, vendor = "), val);
15524         if (p < end - 1)
15525           {
15526             size_t maxlen = (end - p) - 1;
15527
15528             print_symbol ((int) maxlen, (const char *) p);
15529             p += strnlen ((char *) p, maxlen) + 1;
15530           }
15531         else
15532           {
15533             printf (_("<corrupt>"));
15534             p = (unsigned char *) end;
15535           }
15536         putchar ('\n');
15537         return p;
15538       }
15539
15540     case Tag_ABI_conformance:
15541       {
15542         printf ("  Tag_ABI_conformance: \"");
15543         if (p < end - 1)
15544           {
15545             size_t maxlen = (end - p) - 1;
15546
15547             print_symbol ((int) maxlen, (const char *) p);
15548             p += strnlen ((char *) p, maxlen) + 1;
15549           }
15550         else
15551           {
15552             printf (_("<corrupt>"));
15553             p = (unsigned char *) end;
15554           }
15555         printf ("\"\n");
15556         return p;
15557       }
15558     }
15559
15560   return display_tag_value (tag, p, end);
15561 }
15562
15563 static void
15564 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15565 {
15566   unsigned long addr = 0;
15567   size_t bytes = end - p;
15568
15569   assert (end >= p);
15570   while (bytes)
15571     {
15572       int j;
15573       int k;
15574       int lbytes = (bytes > 16 ? 16 : bytes);
15575
15576       printf ("  0x%8.8lx ", addr);
15577
15578       for (j = 0; j < 16; j++)
15579         {
15580           if (j < lbytes)
15581             printf ("%2.2x", p[j]);
15582           else
15583             printf ("  ");
15584
15585           if ((j & 3) == 3)
15586             printf (" ");
15587         }
15588
15589       for (j = 0; j < lbytes; j++)
15590         {
15591           k = p[j];
15592           if (k >= ' ' && k < 0x7f)
15593             printf ("%c", k);
15594           else
15595             printf (".");
15596         }
15597
15598       putchar ('\n');
15599
15600       p  += lbytes;
15601       bytes -= lbytes;
15602       addr += lbytes;
15603     }
15604
15605   putchar ('\n');
15606 }
15607
15608 static unsigned char *
15609 display_msp430x_attribute (unsigned char * p,
15610                            const unsigned char * const end)
15611 {
15612   unsigned int len;
15613   unsigned int val;
15614   unsigned int tag;
15615
15616   tag = read_uleb128 (p, & len, end);
15617   p += len;
15618
15619   switch (tag)
15620     {
15621     case OFBA_MSPABI_Tag_ISA:
15622       val = read_uleb128 (p, &len, end);
15623       p += len;
15624       printf ("  Tag_ISA: ");
15625       switch (val)
15626         {
15627         case 0: printf (_("None\n")); break;
15628         case 1: printf (_("MSP430\n")); break;
15629         case 2: printf (_("MSP430X\n")); break;
15630         default: printf ("??? (%d)\n", val); break;
15631         }
15632       break;
15633
15634     case OFBA_MSPABI_Tag_Code_Model:
15635       val = read_uleb128 (p, &len, end);
15636       p += len;
15637       printf ("  Tag_Code_Model: ");
15638       switch (val)
15639         {
15640         case 0: printf (_("None\n")); break;
15641         case 1: printf (_("Small\n")); break;
15642         case 2: printf (_("Large\n")); break;
15643         default: printf ("??? (%d)\n", val); break;
15644         }
15645       break;
15646
15647     case OFBA_MSPABI_Tag_Data_Model:
15648       val = read_uleb128 (p, &len, end);
15649       p += len;
15650       printf ("  Tag_Data_Model: ");
15651       switch (val)
15652         {
15653         case 0: printf (_("None\n")); break;
15654         case 1: printf (_("Small\n")); break;
15655         case 2: printf (_("Large\n")); break;
15656         case 3: printf (_("Restricted Large\n")); break;
15657         default: printf ("??? (%d)\n", val); break;
15658         }
15659       break;
15660
15661     default:
15662       printf (_("  <unknown tag %d>: "), tag);
15663
15664       if (tag & 1)
15665         {
15666           putchar ('"');
15667           if (p < end - 1)
15668             {
15669               size_t maxlen = (end - p) - 1;
15670
15671               print_symbol ((int) maxlen, (const char *) p);
15672               p += strnlen ((char *) p, maxlen) + 1;
15673             }
15674           else
15675             {
15676               printf (_("<corrupt>"));
15677               p = (unsigned char *) end;
15678             }
15679           printf ("\"\n");
15680         }
15681       else
15682         {
15683           val = read_uleb128 (p, &len, end);
15684           p += len;
15685           printf ("%d (0x%x)\n", val, val);
15686         }
15687       break;
15688    }
15689
15690   assert (p <= end);
15691   return p;
15692 }
15693
15694 struct riscv_attr_tag_t {
15695   const char *name;
15696   int tag;
15697 };
15698
15699 static struct riscv_attr_tag_t riscv_attr_tag[] =
15700 {
15701 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15702   T(arch),
15703   T(priv_spec),
15704   T(priv_spec_minor),
15705   T(priv_spec_revision),
15706   T(unaligned_access),
15707   T(stack_align),
15708 #undef T
15709 };
15710
15711 static unsigned char *
15712 display_riscv_attribute (unsigned char *p,
15713                          const unsigned char * const end)
15714 {
15715   unsigned int len;
15716   int val;
15717   int tag;
15718   struct riscv_attr_tag_t *attr = NULL;
15719   unsigned i;
15720
15721   tag = read_uleb128 (p, &len, end);
15722   p += len;
15723
15724   /* Find the name of attribute. */
15725   for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
15726     {
15727       if (riscv_attr_tag[i].tag == tag)
15728         {
15729           attr = &riscv_attr_tag[i];
15730           break;
15731         }
15732     }
15733
15734   if (attr)
15735     printf ("  %s: ", attr->name);
15736   else
15737     return display_tag_value (tag, p, end);
15738
15739   switch (tag)
15740     {
15741     case Tag_RISCV_priv_spec:
15742     case Tag_RISCV_priv_spec_minor:
15743     case Tag_RISCV_priv_spec_revision:
15744       val = read_uleb128 (p, &len, end);
15745       p += len;
15746       printf (_("%d\n"), val);
15747       break;
15748     case Tag_RISCV_unaligned_access:
15749       val = read_uleb128 (p, &len, end);
15750       p += len;
15751       switch (val)
15752         {
15753         case 0:
15754           printf (_("No unaligned access\n"));
15755           break;
15756         case 1:
15757           printf (_("Unaligned access\n"));
15758           break;
15759         }
15760       break;
15761     case Tag_RISCV_stack_align:
15762       val = read_uleb128 (p, &len, end);
15763       p += len;
15764       printf (_("%d-bytes\n"), val);
15765       break;
15766     case Tag_RISCV_arch:
15767       p = display_tag_value (-1, p, end);
15768       break;
15769     default:
15770       return display_tag_value (tag, p, end);
15771     }
15772
15773   return p;
15774 }
15775
15776 static bfd_boolean
15777 process_attributes (Filedata * filedata,
15778                     const char * public_name,
15779                     unsigned int proc_type,
15780                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15781                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15782 {
15783   Elf_Internal_Shdr * sect;
15784   unsigned i;
15785   bfd_boolean res = TRUE;
15786
15787   /* Find the section header so that we get the size.  */
15788   for (i = 0, sect = filedata->section_headers;
15789        i < filedata->file_header.e_shnum;
15790        i++, sect++)
15791     {
15792       unsigned char * contents;
15793       unsigned char * p;
15794
15795       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15796         continue;
15797
15798       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15799                                              sect->sh_size, _("attributes"));
15800       if (contents == NULL)
15801         {
15802           res = FALSE;
15803           continue;
15804         }
15805
15806       p = contents;
15807       /* The first character is the version of the attributes.
15808          Currently only version 1, (aka 'A') is recognised here.  */
15809       if (*p != 'A')
15810         {
15811           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15812           res = FALSE;
15813         }
15814       else
15815         {
15816           bfd_vma section_len;
15817
15818           section_len = sect->sh_size - 1;
15819           p++;
15820
15821           while (section_len > 0)
15822             {
15823               bfd_vma attr_len;
15824               unsigned int namelen;
15825               bfd_boolean public_section;
15826               bfd_boolean gnu_section;
15827
15828               if (section_len <= 4)
15829                 {
15830                   error (_("Tag section ends prematurely\n"));
15831                   res = FALSE;
15832                   break;
15833                 }
15834               attr_len = byte_get (p, 4);
15835               p += 4;
15836
15837               if (attr_len > section_len)
15838                 {
15839                   error (_("Bad attribute length (%u > %u)\n"),
15840                           (unsigned) attr_len, (unsigned) section_len);
15841                   attr_len = section_len;
15842                   res = FALSE;
15843                 }
15844               /* PR 17531: file: 001-101425-0.004  */
15845               else if (attr_len < 5)
15846                 {
15847                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15848                   res = FALSE;
15849                   break;
15850                 }
15851
15852               section_len -= attr_len;
15853               attr_len -= 4;
15854
15855               namelen = strnlen ((char *) p, attr_len) + 1;
15856               if (namelen == 0 || namelen >= attr_len)
15857                 {
15858                   error (_("Corrupt attribute section name\n"));
15859                   res = FALSE;
15860                   break;
15861                 }
15862
15863               printf (_("Attribute Section: "));
15864               print_symbol (INT_MAX, (const char *) p);
15865               putchar ('\n');
15866
15867               if (public_name && streq ((char *) p, public_name))
15868                 public_section = TRUE;
15869               else
15870                 public_section = FALSE;
15871
15872               if (streq ((char *) p, "gnu"))
15873                 gnu_section = TRUE;
15874               else
15875                 gnu_section = FALSE;
15876
15877               p += namelen;
15878               attr_len -= namelen;
15879
15880               while (attr_len > 0 && p < contents + sect->sh_size)
15881                 {
15882                   int tag;
15883                   int val;
15884                   bfd_vma size;
15885                   unsigned char * end;
15886
15887                   /* PR binutils/17531: Safe handling of corrupt files.  */
15888                   if (attr_len < 6)
15889                     {
15890                       error (_("Unused bytes at end of section\n"));
15891                       res = FALSE;
15892                       section_len = 0;
15893                       break;
15894                     }
15895
15896                   tag = *(p++);
15897                   size = byte_get (p, 4);
15898                   if (size > attr_len)
15899                     {
15900                       error (_("Bad subsection length (%u > %u)\n"),
15901                               (unsigned) size, (unsigned) attr_len);
15902                       res = FALSE;
15903                       size = attr_len;
15904                     }
15905                   /* PR binutils/17531: Safe handling of corrupt files.  */
15906                   if (size < 6)
15907                     {
15908                       error (_("Bad subsection length (%u < 6)\n"),
15909                               (unsigned) size);
15910                       res = FALSE;
15911                       section_len = 0;
15912                       break;
15913                     }
15914
15915                   attr_len -= size;
15916                   end = p + size - 1;
15917                   assert (end <= contents + sect->sh_size);
15918                   p += 4;
15919
15920                   switch (tag)
15921                     {
15922                     case 1:
15923                       printf (_("File Attributes\n"));
15924                       break;
15925                     case 2:
15926                       printf (_("Section Attributes:"));
15927                       goto do_numlist;
15928                     case 3:
15929                       printf (_("Symbol Attributes:"));
15930                       /* Fall through.  */
15931                     do_numlist:
15932                       for (;;)
15933                         {
15934                           unsigned int j;
15935
15936                           val = read_uleb128 (p, &j, end);
15937                           p += j;
15938                           if (val == 0)
15939                             break;
15940                           printf (" %d", val);
15941                         }
15942                       printf ("\n");
15943                       break;
15944                     default:
15945                       printf (_("Unknown tag: %d\n"), tag);
15946                       public_section = FALSE;
15947                       break;
15948                     }
15949
15950                   if (public_section && display_pub_attribute != NULL)
15951                     {
15952                       while (p < end)
15953                         p = display_pub_attribute (p, end);
15954                       assert (p == end);
15955                     }
15956                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15957                     {
15958                       while (p < end)
15959                         p = display_gnu_attribute (p,
15960                                                    display_proc_gnu_attribute,
15961                                                    end);
15962                       assert (p == end);
15963                     }
15964                   else if (p < end)
15965                     {
15966                       printf (_("  Unknown attribute:\n"));
15967                       display_raw_attribute (p, end);
15968                       p = end;
15969                     }
15970                   else
15971                     attr_len = 0;
15972                 }
15973             }
15974         }
15975
15976       free (contents);
15977     }
15978
15979   return res;
15980 }
15981
15982 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15983    Print the Address, Access and Initial fields of an entry at VMA ADDR
15984    and return the VMA of the next entry, or -1 if there was a problem.
15985    Does not read from DATA_END or beyond.  */
15986
15987 static bfd_vma
15988 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15989                       unsigned char * data_end)
15990 {
15991   printf ("  ");
15992   print_vma (addr, LONG_HEX);
15993   printf (" ");
15994   if (addr < pltgot + 0xfff0)
15995     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15996   else
15997     printf ("%10s", "");
15998   printf (" ");
15999   if (data == NULL)
16000     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16001   else
16002     {
16003       bfd_vma entry;
16004       unsigned char * from = data + addr - pltgot;
16005
16006       if (from + (is_32bit_elf ? 4 : 8) > data_end)
16007         {
16008           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16009           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
16010           return (bfd_vma) -1;
16011         }
16012       else
16013         {
16014           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16015           print_vma (entry, LONG_HEX);
16016         }
16017     }
16018   return addr + (is_32bit_elf ? 4 : 8);
16019 }
16020
16021 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16022    PLTGOT.  Print the Address and Initial fields of an entry at VMA
16023    ADDR and return the VMA of the next entry.  */
16024
16025 static bfd_vma
16026 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
16027 {
16028   printf ("  ");
16029   print_vma (addr, LONG_HEX);
16030   printf (" ");
16031   if (data == NULL)
16032     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16033   else
16034     {
16035       bfd_vma entry;
16036
16037       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16038       print_vma (entry, LONG_HEX);
16039     }
16040   return addr + (is_32bit_elf ? 4 : 8);
16041 }
16042
16043 static void
16044 print_mips_ases (unsigned int mask)
16045 {
16046   if (mask & AFL_ASE_DSP)
16047     fputs ("\n\tDSP ASE", stdout);
16048   if (mask & AFL_ASE_DSPR2)
16049     fputs ("\n\tDSP R2 ASE", stdout);
16050   if (mask & AFL_ASE_DSPR3)
16051     fputs ("\n\tDSP R3 ASE", stdout);
16052   if (mask & AFL_ASE_EVA)
16053     fputs ("\n\tEnhanced VA Scheme", stdout);
16054   if (mask & AFL_ASE_MCU)
16055     fputs ("\n\tMCU (MicroController) ASE", stdout);
16056   if (mask & AFL_ASE_MDMX)
16057     fputs ("\n\tMDMX ASE", stdout);
16058   if (mask & AFL_ASE_MIPS3D)
16059     fputs ("\n\tMIPS-3D ASE", stdout);
16060   if (mask & AFL_ASE_MT)
16061     fputs ("\n\tMT ASE", stdout);
16062   if (mask & AFL_ASE_SMARTMIPS)
16063     fputs ("\n\tSmartMIPS ASE", stdout);
16064   if (mask & AFL_ASE_VIRT)
16065     fputs ("\n\tVZ ASE", stdout);
16066   if (mask & AFL_ASE_MSA)
16067     fputs ("\n\tMSA ASE", stdout);
16068   if (mask & AFL_ASE_MIPS16)
16069     fputs ("\n\tMIPS16 ASE", stdout);
16070   if (mask & AFL_ASE_MICROMIPS)
16071     fputs ("\n\tMICROMIPS ASE", stdout);
16072   if (mask & AFL_ASE_XPA)
16073     fputs ("\n\tXPA ASE", stdout);
16074   if (mask & AFL_ASE_MIPS16E2)
16075     fputs ("\n\tMIPS16e2 ASE", stdout);
16076   if (mask & AFL_ASE_CRC)
16077     fputs ("\n\tCRC ASE", stdout);
16078   if (mask & AFL_ASE_GINV)
16079     fputs ("\n\tGINV ASE", stdout);
16080   if (mask & AFL_ASE_LOONGSON_MMI)
16081     fputs ("\n\tLoongson MMI ASE", stdout);
16082   if (mask & AFL_ASE_LOONGSON_CAM)
16083     fputs ("\n\tLoongson CAM ASE", stdout);
16084   if (mask & AFL_ASE_LOONGSON_EXT)
16085     fputs ("\n\tLoongson EXT ASE", stdout);
16086   if (mask & AFL_ASE_LOONGSON_EXT2)
16087     fputs ("\n\tLoongson EXT2 ASE", stdout);
16088   if (mask == 0)
16089     fprintf (stdout, "\n\t%s", _("None"));
16090   else if ((mask & ~AFL_ASE_MASK) != 0)
16091     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
16092 }
16093
16094 static void
16095 print_mips_isa_ext (unsigned int isa_ext)
16096 {
16097   switch (isa_ext)
16098     {
16099     case 0:
16100       fputs (_("None"), stdout);
16101       break;
16102     case AFL_EXT_XLR:
16103       fputs ("RMI XLR", stdout);
16104       break;
16105     case AFL_EXT_OCTEON3:
16106       fputs ("Cavium Networks Octeon3", stdout);
16107       break;
16108     case AFL_EXT_OCTEON2:
16109       fputs ("Cavium Networks Octeon2", stdout);
16110       break;
16111     case AFL_EXT_OCTEONP:
16112       fputs ("Cavium Networks OcteonP", stdout);
16113       break;
16114     case AFL_EXT_OCTEON:
16115       fputs ("Cavium Networks Octeon", stdout);
16116       break;
16117     case AFL_EXT_5900:
16118       fputs ("Toshiba R5900", stdout);
16119       break;
16120     case AFL_EXT_4650:
16121       fputs ("MIPS R4650", stdout);
16122       break;
16123     case AFL_EXT_4010:
16124       fputs ("LSI R4010", stdout);
16125       break;
16126     case AFL_EXT_4100:
16127       fputs ("NEC VR4100", stdout);
16128       break;
16129     case AFL_EXT_3900:
16130       fputs ("Toshiba R3900", stdout);
16131       break;
16132     case AFL_EXT_10000:
16133       fputs ("MIPS R10000", stdout);
16134       break;
16135     case AFL_EXT_SB1:
16136       fputs ("Broadcom SB-1", stdout);
16137       break;
16138     case AFL_EXT_4111:
16139       fputs ("NEC VR4111/VR4181", stdout);
16140       break;
16141     case AFL_EXT_4120:
16142       fputs ("NEC VR4120", stdout);
16143       break;
16144     case AFL_EXT_5400:
16145       fputs ("NEC VR5400", stdout);
16146       break;
16147     case AFL_EXT_5500:
16148       fputs ("NEC VR5500", stdout);
16149       break;
16150     case AFL_EXT_LOONGSON_2E:
16151       fputs ("ST Microelectronics Loongson 2E", stdout);
16152       break;
16153     case AFL_EXT_LOONGSON_2F:
16154       fputs ("ST Microelectronics Loongson 2F", stdout);
16155       break;
16156     case AFL_EXT_INTERAPTIV_MR2:
16157       fputs ("Imagination interAptiv MR2", stdout);
16158       break;
16159     default:
16160       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
16161     }
16162 }
16163
16164 static signed int
16165 get_mips_reg_size (int reg_size)
16166 {
16167   return (reg_size == AFL_REG_NONE) ? 0
16168          : (reg_size == AFL_REG_32) ? 32
16169          : (reg_size == AFL_REG_64) ? 64
16170          : (reg_size == AFL_REG_128) ? 128
16171          : -1;
16172 }
16173
16174 static bfd_boolean
16175 process_mips_specific (Filedata * filedata)
16176 {
16177   Elf_Internal_Dyn * entry;
16178   Elf_Internal_Shdr *sect = NULL;
16179   size_t liblist_offset = 0;
16180   size_t liblistno = 0;
16181   size_t conflictsno = 0;
16182   size_t options_offset = 0;
16183   size_t conflicts_offset = 0;
16184   size_t pltrelsz = 0;
16185   size_t pltrel = 0;
16186   bfd_vma pltgot = 0;
16187   bfd_vma mips_pltgot = 0;
16188   bfd_vma jmprel = 0;
16189   bfd_vma local_gotno = 0;
16190   bfd_vma gotsym = 0;
16191   bfd_vma symtabno = 0;
16192   bfd_boolean res = TRUE;
16193
16194   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
16195                             display_mips_gnu_attribute))
16196     res = FALSE;
16197
16198   sect = find_section (filedata, ".MIPS.abiflags");
16199
16200   if (sect != NULL)
16201     {
16202       Elf_External_ABIFlags_v0 *abiflags_ext;
16203       Elf_Internal_ABIFlags_v0 abiflags_in;
16204
16205       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
16206         {
16207           error (_("Corrupt MIPS ABI Flags section.\n"));
16208           res = FALSE;
16209         }
16210       else
16211         {
16212           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
16213                                    sect->sh_size, _("MIPS ABI Flags section"));
16214           if (abiflags_ext)
16215             {
16216               abiflags_in.version = BYTE_GET (abiflags_ext->version);
16217               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
16218               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
16219               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
16220               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
16221               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
16222               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
16223               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
16224               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
16225               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
16226               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
16227
16228               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
16229               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
16230               if (abiflags_in.isa_rev > 1)
16231                 printf ("r%d", abiflags_in.isa_rev);
16232               printf ("\nGPR size: %d",
16233                       get_mips_reg_size (abiflags_in.gpr_size));
16234               printf ("\nCPR1 size: %d",
16235                       get_mips_reg_size (abiflags_in.cpr1_size));
16236               printf ("\nCPR2 size: %d",
16237                       get_mips_reg_size (abiflags_in.cpr2_size));
16238               fputs ("\nFP ABI: ", stdout);
16239               print_mips_fp_abi_value (abiflags_in.fp_abi);
16240               fputs ("ISA Extension: ", stdout);
16241               print_mips_isa_ext (abiflags_in.isa_ext);
16242               fputs ("\nASEs:", stdout);
16243               print_mips_ases (abiflags_in.ases);
16244               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
16245               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
16246               fputc ('\n', stdout);
16247               free (abiflags_ext);
16248             }
16249         }
16250     }
16251
16252   /* We have a lot of special sections.  Thanks SGI!  */
16253   if (dynamic_section == NULL)
16254     {
16255       /* No dynamic information available.  See if there is static GOT.  */
16256       sect = find_section (filedata, ".got");
16257       if (sect != NULL)
16258         {
16259           unsigned char *data_end;
16260           unsigned char *data;
16261           bfd_vma ent, end;
16262           int addr_size;
16263
16264           pltgot = sect->sh_addr;
16265
16266           ent = pltgot;
16267           addr_size = (is_32bit_elf ? 4 : 8);
16268           end = pltgot + sect->sh_size;
16269
16270           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
16271                                              end - pltgot, 1,
16272                                              _("Global Offset Table data"));
16273           /* PR 12855: Null data is handled gracefully throughout.  */
16274           data_end = data + (end - pltgot);
16275
16276           printf (_("\nStatic GOT:\n"));
16277           printf (_(" Canonical gp value: "));
16278           print_vma (ent + 0x7ff0, LONG_HEX);
16279           printf ("\n\n");
16280
16281           /* In a dynamic binary GOT[0] is reserved for the dynamic
16282              loader to store the lazy resolver pointer, however in
16283              a static binary it may well have been omitted and GOT
16284              reduced to a table of addresses.
16285              PR 21344: Check for the entry being fully available
16286              before fetching it.  */
16287           if (data
16288               && data + ent - pltgot + addr_size <= data_end
16289               && byte_get (data + ent - pltgot, addr_size) == 0)
16290             {
16291               printf (_(" Reserved entries:\n"));
16292               printf (_("  %*s %10s %*s\n"),
16293                       addr_size * 2, _("Address"), _("Access"),
16294                       addr_size * 2, _("Value"));
16295               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16296               printf ("\n");
16297               if (ent == (bfd_vma) -1)
16298                 goto sgot_print_fail;
16299
16300               /* Check for the MSB of GOT[1] being set, identifying a
16301                  GNU object.  This entry will be used by some runtime
16302                  loaders, to store the module pointer.  Otherwise this
16303                  is an ordinary local entry.
16304                  PR 21344: Check for the entry being fully available
16305                  before fetching it.  */
16306               if (data
16307                   && data + ent - pltgot + addr_size <= data_end
16308                   && (byte_get (data + ent - pltgot, addr_size)
16309                       >> (addr_size * 8 - 1)) != 0)
16310                 {
16311                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
16312                   printf ("\n");
16313                   if (ent == (bfd_vma) -1)
16314                     goto sgot_print_fail;
16315                 }
16316               printf ("\n");
16317             }
16318
16319           if (data != NULL && ent < end)
16320             {
16321               printf (_(" Local entries:\n"));
16322               printf ("  %*s %10s %*s\n",
16323                       addr_size * 2, _("Address"), _("Access"),
16324                       addr_size * 2, _("Value"));
16325               while (ent < end)
16326                 {
16327                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
16328                   printf ("\n");
16329                   if (ent == (bfd_vma) -1)
16330                     goto sgot_print_fail;
16331                 }
16332               printf ("\n");
16333             }
16334
16335         sgot_print_fail:
16336           if (data)
16337             free (data);
16338         }
16339       return res;
16340     }
16341
16342   for (entry = dynamic_section;
16343        /* PR 17531 file: 012-50589-0.004.  */
16344        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
16345        ++entry)
16346     switch (entry->d_tag)
16347       {
16348       case DT_MIPS_LIBLIST:
16349         liblist_offset
16350           = offset_from_vma (filedata, entry->d_un.d_val,
16351                              liblistno * sizeof (Elf32_External_Lib));
16352         break;
16353       case DT_MIPS_LIBLISTNO:
16354         liblistno = entry->d_un.d_val;
16355         break;
16356       case DT_MIPS_OPTIONS:
16357         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
16358         break;
16359       case DT_MIPS_CONFLICT:
16360         conflicts_offset
16361           = offset_from_vma (filedata, entry->d_un.d_val,
16362                              conflictsno * sizeof (Elf32_External_Conflict));
16363         break;
16364       case DT_MIPS_CONFLICTNO:
16365         conflictsno = entry->d_un.d_val;
16366         break;
16367       case DT_PLTGOT:
16368         pltgot = entry->d_un.d_ptr;
16369         break;
16370       case DT_MIPS_LOCAL_GOTNO:
16371         local_gotno = entry->d_un.d_val;
16372         break;
16373       case DT_MIPS_GOTSYM:
16374         gotsym = entry->d_un.d_val;
16375         break;
16376       case DT_MIPS_SYMTABNO:
16377         symtabno = entry->d_un.d_val;
16378         break;
16379       case DT_MIPS_PLTGOT:
16380         mips_pltgot = entry->d_un.d_ptr;
16381         break;
16382       case DT_PLTREL:
16383         pltrel = entry->d_un.d_val;
16384         break;
16385       case DT_PLTRELSZ:
16386         pltrelsz = entry->d_un.d_val;
16387         break;
16388       case DT_JMPREL:
16389         jmprel = entry->d_un.d_ptr;
16390         break;
16391       default:
16392         break;
16393       }
16394
16395   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
16396     {
16397       Elf32_External_Lib * elib;
16398       size_t cnt;
16399
16400       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
16401                                               liblistno,
16402                                               sizeof (Elf32_External_Lib),
16403                                               _("liblist section data"));
16404       if (elib)
16405         {
16406           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16407                             "\nSection '.liblist' contains %lu entries:\n",
16408                             (unsigned long) liblistno),
16409                   (unsigned long) liblistno);
16410           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
16411                  stdout);
16412
16413           for (cnt = 0; cnt < liblistno; ++cnt)
16414             {
16415               Elf32_Lib liblist;
16416               time_t atime;
16417               char timebuf[128];
16418               struct tm * tmp;
16419
16420               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16421               atime = BYTE_GET (elib[cnt].l_time_stamp);
16422               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16423               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16424               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16425
16426               tmp = gmtime (&atime);
16427               snprintf (timebuf, sizeof (timebuf),
16428                         "%04u-%02u-%02uT%02u:%02u:%02u",
16429                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16430                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16431
16432               printf ("%3lu: ", (unsigned long) cnt);
16433               if (VALID_DYNAMIC_NAME (liblist.l_name))
16434                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16435               else
16436                 printf (_("<corrupt: %9ld>"), liblist.l_name);
16437               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16438                       liblist.l_version);
16439
16440               if (liblist.l_flags == 0)
16441                 puts (_(" NONE"));
16442               else
16443                 {
16444                   static const struct
16445                   {
16446                     const char * name;
16447                     int bit;
16448                   }
16449                   l_flags_vals[] =
16450                   {
16451                     { " EXACT_MATCH", LL_EXACT_MATCH },
16452                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16453                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16454                     { " EXPORTS", LL_EXPORTS },
16455                     { " DELAY_LOAD", LL_DELAY_LOAD },
16456                     { " DELTA", LL_DELTA }
16457                   };
16458                   int flags = liblist.l_flags;
16459                   size_t fcnt;
16460
16461                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16462                     if ((flags & l_flags_vals[fcnt].bit) != 0)
16463                       {
16464                         fputs (l_flags_vals[fcnt].name, stdout);
16465                         flags ^= l_flags_vals[fcnt].bit;
16466                       }
16467                   if (flags != 0)
16468                     printf (" %#x", (unsigned int) flags);
16469
16470                   puts ("");
16471                 }
16472             }
16473
16474           free (elib);
16475         }
16476       else
16477         res = FALSE;
16478     }
16479
16480   if (options_offset != 0)
16481     {
16482       Elf_External_Options * eopt;
16483       size_t offset;
16484       int cnt;
16485       sect = filedata->section_headers;
16486
16487       /* Find the section header so that we get the size.  */
16488       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16489       /* PR 17533 file: 012-277276-0.004.  */
16490       if (sect == NULL)
16491         {
16492           error (_("No MIPS_OPTIONS header found\n"));
16493           return FALSE;
16494         }
16495       /* PR 24243  */
16496       if (sect->sh_size < sizeof (* eopt))
16497         {
16498           error (_("The MIPS options section is too small.\n"));
16499           return FALSE;
16500         }
16501
16502       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16503                                                 sect->sh_size, _("options"));
16504       if (eopt)
16505         {
16506           Elf_Internal_Options * iopt;
16507           Elf_Internal_Options * option;
16508           Elf_Internal_Options * iopt_end;
16509
16510           iopt = (Elf_Internal_Options *)
16511               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16512           if (iopt == NULL)
16513             {
16514               error (_("Out of memory allocating space for MIPS options\n"));
16515               return FALSE;
16516             }
16517
16518           offset = cnt = 0;
16519           option = iopt;
16520           iopt_end = iopt + (sect->sh_size / sizeof (eopt));
16521
16522           while (offset <= sect->sh_size - sizeof (* eopt))
16523             {
16524               Elf_External_Options * eoption;
16525
16526               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16527
16528               option->kind = BYTE_GET (eoption->kind);
16529               option->size = BYTE_GET (eoption->size);
16530               option->section = BYTE_GET (eoption->section);
16531               option->info = BYTE_GET (eoption->info);
16532
16533               /* PR 17531: file: ffa0fa3b.  */
16534               if (option->size < sizeof (* eopt)
16535                   || offset + option->size > sect->sh_size)
16536                 {
16537                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
16538                   return FALSE;
16539                 }
16540               offset += option->size;
16541
16542               ++option;
16543               ++cnt;
16544             }
16545
16546           printf (ngettext ("\nSection '%s' contains %d entry:\n",
16547                             "\nSection '%s' contains %d entries:\n",
16548                             cnt),
16549                   printable_section_name (filedata, sect), cnt);
16550
16551           option = iopt;
16552           offset = 0;
16553
16554           while (cnt-- > 0)
16555             {
16556               size_t len;
16557
16558               switch (option->kind)
16559                 {
16560                 case ODK_NULL:
16561                   /* This shouldn't happen.  */
16562                   printf (" NULL       %d %lx", option->section, option->info);
16563                   break;
16564
16565                 case ODK_REGINFO:
16566                   printf (" REGINFO    ");
16567                   if (filedata->file_header.e_machine == EM_MIPS)
16568                     {
16569                       Elf32_External_RegInfo * ereg;
16570                       Elf32_RegInfo reginfo;
16571
16572                       /* 32bit form.  */
16573                       if (option + 2 > iopt_end)
16574                         {
16575                           printf (_("<corrupt>\n"));
16576                           error (_("Truncated MIPS REGINFO option\n"));
16577                           cnt = 0;
16578                           break;
16579                         }
16580
16581                       ereg = (Elf32_External_RegInfo *) (option + 1);
16582
16583                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16584                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16585                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16586                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16587                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16588                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16589
16590                       printf ("GPR %08lx  GP 0x%lx\n",
16591                               reginfo.ri_gprmask,
16592                               (unsigned long) reginfo.ri_gp_value);
16593                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16594                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16595                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16596                     }
16597                   else
16598                     {
16599                       /* 64 bit form.  */
16600                       Elf64_External_RegInfo * ereg;
16601                       Elf64_Internal_RegInfo reginfo;
16602
16603                       if (option + 2 > iopt_end)
16604                         {
16605                           printf (_("<corrupt>\n"));
16606                           error (_("Truncated MIPS REGINFO option\n"));
16607                           cnt = 0;
16608                           break;
16609                         }
16610
16611                       ereg = (Elf64_External_RegInfo *) (option + 1);
16612                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
16613                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16614                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16615                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16616                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16617                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16618
16619                       printf ("GPR %08lx  GP 0x",
16620                               reginfo.ri_gprmask);
16621                       printf_vma (reginfo.ri_gp_value);
16622                       printf ("\n");
16623
16624                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16625                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16626                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16627                     }
16628                   ++option;
16629                   continue;
16630
16631                 case ODK_EXCEPTIONS:
16632                   fputs (" EXCEPTIONS fpe_min(", stdout);
16633                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16634                   fputs (") fpe_max(", stdout);
16635                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16636                   fputs (")", stdout);
16637
16638                   if (option->info & OEX_PAGE0)
16639                     fputs (" PAGE0", stdout);
16640                   if (option->info & OEX_SMM)
16641                     fputs (" SMM", stdout);
16642                   if (option->info & OEX_FPDBUG)
16643                     fputs (" FPDBUG", stdout);
16644                   if (option->info & OEX_DISMISS)
16645                     fputs (" DISMISS", stdout);
16646                   break;
16647
16648                 case ODK_PAD:
16649                   fputs (" PAD       ", stdout);
16650                   if (option->info & OPAD_PREFIX)
16651                     fputs (" PREFIX", stdout);
16652                   if (option->info & OPAD_POSTFIX)
16653                     fputs (" POSTFIX", stdout);
16654                   if (option->info & OPAD_SYMBOL)
16655                     fputs (" SYMBOL", stdout);
16656                   break;
16657
16658                 case ODK_HWPATCH:
16659                   fputs (" HWPATCH   ", stdout);
16660                   if (option->info & OHW_R4KEOP)
16661                     fputs (" R4KEOP", stdout);
16662                   if (option->info & OHW_R8KPFETCH)
16663                     fputs (" R8KPFETCH", stdout);
16664                   if (option->info & OHW_R5KEOP)
16665                     fputs (" R5KEOP", stdout);
16666                   if (option->info & OHW_R5KCVTL)
16667                     fputs (" R5KCVTL", stdout);
16668                   break;
16669
16670                 case ODK_FILL:
16671                   fputs (" FILL       ", stdout);
16672                   /* XXX Print content of info word?  */
16673                   break;
16674
16675                 case ODK_TAGS:
16676                   fputs (" TAGS       ", stdout);
16677                   /* XXX Print content of info word?  */
16678                   break;
16679
16680                 case ODK_HWAND:
16681                   fputs (" HWAND     ", stdout);
16682                   if (option->info & OHWA0_R4KEOP_CHECKED)
16683                     fputs (" R4KEOP_CHECKED", stdout);
16684                   if (option->info & OHWA0_R4KEOP_CLEAN)
16685                     fputs (" R4KEOP_CLEAN", stdout);
16686                   break;
16687
16688                 case ODK_HWOR:
16689                   fputs (" HWOR      ", stdout);
16690                   if (option->info & OHWA0_R4KEOP_CHECKED)
16691                     fputs (" R4KEOP_CHECKED", stdout);
16692                   if (option->info & OHWA0_R4KEOP_CLEAN)
16693                     fputs (" R4KEOP_CLEAN", stdout);
16694                   break;
16695
16696                 case ODK_GP_GROUP:
16697                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16698                           option->info & OGP_GROUP,
16699                           (option->info & OGP_SELF) >> 16);
16700                   break;
16701
16702                 case ODK_IDENT:
16703                   printf (" IDENT     %#06lx  self-contained %#06lx",
16704                           option->info & OGP_GROUP,
16705                           (option->info & OGP_SELF) >> 16);
16706                   break;
16707
16708                 default:
16709                   /* This shouldn't happen.  */
16710                   printf (" %3d ???     %d %lx",
16711                           option->kind, option->section, option->info);
16712                   break;
16713                 }
16714
16715               len = sizeof (* eopt);
16716               while (len < option->size)
16717                 {
16718                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16719
16720                   if (ISPRINT (datum))
16721                     printf ("%c", datum);
16722                   else
16723                     printf ("\\%03o", datum);
16724                   len ++;
16725                 }
16726               fputs ("\n", stdout);
16727
16728               offset += option->size;
16729               ++option;
16730             }
16731
16732           free (eopt);
16733         }
16734       else
16735         res = FALSE;
16736     }
16737
16738   if (conflicts_offset != 0 && conflictsno != 0)
16739     {
16740       Elf32_Conflict * iconf;
16741       size_t cnt;
16742
16743       if (dynamic_symbols == NULL)
16744         {
16745           error (_("conflict list found without a dynamic symbol table\n"));
16746           return FALSE;
16747         }
16748
16749       /* PR 21345 - print a slightly more helpful error message
16750          if we are sure that the cmalloc will fail.  */
16751       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16752         {
16753           error (_("Overlarge number of conflicts detected: %lx\n"),
16754                  (long) conflictsno);
16755           return FALSE;
16756         }
16757
16758       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16759       if (iconf == NULL)
16760         {
16761           error (_("Out of memory allocating space for dynamic conflicts\n"));
16762           return FALSE;
16763         }
16764
16765       if (is_32bit_elf)
16766         {
16767           Elf32_External_Conflict * econf32;
16768
16769           econf32 = (Elf32_External_Conflict *)
16770               get_data (NULL, filedata, conflicts_offset, conflictsno,
16771                         sizeof (* econf32), _("conflict"));
16772           if (!econf32)
16773             return FALSE;
16774
16775           for (cnt = 0; cnt < conflictsno; ++cnt)
16776             iconf[cnt] = BYTE_GET (econf32[cnt]);
16777
16778           free (econf32);
16779         }
16780       else
16781         {
16782           Elf64_External_Conflict * econf64;
16783
16784           econf64 = (Elf64_External_Conflict *)
16785               get_data (NULL, filedata, conflicts_offset, conflictsno,
16786                         sizeof (* econf64), _("conflict"));
16787           if (!econf64)
16788             return FALSE;
16789
16790           for (cnt = 0; cnt < conflictsno; ++cnt)
16791             iconf[cnt] = BYTE_GET (econf64[cnt]);
16792
16793           free (econf64);
16794         }
16795
16796       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16797                         "\nSection '.conflict' contains %lu entries:\n",
16798                         (unsigned long) conflictsno),
16799               (unsigned long) conflictsno);
16800       puts (_("  Num:    Index       Value  Name"));
16801
16802       for (cnt = 0; cnt < conflictsno; ++cnt)
16803         {
16804           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16805
16806           if (iconf[cnt] >= num_dynamic_syms)
16807             printf (_("<corrupt symbol index>"));
16808           else
16809             {
16810               Elf_Internal_Sym * psym;
16811
16812               psym = & dynamic_symbols[iconf[cnt]];
16813               print_vma (psym->st_value, FULL_HEX);
16814               putchar (' ');
16815               if (VALID_DYNAMIC_NAME (psym->st_name))
16816                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16817               else
16818                 printf (_("<corrupt: %14ld>"), psym->st_name);
16819             }
16820           putchar ('\n');
16821         }
16822
16823       free (iconf);
16824     }
16825
16826   if (pltgot != 0 && local_gotno != 0)
16827     {
16828       bfd_vma ent, local_end, global_end;
16829       size_t i, offset;
16830       unsigned char * data;
16831       unsigned char * data_end;
16832       int addr_size;
16833
16834       ent = pltgot;
16835       addr_size = (is_32bit_elf ? 4 : 8);
16836       local_end = pltgot + local_gotno * addr_size;
16837
16838       /* PR binutils/17533 file: 012-111227-0.004  */
16839       if (symtabno < gotsym)
16840         {
16841           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16842                  (unsigned long) gotsym, (unsigned long) symtabno);
16843           return FALSE;
16844         }
16845
16846       global_end = local_end + (symtabno - gotsym) * addr_size;
16847       /* PR 17531: file: 54c91a34.  */
16848       if (global_end < local_end)
16849         {
16850           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16851           return FALSE;
16852         }
16853
16854       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16855       data = (unsigned char *) get_data (NULL, filedata, offset,
16856                                          global_end - pltgot, 1,
16857                                          _("Global Offset Table data"));
16858       /* PR 12855: Null data is handled gracefully throughout.  */
16859       data_end = data + (global_end - pltgot);
16860
16861       printf (_("\nPrimary GOT:\n"));
16862       printf (_(" Canonical gp value: "));
16863       print_vma (pltgot + 0x7ff0, LONG_HEX);
16864       printf ("\n\n");
16865
16866       printf (_(" Reserved entries:\n"));
16867       printf (_("  %*s %10s %*s Purpose\n"),
16868               addr_size * 2, _("Address"), _("Access"),
16869               addr_size * 2, _("Initial"));
16870       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16871       printf (_(" Lazy resolver\n"));
16872       if (ent == (bfd_vma) -1)
16873         goto got_print_fail;
16874
16875       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16876          This entry will be used by some runtime loaders, to store the
16877          module pointer.  Otherwise this is an ordinary local entry.
16878          PR 21344: Check for the entry being fully available before
16879          fetching it.  */
16880       if (data
16881           && data + ent - pltgot + addr_size <= data_end
16882           && (byte_get (data + ent - pltgot, addr_size)
16883               >> (addr_size * 8 - 1)) != 0)
16884         {
16885           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16886           printf (_(" Module pointer (GNU extension)\n"));
16887           if (ent == (bfd_vma) -1)
16888             goto got_print_fail;
16889         }
16890       printf ("\n");
16891
16892       if (data != NULL && ent < local_end)
16893         {
16894           printf (_(" Local entries:\n"));
16895           printf ("  %*s %10s %*s\n",
16896                   addr_size * 2, _("Address"), _("Access"),
16897                   addr_size * 2, _("Initial"));
16898           while (ent < local_end)
16899             {
16900               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16901               printf ("\n");
16902               if (ent == (bfd_vma) -1)
16903                 goto got_print_fail;
16904             }
16905           printf ("\n");
16906         }
16907
16908       if (data != NULL && gotsym < symtabno)
16909         {
16910           int sym_width;
16911
16912           printf (_(" Global entries:\n"));
16913           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16914                   addr_size * 2, _("Address"),
16915                   _("Access"),
16916                   addr_size * 2, _("Initial"),
16917                   addr_size * 2, _("Sym.Val."),
16918                   _("Type"),
16919                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16920                   _("Ndx"), _("Name"));
16921
16922           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16923
16924           for (i = gotsym; i < symtabno; i++)
16925             {
16926               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16927               printf (" ");
16928
16929               if (dynamic_symbols == NULL)
16930                 printf (_("<no dynamic symbols>"));
16931               else if (i < num_dynamic_syms)
16932                 {
16933                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16934
16935                   print_vma (psym->st_value, LONG_HEX);
16936                   printf (" %-7s %3s ",
16937                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16938                           get_symbol_index_type (filedata, psym->st_shndx));
16939
16940                   if (VALID_DYNAMIC_NAME (psym->st_name))
16941                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16942                   else
16943                     printf (_("<corrupt: %14ld>"), psym->st_name);
16944                 }
16945               else
16946                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16947                         (unsigned long) i);
16948
16949               printf ("\n");
16950               if (ent == (bfd_vma) -1)
16951                 break;
16952             }
16953           printf ("\n");
16954         }
16955
16956     got_print_fail:
16957       if (data)
16958         free (data);
16959     }
16960
16961   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16962     {
16963       bfd_vma ent, end;
16964       size_t offset, rel_offset;
16965       unsigned long count, i;
16966       unsigned char * data;
16967       int addr_size, sym_width;
16968       Elf_Internal_Rela * rels;
16969
16970       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16971       if (pltrel == DT_RELA)
16972         {
16973           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16974             return FALSE;
16975         }
16976       else
16977         {
16978           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16979             return FALSE;
16980         }
16981
16982       ent = mips_pltgot;
16983       addr_size = (is_32bit_elf ? 4 : 8);
16984       end = mips_pltgot + (2 + count) * addr_size;
16985
16986       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16987       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16988                                          1, _("Procedure Linkage Table data"));
16989       if (data == NULL)
16990         return FALSE;
16991
16992       printf ("\nPLT GOT:\n\n");
16993       printf (_(" Reserved entries:\n"));
16994       printf (_("  %*s %*s Purpose\n"),
16995               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16996       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16997       printf (_(" PLT lazy resolver\n"));
16998       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16999       printf (_(" Module pointer\n"));
17000       printf ("\n");
17001
17002       printf (_(" Entries:\n"));
17003       printf ("  %*s %*s %*s %-7s %3s %s\n",
17004               addr_size * 2, _("Address"),
17005               addr_size * 2, _("Initial"),
17006               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17007       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
17008       for (i = 0; i < count; i++)
17009         {
17010           unsigned long idx = get_reloc_symindex (rels[i].r_info);
17011
17012           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17013           printf (" ");
17014
17015           if (idx >= num_dynamic_syms)
17016             printf (_("<corrupt symbol index: %lu>"), idx);
17017           else
17018             {
17019               Elf_Internal_Sym * psym = dynamic_symbols + idx;
17020
17021               print_vma (psym->st_value, LONG_HEX);
17022               printf (" %-7s %3s ",
17023                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17024                       get_symbol_index_type (filedata, psym->st_shndx));
17025               if (VALID_DYNAMIC_NAME (psym->st_name))
17026                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
17027               else
17028                 printf (_("<corrupt: %14ld>"), psym->st_name);
17029             }
17030           printf ("\n");
17031         }
17032       printf ("\n");
17033
17034       if (data)
17035         free (data);
17036       free (rels);
17037     }
17038
17039   return res;
17040 }
17041
17042 static bfd_boolean
17043 process_nds32_specific (Filedata * filedata)
17044 {
17045   Elf_Internal_Shdr *sect = NULL;
17046
17047   sect = find_section (filedata, ".nds32_e_flags");
17048   if (sect != NULL)
17049     {
17050       unsigned int *flag;
17051
17052       printf ("\nNDS32 elf flags section:\n");
17053       flag = get_data (NULL, filedata, sect->sh_offset, 1,
17054                        sect->sh_size, _("NDS32 elf flags section"));
17055
17056       if (! flag)
17057         return FALSE;
17058
17059       switch ((*flag) & 0x3)
17060         {
17061         case 0:
17062           printf ("(VEC_SIZE):\tNo entry.\n");
17063           break;
17064         case 1:
17065           printf ("(VEC_SIZE):\t4 bytes\n");
17066           break;
17067         case 2:
17068           printf ("(VEC_SIZE):\t16 bytes\n");
17069           break;
17070         case 3:
17071           printf ("(VEC_SIZE):\treserved\n");
17072           break;
17073         }
17074     }
17075
17076   return TRUE;
17077 }
17078
17079 static bfd_boolean
17080 process_gnu_liblist (Filedata * filedata)
17081 {
17082   Elf_Internal_Shdr * section;
17083   Elf_Internal_Shdr * string_sec;
17084   Elf32_External_Lib * elib;
17085   char * strtab;
17086   size_t strtab_size;
17087   size_t cnt;
17088   unsigned long num_liblist;
17089   unsigned i;
17090   bfd_boolean res = TRUE;
17091
17092   if (! do_arch)
17093     return TRUE;
17094
17095   for (i = 0, section = filedata->section_headers;
17096        i < filedata->file_header.e_shnum;
17097        i++, section++)
17098     {
17099       switch (section->sh_type)
17100         {
17101         case SHT_GNU_LIBLIST:
17102           if (section->sh_link >= filedata->file_header.e_shnum)
17103             break;
17104
17105           elib = (Elf32_External_Lib *)
17106               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
17107                         _("liblist section data"));
17108
17109           if (elib == NULL)
17110             {
17111               res = FALSE;
17112               break;
17113             }
17114
17115           string_sec = filedata->section_headers + section->sh_link;
17116           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
17117                                       string_sec->sh_size,
17118                                       _("liblist string table"));
17119           if (strtab == NULL
17120               || section->sh_entsize != sizeof (Elf32_External_Lib))
17121             {
17122               free (elib);
17123               free (strtab);
17124               res = FALSE;
17125               break;
17126             }
17127           strtab_size = string_sec->sh_size;
17128
17129           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
17130           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17131                             "\nLibrary list section '%s' contains %lu entries:\n",
17132                             num_liblist),
17133                   printable_section_name (filedata, section),
17134                   num_liblist);
17135
17136           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
17137
17138           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
17139                ++cnt)
17140             {
17141               Elf32_Lib liblist;
17142               time_t atime;
17143               char timebuf[128];
17144               struct tm * tmp;
17145
17146               liblist.l_name = BYTE_GET (elib[cnt].l_name);
17147               atime = BYTE_GET (elib[cnt].l_time_stamp);
17148               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
17149               liblist.l_version = BYTE_GET (elib[cnt].l_version);
17150               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
17151
17152               tmp = gmtime (&atime);
17153               snprintf (timebuf, sizeof (timebuf),
17154                         "%04u-%02u-%02uT%02u:%02u:%02u",
17155                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
17156                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
17157
17158               printf ("%3lu: ", (unsigned long) cnt);
17159               if (do_wide)
17160                 printf ("%-20s", liblist.l_name < strtab_size
17161                         ? strtab + liblist.l_name : _("<corrupt>"));
17162               else
17163                 printf ("%-20.20s", liblist.l_name < strtab_size
17164                         ? strtab + liblist.l_name : _("<corrupt>"));
17165               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
17166                       liblist.l_version, liblist.l_flags);
17167             }
17168
17169           free (elib);
17170           free (strtab);
17171         }
17172     }
17173
17174   return res;
17175 }
17176
17177 static const char *
17178 get_note_type (Filedata * filedata, unsigned e_type)
17179 {
17180   static char buff[64];
17181
17182   if (filedata->file_header.e_type == ET_CORE)
17183     switch (e_type)
17184       {
17185       case NT_AUXV:
17186         return _("NT_AUXV (auxiliary vector)");
17187       case NT_PRSTATUS:
17188         return _("NT_PRSTATUS (prstatus structure)");
17189       case NT_FPREGSET:
17190         return _("NT_FPREGSET (floating point registers)");
17191       case NT_PRPSINFO:
17192         return _("NT_PRPSINFO (prpsinfo structure)");
17193       case NT_TASKSTRUCT:
17194         return _("NT_TASKSTRUCT (task structure)");
17195       case NT_PRXFPREG:
17196         return _("NT_PRXFPREG (user_xfpregs structure)");
17197       case NT_PPC_VMX:
17198         return _("NT_PPC_VMX (ppc Altivec registers)");
17199       case NT_PPC_VSX:
17200         return _("NT_PPC_VSX (ppc VSX registers)");
17201       case NT_PPC_TAR:
17202         return _("NT_PPC_TAR (ppc TAR register)");
17203       case NT_PPC_PPR:
17204         return _("NT_PPC_PPR (ppc PPR register)");
17205       case NT_PPC_DSCR:
17206         return _("NT_PPC_DSCR (ppc DSCR register)");
17207       case NT_PPC_EBB:
17208         return _("NT_PPC_EBB (ppc EBB registers)");
17209       case NT_PPC_PMU:
17210         return _("NT_PPC_PMU (ppc PMU registers)");
17211       case NT_PPC_TM_CGPR:
17212         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17213       case NT_PPC_TM_CFPR:
17214         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17215       case NT_PPC_TM_CVMX:
17216         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17217       case NT_PPC_TM_CVSX:
17218         return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17219       case NT_PPC_TM_SPR:
17220         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17221       case NT_PPC_TM_CTAR:
17222         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17223       case NT_PPC_TM_CPPR:
17224         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17225       case NT_PPC_TM_CDSCR:
17226         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17227       case NT_386_TLS:
17228         return _("NT_386_TLS (x86 TLS information)");
17229       case NT_386_IOPERM:
17230         return _("NT_386_IOPERM (x86 I/O permissions)");
17231       case NT_X86_XSTATE:
17232         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17233       case NT_S390_HIGH_GPRS:
17234         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17235       case NT_S390_TIMER:
17236         return _("NT_S390_TIMER (s390 timer register)");
17237       case NT_S390_TODCMP:
17238         return _("NT_S390_TODCMP (s390 TOD comparator register)");
17239       case NT_S390_TODPREG:
17240         return _("NT_S390_TODPREG (s390 TOD programmable register)");
17241       case NT_S390_CTRS:
17242         return _("NT_S390_CTRS (s390 control registers)");
17243       case NT_S390_PREFIX:
17244         return _("NT_S390_PREFIX (s390 prefix register)");
17245       case NT_S390_LAST_BREAK:
17246         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17247       case NT_S390_SYSTEM_CALL:
17248         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17249       case NT_S390_TDB:
17250         return _("NT_S390_TDB (s390 transaction diagnostic block)");
17251       case NT_S390_VXRS_LOW:
17252         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17253       case NT_S390_VXRS_HIGH:
17254         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17255       case NT_S390_GS_CB:
17256         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17257       case NT_S390_GS_BC:
17258         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17259       case NT_ARM_VFP:
17260         return _("NT_ARM_VFP (arm VFP registers)");
17261       case NT_ARM_TLS:
17262         return _("NT_ARM_TLS (AArch TLS registers)");
17263       case NT_ARM_HW_BREAK:
17264         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17265       case NT_ARM_HW_WATCH:
17266         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17267       case NT_PSTATUS:
17268         return _("NT_PSTATUS (pstatus structure)");
17269       case NT_FPREGS:
17270         return _("NT_FPREGS (floating point registers)");
17271       case NT_PSINFO:
17272         return _("NT_PSINFO (psinfo structure)");
17273       case NT_LWPSTATUS:
17274         return _("NT_LWPSTATUS (lwpstatus_t structure)");
17275       case NT_LWPSINFO:
17276         return _("NT_LWPSINFO (lwpsinfo_t structure)");
17277       case NT_WIN32PSTATUS:
17278         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17279       case NT_SIGINFO:
17280         return _("NT_SIGINFO (siginfo_t data)");
17281       case NT_FILE:
17282         return _("NT_FILE (mapped files)");
17283       default:
17284         break;
17285       }
17286   else
17287     switch (e_type)
17288       {
17289       case NT_VERSION:
17290         return _("NT_VERSION (version)");
17291       case NT_ARCH:
17292         return _("NT_ARCH (architecture)");
17293       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17294         return _("OPEN");
17295       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17296         return _("func");
17297       default:
17298         break;
17299       }
17300
17301   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17302   return buff;
17303 }
17304
17305 static bfd_boolean
17306 print_core_note (Elf_Internal_Note *pnote)
17307 {
17308   unsigned int addr_size = is_32bit_elf ? 4 : 8;
17309   bfd_vma count, page_size;
17310   unsigned char *descdata, *filenames, *descend;
17311
17312   if (pnote->type != NT_FILE)
17313     {
17314       if (do_wide)
17315         printf ("\n");
17316       return TRUE;
17317     }
17318
17319 #ifndef BFD64
17320   if (!is_32bit_elf)
17321     {
17322       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
17323       /* Still "successful".  */
17324       return TRUE;
17325     }
17326 #endif
17327
17328   if (pnote->descsz < 2 * addr_size)
17329     {
17330       error (_("    Malformed note - too short for header\n"));
17331       return FALSE;
17332     }
17333
17334   descdata = (unsigned char *) pnote->descdata;
17335   descend = descdata + pnote->descsz;
17336
17337   if (descdata[pnote->descsz - 1] != '\0')
17338     {
17339       error (_("    Malformed note - does not end with \\0\n"));
17340       return FALSE;
17341     }
17342
17343   count = byte_get (descdata, addr_size);
17344   descdata += addr_size;
17345
17346   page_size = byte_get (descdata, addr_size);
17347   descdata += addr_size;
17348
17349   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
17350       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
17351     {
17352       error (_("    Malformed note - too short for supplied file count\n"));
17353       return FALSE;
17354     }
17355
17356   printf (_("    Page size: "));
17357   print_vma (page_size, DEC);
17358   printf ("\n");
17359
17360   printf (_("    %*s%*s%*s\n"),
17361           (int) (2 + 2 * addr_size), _("Start"),
17362           (int) (4 + 2 * addr_size), _("End"),
17363           (int) (4 + 2 * addr_size), _("Page Offset"));
17364   filenames = descdata + count * 3 * addr_size;
17365   while (count-- > 0)
17366     {
17367       bfd_vma start, end, file_ofs;
17368
17369       if (filenames == descend)
17370         {
17371           error (_("    Malformed note - filenames end too early\n"));
17372           return FALSE;
17373         }
17374
17375       start = byte_get (descdata, addr_size);
17376       descdata += addr_size;
17377       end = byte_get (descdata, addr_size);
17378       descdata += addr_size;
17379       file_ofs = byte_get (descdata, addr_size);
17380       descdata += addr_size;
17381
17382       printf ("    ");
17383       print_vma (start, FULL_HEX);
17384       printf ("  ");
17385       print_vma (end, FULL_HEX);
17386       printf ("  ");
17387       print_vma (file_ofs, FULL_HEX);
17388       printf ("\n        %s\n", filenames);
17389
17390       filenames += 1 + strlen ((char *) filenames);
17391     }
17392
17393   return TRUE;
17394 }
17395
17396 static const char *
17397 get_gnu_elf_note_type (unsigned e_type)
17398 {
17399   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
17400   switch (e_type)
17401     {
17402     case NT_GNU_ABI_TAG:
17403       return _("NT_GNU_ABI_TAG (ABI version tag)");
17404     case NT_GNU_HWCAP:
17405       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17406     case NT_GNU_BUILD_ID:
17407       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17408     case NT_GNU_GOLD_VERSION:
17409       return _("NT_GNU_GOLD_VERSION (gold version)");
17410     case NT_GNU_PROPERTY_TYPE_0:
17411       return _("NT_GNU_PROPERTY_TYPE_0");
17412     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17413       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17414     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17415       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17416     default:
17417       {
17418         static char buff[64];
17419
17420         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17421         return buff;
17422       }
17423     }
17424 }
17425
17426 static void
17427 decode_x86_compat_isa (unsigned int bitmask)
17428 {
17429   while (bitmask)
17430     {
17431       unsigned int bit = bitmask & (- bitmask);
17432
17433       bitmask &= ~ bit;
17434       switch (bit)
17435         {
17436         case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
17437           printf ("i486");
17438           break;
17439         case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
17440           printf ("586");
17441           break;
17442         case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
17443           printf ("686");
17444           break;
17445         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
17446           printf ("SSE");
17447           break;
17448         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17449           printf ("SSE2");
17450           break;
17451         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17452           printf ("SSE3");
17453           break;
17454         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17455           printf ("SSSE3");
17456           break;
17457         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17458           printf ("SSE4_1");
17459           break;
17460         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17461           printf ("SSE4_2");
17462           break;
17463         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17464           printf ("AVX");
17465           break;
17466         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17467           printf ("AVX2");
17468           break;
17469         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17470           printf ("AVX512F");
17471           break;
17472         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17473           printf ("AVX512CD");
17474           break;
17475         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17476           printf ("AVX512ER");
17477           break;
17478         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17479           printf ("AVX512PF");
17480           break;
17481         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17482           printf ("AVX512VL");
17483           break;
17484         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17485           printf ("AVX512DQ");
17486           break;
17487         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17488           printf ("AVX512BW");
17489           break;
17490         default:
17491           printf (_("<unknown: %x>"), bit);
17492           break;
17493         }
17494       if (bitmask)
17495         printf (", ");
17496     }
17497 }
17498
17499 static void
17500 decode_x86_isa (unsigned int bitmask)
17501 {
17502   if (!bitmask)
17503     {
17504       printf (_("<None>"));
17505       return;
17506     }
17507
17508   while (bitmask)
17509     {
17510       unsigned int bit = bitmask & (- bitmask);
17511
17512       bitmask &= ~ bit;
17513       switch (bit)
17514         {
17515         case GNU_PROPERTY_X86_ISA_1_CMOV:
17516           printf ("CMOV");
17517           break;
17518         case GNU_PROPERTY_X86_ISA_1_SSE:
17519           printf ("SSE");
17520           break;
17521         case GNU_PROPERTY_X86_ISA_1_SSE2:
17522           printf ("SSE2");
17523           break;
17524         case GNU_PROPERTY_X86_ISA_1_SSE3:
17525           printf ("SSE3");
17526           break;
17527         case GNU_PROPERTY_X86_ISA_1_SSSE3:
17528           printf ("SSSE3");
17529           break;
17530         case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17531           printf ("SSE4_1");
17532           break;
17533         case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17534           printf ("SSE4_2");
17535           break;
17536         case GNU_PROPERTY_X86_ISA_1_AVX:
17537           printf ("AVX");
17538           break;
17539         case GNU_PROPERTY_X86_ISA_1_AVX2:
17540           printf ("AVX2");
17541           break;
17542         case GNU_PROPERTY_X86_ISA_1_FMA:
17543           printf ("FMA");
17544           break;
17545         case GNU_PROPERTY_X86_ISA_1_AVX512F:
17546           printf ("AVX512F");
17547           break;
17548         case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17549           printf ("AVX512CD");
17550           break;
17551         case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17552           printf ("AVX512ER");
17553           break;
17554         case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17555           printf ("AVX512PF");
17556           break;
17557         case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17558           printf ("AVX512VL");
17559           break;
17560         case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17561           printf ("AVX512DQ");
17562           break;
17563         case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17564           printf ("AVX512BW");
17565           break;
17566         case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17567           printf ("AVX512_4FMAPS");
17568           break;
17569         case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17570           printf ("AVX512_4VNNIW");
17571           break;
17572         case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17573           printf ("AVX512_BITALG");
17574           break;
17575         case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17576           printf ("AVX512_IFMA");
17577           break;
17578         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17579           printf ("AVX512_VBMI");
17580           break;
17581         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17582           printf ("AVX512_VBMI2");
17583           break;
17584         case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17585           printf ("AVX512_VNNI");
17586           break;
17587         case GNU_PROPERTY_X86_ISA_1_AVX512_BF16:
17588           printf ("AVX512_BF16");
17589           break;
17590         default:
17591           printf (_("<unknown: %x>"), bit);
17592           break;
17593         }
17594       if (bitmask)
17595         printf (", ");
17596     }
17597 }
17598
17599 static void
17600 decode_x86_feature_1 (unsigned int bitmask)
17601 {
17602   if (!bitmask)
17603     {
17604       printf (_("<None>"));
17605       return;
17606     }
17607
17608   while (bitmask)
17609     {
17610       unsigned int bit = bitmask & (- bitmask);
17611
17612       bitmask &= ~ bit;
17613       switch (bit)
17614         {
17615         case GNU_PROPERTY_X86_FEATURE_1_IBT:
17616           printf ("IBT");
17617           break;
17618         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17619           printf ("SHSTK");
17620           break;
17621         default:
17622           printf (_("<unknown: %x>"), bit);
17623           break;
17624         }
17625       if (bitmask)
17626         printf (", ");
17627     }
17628 }
17629
17630 static void
17631 decode_x86_feature_2 (unsigned int bitmask)
17632 {
17633   if (!bitmask)
17634     {
17635       printf (_("<None>"));
17636       return;
17637     }
17638
17639   while (bitmask)
17640     {
17641       unsigned int bit = bitmask & (- bitmask);
17642
17643       bitmask &= ~ bit;
17644       switch (bit)
17645         {
17646         case GNU_PROPERTY_X86_FEATURE_2_X86:
17647           printf ("x86");
17648           break;
17649         case GNU_PROPERTY_X86_FEATURE_2_X87:
17650           printf ("x87");
17651           break;
17652         case GNU_PROPERTY_X86_FEATURE_2_MMX:
17653           printf ("MMX");
17654           break;
17655         case GNU_PROPERTY_X86_FEATURE_2_XMM:
17656           printf ("XMM");
17657           break;
17658         case GNU_PROPERTY_X86_FEATURE_2_YMM:
17659           printf ("YMM");
17660           break;
17661         case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17662           printf ("ZMM");
17663           break;
17664         case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17665           printf ("FXSR");
17666           break;
17667         case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17668           printf ("XSAVE");
17669           break;
17670         case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17671           printf ("XSAVEOPT");
17672           break;
17673         case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17674           printf ("XSAVEC");
17675           break;
17676         default:
17677           printf (_("<unknown: %x>"), bit);
17678           break;
17679         }
17680       if (bitmask)
17681         printf (", ");
17682     }
17683 }
17684
17685 static void
17686 decode_aarch64_feature_1_and (unsigned int bitmask)
17687 {
17688   while (bitmask)
17689     {
17690       unsigned int bit = bitmask & (- bitmask);
17691
17692       bitmask &= ~ bit;
17693       switch (bit)
17694         {
17695         case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
17696           printf ("BTI");
17697           break;
17698
17699         case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
17700           printf ("PAC");
17701           break;
17702
17703         default:
17704           printf (_("<unknown: %x>"), bit);
17705           break;
17706         }
17707       if (bitmask)
17708         printf (", ");
17709     }
17710 }
17711
17712 static void
17713 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17714 {
17715   unsigned char * ptr = (unsigned char *) pnote->descdata;
17716   unsigned char * ptr_end = ptr + pnote->descsz;
17717   unsigned int    size = is_32bit_elf ? 4 : 8;
17718
17719   printf (_("      Properties: "));
17720
17721   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17722     {
17723       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17724       return;
17725     }
17726
17727   while (ptr < ptr_end)
17728     {
17729       unsigned int j;
17730       unsigned int type;
17731       unsigned int datasz;
17732
17733       if ((size_t) (ptr_end - ptr) < 8)
17734         {
17735           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17736           break;
17737         }
17738
17739       type = byte_get (ptr, 4);
17740       datasz = byte_get (ptr + 4, 4);
17741
17742       ptr += 8;
17743
17744       if (datasz > (size_t) (ptr_end - ptr))
17745         {
17746           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17747                   type, datasz);
17748           break;
17749         }
17750
17751       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17752         {
17753           if (filedata->file_header.e_machine == EM_X86_64
17754               || filedata->file_header.e_machine == EM_IAMCU
17755               || filedata->file_header.e_machine == EM_386)
17756             {
17757               unsigned int bitmask;
17758
17759               if (datasz == 4)
17760                 bitmask = byte_get (ptr, 4);
17761               else
17762                 bitmask = 0;
17763
17764               switch (type)
17765                 {
17766                 case GNU_PROPERTY_X86_ISA_1_USED:
17767                   if (datasz != 4)
17768                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17769                             datasz);
17770                   else
17771                     {
17772                       printf ("x86 ISA used: ");
17773                       decode_x86_isa (bitmask);
17774                     }
17775                   goto next;
17776
17777                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17778                   if (datasz != 4)
17779                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17780                             datasz);
17781                   else
17782                     {
17783                       printf ("x86 ISA needed: ");
17784                       decode_x86_isa (bitmask);
17785                     }
17786                   goto next;
17787
17788                 case GNU_PROPERTY_X86_FEATURE_1_AND:
17789                   if (datasz != 4)
17790                     printf (_("x86 feature: <corrupt length: %#x> "),
17791                             datasz);
17792                   else
17793                     {
17794                       printf ("x86 feature: ");
17795                       decode_x86_feature_1 (bitmask);
17796                     }
17797                   goto next;
17798
17799                 case GNU_PROPERTY_X86_FEATURE_2_USED:
17800                   if (datasz != 4)
17801                     printf (_("x86 feature used: <corrupt length: %#x> "),
17802                             datasz);
17803                   else
17804                     {
17805                       printf ("x86 feature used: ");
17806                       decode_x86_feature_2 (bitmask);
17807                     }
17808                   goto next;
17809
17810                 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17811                   if (datasz != 4)
17812                     printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17813                   else
17814                     {
17815                       printf ("x86 feature needed: ");
17816                       decode_x86_feature_2 (bitmask);
17817                     }
17818                   goto next;
17819
17820                 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17821                   if (datasz != 4)
17822                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17823                             datasz);
17824                   else
17825                     {
17826                       printf ("x86 ISA used: ");
17827                       decode_x86_compat_isa (bitmask);
17828                     }
17829                   goto next;
17830
17831                 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17832                   if (datasz != 4)
17833                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17834                             datasz);
17835                   else
17836                     {
17837                       printf ("x86 ISA needed: ");
17838                       decode_x86_compat_isa (bitmask);
17839                     }
17840                   goto next;
17841
17842                 default:
17843                   break;
17844                 }
17845             }
17846           else if (filedata->file_header.e_machine == EM_AARCH64)
17847             {
17848               if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
17849                 {
17850                   printf ("AArch64 feature: ");
17851                   if (datasz != 4)
17852                     printf (_("<corrupt length: %#x> "), datasz);
17853                   else
17854                     decode_aarch64_feature_1_and (byte_get (ptr, 4));
17855                   goto next;
17856                 }
17857             }
17858         }
17859       else
17860         {
17861           switch (type)
17862             {
17863             case GNU_PROPERTY_STACK_SIZE:
17864               printf (_("stack size: "));
17865               if (datasz != size)
17866                 printf (_("<corrupt length: %#x> "), datasz);
17867               else
17868                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17869               goto next;
17870
17871             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17872               printf ("no copy on protected ");
17873               if (datasz)
17874                 printf (_("<corrupt length: %#x> "), datasz);
17875               goto next;
17876
17877             default:
17878               break;
17879             }
17880         }
17881
17882       if (type < GNU_PROPERTY_LOPROC)
17883         printf (_("<unknown type %#x data: "), type);
17884       else if (type < GNU_PROPERTY_LOUSER)
17885         printf (_("<procesor-specific type %#x data: "), type);
17886       else
17887         printf (_("<application-specific type %#x data: "), type);
17888       for (j = 0; j < datasz; ++j)
17889         printf ("%02x ", ptr[j] & 0xff);
17890       printf (">");
17891
17892 next:
17893       ptr += ((datasz + (size - 1)) & ~ (size - 1));
17894       if (ptr == ptr_end)
17895         break;
17896
17897       if (do_wide)
17898         printf (", ");
17899       else
17900         printf ("\n\t");
17901     }
17902
17903   printf ("\n");
17904 }
17905
17906 static bfd_boolean
17907 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17908 {
17909   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17910   switch (pnote->type)
17911     {
17912     case NT_GNU_BUILD_ID:
17913       {
17914         unsigned long i;
17915
17916         printf (_("    Build ID: "));
17917         for (i = 0; i < pnote->descsz; ++i)
17918           printf ("%02x", pnote->descdata[i] & 0xff);
17919         printf ("\n");
17920       }
17921       break;
17922
17923     case NT_GNU_ABI_TAG:
17924       {
17925         unsigned long os, major, minor, subminor;
17926         const char *osname;
17927
17928         /* PR 17531: file: 030-599401-0.004.  */
17929         if (pnote->descsz < 16)
17930           {
17931             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17932             break;
17933           }
17934
17935         os = byte_get ((unsigned char *) pnote->descdata, 4);
17936         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17937         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17938         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17939
17940         switch (os)
17941           {
17942           case GNU_ABI_TAG_LINUX:
17943             osname = "Linux";
17944             break;
17945           case GNU_ABI_TAG_HURD:
17946             osname = "Hurd";
17947             break;
17948           case GNU_ABI_TAG_SOLARIS:
17949             osname = "Solaris";
17950             break;
17951           case GNU_ABI_TAG_FREEBSD:
17952             osname = "FreeBSD";
17953             break;
17954           case GNU_ABI_TAG_NETBSD:
17955             osname = "NetBSD";
17956             break;
17957           case GNU_ABI_TAG_SYLLABLE:
17958             osname = "Syllable";
17959             break;
17960           case GNU_ABI_TAG_NACL:
17961             osname = "NaCl";
17962             break;
17963           default:
17964             osname = "Unknown";
17965             break;
17966           }
17967
17968         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17969                 major, minor, subminor);
17970       }
17971       break;
17972
17973     case NT_GNU_GOLD_VERSION:
17974       {
17975         unsigned long i;
17976
17977         printf (_("    Version: "));
17978         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17979           printf ("%c", pnote->descdata[i]);
17980         printf ("\n");
17981       }
17982       break;
17983
17984     case NT_GNU_HWCAP:
17985       {
17986         unsigned long num_entries, mask;
17987
17988         /* Hardware capabilities information.  Word 0 is the number of entries.
17989            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17990            is a series of entries, where each entry is a single byte followed
17991            by a nul terminated string.  The byte gives the bit number to test
17992            if enabled in the bitmask.  */
17993         printf (_("      Hardware Capabilities: "));
17994         if (pnote->descsz < 8)
17995           {
17996             error (_("<corrupt GNU_HWCAP>\n"));
17997             return FALSE;
17998           }
17999         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
18000         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18001         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
18002         /* FIXME: Add code to display the entries... */
18003       }
18004       break;
18005
18006     case NT_GNU_PROPERTY_TYPE_0:
18007       print_gnu_property_note (filedata, pnote);
18008       break;
18009
18010     default:
18011       /* Handle unrecognised types.  An error message should have already been
18012          created by get_gnu_elf_note_type(), so all that we need to do is to
18013          display the data.  */
18014       {
18015         unsigned long i;
18016
18017         printf (_("    Description data: "));
18018         for (i = 0; i < pnote->descsz; ++i)
18019           printf ("%02x ", pnote->descdata[i] & 0xff);
18020         printf ("\n");
18021       }
18022       break;
18023     }
18024
18025   return TRUE;
18026 }
18027
18028 static const char *
18029 get_v850_elf_note_type (enum v850_notes n_type)
18030 {
18031   static char buff[64];
18032
18033   switch (n_type)
18034     {
18035     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
18036     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
18037     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
18038     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
18039     case V850_NOTE_CACHE_INFO: return _("Use of cache");
18040     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
18041     default:
18042       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
18043       return buff;
18044     }
18045 }
18046
18047 static bfd_boolean
18048 print_v850_note (Elf_Internal_Note * pnote)
18049 {
18050   unsigned int val;
18051
18052   if (pnote->descsz != 4)
18053     return FALSE;
18054
18055   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
18056
18057   if (val == 0)
18058     {
18059       printf (_("not set\n"));
18060       return TRUE;
18061     }
18062
18063   switch (pnote->type)
18064     {
18065     case V850_NOTE_ALIGNMENT:
18066       switch (val)
18067         {
18068         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
18069         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
18070         }
18071       break;
18072
18073     case V850_NOTE_DATA_SIZE:
18074       switch (val)
18075         {
18076         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
18077         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
18078         }
18079       break;
18080
18081     case V850_NOTE_FPU_INFO:
18082       switch (val)
18083         {
18084         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
18085         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
18086         }
18087       break;
18088
18089     case V850_NOTE_MMU_INFO:
18090     case V850_NOTE_CACHE_INFO:
18091     case V850_NOTE_SIMD_INFO:
18092       if (val == EF_RH850_SIMD)
18093         {
18094           printf (_("yes\n"));
18095           return TRUE;
18096         }
18097       break;
18098
18099     default:
18100       /* An 'unknown note type' message will already have been displayed.  */
18101       break;
18102     }
18103
18104   printf (_("unknown value: %x\n"), val);
18105   return FALSE;
18106 }
18107
18108 static bfd_boolean
18109 process_netbsd_elf_note (Elf_Internal_Note * pnote)
18110 {
18111   unsigned int version;
18112
18113   switch (pnote->type)
18114     {
18115     case NT_NETBSD_IDENT:
18116       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18117       if ((version / 10000) % 100)
18118         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
18119                 version, version / 100000000, (version / 1000000) % 100,
18120                 (version / 10000) % 100 > 26 ? "Z" : "",
18121                 'A' + (version / 10000) % 26);
18122       else
18123         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
18124                 version, version / 100000000, (version / 1000000) % 100,
18125                 (version / 100) % 100);
18126       return TRUE;
18127
18128     case NT_NETBSD_MARCH:
18129       printf ("  NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
18130               pnote->descdata);
18131       return TRUE;
18132
18133 #ifdef   NT_NETBSD_PAX
18134     case NT_NETBSD_PAX:
18135       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18136       printf ("  NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote->descsz,
18137               ((version & NT_NETBSD_PAX_MPROTECT) ? "+mprotect" : ""),
18138               ((version & NT_NETBSD_PAX_NOMPROTECT) ? "-mprotect" : ""),
18139               ((version & NT_NETBSD_PAX_GUARD) ? "+guard" : ""),
18140               ((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""),
18141               ((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""),
18142               ((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : ""));
18143       return TRUE;
18144 #endif
18145
18146     default:
18147       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
18148               pnote->type);
18149       return FALSE;
18150     }
18151 }
18152
18153 static const char *
18154 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18155 {
18156   switch (e_type)
18157     {
18158     case NT_FREEBSD_THRMISC:
18159       return _("NT_THRMISC (thrmisc structure)");
18160     case NT_FREEBSD_PROCSTAT_PROC:
18161       return _("NT_PROCSTAT_PROC (proc data)");
18162     case NT_FREEBSD_PROCSTAT_FILES:
18163       return _("NT_PROCSTAT_FILES (files data)");
18164     case NT_FREEBSD_PROCSTAT_VMMAP:
18165       return _("NT_PROCSTAT_VMMAP (vmmap data)");
18166     case NT_FREEBSD_PROCSTAT_GROUPS:
18167       return _("NT_PROCSTAT_GROUPS (groups data)");
18168     case NT_FREEBSD_PROCSTAT_UMASK:
18169       return _("NT_PROCSTAT_UMASK (umask data)");
18170     case NT_FREEBSD_PROCSTAT_RLIMIT:
18171       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18172     case NT_FREEBSD_PROCSTAT_OSREL:
18173       return _("NT_PROCSTAT_OSREL (osreldate data)");
18174     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
18175       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18176     case NT_FREEBSD_PROCSTAT_AUXV:
18177       return _("NT_PROCSTAT_AUXV (auxv data)");
18178     case NT_FREEBSD_PTLWPINFO:
18179       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18180     }
18181   return get_note_type (filedata, e_type);
18182 }
18183
18184 static const char *
18185 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18186 {
18187   static char buff[64];
18188
18189   switch (e_type)
18190     {
18191     case NT_NETBSDCORE_PROCINFO:
18192       /* NetBSD core "procinfo" structure.  */
18193       return _("NetBSD procinfo structure");
18194
18195 #ifdef NT_NETBSDCORE_AUXV
18196     case NT_NETBSDCORE_AUXV:
18197       return _("NetBSD ELF auxiliary vector data");
18198 #endif
18199
18200     default:
18201       /* As of Jan 2002 there are no other machine-independent notes
18202          defined for NetBSD core files.  If the note type is less
18203          than the start of the machine-dependent note types, we don't
18204          understand it.  */
18205
18206       if (e_type < NT_NETBSDCORE_FIRSTMACH)
18207         {
18208           snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18209           return buff;
18210         }
18211       break;
18212     }
18213
18214   switch (filedata->file_header.e_machine)
18215     {
18216     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18217        and PT_GETFPREGS == mach+2.  */
18218
18219     case EM_OLD_ALPHA:
18220     case EM_ALPHA:
18221     case EM_SPARC:
18222     case EM_SPARC32PLUS:
18223     case EM_SPARCV9:
18224       switch (e_type)
18225         {
18226         case NT_NETBSDCORE_FIRSTMACH + 0:
18227           return _("PT_GETREGS (reg structure)");
18228         case NT_NETBSDCORE_FIRSTMACH + 2:
18229           return _("PT_GETFPREGS (fpreg structure)");
18230         default:
18231           break;
18232         }
18233       break;
18234
18235     /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18236        There's also old PT___GETREGS40 == mach + 1 for old reg
18237        structure which lacks GBR.  */
18238     case EM_SH:
18239       switch (e_type)
18240         {
18241         case NT_NETBSDCORE_FIRSTMACH + 1:
18242           return _("PT___GETREGS40 (old reg structure)");
18243         case NT_NETBSDCORE_FIRSTMACH + 3:
18244           return _("PT_GETREGS (reg structure)");
18245         case NT_NETBSDCORE_FIRSTMACH + 5:
18246           return _("PT_GETFPREGS (fpreg structure)");
18247         default:
18248           break;
18249         }
18250       break;
18251
18252     /* On all other arch's, PT_GETREGS == mach+1 and
18253        PT_GETFPREGS == mach+3.  */
18254     default:
18255       switch (e_type)
18256         {
18257         case NT_NETBSDCORE_FIRSTMACH + 1:
18258           return _("PT_GETREGS (reg structure)");
18259         case NT_NETBSDCORE_FIRSTMACH + 3:
18260           return _("PT_GETFPREGS (fpreg structure)");
18261         default:
18262           break;
18263         }
18264     }
18265
18266   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
18267             e_type - NT_NETBSDCORE_FIRSTMACH);
18268   return buff;
18269 }
18270
18271 static const char *
18272 get_stapsdt_note_type (unsigned e_type)
18273 {
18274   static char buff[64];
18275
18276   switch (e_type)
18277     {
18278     case NT_STAPSDT:
18279       return _("NT_STAPSDT (SystemTap probe descriptors)");
18280
18281     default:
18282       break;
18283     }
18284
18285   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18286   return buff;
18287 }
18288
18289 static bfd_boolean
18290 print_stapsdt_note (Elf_Internal_Note *pnote)
18291 {
18292   size_t len, maxlen;
18293   unsigned long addr_size = is_32bit_elf ? 4 : 8;
18294   char *data = pnote->descdata;
18295   char *data_end = pnote->descdata + pnote->descsz;
18296   bfd_vma pc, base_addr, semaphore;
18297   char *provider, *probe, *arg_fmt;
18298
18299   if (pnote->descsz < (addr_size * 3))
18300     goto stapdt_note_too_small;
18301
18302   pc = byte_get ((unsigned char *) data, addr_size);
18303   data += addr_size;
18304
18305   base_addr = byte_get ((unsigned char *) data, addr_size);
18306   data += addr_size;
18307
18308   semaphore = byte_get ((unsigned char *) data, addr_size);
18309   data += addr_size;
18310
18311   if (data >= data_end)
18312     goto stapdt_note_too_small;
18313   maxlen = data_end - data;
18314   len = strnlen (data, maxlen);
18315   if (len < maxlen)
18316     {
18317       provider = data;
18318       data += len + 1;
18319     }
18320   else
18321     goto stapdt_note_too_small;
18322
18323   if (data >= data_end)
18324     goto stapdt_note_too_small;
18325   maxlen = data_end - data;
18326   len = strnlen (data, maxlen);
18327   if (len < maxlen)
18328     {
18329       probe = data;
18330       data += len + 1;
18331     }
18332   else
18333     goto stapdt_note_too_small;
18334
18335   if (data >= data_end)
18336     goto stapdt_note_too_small;
18337   maxlen = data_end - data;
18338   len = strnlen (data, maxlen);
18339   if (len < maxlen)
18340     {
18341       arg_fmt = data;
18342       data += len + 1;
18343     }
18344   else
18345     goto stapdt_note_too_small;
18346
18347   printf (_("    Provider: %s\n"), provider);
18348   printf (_("    Name: %s\n"), probe);
18349   printf (_("    Location: "));
18350   print_vma (pc, FULL_HEX);
18351   printf (_(", Base: "));
18352   print_vma (base_addr, FULL_HEX);
18353   printf (_(", Semaphore: "));
18354   print_vma (semaphore, FULL_HEX);
18355   printf ("\n");
18356   printf (_("    Arguments: %s\n"), arg_fmt);
18357
18358   return data == data_end;
18359
18360  stapdt_note_too_small:
18361   printf (_("  <corrupt - note is too small>\n"));
18362   error (_("corrupt stapdt note - the data size is too small\n"));
18363   return FALSE;
18364 }
18365
18366 static const char *
18367 get_ia64_vms_note_type (unsigned e_type)
18368 {
18369   static char buff[64];
18370
18371   switch (e_type)
18372     {
18373     case NT_VMS_MHD:
18374       return _("NT_VMS_MHD (module header)");
18375     case NT_VMS_LNM:
18376       return _("NT_VMS_LNM (language name)");
18377     case NT_VMS_SRC:
18378       return _("NT_VMS_SRC (source files)");
18379     case NT_VMS_TITLE:
18380       return "NT_VMS_TITLE";
18381     case NT_VMS_EIDC:
18382       return _("NT_VMS_EIDC (consistency check)");
18383     case NT_VMS_FPMODE:
18384       return _("NT_VMS_FPMODE (FP mode)");
18385     case NT_VMS_LINKTIME:
18386       return "NT_VMS_LINKTIME";
18387     case NT_VMS_IMGNAM:
18388       return _("NT_VMS_IMGNAM (image name)");
18389     case NT_VMS_IMGID:
18390       return _("NT_VMS_IMGID (image id)");
18391     case NT_VMS_LINKID:
18392       return _("NT_VMS_LINKID (link id)");
18393     case NT_VMS_IMGBID:
18394       return _("NT_VMS_IMGBID (build id)");
18395     case NT_VMS_GSTNAM:
18396       return _("NT_VMS_GSTNAM (sym table name)");
18397     case NT_VMS_ORIG_DYN:
18398       return "NT_VMS_ORIG_DYN";
18399     case NT_VMS_PATCHTIME:
18400       return "NT_VMS_PATCHTIME";
18401     default:
18402       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18403       return buff;
18404     }
18405 }
18406
18407 static bfd_boolean
18408 print_ia64_vms_note (Elf_Internal_Note * pnote)
18409 {
18410   int maxlen = pnote->descsz;
18411
18412   if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
18413     goto desc_size_fail;
18414
18415   switch (pnote->type)
18416     {
18417     case NT_VMS_MHD:
18418       if (maxlen <= 36)
18419         goto desc_size_fail;
18420
18421       int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
18422
18423       printf (_("    Creation date  : %.17s\n"), pnote->descdata);
18424       printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
18425       if (l + 34 < maxlen)
18426         {
18427           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
18428           if (l + 35 < maxlen)
18429             printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
18430           else
18431             printf (_("    Module version : <missing>\n"));
18432         }
18433       else
18434         {
18435           printf (_("    Module name    : <missing>\n"));
18436           printf (_("    Module version : <missing>\n"));
18437         }
18438       break;
18439
18440     case NT_VMS_LNM:
18441       printf (_("   Language: %.*s\n"), maxlen, pnote->descdata);
18442       break;
18443
18444 #ifdef BFD64
18445     case NT_VMS_FPMODE:
18446       printf (_("   Floating Point mode: "));
18447       if (maxlen < 8)
18448         goto desc_size_fail;
18449       /* FIXME: Generate an error if descsz > 8 ?  */
18450
18451       printf ("0x%016" BFD_VMA_FMT "x\n",
18452               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
18453       break;
18454
18455     case NT_VMS_LINKTIME:
18456       printf (_("   Link time: "));
18457       if (maxlen < 8)
18458         goto desc_size_fail;
18459       /* FIXME: Generate an error if descsz > 8 ?  */
18460
18461       print_vms_time
18462         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18463       printf ("\n");
18464       break;
18465
18466     case NT_VMS_PATCHTIME:
18467       printf (_("   Patch time: "));
18468       if (maxlen < 8)
18469         goto desc_size_fail;
18470       /* FIXME: Generate an error if descsz > 8 ?  */
18471
18472       print_vms_time
18473         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18474       printf ("\n");
18475       break;
18476
18477     case NT_VMS_ORIG_DYN:
18478       if (maxlen < 34)
18479         goto desc_size_fail;
18480
18481       printf (_("   Major id: %u,  minor id: %u\n"),
18482               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
18483               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
18484       printf (_("   Last modified  : "));
18485       print_vms_time
18486         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
18487       printf (_("\n   Link flags  : "));
18488       printf ("0x%016" BFD_VMA_FMT "x\n",
18489               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
18490       printf (_("   Header flags: 0x%08x\n"),
18491               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
18492       printf (_("   Image id    : %.*s\n"), maxlen - 32, pnote->descdata + 32);
18493       break;
18494 #endif
18495
18496     case NT_VMS_IMGNAM:
18497       printf (_("    Image name: %.*s\n"), maxlen, pnote->descdata);
18498       break;
18499
18500     case NT_VMS_GSTNAM:
18501       printf (_("    Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
18502       break;
18503
18504     case NT_VMS_IMGID:
18505       printf (_("    Image id: %.*s\n"), maxlen, pnote->descdata);
18506       break;
18507
18508     case NT_VMS_LINKID:
18509       printf (_("    Linker id: %.*s\n"), maxlen, pnote->descdata);
18510       break;
18511
18512     default:
18513       return FALSE;
18514     }
18515
18516   return TRUE;
18517
18518  desc_size_fail:
18519   printf (_("  <corrupt - data size is too small>\n"));
18520   error (_("corrupt IA64 note: data size is too small\n"));
18521   return FALSE;
18522 }
18523
18524 /* Find the symbol associated with a build attribute that is attached
18525    to address OFFSET.  If PNAME is non-NULL then store the name of
18526    the symbol (if found) in the provided pointer,  Returns NULL if a
18527    symbol could not be found.  */
18528
18529 static Elf_Internal_Sym *
18530 get_symbol_for_build_attribute (Filedata *       filedata,
18531                                 unsigned long    offset,
18532                                 bfd_boolean      is_open_attr,
18533                                 const char **    pname)
18534 {
18535   static Filedata *         saved_filedata = NULL;
18536   static char *             strtab;
18537   static unsigned long      strtablen;
18538   static Elf_Internal_Sym * symtab;
18539   static unsigned long      nsyms;
18540   Elf_Internal_Sym *        saved_sym = NULL;
18541   Elf_Internal_Sym *        sym;
18542
18543   if (filedata->section_headers != NULL
18544       && (saved_filedata == NULL || filedata != saved_filedata))
18545     {
18546       Elf_Internal_Shdr * symsec;
18547
18548       /* Load the symbol and string sections.  */
18549       for (symsec = filedata->section_headers;
18550            symsec < filedata->section_headers + filedata->file_header.e_shnum;
18551            symsec ++)
18552         {
18553           if (symsec->sh_type == SHT_SYMTAB)
18554             {
18555               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
18556
18557               if (symsec->sh_link < filedata->file_header.e_shnum)
18558                 {
18559                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
18560
18561                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
18562                                               1, strtab_sec->sh_size,
18563                                               _("string table"));
18564                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
18565                 }
18566             }
18567         }
18568       saved_filedata = filedata;
18569     }
18570
18571   if (symtab == NULL || strtab == NULL)
18572     return NULL;
18573
18574   /* Find a symbol whose value matches offset.  */
18575   for (sym = symtab; sym < symtab + nsyms; sym ++)
18576     if (sym->st_value == offset)
18577       {
18578         if (sym->st_name >= strtablen)
18579           /* Huh ?  This should not happen.  */
18580           continue;
18581
18582         if (strtab[sym->st_name] == 0)
18583           continue;
18584
18585         /* The AArch64 and ARM architectures define mapping symbols
18586            (eg $d, $x, $t) which we want to ignore.  */
18587         if (strtab[sym->st_name] == '$'
18588             && strtab[sym->st_name + 1] != 0
18589             && strtab[sym->st_name + 2] == 0)
18590           continue;
18591
18592         if (is_open_attr)
18593           {
18594             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18595                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
18596                FUNC symbols entirely.  */
18597             switch (ELF_ST_TYPE (sym->st_info))
18598               {
18599               case STT_OBJECT:
18600               case STT_FILE:
18601                 saved_sym = sym;
18602                 if (sym->st_size)
18603                   {
18604                     /* If the symbol has a size associated
18605                        with it then we can stop searching.  */
18606                     sym = symtab + nsyms;
18607                   }
18608                 continue;
18609
18610               case STT_FUNC:
18611                 /* Ignore function symbols.  */
18612                 continue;
18613
18614               default:
18615                 break;
18616               }
18617
18618             switch (ELF_ST_BIND (sym->st_info))
18619               {
18620               case STB_GLOBAL:
18621                 if (saved_sym == NULL
18622                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18623                   saved_sym = sym;
18624                 break;
18625
18626               case STB_LOCAL:
18627                 if (saved_sym == NULL)
18628                   saved_sym = sym;
18629                 break;
18630
18631               default:
18632                 break;
18633               }
18634           }
18635         else
18636           {
18637             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18638               continue;
18639
18640             saved_sym = sym;
18641             break;
18642           }
18643       }
18644
18645   if (saved_sym && pname)
18646     * pname = strtab + saved_sym->st_name;
18647
18648   return saved_sym;
18649 }
18650
18651 /* Returns true iff addr1 and addr2 are in the same section.  */
18652
18653 static bfd_boolean
18654 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18655 {
18656   Elf_Internal_Shdr * a1;
18657   Elf_Internal_Shdr * a2;
18658
18659   a1 = find_section_by_address (filedata, addr1);
18660   a2 = find_section_by_address (filedata, addr2);
18661
18662   return a1 == a2 && a1 != NULL;
18663 }
18664
18665 static bfd_boolean
18666 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
18667                                        Filedata *           filedata)
18668 {
18669   static unsigned long  global_offset = 0;
18670   static unsigned long  global_end = 0;
18671   static unsigned long  func_offset = 0;
18672   static unsigned long  func_end = 0;
18673
18674   Elf_Internal_Sym *    sym;
18675   const char *          name;
18676   unsigned long         start;
18677   unsigned long         end;
18678   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18679
18680   switch (pnote->descsz)
18681     {
18682     case 0:
18683       /* A zero-length description means that the range of
18684          the previous note of the same type should be used.  */
18685       if (is_open_attr)
18686         {
18687           if (global_end > global_offset)
18688             printf (_("    Applies to region from %#lx to %#lx\n"),
18689                     global_offset, global_end);
18690           else
18691             printf (_("    Applies to region from %#lx\n"), global_offset);
18692         }
18693       else
18694         {
18695           if (func_end > func_offset)
18696             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18697           else
18698             printf (_("    Applies to region from %#lx\n"), func_offset);
18699         }
18700       return TRUE;
18701
18702     case 4:
18703       start = byte_get ((unsigned char *) pnote->descdata, 4);
18704       end = 0;
18705       break;
18706
18707     case 8:
18708       if (is_32bit_elf)
18709         {
18710           /* FIXME: We should check that version 3+ notes are being used here...  */
18711           start = byte_get ((unsigned char *) pnote->descdata, 4);
18712           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18713         }
18714       else
18715         {
18716           start = byte_get ((unsigned char *) pnote->descdata, 8);
18717           end = 0;
18718         }
18719       break;
18720
18721     case 16:
18722       start = byte_get ((unsigned char *) pnote->descdata, 8);
18723       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18724       break;
18725
18726     default:
18727       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
18728       printf (_("    <invalid descsz>"));
18729       return FALSE;
18730     }
18731
18732   name = NULL;
18733   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18734   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18735      in order to avoid them being confused with the start address of the
18736      first function in the file...  */
18737   if (sym == NULL && is_open_attr)
18738     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18739                                           & name);
18740
18741   if (end == 0 && sym != NULL && sym->st_size > 0)
18742     end = start + sym->st_size;
18743
18744   if (is_open_attr)
18745     {
18746       /* FIXME: Need to properly allow for section alignment.
18747          16 is just the alignment used on x86_64.  */
18748       if (global_end > 0
18749           && start > BFD_ALIGN (global_end, 16)
18750           /* Build notes are not guaranteed to be organised in order of
18751              increasing address, but we should find the all of the notes
18752              for one section in the same place.  */
18753           && same_section (filedata, start, global_end))
18754         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18755               global_end + 1, start - 1);
18756
18757       printf (_("    Applies to region from %#lx"), start);
18758       global_offset = start;
18759
18760       if (end)
18761         {
18762           printf (_(" to %#lx"), end);
18763           global_end = end;
18764         }
18765     }
18766   else
18767     {
18768       printf (_("    Applies to region from %#lx"), start);
18769       func_offset = start;
18770
18771       if (end)
18772         {
18773           printf (_(" to %#lx"), end);
18774           func_end = end;
18775         }
18776     }
18777
18778   if (sym && name)
18779     printf (_(" (%s)"), name);
18780
18781   printf ("\n");
18782   return TRUE;
18783 }
18784
18785 static bfd_boolean
18786 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18787 {
18788   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18789   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18790   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18791   char         name_type;
18792   char         name_attribute;
18793   const char * expected_types;
18794   const char * name = pnote->namedata;
18795   const char * text;
18796   signed int   left;
18797
18798   if (name == NULL || pnote->namesz < 2)
18799     {
18800       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18801       print_symbol (-20, _("  <corrupt name>"));
18802       return FALSE;
18803     }
18804
18805   if (do_wide)
18806     left = 28;
18807   else
18808     left = 20;
18809
18810   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
18811   if (name[0] == 'G' && name[1] == 'A')
18812     {
18813       if (pnote->namesz < 4)
18814         {
18815           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18816           print_symbol (-20, _("  <corrupt name>"));
18817           return FALSE;
18818         }
18819
18820       printf ("GA");
18821       name += 2;
18822       left -= 2;
18823     }
18824
18825   switch ((name_type = * name))
18826     {
18827     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18828     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18829     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18830     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18831       printf ("%c", * name);
18832       left --;
18833       break;
18834     default:
18835       error (_("unrecognised attribute type in name field: %d\n"), name_type);
18836       print_symbol (-20, _("<unknown name type>"));
18837       return FALSE;
18838     }
18839
18840   ++ name;
18841   text = NULL;
18842
18843   switch ((name_attribute = * name))
18844     {
18845     case GNU_BUILD_ATTRIBUTE_VERSION:
18846       text = _("<version>");
18847       expected_types = string_expected;
18848       ++ name;
18849       break;
18850     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18851       text = _("<stack prot>");
18852       expected_types = "!+*";
18853       ++ name;
18854       break;
18855     case GNU_BUILD_ATTRIBUTE_RELRO:
18856       text = _("<relro>");
18857       expected_types = bool_expected;
18858       ++ name;
18859       break;
18860     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18861       text = _("<stack size>");
18862       expected_types = number_expected;
18863       ++ name;
18864       break;
18865     case GNU_BUILD_ATTRIBUTE_TOOL:
18866       text = _("<tool>");
18867       expected_types = string_expected;
18868       ++ name;
18869       break;
18870     case GNU_BUILD_ATTRIBUTE_ABI:
18871       text = _("<ABI>");
18872       expected_types = "$*";
18873       ++ name;
18874       break;
18875     case GNU_BUILD_ATTRIBUTE_PIC:
18876       text = _("<PIC>");
18877       expected_types = number_expected;
18878       ++ name;
18879       break;
18880     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18881       text = _("<short enum>");
18882       expected_types = bool_expected;
18883       ++ name;
18884       break;
18885     default:
18886       if (ISPRINT (* name))
18887         {
18888           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18889
18890           if (len > left && ! do_wide)
18891             len = left;
18892           printf ("%.*s:", len, name);
18893           left -= len;
18894           name += len;
18895         }
18896       else
18897         {
18898           static char tmpbuf [128];
18899
18900           error (_("unrecognised byte in name field: %d\n"), * name);
18901           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18902           text = tmpbuf;
18903           name ++;
18904         }
18905       expected_types = "*$!+";
18906       break;
18907     }
18908
18909   if (text)
18910     left -= printf ("%s", text);
18911
18912   if (strchr (expected_types, name_type) == NULL)
18913     warn (_("attribute does not have an expected type (%c)\n"), name_type);
18914
18915   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18916     {
18917       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18918              (unsigned long) pnote->namesz,
18919              (long) (name - pnote->namedata));
18920       return FALSE;
18921     }
18922
18923   if (left < 1 && ! do_wide)
18924     return TRUE;
18925
18926   switch (name_type)
18927     {
18928     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18929       {
18930         unsigned int        bytes;
18931         unsigned long long  val = 0;
18932         unsigned int        shift = 0;
18933         char *              decoded = NULL;
18934
18935         bytes = pnote->namesz - (name - pnote->namedata);
18936         if (bytes > 0)
18937           /* The -1 is because the name field is always 0 terminated, and we
18938              want to be able to ensure that the shift in the while loop below
18939              will not overflow.  */
18940           -- bytes;
18941
18942         if (bytes > sizeof (val))
18943           {
18944             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18945                    bytes);
18946             bytes = sizeof (val);
18947           }
18948         /* We do not bother to warn if bytes == 0 as this can
18949            happen with some early versions of the gcc plugin.  */
18950
18951         while (bytes --)
18952           {
18953             unsigned long byte = (* name ++) & 0xff;
18954
18955             val |= byte << shift;
18956             shift += 8;
18957           }
18958
18959         switch (name_attribute)
18960           {
18961           case GNU_BUILD_ATTRIBUTE_PIC:
18962             switch (val)
18963               {
18964               case 0: decoded = "static"; break;
18965               case 1: decoded = "pic"; break;
18966               case 2: decoded = "PIC"; break;
18967               case 3: decoded = "pie"; break;
18968               case 4: decoded = "PIE"; break;
18969               default: break;
18970               }
18971             break;
18972           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18973             switch (val)
18974               {
18975                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
18976               case 0: decoded = "off"; break;
18977               case 1: decoded = "on"; break;
18978               case 2: decoded = "all"; break;
18979               case 3: decoded = "strong"; break;
18980               case 4: decoded = "explicit"; break;
18981               default: break;
18982               }
18983             break;
18984           default:
18985             break;
18986           }
18987
18988         if (decoded != NULL)
18989           {
18990             print_symbol (-left, decoded);
18991             left = 0;
18992           }
18993         else if (val == 0)
18994           {
18995             printf ("0x0");
18996             left -= 3;
18997           }
18998         else
18999           {
19000             if (do_wide)
19001               left -= printf ("0x%llx", val);
19002             else
19003               left -= printf ("0x%-.*llx", left, val);
19004           }
19005       }
19006       break;
19007     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19008       left -= print_symbol (- left, name);
19009       break;
19010     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19011       left -= print_symbol (- left, "true");
19012       break;
19013     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19014       left -= print_symbol (- left, "false");
19015       break;
19016     }
19017
19018   if (do_wide && left > 0)
19019     printf ("%-*s", left, " ");
19020
19021   return TRUE;
19022 }
19023
19024 /* Note that by the ELF standard, the name field is already null byte
19025    terminated, and namesz includes the terminating null byte.
19026    I.E. the value of namesz for the name "FSF" is 4.
19027
19028    If the value of namesz is zero, there is no name present.  */
19029
19030 static bfd_boolean
19031 process_note (Elf_Internal_Note *  pnote,
19032               Filedata *           filedata)
19033 {
19034   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
19035   const char * nt;
19036
19037   if (pnote->namesz == 0)
19038     /* If there is no note name, then use the default set of
19039        note type strings.  */
19040     nt = get_note_type (filedata, pnote->type);
19041
19042   else if (const_strneq (pnote->namedata, "GNU"))
19043     /* GNU-specific object file notes.  */
19044     nt = get_gnu_elf_note_type (pnote->type);
19045
19046   else if (const_strneq (pnote->namedata, "FreeBSD"))
19047     /* FreeBSD-specific core file notes.  */
19048     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
19049
19050   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
19051     /* NetBSD-specific core file notes.  */
19052     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
19053
19054   else if (const_strneq (pnote->namedata, "NetBSD"))
19055     /* NetBSD-specific core file notes.  */
19056     return process_netbsd_elf_note (pnote);
19057
19058   else if (const_strneq (pnote->namedata, "PaX"))
19059     /* NetBSD-specific core file notes.  */
19060     return process_netbsd_elf_note (pnote);
19061
19062   else if (strneq (pnote->namedata, "SPU/", 4))
19063     {
19064       /* SPU-specific core file notes.  */
19065       nt = pnote->namedata + 4;
19066       name = "SPU";
19067     }
19068
19069   else if (const_strneq (pnote->namedata, "IPF/VMS"))
19070     /* VMS/ia64-specific file notes.  */
19071     nt = get_ia64_vms_note_type (pnote->type);
19072
19073   else if (const_strneq (pnote->namedata, "stapsdt"))
19074     nt = get_stapsdt_note_type (pnote->type);
19075
19076   else
19077     /* Don't recognize this note name; just use the default set of
19078        note type strings.  */
19079     nt = get_note_type (filedata, pnote->type);
19080
19081   printf ("  ");
19082
19083   if (((const_strneq (pnote->namedata, "GA")
19084         && strchr ("*$!+", pnote->namedata[2]) != NULL)
19085        || strchr ("*$!+", pnote->namedata[0]) != NULL)
19086       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19087           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19088     print_gnu_build_attribute_name (pnote);
19089   else
19090     print_symbol (-20, name);
19091
19092   if (do_wide)
19093     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
19094   else
19095     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
19096
19097   if (const_strneq (pnote->namedata, "IPF/VMS"))
19098     return print_ia64_vms_note (pnote);
19099   else if (const_strneq (pnote->namedata, "GNU"))
19100     return print_gnu_note (filedata, pnote);
19101   else if (const_strneq (pnote->namedata, "stapsdt"))
19102     return print_stapsdt_note (pnote);
19103   else if (const_strneq (pnote->namedata, "CORE"))
19104     return print_core_note (pnote);
19105   else if (((const_strneq (pnote->namedata, "GA")
19106              && strchr ("*$!+", pnote->namedata[2]) != NULL)
19107             || strchr ("*$!+", pnote->namedata[0]) != NULL)
19108            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19109                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19110     return print_gnu_build_attribute_description (pnote, filedata);
19111
19112   if (pnote->descsz)
19113     {
19114       unsigned long i;
19115
19116       printf (_("   description data: "));
19117       for (i = 0; i < pnote->descsz; i++)
19118         printf ("%02x ", pnote->descdata[i] & 0xff);
19119       if (!do_wide)
19120         printf ("\n");
19121     }
19122
19123   if (do_wide)
19124     printf ("\n");
19125
19126   return TRUE;
19127 }
19128
19129 static bfd_boolean
19130 process_notes_at (Filedata *           filedata,
19131                   Elf_Internal_Shdr *  section,
19132                   bfd_vma              offset,
19133                   bfd_vma              length,
19134                   bfd_vma              align)
19135 {
19136   Elf_External_Note * pnotes;
19137   Elf_External_Note * external;
19138   char *              end;
19139   bfd_boolean         res = TRUE;
19140
19141   if (length <= 0)
19142     return FALSE;
19143
19144   if (section)
19145     {
19146       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
19147       if (pnotes)
19148         {
19149           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
19150             return FALSE;
19151         }
19152     }
19153   else
19154     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19155                                              _("notes"));
19156
19157   if (pnotes == NULL)
19158     return FALSE;
19159
19160   external = pnotes;
19161
19162   if (section)
19163     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
19164   else
19165     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19166             (unsigned long) offset, (unsigned long) length);
19167
19168   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
19169      specifies that notes should be aligned to 4 bytes in 32-bit
19170      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
19171      we also support 4 byte alignment in 64-bit objects.  If section
19172      alignment is less than 4, we treate alignment as 4 bytes.   */
19173   if (align < 4)
19174     align = 4;
19175   else if (align != 4 && align != 8)
19176     {
19177       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19178             (long) align);
19179       return FALSE;
19180     }
19181
19182   printf (_("  %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19183
19184   end = (char *) pnotes + length;
19185   while ((char *) external < end)
19186     {
19187       Elf_Internal_Note inote;
19188       size_t min_notesz;
19189       char * next;
19190       char * temp = NULL;
19191       size_t data_remaining = end - (char *) external;
19192
19193       if (!is_ia64_vms (filedata))
19194         {
19195           /* PR binutils/15191
19196              Make sure that there is enough data to read.  */
19197           min_notesz = offsetof (Elf_External_Note, name);
19198           if (data_remaining < min_notesz)
19199             {
19200               warn (ngettext ("Corrupt note: only %ld byte remains, "
19201                               "not enough for a full note\n",
19202                               "Corrupt note: only %ld bytes remain, "
19203                               "not enough for a full note\n",
19204                               data_remaining),
19205                     (long) data_remaining);
19206               break;
19207             }
19208           data_remaining -= min_notesz;
19209
19210           inote.type     = BYTE_GET (external->type);
19211           inote.namesz   = BYTE_GET (external->namesz);
19212           inote.namedata = external->name;
19213           inote.descsz   = BYTE_GET (external->descsz);
19214           inote.descdata = ((char *) external
19215                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
19216           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19217           next = ((char *) external
19218                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
19219         }
19220       else
19221         {
19222           Elf64_External_VMS_Note *vms_external;
19223
19224           /* PR binutils/15191
19225              Make sure that there is enough data to read.  */
19226           min_notesz = offsetof (Elf64_External_VMS_Note, name);
19227           if (data_remaining < min_notesz)
19228             {
19229               warn (ngettext ("Corrupt note: only %ld byte remains, "
19230                               "not enough for a full note\n",
19231                               "Corrupt note: only %ld bytes remain, "
19232                               "not enough for a full note\n",
19233                               data_remaining),
19234                     (long) data_remaining);
19235               break;
19236             }
19237           data_remaining -= min_notesz;
19238
19239           vms_external = (Elf64_External_VMS_Note *) external;
19240           inote.type     = BYTE_GET (vms_external->type);
19241           inote.namesz   = BYTE_GET (vms_external->namesz);
19242           inote.namedata = vms_external->name;
19243           inote.descsz   = BYTE_GET (vms_external->descsz);
19244           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
19245           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19246           next = inote.descdata + align_power (inote.descsz, 3);
19247         }
19248
19249       /* PR 17531: file: 3443835e.  */
19250       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
19251       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
19252           || (size_t) (inote.descdata - inote.namedata) > data_remaining
19253           || (size_t) (next - inote.descdata) < inote.descsz
19254           || ((size_t) (next - inote.descdata)
19255               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
19256         {
19257           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19258                 (unsigned long) ((char *) external - (char *) pnotes));
19259           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19260                 inote.type, inote.namesz, inote.descsz, (int) align);
19261           break;
19262         }
19263
19264       external = (Elf_External_Note *) next;
19265
19266       /* Verify that name is null terminated.  It appears that at least
19267          one version of Linux (RedHat 6.0) generates corefiles that don't
19268          comply with the ELF spec by failing to include the null byte in
19269          namesz.  */
19270       if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
19271         {
19272           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
19273             {
19274               temp = (char *) malloc (inote.namesz + 1);
19275               if (temp == NULL)
19276                 {
19277                   error (_("Out of memory allocating space for inote name\n"));
19278                   res = FALSE;
19279                   break;
19280                 }
19281
19282               memcpy (temp, inote.namedata, inote.namesz);
19283               inote.namedata = temp;
19284             }
19285           inote.namedata[inote.namesz] = 0;
19286         }
19287
19288       if (! process_note (& inote, filedata))
19289         res = FALSE;
19290
19291       if (temp != NULL)
19292         {
19293           free (temp);
19294           temp = NULL;
19295         }
19296     }
19297
19298   free (pnotes);
19299
19300   return res;
19301 }
19302
19303 static bfd_boolean
19304 process_corefile_note_segments (Filedata * filedata)
19305 {
19306   Elf_Internal_Phdr * segment;
19307   unsigned int i;
19308   bfd_boolean res = TRUE;
19309
19310   if (! get_program_headers (filedata))
19311     return TRUE;
19312
19313   for (i = 0, segment = filedata->program_headers;
19314        i < filedata->file_header.e_phnum;
19315        i++, segment++)
19316     {
19317       if (segment->p_type == PT_NOTE)
19318         if (! process_notes_at (filedata, NULL,
19319                                 (bfd_vma) segment->p_offset,
19320                                 (bfd_vma) segment->p_filesz,
19321                                 (bfd_vma) segment->p_align))
19322           res = FALSE;
19323     }
19324
19325   return res;
19326 }
19327
19328 static bfd_boolean
19329 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
19330 {
19331   Elf_External_Note * pnotes;
19332   Elf_External_Note * external;
19333   char * end;
19334   bfd_boolean res = TRUE;
19335
19336   if (length <= 0)
19337     return FALSE;
19338
19339   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19340                                            _("v850 notes"));
19341   if (pnotes == NULL)
19342     return FALSE;
19343
19344   external = pnotes;
19345   end = (char*) pnotes + length;
19346
19347   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19348           (unsigned long) offset, (unsigned long) length);
19349
19350   while ((char *) external + sizeof (Elf_External_Note) < end)
19351     {
19352       Elf_External_Note * next;
19353       Elf_Internal_Note inote;
19354
19355       inote.type     = BYTE_GET (external->type);
19356       inote.namesz   = BYTE_GET (external->namesz);
19357       inote.namedata = external->name;
19358       inote.descsz   = BYTE_GET (external->descsz);
19359       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
19360       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19361
19362       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
19363         {
19364           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
19365           inote.descdata = inote.namedata;
19366           inote.namesz   = 0;
19367         }
19368
19369       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
19370
19371       if (   ((char *) next > end)
19372           || ((char *) next <  (char *) pnotes))
19373         {
19374           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19375                 (unsigned long) ((char *) external - (char *) pnotes));
19376           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19377                 inote.type, inote.namesz, inote.descsz);
19378           break;
19379         }
19380
19381       external = next;
19382
19383       /* Prevent out-of-bounds indexing.  */
19384       if (   inote.namedata + inote.namesz > end
19385           || inote.namedata + inote.namesz < inote.namedata)
19386         {
19387           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19388                 (unsigned long) ((char *) external - (char *) pnotes));
19389           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19390                 inote.type, inote.namesz, inote.descsz);
19391           break;
19392         }
19393
19394       printf ("  %s: ", get_v850_elf_note_type (inote.type));
19395
19396       if (! print_v850_note (& inote))
19397         {
19398           res = FALSE;
19399           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19400                   inote.namesz, inote.descsz);
19401         }
19402     }
19403
19404   free (pnotes);
19405
19406   return res;
19407 }
19408
19409 static bfd_boolean
19410 process_note_sections (Filedata * filedata)
19411 {
19412   Elf_Internal_Shdr * section;
19413   unsigned long i;
19414   unsigned int n = 0;
19415   bfd_boolean res = TRUE;
19416
19417   for (i = 0, section = filedata->section_headers;
19418        i < filedata->file_header.e_shnum && section != NULL;
19419        i++, section++)
19420     {
19421       if (section->sh_type == SHT_NOTE)
19422         {
19423           if (! process_notes_at (filedata, section,
19424                                   (bfd_vma) section->sh_offset,
19425                                   (bfd_vma) section->sh_size,
19426                                   (bfd_vma) section->sh_addralign))
19427             res = FALSE;
19428           n++;
19429         }
19430
19431       if ((   filedata->file_header.e_machine == EM_V800
19432            || filedata->file_header.e_machine == EM_V850
19433            || filedata->file_header.e_machine == EM_CYGNUS_V850)
19434           && section->sh_type == SHT_RENESAS_INFO)
19435         {
19436           if (! process_v850_notes (filedata,
19437                                     (bfd_vma) section->sh_offset,
19438                                     (bfd_vma) section->sh_size))
19439             res = FALSE;
19440           n++;
19441         }
19442     }
19443
19444   if (n == 0)
19445     /* Try processing NOTE segments instead.  */
19446     return process_corefile_note_segments (filedata);
19447
19448   return res;
19449 }
19450
19451 static bfd_boolean
19452 process_notes (Filedata * filedata)
19453 {
19454   /* If we have not been asked to display the notes then do nothing.  */
19455   if (! do_notes)
19456     return TRUE;
19457
19458   if (filedata->file_header.e_type != ET_CORE)
19459     return process_note_sections (filedata);
19460
19461   /* No program headers means no NOTE segment.  */
19462   if (filedata->file_header.e_phnum > 0)
19463     return process_corefile_note_segments (filedata);
19464
19465   printf (_("No note segments present in the core file.\n"));
19466   return TRUE;
19467 }
19468
19469 static unsigned char *
19470 display_public_gnu_attributes (unsigned char * start,
19471                                const unsigned char * const end)
19472 {
19473   printf (_("  Unknown GNU attribute: %s\n"), start);
19474
19475   start += strnlen ((char *) start, end - start);
19476   display_raw_attribute (start, end);
19477
19478   return (unsigned char *) end;
19479 }
19480
19481 static unsigned char *
19482 display_generic_attribute (unsigned char * start,
19483                            unsigned int tag,
19484                            const unsigned char * const end)
19485 {
19486   if (tag == 0)
19487     return (unsigned char *) end;
19488
19489   return display_tag_value (tag, start, end);
19490 }
19491
19492 static bfd_boolean
19493 process_arch_specific (Filedata * filedata)
19494 {
19495   if (! do_arch)
19496     return TRUE;
19497
19498   switch (filedata->file_header.e_machine)
19499     {
19500     case EM_ARC:
19501     case EM_ARC_COMPACT:
19502     case EM_ARC_COMPACT2:
19503       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
19504                                  display_arc_attribute,
19505                                  display_generic_attribute);
19506     case EM_ARM:
19507       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
19508                                  display_arm_attribute,
19509                                  display_generic_attribute);
19510
19511     case EM_MIPS:
19512     case EM_MIPS_RS3_LE:
19513       return process_mips_specific (filedata);
19514
19515     case EM_MSP430:
19516      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
19517                                 display_msp430x_attribute,
19518                                 display_generic_attribute);
19519
19520     case EM_RISCV:
19521      return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
19522                                 display_riscv_attribute,
19523                                 display_generic_attribute);
19524
19525     case EM_NDS32:
19526       return process_nds32_specific (filedata);
19527
19528     case EM_PPC:
19529     case EM_PPC64:
19530       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19531                                  display_power_gnu_attribute);
19532
19533     case EM_S390:
19534     case EM_S390_OLD:
19535       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19536                                  display_s390_gnu_attribute);
19537
19538     case EM_SPARC:
19539     case EM_SPARC32PLUS:
19540     case EM_SPARCV9:
19541       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19542                                  display_sparc_gnu_attribute);
19543
19544     case EM_TI_C6000:
19545       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
19546                                  display_tic6x_attribute,
19547                                  display_generic_attribute);
19548
19549     default:
19550       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
19551                                  display_public_gnu_attributes,
19552                                  display_generic_attribute);
19553     }
19554 }
19555
19556 static bfd_boolean
19557 get_file_header (Filedata * filedata)
19558 {
19559   /* Read in the identity array.  */
19560   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
19561     return FALSE;
19562
19563   /* Determine how to read the rest of the header.  */
19564   switch (filedata->file_header.e_ident[EI_DATA])
19565     {
19566     default:
19567     case ELFDATANONE:
19568     case ELFDATA2LSB:
19569       byte_get = byte_get_little_endian;
19570       byte_put = byte_put_little_endian;
19571       break;
19572     case ELFDATA2MSB:
19573       byte_get = byte_get_big_endian;
19574       byte_put = byte_put_big_endian;
19575       break;
19576     }
19577
19578   /* For now we only support 32 bit and 64 bit ELF files.  */
19579   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
19580
19581   /* Read in the rest of the header.  */
19582   if (is_32bit_elf)
19583     {
19584       Elf32_External_Ehdr ehdr32;
19585
19586       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
19587         return FALSE;
19588
19589       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
19590       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
19591       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
19592       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
19593       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
19594       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
19595       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
19596       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
19597       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
19598       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
19599       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
19600       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
19601       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
19602     }
19603   else
19604     {
19605       Elf64_External_Ehdr ehdr64;
19606
19607       /* If we have been compiled with sizeof (bfd_vma) == 4, then
19608          we will not be able to cope with the 64bit data found in
19609          64 ELF files.  Detect this now and abort before we start
19610          overwriting things.  */
19611       if (sizeof (bfd_vma) < 8)
19612         {
19613           error (_("This instance of readelf has been built without support for a\n\
19614 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19615           return FALSE;
19616         }
19617
19618       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
19619         return FALSE;
19620
19621       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
19622       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
19623       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
19624       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
19625       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
19626       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
19627       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
19628       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
19629       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19630       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
19631       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19632       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
19633       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
19634     }
19635
19636   if (filedata->file_header.e_shoff)
19637     {
19638       /* There may be some extensions in the first section header.  Don't
19639          bomb if we can't read it.  */
19640       if (is_32bit_elf)
19641         get_32bit_section_headers (filedata, TRUE);
19642       else
19643         get_64bit_section_headers (filedata, TRUE);
19644     }
19645
19646   return TRUE;
19647 }
19648
19649 static void
19650 close_file (Filedata * filedata)
19651 {
19652   if (filedata)
19653     {
19654       if (filedata->handle)
19655         fclose (filedata->handle);
19656       free (filedata);
19657     }
19658 }
19659
19660 void
19661 close_debug_file (void * data)
19662 {
19663   close_file ((Filedata *) data);
19664 }
19665
19666 static Filedata *
19667 open_file (const char * pathname)
19668 {
19669   struct stat  statbuf;
19670   Filedata *   filedata = NULL;
19671
19672   if (stat (pathname, & statbuf) < 0
19673       || ! S_ISREG (statbuf.st_mode))
19674     goto fail;
19675
19676   filedata = calloc (1, sizeof * filedata);
19677   if (filedata == NULL)
19678     goto fail;
19679
19680   filedata->handle = fopen (pathname, "rb");
19681   if (filedata->handle == NULL)
19682     goto fail;
19683
19684   filedata->file_size = (bfd_size_type) statbuf.st_size;
19685   filedata->file_name = pathname;
19686
19687   if (! get_file_header (filedata))
19688     goto fail;
19689
19690   if (filedata->file_header.e_shoff)
19691     {
19692       bfd_boolean res;
19693
19694       /* Read the section headers again, this time for real.  */
19695       if (is_32bit_elf)
19696         res = get_32bit_section_headers (filedata, FALSE);
19697       else
19698         res = get_64bit_section_headers (filedata, FALSE);
19699
19700       if (!res)
19701         goto fail;
19702     }
19703
19704   return filedata;
19705
19706  fail:
19707   if (filedata)
19708     {
19709       if (filedata->handle)
19710         fclose (filedata->handle);
19711       free (filedata);
19712     }
19713   return NULL;
19714 }
19715
19716 void *
19717 open_debug_file (const char * pathname)
19718 {
19719   return open_file (pathname);
19720 }
19721
19722 /* Process one ELF object file according to the command line options.
19723    This file may actually be stored in an archive.  The file is
19724    positioned at the start of the ELF object.  Returns TRUE if no
19725    problems were encountered, FALSE otherwise.  */
19726
19727 static bfd_boolean
19728 process_object (Filedata * filedata)
19729 {
19730   bfd_boolean  have_separate_files;
19731   unsigned int i;
19732   bfd_boolean res = TRUE;
19733
19734   if (! get_file_header (filedata))
19735     {
19736       error (_("%s: Failed to read file header\n"), filedata->file_name);
19737       return FALSE;
19738     }
19739
19740   /* Initialise per file variables.  */
19741   for (i = ARRAY_SIZE (version_info); i--;)
19742     version_info[i] = 0;
19743
19744   for (i = ARRAY_SIZE (dynamic_info); i--;)
19745     dynamic_info[i] = 0;
19746   dynamic_info_DT_GNU_HASH = 0;
19747
19748   /* Process the file.  */
19749   if (show_name)
19750     printf (_("\nFile: %s\n"), filedata->file_name);
19751
19752   /* Initialise the dump_sects array from the cmdline_dump_sects array.
19753      Note we do this even if cmdline_dump_sects is empty because we
19754      must make sure that the dump_sets array is zeroed out before each
19755      object file is processed.  */
19756   if (filedata->num_dump_sects > cmdline.num_dump_sects)
19757     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19758
19759   if (cmdline.num_dump_sects > 0)
19760     {
19761       if (filedata->num_dump_sects == 0)
19762         /* A sneaky way of allocating the dump_sects array.  */
19763         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19764
19765       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19766       memcpy (filedata->dump_sects, cmdline.dump_sects,
19767               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19768     }
19769
19770   if (! process_file_header (filedata))
19771     return FALSE;
19772
19773   if (! process_section_headers (filedata))
19774     {
19775       /* Without loaded section headers we cannot process lots of things.  */
19776       do_unwind = do_version = do_dump = do_arch = FALSE;
19777
19778       if (! do_using_dynamic)
19779         do_syms = do_dyn_syms = do_reloc = FALSE;
19780     }
19781
19782   if (! process_section_groups (filedata))
19783     /* Without loaded section groups we cannot process unwind.  */
19784     do_unwind = FALSE;
19785
19786   if (process_program_headers (filedata))
19787     process_dynamic_section (filedata);
19788   else
19789     res = FALSE;
19790
19791   if (! process_relocs (filedata))
19792     res = FALSE;
19793
19794   if (! process_unwind (filedata))
19795     res = FALSE;
19796
19797   if (! process_symbol_table (filedata))
19798     res = FALSE;
19799
19800   if (! process_syminfo (filedata))
19801     res = FALSE;
19802
19803   if (! process_version_sections (filedata))
19804     res = FALSE;
19805
19806   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19807     have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
19808   else
19809     have_separate_files = FALSE;
19810
19811   if (! process_section_contents (filedata))
19812     res = FALSE;
19813
19814   if (have_separate_files)
19815     {
19816       separate_info * d;
19817
19818       for (d = first_separate_info; d != NULL; d = d->next)
19819         {
19820           if (! process_section_headers (d->handle))
19821             res = FALSE;
19822           else if (! process_section_contents (d->handle))
19823             res = FALSE;
19824         }
19825
19826       /* The file handles are closed by the call to free_debug_memory() below.  */
19827     }
19828
19829   if (! process_notes (filedata))
19830     res = FALSE;
19831
19832   if (! process_gnu_liblist (filedata))
19833     res = FALSE;
19834
19835   if (! process_arch_specific (filedata))
19836     res = FALSE;
19837
19838   free (filedata->program_headers);
19839   filedata->program_headers = NULL;
19840
19841   free (filedata->section_headers);
19842   filedata->section_headers = NULL;
19843
19844   free (filedata->string_table);
19845   filedata->string_table = NULL;
19846   filedata->string_table_length = 0;
19847
19848   if (dynamic_strings)
19849     {
19850       free (dynamic_strings);
19851       dynamic_strings = NULL;
19852       dynamic_strings_length = 0;
19853     }
19854
19855   if (dynamic_symbols)
19856     {
19857       free (dynamic_symbols);
19858       dynamic_symbols = NULL;
19859       num_dynamic_syms = 0;
19860     }
19861
19862   if (dynamic_syminfo)
19863     {
19864       free (dynamic_syminfo);
19865       dynamic_syminfo = NULL;
19866     }
19867
19868   if (dynamic_section)
19869     {
19870       free (dynamic_section);
19871       dynamic_section = NULL;
19872     }
19873
19874   if (section_headers_groups)
19875     {
19876       free (section_headers_groups);
19877       section_headers_groups = NULL;
19878     }
19879
19880   if (section_groups)
19881     {
19882       struct group_list * g;
19883       struct group_list * next;
19884
19885       for (i = 0; i < group_count; i++)
19886         {
19887           for (g = section_groups [i].root; g != NULL; g = next)
19888             {
19889               next = g->next;
19890               free (g);
19891             }
19892         }
19893
19894       free (section_groups);
19895       section_groups = NULL;
19896     }
19897
19898   free_debug_memory ();
19899
19900   return res;
19901 }
19902
19903 /* Process an ELF archive.
19904    On entry the file is positioned just after the ARMAG string.
19905    Returns TRUE upon success, FALSE otherwise.  */
19906
19907 static bfd_boolean
19908 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19909 {
19910   struct archive_info arch;
19911   struct archive_info nested_arch;
19912   size_t got;
19913   bfd_boolean ret = TRUE;
19914
19915   show_name = TRUE;
19916
19917   /* The ARCH structure is used to hold information about this archive.  */
19918   arch.file_name = NULL;
19919   arch.file = NULL;
19920   arch.index_array = NULL;
19921   arch.sym_table = NULL;
19922   arch.longnames = NULL;
19923
19924   /* The NESTED_ARCH structure is used as a single-item cache of information
19925      about a nested archive (when members of a thin archive reside within
19926      another regular archive file).  */
19927   nested_arch.file_name = NULL;
19928   nested_arch.file = NULL;
19929   nested_arch.index_array = NULL;
19930   nested_arch.sym_table = NULL;
19931   nested_arch.longnames = NULL;
19932
19933   if (setup_archive (&arch, filedata->file_name, filedata->handle,
19934                      is_thin_archive, do_archive_index) != 0)
19935     {
19936       ret = FALSE;
19937       goto out;
19938     }
19939
19940   if (do_archive_index)
19941     {
19942       if (arch.sym_table == NULL)
19943         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19944       else
19945         {
19946           unsigned long i, l;
19947           unsigned long current_pos;
19948
19949           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19950                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19951
19952           current_pos = ftell (filedata->handle);
19953
19954           for (i = l = 0; i < arch.index_num; i++)
19955             {
19956               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19957                 {
19958                   char * member_name;
19959
19960                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19961
19962                   if (member_name != NULL)
19963                     {
19964                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19965
19966                       if (qualified_name != NULL)
19967                         {
19968                           printf (_("Contents of binary %s at offset "), qualified_name);
19969                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
19970                           putchar ('\n');
19971                           free (qualified_name);
19972                         }
19973                     }
19974                 }
19975
19976               if (l >= arch.sym_size)
19977                 {
19978                   error (_("%s: end of the symbol table reached before the end of the index\n"),
19979                          filedata->file_name);
19980                   ret = FALSE;
19981                   break;
19982                 }
19983               /* PR 17531: file: 0b6630b2.  */
19984               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19985               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19986             }
19987
19988           if (arch.uses_64bit_indices)
19989             l = (l + 7) & ~ 7;
19990           else
19991             l += l & 1;
19992
19993           if (l < arch.sym_size)
19994             {
19995               error (ngettext ("%s: %ld byte remains in the symbol table, "
19996                                "but without corresponding entries in "
19997                                "the index table\n",
19998                                "%s: %ld bytes remain in the symbol table, "
19999                                "but without corresponding entries in "
20000                                "the index table\n",
20001                                arch.sym_size - l),
20002                      filedata->file_name, arch.sym_size - l);
20003               ret = FALSE;
20004             }
20005
20006           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
20007             {
20008               error (_("%s: failed to seek back to start of object files in the archive\n"),
20009                      filedata->file_name);
20010               ret = FALSE;
20011               goto out;
20012             }
20013         }
20014
20015       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
20016           && !do_segments && !do_header && !do_dump && !do_version
20017           && !do_histogram && !do_debugging && !do_arch && !do_notes
20018           && !do_section_groups && !do_dyn_syms)
20019         {
20020           ret = TRUE; /* Archive index only.  */
20021           goto out;
20022         }
20023     }
20024
20025   while (1)
20026     {
20027       char * name;
20028       size_t namelen;
20029       char * qualified_name;
20030
20031       /* Read the next archive header.  */
20032       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
20033         {
20034           error (_("%s: failed to seek to next archive header\n"), arch.file_name);
20035           return FALSE;
20036         }
20037       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
20038       if (got != sizeof arch.arhdr)
20039         {
20040           if (got == 0)
20041             break;
20042           /* PR 24049 - we cannot use filedata->file_name as this will
20043              have already been freed.  */
20044           error (_("%s: failed to read archive header\n"), arch.file_name);
20045
20046           ret = FALSE;
20047           break;
20048         }
20049       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
20050         {
20051           error (_("%s: did not find a valid archive header\n"), arch.file_name);
20052           ret = FALSE;
20053           break;
20054         }
20055
20056       arch.next_arhdr_offset += sizeof arch.arhdr;
20057
20058       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
20059       if (archive_file_size & 01)
20060         ++archive_file_size;
20061
20062       name = get_archive_member_name (&arch, &nested_arch);
20063       if (name == NULL)
20064         {
20065           error (_("%s: bad archive file name\n"), arch.file_name);
20066           ret = FALSE;
20067           break;
20068         }
20069       namelen = strlen (name);
20070
20071       qualified_name = make_qualified_name (&arch, &nested_arch, name);
20072       if (qualified_name == NULL)
20073         {
20074           error (_("%s: bad archive file name\n"), arch.file_name);
20075           ret = FALSE;
20076           break;
20077         }
20078
20079       if (is_thin_archive && arch.nested_member_origin == 0)
20080         {
20081           /* This is a proxy for an external member of a thin archive.  */
20082           Filedata * member_filedata;
20083           char * member_file_name = adjust_relative_path
20084             (filedata->file_name, name, namelen);
20085
20086           if (member_file_name == NULL)
20087             {
20088               ret = FALSE;
20089               break;
20090             }
20091
20092           member_filedata = open_file (member_file_name);
20093           if (member_filedata == NULL)
20094             {
20095               error (_("Input file '%s' is not readable.\n"), member_file_name);
20096               free (member_file_name);
20097               ret = FALSE;
20098               break;
20099             }
20100
20101           archive_file_offset = arch.nested_member_origin;
20102           member_filedata->file_name = qualified_name;
20103
20104           if (! process_object (member_filedata))
20105             ret = FALSE;
20106
20107           close_file (member_filedata);
20108           free (member_file_name);
20109         }
20110       else if (is_thin_archive)
20111         {
20112           Filedata thin_filedata;
20113
20114           memset (&thin_filedata, 0, sizeof (thin_filedata));
20115
20116           /* PR 15140: Allow for corrupt thin archives.  */
20117           if (nested_arch.file == NULL)
20118             {
20119               error (_("%s: contains corrupt thin archive: %s\n"),
20120                      qualified_name, name);
20121               ret = FALSE;
20122               break;
20123             }
20124
20125           /* This is a proxy for a member of a nested archive.  */
20126           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
20127
20128           /* The nested archive file will have been opened and setup by
20129              get_archive_member_name.  */
20130           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
20131             {
20132               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
20133               ret = FALSE;
20134               break;
20135             }
20136
20137           thin_filedata.handle = nested_arch.file;
20138           thin_filedata.file_name = qualified_name;
20139
20140           if (! process_object (& thin_filedata))
20141             ret = FALSE;
20142         }
20143       else
20144         {
20145           archive_file_offset = arch.next_arhdr_offset;
20146           arch.next_arhdr_offset += archive_file_size;
20147
20148           filedata->file_name = qualified_name;
20149           if (! process_object (filedata))
20150             ret = FALSE;
20151         }
20152
20153       if (filedata->dump_sects != NULL)
20154         {
20155           free (filedata->dump_sects);
20156           filedata->dump_sects = NULL;
20157           filedata->num_dump_sects = 0;
20158         }
20159
20160       free (qualified_name);
20161     }
20162
20163  out:
20164   if (nested_arch.file != NULL)
20165     fclose (nested_arch.file);
20166   release_archive (&nested_arch);
20167   release_archive (&arch);
20168
20169   return ret;
20170 }
20171
20172 static bfd_boolean
20173 process_file (char * file_name)
20174 {
20175   Filedata * filedata = NULL;
20176   struct stat statbuf;
20177   char armag[SARMAG];
20178   bfd_boolean ret = TRUE;
20179
20180   if (stat (file_name, &statbuf) < 0)
20181     {
20182       if (errno == ENOENT)
20183         error (_("'%s': No such file\n"), file_name);
20184       else
20185         error (_("Could not locate '%s'.  System error message: %s\n"),
20186                file_name, strerror (errno));
20187       return FALSE;
20188     }
20189
20190   if (! S_ISREG (statbuf.st_mode))
20191     {
20192       error (_("'%s' is not an ordinary file\n"), file_name);
20193       return FALSE;
20194     }
20195
20196   filedata = calloc (1, sizeof * filedata);
20197   if (filedata == NULL)
20198     {
20199       error (_("Out of memory allocating file data structure\n"));
20200       return FALSE;
20201     }
20202
20203   filedata->file_name = file_name;
20204   filedata->handle = fopen (file_name, "rb");
20205   if (filedata->handle == NULL)
20206     {
20207       error (_("Input file '%s' is not readable.\n"), file_name);
20208       free (filedata);
20209       return FALSE;
20210     }
20211
20212   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
20213     {
20214       error (_("%s: Failed to read file's magic number\n"), file_name);
20215       fclose (filedata->handle);
20216       free (filedata);
20217       return FALSE;
20218     }
20219
20220   filedata->file_size = (bfd_size_type) statbuf.st_size;
20221
20222   if (memcmp (armag, ARMAG, SARMAG) == 0)
20223     {
20224       if (! process_archive (filedata, FALSE))
20225         ret = FALSE;
20226     }
20227   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
20228     {
20229       if ( ! process_archive (filedata, TRUE))
20230         ret = FALSE;
20231     }
20232   else
20233     {
20234       if (do_archive_index)
20235         error (_("File %s is not an archive so its index cannot be displayed.\n"),
20236                file_name);
20237
20238       rewind (filedata->handle);
20239       archive_file_size = archive_file_offset = 0;
20240
20241       if (! process_object (filedata))
20242         ret = FALSE;
20243     }
20244
20245   fclose (filedata->handle);
20246   free (filedata);
20247
20248   return ret;
20249 }
20250
20251 #ifdef SUPPORT_DISASSEMBLY
20252 /* Needed by the i386 disassembler.  For extra credit, someone could
20253    fix this so that we insert symbolic addresses here, esp for GOT/PLT
20254    symbols.  */
20255
20256 void
20257 print_address (unsigned int addr, FILE * outfile)
20258 {
20259   fprintf (outfile,"0x%8.8x", addr);
20260 }
20261
20262 /* Needed by the i386 disassembler.  */
20263
20264 void
20265 db_task_printsym (unsigned int addr)
20266 {
20267   print_address (addr, stderr);
20268 }
20269 #endif
20270
20271 int
20272 main (int argc, char ** argv)
20273 {
20274   int err;
20275
20276 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20277   setlocale (LC_MESSAGES, "");
20278 #endif
20279 #if defined (HAVE_SETLOCALE)
20280   setlocale (LC_CTYPE, "");
20281 #endif
20282   bindtextdomain (PACKAGE, LOCALEDIR);
20283   textdomain (PACKAGE);
20284
20285   expandargv (&argc, &argv);
20286
20287   cmdline.file_name = "<cmdline>";
20288   parse_args (& cmdline, argc, argv);
20289
20290   if (optind < (argc - 1))
20291     show_name = TRUE;
20292   else if (optind >= argc)
20293     {
20294       warn (_("Nothing to do.\n"));
20295       usage (stderr);
20296     }
20297
20298   err = FALSE;
20299   while (optind < argc)
20300     if (! process_file (argv[optind++]))
20301       err = TRUE;
20302
20303   if (cmdline.dump_sects != NULL)
20304     free (cmdline.dump_sects);
20305
20306   free (dump_ctf_symtab_name);
20307   free (dump_ctf_strtab_name);
20308   free (dump_ctf_parent_name);
20309
20310   return err ? EXIT_FAILURE : EXIT_SUCCESS;
20311 }