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 #ifdef HAVE_LIBCTF
  64 #include "ctf-api.h"
  65 #endif
  66
  67 #include "elf/common.h"
  68 #include "elf/external.h"
  69 #include "elf/internal.h"
  70
  71
  72 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  73    we can obtain the H8 reloc numbers.  We need these for the
  74    get_reloc_size() function.  We include h8.h again after defining
  75    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  76
  77 #include "elf/h8.h"
  78 #undef _ELF_H8_H
  79
  80 /* Undo the effects of #including reloc-macros.h.  */
  81
  82 #undef START_RELOC_NUMBERS
  83 #undef RELOC_NUMBER
  84 #undef FAKE_RELOC
  85 #undef EMPTY_RELOC
  86 #undef END_RELOC_NUMBERS
  87 #undef _RELOC_MACROS_H
  88
  89 /* The following headers use the elf/reloc-macros.h file to
  90    automatically generate relocation recognition functions
  91    such as elf_mips_reloc_type()  */
  92
  93 #define RELOC_MACROS_GEN_FUNC
  94
  95 #include "elf/aarch64.h"
  96 #include "elf/alpha.h"
  97 #include "elf/arc.h"
  98 #include "elf/arm.h"
  99 #include "elf/avr.h"
 100 #include "elf/bfin.h"
 101 #include "elf/cr16.h"
 102 #include "elf/cris.h"
 103 #include "elf/crx.h"
 104 #include "elf/csky.h"
 105 #include "elf/d10v.h"
 106 #include "elf/d30v.h"
 107 #include "elf/dlx.h"
 108 #include "elf/bpf.h"
 109 #include "elf/epiphany.h"
 110 #include "elf/fr30.h"
 111 #include "elf/frv.h"
 112 #include "elf/ft32.h"
 113 #include "elf/h8.h"
 114 #include "elf/hppa.h"
 115 #include "elf/i386.h"
 116 #include "elf/i370.h"
 117 #include "elf/i860.h"
 118 #include "elf/i960.h"
 119 #include "elf/ia64.h"
 120 #include "elf/ip2k.h"
 121 #include "elf/lm32.h"
 122 #include "elf/iq2000.h"
 123 #include "elf/m32c.h"
 124 #include "elf/m32r.h"
 125 #include "elf/m68k.h"
 126 #include "elf/m68hc11.h"
 127 #include "elf/s12z.h"
 128 #include "elf/mcore.h"
 129 #include "elf/mep.h"
 130 #include "elf/metag.h"
 131 #include "elf/microblaze.h"
 132 #include "elf/mips.h"
 133 #include "elf/mmix.h"
 134 #include "elf/mn10200.h"
 135 #include "elf/mn10300.h"
 136 #include "elf/moxie.h"
 137 #include "elf/mt.h"
 138 #include "elf/msp430.h"
 139 #include "elf/nds32.h"
 140 #include "elf/nfp.h"
 141 #include "elf/nios2.h"
 142 #include "elf/or1k.h"
 143 #include "elf/pj.h"
 144 #include "elf/ppc.h"
 145 #include "elf/ppc64.h"
 146 #include "elf/pru.h"
 147 #include "elf/riscv.h"
 148 #include "elf/rl78.h"
 149 #include "elf/rx.h"
 150 #include "elf/s390.h"
 151 #include "elf/score.h"
 152 #include "elf/sh.h"
 153 #include "elf/sparc.h"
 154 #include "elf/spu.h"
 155 #include "elf/tic6x.h"
 156 #include "elf/tilegx.h"
 157 #include "elf/tilepro.h"
 158 #include "elf/v850.h"
 159 #include "elf/vax.h"
 160 #include "elf/visium.h"
 161 #include "elf/wasm32.h"
 162 #include "elf/x86-64.h"
 163 #include "elf/xc16x.h"
 164 #include "elf/xgate.h"
 165 #include "elf/xstormy16.h"
 166 #include "elf/xtensa.h"
 167
 168 #include "getopt.h"
 169 #include "libiberty.h"
 170 #include "safe-ctype.h"
 171 #include "filenames.h"
 172
 173 #ifndef offsetof
 174 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 175 #endif
 176
 177 typedef struct elf_section_list
 178 {
 179   Elf_Internal_Shdr *        hdr;
 180   struct elf_section_list *  next;
 181 } elf_section_list;
 182
 183 /* Flag bits indicating particular types of dump.  */
 184 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 185 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 186 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 187 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 188 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 189 #ifdef HAVE_LIBCTF
 190 #define CTF_DUMP        (1 << 5)        /* The --ctf command line switch.  */
 191 #endif
 192
 193 typedef unsigned char dump_type;
 194
 195 /* A linked list of the section names for which dumps were requested.  */
 196 struct dump_list_entry
 197 {
 198   char *                    name;
 199   dump_type                 type;
 200   struct dump_list_entry *  next;
 201 };
 202
 203 typedef struct filedata
 204 {
 205   const char *         file_name;
 206   FILE *               handle;
 207   bfd_size_type        file_size;
 208   Elf_Internal_Ehdr    file_header;
 209   Elf_Internal_Shdr *  section_headers;
 210   Elf_Internal_Phdr *  program_headers;
 211   char *               string_table;
 212   unsigned long        string_table_length;
 213   /* A dynamic array of flags indicating for which sections a dump of
 214      some kind has been requested.  It is reset on a per-object file
 215      basis and then initialised from the cmdline_dump_sects array,
 216      the results of interpreting the -w switch, and the
 217      dump_sects_byname list.  */
 218   dump_type *          dump_sects;
 219   unsigned int         num_dump_sects;
 220 } Filedata;
 221
 222 char * program_name = "readelf";
 223
 224 static unsigned long archive_file_offset;
 225 static unsigned long archive_file_size;
 226 static unsigned long dynamic_addr;
 227 static bfd_size_type dynamic_size;
 228 static size_t dynamic_nent;
 229 static char * dynamic_strings;
 230 static unsigned long dynamic_strings_length;
 231 static unsigned long num_dynamic_syms;
 232 static Elf_Internal_Sym * dynamic_symbols;
 233 static Elf_Internal_Syminfo * dynamic_syminfo;
 234 static unsigned long dynamic_syminfo_offset;
 235 static unsigned int dynamic_syminfo_nent;
 236 static char program_interpreter[PATH_MAX];
 237 static bfd_vma dynamic_info[DT_ENCODING];
 238 static bfd_vma dynamic_info_DT_GNU_HASH;
 239 static bfd_vma version_info[16];
 240 static Elf_Internal_Dyn *  dynamic_section;
 241 static elf_section_list * symtab_shndx_list;
 242 static bfd_boolean show_name = FALSE;
 243 static bfd_boolean do_dynamic = FALSE;
 244 static bfd_boolean do_syms = FALSE;
 245 static bfd_boolean do_dyn_syms = FALSE;
 246 static bfd_boolean do_reloc = FALSE;
 247 static bfd_boolean do_sections = FALSE;
 248 static bfd_boolean do_section_groups = FALSE;
 249 static bfd_boolean do_section_details = FALSE;
 250 static bfd_boolean do_segments = FALSE;
 251 static bfd_boolean do_unwind = FALSE;
 252 static bfd_boolean do_using_dynamic = FALSE;
 253 static bfd_boolean do_header = FALSE;
 254 static bfd_boolean do_dump = FALSE;
 255 static bfd_boolean do_version = FALSE;
 256 static bfd_boolean do_histogram = FALSE;
 257 static bfd_boolean do_debugging = FALSE;
 258 #ifdef HAVE_LIBCTF
 259 static bfd_boolean do_ctf = FALSE;
 260 #endif
 261 static bfd_boolean do_arch = FALSE;
 262 static bfd_boolean do_notes = FALSE;
 263 static bfd_boolean do_archive_index = FALSE;
 264 static bfd_boolean is_32bit_elf = FALSE;
 265 static bfd_boolean decompress_dumps = FALSE;
 266
 267 #ifdef HAVE_LIBCTF
 268 static char *dump_ctf_parent_name;
 269 static char *dump_ctf_symtab_name;
 270 static char *dump_ctf_strtab_name;
 271 #endif
 272
 273 struct group_list
 274 {
 275   struct group_list *  next;
 276   unsigned int         section_index;
 277 };
 278
 279 struct group
 280 {
 281   struct group_list *  root;
 282   unsigned int         group_index;
 283 };
 284
 285 static size_t           group_count;
 286 static struct group *   section_groups;
 287 static struct group **  section_headers_groups;
 288
 289 /* A dynamic array of flags indicating for which sections a dump
 290    has been requested via command line switches.  */
 291 static Filedata         cmdline;
 292
 293 static struct dump_list_entry * dump_sects_byname;
 294
 295 /* How to print a vma value.  */
 296 typedef enum print_mode
 297 {
 298   HEX,
 299   DEC,
 300   DEC_5,
 301   UNSIGNED,
 302   PREFIX_HEX,
 303   FULL_HEX,
 304   LONG_HEX
 305 }
 306 print_mode;
 307
 308 /* Versioned symbol info.  */
 309 enum versioned_symbol_info
 310 {
 311   symbol_undefined,
 312   symbol_hidden,
 313   symbol_public
 314 };
 315
 316 static const char * get_symbol_version_string
 317   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 318    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 319
 320 #define UNKNOWN -1
 321
 322 #define SECTION_NAME(X)                                         \
 323   ((X) == NULL ? _("<none>")                                    \
 324    : filedata->string_table == NULL ? _("<no-strings>")         \
 325    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 326   : filedata->string_table + (X)->sh_name))
 327
 328 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 329
 330 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 331   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 332    : get_64bit_elf_symbols (file, section, sym_count))
 333
 334 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 335 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 336    already been called and verified that the string exists.  */
 337 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 338
 339 #define REMOVE_ARCH_BITS(ADDR)                  \
 340   do                                            \
 341     {                                           \
 342       if (filedata->file_header.e_machine == EM_ARM)    \
 343         (ADDR) &= ~1;                           \
 344     }                                           \
 345   while (0)
 346 \f
 347 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 348    BFD_FMA_FMT can't be used in translated strings.  */
 349
 350 static const char *
 351 bfd_vmatoa (char *fmtch, bfd_vma value)
 352 {
 353   /* bfd_vmatoa is used more then once in a printf call for output.
 354      Cycle through an array of buffers.  */
 355   static int buf_pos = 0;
 356   static struct bfd_vmatoa_buf
 357   {
 358     char place[64];
 359   } buf[4];
 360   char *ret;
 361   char fmt[32];
 362
 363   ret = buf[buf_pos++].place;
 364   buf_pos %= ARRAY_SIZE (buf);
 365
 366   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 367   snprintf (ret, sizeof (buf[0].place), fmt, value);
 368   return ret;
 369 }
 370
 371 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 372    OFFSET + the offset of the current archive member, if we are examining an
 373    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 374    allocate a buffer using malloc and fill that.  In either case return the
 375    pointer to the start of the retrieved data or NULL if something went wrong.
 376    If something does go wrong and REASON is not NULL then emit an error
 377    message using REASON as part of the context.  */
 378
 379 static void *
 380 get_data (void *         var,
 381           Filedata *     filedata,
 382           unsigned long  offset,
 383           bfd_size_type  size,
 384           bfd_size_type  nmemb,
 385           const char *   reason)
 386 {
 387   void * mvar;
 388   bfd_size_type amt = size * nmemb;
 389
 390   if (size == 0 || nmemb == 0)
 391     return NULL;
 392
 393   /* If the size_t type is smaller than the bfd_size_type, eg because
 394      you are building a 32-bit tool on a 64-bit host, then make sure
 395      that when the sizes are cast to (size_t) no information is lost.  */
 396   if (sizeof (size_t) < sizeof (bfd_size_type)
 397       && (   (bfd_size_type) ((size_t) size) != size
 398           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 399     {
 400       if (reason)
 401         error (_("Size truncation prevents reading %s"
 402                  " elements of size %s for %s\n"),
 403                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 404       return NULL;
 405     }
 406
 407   /* Check for size overflow.  */
 408   if (amt < nmemb)
 409     {
 410       if (reason)
 411         error (_("Size overflow prevents reading %s"
 412                  " elements of size %s for %s\n"),
 413                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 414       return NULL;
 415     }
 416
 417   /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
 418      attempting to allocate memory when the read is bound to fail.  */
 419   if (archive_file_offset > filedata->file_size
 420       || offset > filedata->file_size - archive_file_offset
 421       || amt > filedata->file_size - archive_file_offset - offset)
 422     {
 423       if (reason)
 424         error (_("Reading %s bytes extends past end of file for %s\n"),
 425                bfd_vmatoa ("u", amt), reason);
 426       return NULL;
 427     }
 428
 429   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 430     {
 431       if (reason)
 432         error (_("Unable to seek to 0x%lx for %s\n"),
 433                archive_file_offset + offset, reason);
 434       return NULL;
 435     }
 436
 437   mvar = var;
 438   if (mvar == NULL)
 439     {
 440       /* Check for overflow.  */
 441       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 442         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 443         mvar = malloc ((size_t) amt + 1);
 444
 445       if (mvar == NULL)
 446         {
 447           if (reason)
 448             error (_("Out of memory allocating %s bytes for %s\n"),
 449                    bfd_vmatoa ("u", amt), reason);
 450           return NULL;
 451         }
 452
 453       ((char *) mvar)[amt] = '\0';
 454     }
 455
 456   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 457     {
 458       if (reason)
 459         error (_("Unable to read in %s bytes of %s\n"),
 460                bfd_vmatoa ("u", amt), reason);
 461       if (mvar != var)
 462         free (mvar);
 463       return NULL;
 464     }
 465
 466   return mvar;
 467 }
 468
 469 /* Print a VMA value in the MODE specified.
 470    Returns the number of characters displayed.  */
 471
 472 static unsigned int
 473 print_vma (bfd_vma vma, print_mode mode)
 474 {
 475   unsigned int nc = 0;
 476
 477   switch (mode)
 478     {
 479     case FULL_HEX:
 480       nc = printf ("0x");
 481       /* Fall through.  */
 482     case LONG_HEX:
 483 #ifdef BFD64
 484       if (is_32bit_elf)
 485         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 486 #endif
 487       printf_vma (vma);
 488       return nc + 16;
 489
 490     case DEC_5:
 491       if (vma <= 99999)
 492         return printf ("%5" BFD_VMA_FMT "d", vma);
 493       /* Fall through.  */
 494     case PREFIX_HEX:
 495       nc = printf ("0x");
 496       /* Fall through.  */
 497     case HEX:
 498       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 499
 500     case DEC:
 501       return printf ("%" BFD_VMA_FMT "d", vma);
 502
 503     case UNSIGNED:
 504       return printf ("%" BFD_VMA_FMT "u", vma);
 505
 506     default:
 507       /* FIXME: Report unrecognised mode ?  */
 508       return 0;
 509     }
 510 }
 511
 512 /* Display a symbol on stdout.  Handles the display of control characters and
 513    multibye characters (assuming the host environment supports them).
 514
 515    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 516
 517    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 518    padding as necessary.
 519
 520    Returns the number of emitted characters.  */
 521
 522 static unsigned int
 523 print_symbol (signed int width, const char *symbol)
 524 {
 525   bfd_boolean extra_padding = FALSE;
 526   signed int num_printed = 0;
 527 #ifdef HAVE_MBSTATE_T
 528   mbstate_t state;
 529 #endif
 530   unsigned int width_remaining;
 531
 532   if (width < 0)
 533     {
 534       /* Keep the width positive.  This helps the code below.  */
 535       width = - width;
 536       extra_padding = TRUE;
 537     }
 538   else if (width == 0)
 539     return 0;
 540
 541   if (do_wide)
 542     /* Set the remaining width to a very large value.
 543        This simplifies the code below.  */
 544     width_remaining = INT_MAX;
 545   else
 546     width_remaining = width;
 547
 548 #ifdef HAVE_MBSTATE_T
 549   /* Initialise the multibyte conversion state.  */
 550   memset (& state, 0, sizeof (state));
 551 #endif
 552
 553   while (width_remaining)
 554     {
 555       size_t  n;
 556       const char c = *symbol++;
 557
 558       if (c == 0)
 559         break;
 560
 561       /* Do not print control characters directly as they can affect terminal
 562          settings.  Such characters usually appear in the names generated
 563          by the assembler for local labels.  */
 564       if (ISCNTRL (c))
 565         {
 566           if (width_remaining < 2)
 567             break;
 568
 569           printf ("^%c", c + 0x40);
 570           width_remaining -= 2;
 571           num_printed += 2;
 572         }
 573       else if (ISPRINT (c))
 574         {
 575           putchar (c);
 576           width_remaining --;
 577           num_printed ++;
 578         }
 579       else
 580         {
 581 #ifdef HAVE_MBSTATE_T
 582           wchar_t w;
 583 #endif
 584           /* Let printf do the hard work of displaying multibyte characters.  */
 585           printf ("%.1s", symbol - 1);
 586           width_remaining --;
 587           num_printed ++;
 588
 589 #ifdef HAVE_MBSTATE_T
 590           /* Try to find out how many bytes made up the character that was
 591              just printed.  Advance the symbol pointer past the bytes that
 592              were displayed.  */
 593           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 594 #else
 595           n = 1;
 596 #endif
 597           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 598             symbol += (n - 1);
 599         }
 600     }
 601
 602   if (extra_padding && num_printed < width)
 603     {
 604       /* Fill in the remaining spaces.  */
 605       printf ("%-*s", width - num_printed, " ");
 606       num_printed = width;
 607     }
 608
 609   return num_printed;
 610 }
 611
 612 /* Returns a pointer to a static buffer containing a printable version of
 613    the given section's name.  Like print_symbol, except that it does not try
 614    to print multibyte characters, it just interprets them as hex values.  */
 615
 616 static const char *
 617 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 618 {
 619 #define MAX_PRINT_SEC_NAME_LEN 128
 620   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 621   const char * name = SECTION_NAME (sec);
 622   char *       buf = sec_name_buf;
 623   char         c;
 624   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 625
 626   while ((c = * name ++) != 0)
 627     {
 628       if (ISCNTRL (c))
 629         {
 630           if (remaining < 2)
 631             break;
 632
 633           * buf ++ = '^';
 634           * buf ++ = c + 0x40;
 635           remaining -= 2;
 636         }
 637       else if (ISPRINT (c))
 638         {
 639           * buf ++ = c;
 640           remaining -= 1;
 641         }
 642       else
 643         {
 644           static char hex[17] = "0123456789ABCDEF";
 645
 646           if (remaining < 4)
 647             break;
 648           * buf ++ = '<';
 649           * buf ++ = hex[(c & 0xf0) >> 4];
 650           * buf ++ = hex[c & 0x0f];
 651           * buf ++ = '>';
 652           remaining -= 4;
 653         }
 654
 655       if (remaining == 0)
 656         break;
 657     }
 658
 659   * buf = 0;
 660   return sec_name_buf;
 661 }
 662
 663 static const char *
 664 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 665 {
 666   if (ndx >= filedata->file_header.e_shnum)
 667     return _("<corrupt>");
 668
 669   return printable_section_name (filedata, filedata->section_headers + ndx);
 670 }
 671
 672 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 673
 674 static Elf_Internal_Shdr *
 675 find_section (Filedata * filedata, const char * name)
 676 {
 677   unsigned int i;
 678
 679   if (filedata->section_headers == NULL)
 680     return NULL;
 681
 682   for (i = 0; i < filedata->file_header.e_shnum; i++)
 683     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 684       return filedata->section_headers + i;
 685
 686   return NULL;
 687 }
 688
 689 /* Return a pointer to a section containing ADDR, or NULL if no such
 690    section exists.  */
 691
 692 static Elf_Internal_Shdr *
 693 find_section_by_address (Filedata * filedata, bfd_vma addr)
 694 {
 695   unsigned int i;
 696
 697   if (filedata->section_headers == NULL)
 698     return NULL;
 699
 700   for (i = 0; i < filedata->file_header.e_shnum; i++)
 701     {
 702       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 703
 704       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 705         return sec;
 706     }
 707
 708   return NULL;
 709 }
 710
 711 static Elf_Internal_Shdr *
 712 find_section_by_type (Filedata * filedata, unsigned int type)
 713 {
 714   unsigned int i;
 715
 716   if (filedata->section_headers == NULL)
 717     return NULL;
 718
 719   for (i = 0; i < filedata->file_header.e_shnum; i++)
 720     {
 721       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 722
 723       if (sec->sh_type == type)
 724         return sec;
 725     }
 726
 727   return NULL;
 728 }
 729
 730 /* Return a pointer to section NAME, or NULL if no such section exists,
 731    restricted to the list of sections given in SET.  */
 732
 733 static Elf_Internal_Shdr *
 734 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 735 {
 736   unsigned int i;
 737
 738   if (filedata->section_headers == NULL)
 739     return NULL;
 740
 741   if (set != NULL)
 742     {
 743       while ((i = *set++) > 0)
 744         {
 745           /* See PR 21156 for a reproducer.  */
 746           if (i >= filedata->file_header.e_shnum)
 747             continue; /* FIXME: Should we issue an error message ?  */
 748
 749           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 750             return filedata->section_headers + i;
 751         }
 752     }
 753
 754   return find_section (filedata, name);
 755 }
 756
 757 /* Read an unsigned LEB128 encoded value from DATA.
 758    Set *LENGTH_RETURN to the number of bytes read.  */
 759
 760 static inline unsigned long
 761 read_uleb128 (unsigned char * data,
 762               unsigned int * length_return,
 763               const unsigned char * const end)
 764 {
 765   return read_leb128 (data, length_return, FALSE, end);
 766 }
 767
 768 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 769    This OS has so many departures from the ELF standard that we test it at
 770    many places.  */
 771
 772 static inline bfd_boolean
 773 is_ia64_vms (Filedata * filedata)
 774 {
 775   return filedata->file_header.e_machine == EM_IA_64
 776     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 777 }
 778
 779 /* Guess the relocation size commonly used by the specific machines.  */
 780
 781 static bfd_boolean
 782 guess_is_rela (unsigned int e_machine)
 783 {
 784   switch (e_machine)
 785     {
 786       /* Targets that use REL relocations.  */
 787     case EM_386:
 788     case EM_IAMCU:
 789     case EM_960:
 790     case EM_ARM:
 791     case EM_D10V:
 792     case EM_CYGNUS_D10V:
 793     case EM_DLX:
 794     case EM_MIPS:
 795     case EM_MIPS_RS3_LE:
 796     case EM_CYGNUS_M32R:
 797     case EM_SCORE:
 798     case EM_XGATE:
 799     case EM_NFP:
 800     case EM_BPF:
 801       return FALSE;
 802
 803       /* Targets that use RELA relocations.  */
 804     case EM_68K:
 805     case EM_860:
 806     case EM_AARCH64:
 807     case EM_ADAPTEVA_EPIPHANY:
 808     case EM_ALPHA:
 809     case EM_ALTERA_NIOS2:
 810     case EM_ARC:
 811     case EM_ARC_COMPACT:
 812     case EM_ARC_COMPACT2:
 813     case EM_AVR:
 814     case EM_AVR_OLD:
 815     case EM_BLACKFIN:
 816     case EM_CR16:
 817     case EM_CRIS:
 818     case EM_CRX:
 819     case EM_CSKY:
 820     case EM_D30V:
 821     case EM_CYGNUS_D30V:
 822     case EM_FR30:
 823     case EM_FT32:
 824     case EM_CYGNUS_FR30:
 825     case EM_CYGNUS_FRV:
 826     case EM_H8S:
 827     case EM_H8_300:
 828     case EM_H8_300H:
 829     case EM_IA_64:
 830     case EM_IP2K:
 831     case EM_IP2K_OLD:
 832     case EM_IQ2000:
 833     case EM_LATTICEMICO32:
 834     case EM_M32C_OLD:
 835     case EM_M32C:
 836     case EM_M32R:
 837     case EM_MCORE:
 838     case EM_CYGNUS_MEP:
 839     case EM_METAG:
 840     case EM_MMIX:
 841     case EM_MN10200:
 842     case EM_CYGNUS_MN10200:
 843     case EM_MN10300:
 844     case EM_CYGNUS_MN10300:
 845     case EM_MOXIE:
 846     case EM_MSP430:
 847     case EM_MSP430_OLD:
 848     case EM_MT:
 849     case EM_NDS32:
 850     case EM_NIOS32:
 851     case EM_OR1K:
 852     case EM_PPC64:
 853     case EM_PPC:
 854     case EM_TI_PRU:
 855     case EM_RISCV:
 856     case EM_RL78:
 857     case EM_RX:
 858     case EM_S390:
 859     case EM_S390_OLD:
 860     case EM_SH:
 861     case EM_SPARC:
 862     case EM_SPARC32PLUS:
 863     case EM_SPARCV9:
 864     case EM_SPU:
 865     case EM_TI_C6000:
 866     case EM_TILEGX:
 867     case EM_TILEPRO:
 868     case EM_V800:
 869     case EM_V850:
 870     case EM_CYGNUS_V850:
 871     case EM_VAX:
 872     case EM_VISIUM:
 873     case EM_X86_64:
 874     case EM_L1OM:
 875     case EM_K1OM:
 876     case EM_XSTORMY16:
 877     case EM_XTENSA:
 878     case EM_XTENSA_OLD:
 879     case EM_MICROBLAZE:
 880     case EM_MICROBLAZE_OLD:
 881     case EM_WEBASSEMBLY:
 882       return TRUE;
 883
 884     case EM_68HC05:
 885     case EM_68HC08:
 886     case EM_68HC11:
 887     case EM_68HC16:
 888     case EM_FX66:
 889     case EM_ME16:
 890     case EM_MMA:
 891     case EM_NCPU:
 892     case EM_NDR1:
 893     case EM_PCP:
 894     case EM_ST100:
 895     case EM_ST19:
 896     case EM_ST7:
 897     case EM_ST9PLUS:
 898     case EM_STARCORE:
 899     case EM_SVX:
 900     case EM_TINYJ:
 901     default:
 902       warn (_("Don't know about relocations on this machine architecture\n"));
 903       return FALSE;
 904     }
 905 }
 906
 907 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 908    Returns TRUE upon success, FALSE otherwise.  If successful then a
 909    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 910    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 911    responsibility to free the allocated buffer.  */
 912
 913 static bfd_boolean
 914 slurp_rela_relocs (Filedata *            filedata,
 915                    unsigned long         rel_offset,
 916                    unsigned long         rel_size,
 917                    Elf_Internal_Rela **  relasp,
 918                    unsigned long *       nrelasp)
 919 {
 920   Elf_Internal_Rela * relas;
 921   size_t nrelas;
 922   unsigned int i;
 923
 924   if (is_32bit_elf)
 925     {
 926       Elf32_External_Rela * erelas;
 927
 928       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 929                                                  rel_size, _("32-bit relocation data"));
 930       if (!erelas)
 931         return FALSE;
 932
 933       nrelas = rel_size / sizeof (Elf32_External_Rela);
 934
 935       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 936                                              sizeof (Elf_Internal_Rela));
 937
 938       if (relas == NULL)
 939         {
 940           free (erelas);
 941           error (_("out of memory parsing relocs\n"));
 942           return FALSE;
 943         }
 944
 945       for (i = 0; i < nrelas; i++)
 946         {
 947           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 948           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 949           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 950         }
 951
 952       free (erelas);
 953     }
 954   else
 955     {
 956       Elf64_External_Rela * erelas;
 957
 958       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 959                                                  rel_size, _("64-bit relocation data"));
 960       if (!erelas)
 961         return FALSE;
 962
 963       nrelas = rel_size / sizeof (Elf64_External_Rela);
 964
 965       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 966                                              sizeof (Elf_Internal_Rela));
 967
 968       if (relas == NULL)
 969         {
 970           free (erelas);
 971           error (_("out of memory parsing relocs\n"));
 972           return FALSE;
 973         }
 974
 975       for (i = 0; i < nrelas; i++)
 976         {
 977           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 978           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 979           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 980
 981           /* The #ifdef BFD64 below is to prevent a compile time
 982              warning.  We know that if we do not have a 64 bit data
 983              type that we will never execute this code anyway.  */
 984 #ifdef BFD64
 985           if (filedata->file_header.e_machine == EM_MIPS
 986               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 987             {
 988               /* In little-endian objects, r_info isn't really a
 989                  64-bit little-endian value: it has a 32-bit
 990                  little-endian symbol index followed by four
 991                  individual byte fields.  Reorder INFO
 992                  accordingly.  */
 993               bfd_vma inf = relas[i].r_info;
 994               inf = (((inf & 0xffffffff) << 32)
 995                       | ((inf >> 56) & 0xff)
 996                       | ((inf >> 40) & 0xff00)
 997                       | ((inf >> 24) & 0xff0000)
 998                       | ((inf >> 8) & 0xff000000));
 999               relas[i].r_info = inf;
1000             }
1001 #endif /* BFD64 */
1002         }
1003
1004       free (erelas);
1005     }
1006
1007   *relasp = relas;
1008   *nrelasp = nrelas;
1009   return TRUE;
1010 }
1011
1012 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1013    Returns TRUE upon success, FALSE otherwise.  If successful then a
1014    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1015    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
1016    responsibility to free the allocated buffer.  */
1017
1018 static bfd_boolean
1019 slurp_rel_relocs (Filedata *            filedata,
1020                   unsigned long         rel_offset,
1021                   unsigned long         rel_size,
1022                   Elf_Internal_Rela **  relsp,
1023                   unsigned long *       nrelsp)
1024 {
1025   Elf_Internal_Rela * rels;
1026   size_t nrels;
1027   unsigned int i;
1028
1029   if (is_32bit_elf)
1030     {
1031       Elf32_External_Rel * erels;
1032
1033       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1034                                                rel_size, _("32-bit relocation data"));
1035       if (!erels)
1036         return FALSE;
1037
1038       nrels = rel_size / sizeof (Elf32_External_Rel);
1039
1040       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1041
1042       if (rels == NULL)
1043         {
1044           free (erels);
1045           error (_("out of memory parsing relocs\n"));
1046           return FALSE;
1047         }
1048
1049       for (i = 0; i < nrels; i++)
1050         {
1051           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1052           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1053           rels[i].r_addend = 0;
1054         }
1055
1056       free (erels);
1057     }
1058   else
1059     {
1060       Elf64_External_Rel * erels;
1061
1062       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1063                                                rel_size, _("64-bit relocation data"));
1064       if (!erels)
1065         return FALSE;
1066
1067       nrels = rel_size / sizeof (Elf64_External_Rel);
1068
1069       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1070
1071       if (rels == NULL)
1072         {
1073           free (erels);
1074           error (_("out of memory parsing relocs\n"));
1075           return FALSE;
1076         }
1077
1078       for (i = 0; i < nrels; i++)
1079         {
1080           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1081           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1082           rels[i].r_addend = 0;
1083
1084           /* The #ifdef BFD64 below is to prevent a compile time
1085              warning.  We know that if we do not have a 64 bit data
1086              type that we will never execute this code anyway.  */
1087 #ifdef BFD64
1088           if (filedata->file_header.e_machine == EM_MIPS
1089               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1090             {
1091               /* In little-endian objects, r_info isn't really a
1092                  64-bit little-endian value: it has a 32-bit
1093                  little-endian symbol index followed by four
1094                  individual byte fields.  Reorder INFO
1095                  accordingly.  */
1096               bfd_vma inf = rels[i].r_info;
1097               inf = (((inf & 0xffffffff) << 32)
1098                      | ((inf >> 56) & 0xff)
1099                      | ((inf >> 40) & 0xff00)
1100                      | ((inf >> 24) & 0xff0000)
1101                      | ((inf >> 8) & 0xff000000));
1102               rels[i].r_info = inf;
1103             }
1104 #endif /* BFD64 */
1105         }
1106
1107       free (erels);
1108     }
1109
1110   *relsp = rels;
1111   *nrelsp = nrels;
1112   return TRUE;
1113 }
1114
1115 /* Returns the reloc type extracted from the reloc info field.  */
1116
1117 static unsigned int
1118 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1119 {
1120   if (is_32bit_elf)
1121     return ELF32_R_TYPE (reloc_info);
1122
1123   switch (filedata->file_header.e_machine)
1124     {
1125     case EM_MIPS:
1126       /* Note: We assume that reloc_info has already been adjusted for us.  */
1127       return ELF64_MIPS_R_TYPE (reloc_info);
1128
1129     case EM_SPARCV9:
1130       return ELF64_R_TYPE_ID (reloc_info);
1131
1132     default:
1133       return ELF64_R_TYPE (reloc_info);
1134     }
1135 }
1136
1137 /* Return the symbol index extracted from the reloc info field.  */
1138
1139 static bfd_vma
1140 get_reloc_symindex (bfd_vma reloc_info)
1141 {
1142   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1143 }
1144
1145 static inline bfd_boolean
1146 uses_msp430x_relocs (Filedata * filedata)
1147 {
1148   return
1149     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1150     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1151     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1152         /* TI compiler uses ELFOSABI_NONE.  */
1153         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1154 }
1155
1156 /* Display the contents of the relocation data found at the specified
1157    offset.  */
1158
1159 static bfd_boolean
1160 dump_relocations (Filedata *          filedata,
1161                   unsigned long       rel_offset,
1162                   unsigned long       rel_size,
1163                   Elf_Internal_Sym *  symtab,
1164                   unsigned long       nsyms,
1165                   char *              strtab,
1166                   unsigned long       strtablen,
1167                   int                 is_rela,
1168                   bfd_boolean         is_dynsym)
1169 {
1170   unsigned long i;
1171   Elf_Internal_Rela * rels;
1172   bfd_boolean res = TRUE;
1173
1174   if (is_rela == UNKNOWN)
1175     is_rela = guess_is_rela (filedata->file_header.e_machine);
1176
1177   if (is_rela)
1178     {
1179       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1180         return FALSE;
1181     }
1182   else
1183     {
1184       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1185         return FALSE;
1186     }
1187
1188   if (is_32bit_elf)
1189     {
1190       if (is_rela)
1191         {
1192           if (do_wide)
1193             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1194           else
1195             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1196         }
1197       else
1198         {
1199           if (do_wide)
1200             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1201           else
1202             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1203         }
1204     }
1205   else
1206     {
1207       if (is_rela)
1208         {
1209           if (do_wide)
1210             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1211           else
1212             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1213         }
1214       else
1215         {
1216           if (do_wide)
1217             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1218           else
1219             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1220         }
1221     }
1222
1223   for (i = 0; i < rel_size; i++)
1224     {
1225       const char * rtype;
1226       bfd_vma offset;
1227       bfd_vma inf;
1228       bfd_vma symtab_index;
1229       bfd_vma type;
1230
1231       offset = rels[i].r_offset;
1232       inf    = rels[i].r_info;
1233
1234       type = get_reloc_type (filedata, inf);
1235       symtab_index = get_reloc_symindex  (inf);
1236
1237       if (is_32bit_elf)
1238         {
1239           printf ("%8.8lx  %8.8lx ",
1240                   (unsigned long) offset & 0xffffffff,
1241                   (unsigned long) inf & 0xffffffff);
1242         }
1243       else
1244         {
1245 #if BFD_HOST_64BIT_LONG
1246           printf (do_wide
1247                   ? "%16.16lx  %16.16lx "
1248                   : "%12.12lx  %12.12lx ",
1249                   offset, inf);
1250 #elif BFD_HOST_64BIT_LONG_LONG
1251 #ifndef __MSVCRT__
1252           printf (do_wide
1253                   ? "%16.16llx  %16.16llx "
1254                   : "%12.12llx  %12.12llx ",
1255                   offset, inf);
1256 #else
1257           printf (do_wide
1258                   ? "%16.16I64x  %16.16I64x "
1259                   : "%12.12I64x  %12.12I64x ",
1260                   offset, inf);
1261 #endif
1262 #else
1263           printf (do_wide
1264                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1265                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1266                   _bfd_int64_high (offset),
1267                   _bfd_int64_low (offset),
1268                   _bfd_int64_high (inf),
1269                   _bfd_int64_low (inf));
1270 #endif
1271         }
1272
1273       switch (filedata->file_header.e_machine)
1274         {
1275         default:
1276           rtype = NULL;
1277           break;
1278
1279         case EM_AARCH64:
1280           rtype = elf_aarch64_reloc_type (type);
1281           break;
1282
1283         case EM_M32R:
1284         case EM_CYGNUS_M32R:
1285           rtype = elf_m32r_reloc_type (type);
1286           break;
1287
1288         case EM_386:
1289         case EM_IAMCU:
1290           rtype = elf_i386_reloc_type (type);
1291           break;
1292
1293         case EM_68HC11:
1294         case EM_68HC12:
1295           rtype = elf_m68hc11_reloc_type (type);
1296           break;
1297
1298         case EM_S12Z:
1299           rtype = elf_s12z_reloc_type (type);
1300           break;
1301
1302         case EM_68K:
1303           rtype = elf_m68k_reloc_type (type);
1304           break;
1305
1306         case EM_960:
1307           rtype = elf_i960_reloc_type (type);
1308           break;
1309
1310         case EM_AVR:
1311         case EM_AVR_OLD:
1312           rtype = elf_avr_reloc_type (type);
1313           break;
1314
1315         case EM_OLD_SPARCV9:
1316         case EM_SPARC32PLUS:
1317         case EM_SPARCV9:
1318         case EM_SPARC:
1319           rtype = elf_sparc_reloc_type (type);
1320           break;
1321
1322         case EM_SPU:
1323           rtype = elf_spu_reloc_type (type);
1324           break;
1325
1326         case EM_V800:
1327           rtype = v800_reloc_type (type);
1328           break;
1329         case EM_V850:
1330         case EM_CYGNUS_V850:
1331           rtype = v850_reloc_type (type);
1332           break;
1333
1334         case EM_D10V:
1335         case EM_CYGNUS_D10V:
1336           rtype = elf_d10v_reloc_type (type);
1337           break;
1338
1339         case EM_D30V:
1340         case EM_CYGNUS_D30V:
1341           rtype = elf_d30v_reloc_type (type);
1342           break;
1343
1344         case EM_DLX:
1345           rtype = elf_dlx_reloc_type (type);
1346           break;
1347
1348         case EM_SH:
1349           rtype = elf_sh_reloc_type (type);
1350           break;
1351
1352         case EM_MN10300:
1353         case EM_CYGNUS_MN10300:
1354           rtype = elf_mn10300_reloc_type (type);
1355           break;
1356
1357         case EM_MN10200:
1358         case EM_CYGNUS_MN10200:
1359           rtype = elf_mn10200_reloc_type (type);
1360           break;
1361
1362         case EM_FR30:
1363         case EM_CYGNUS_FR30:
1364           rtype = elf_fr30_reloc_type (type);
1365           break;
1366
1367         case EM_CYGNUS_FRV:
1368           rtype = elf_frv_reloc_type (type);
1369           break;
1370
1371         case EM_CSKY:
1372           rtype = elf_csky_reloc_type (type);
1373           break;
1374
1375         case EM_FT32:
1376           rtype = elf_ft32_reloc_type (type);
1377           break;
1378
1379         case EM_MCORE:
1380           rtype = elf_mcore_reloc_type (type);
1381           break;
1382
1383         case EM_MMIX:
1384           rtype = elf_mmix_reloc_type (type);
1385           break;
1386
1387         case EM_MOXIE:
1388           rtype = elf_moxie_reloc_type (type);
1389           break;
1390
1391         case EM_MSP430:
1392           if (uses_msp430x_relocs (filedata))
1393             {
1394               rtype = elf_msp430x_reloc_type (type);
1395               break;
1396             }
1397           /* Fall through.  */
1398         case EM_MSP430_OLD:
1399           rtype = elf_msp430_reloc_type (type);
1400           break;
1401
1402         case EM_NDS32:
1403           rtype = elf_nds32_reloc_type (type);
1404           break;
1405
1406         case EM_PPC:
1407           rtype = elf_ppc_reloc_type (type);
1408           break;
1409
1410         case EM_PPC64:
1411           rtype = elf_ppc64_reloc_type (type);
1412           break;
1413
1414         case EM_MIPS:
1415         case EM_MIPS_RS3_LE:
1416           rtype = elf_mips_reloc_type (type);
1417           break;
1418
1419         case EM_RISCV:
1420           rtype = elf_riscv_reloc_type (type);
1421           break;
1422
1423         case EM_ALPHA:
1424           rtype = elf_alpha_reloc_type (type);
1425           break;
1426
1427         case EM_ARM:
1428           rtype = elf_arm_reloc_type (type);
1429           break;
1430
1431         case EM_ARC:
1432         case EM_ARC_COMPACT:
1433         case EM_ARC_COMPACT2:
1434           rtype = elf_arc_reloc_type (type);
1435           break;
1436
1437         case EM_PARISC:
1438           rtype = elf_hppa_reloc_type (type);
1439           break;
1440
1441         case EM_H8_300:
1442         case EM_H8_300H:
1443         case EM_H8S:
1444           rtype = elf_h8_reloc_type (type);
1445           break;
1446
1447         case EM_OR1K:
1448           rtype = elf_or1k_reloc_type (type);
1449           break;
1450
1451         case EM_PJ:
1452         case EM_PJ_OLD:
1453           rtype = elf_pj_reloc_type (type);
1454           break;
1455         case EM_IA_64:
1456           rtype = elf_ia64_reloc_type (type);
1457           break;
1458
1459         case EM_CRIS:
1460           rtype = elf_cris_reloc_type (type);
1461           break;
1462
1463         case EM_860:
1464           rtype = elf_i860_reloc_type (type);
1465           break;
1466
1467         case EM_X86_64:
1468         case EM_L1OM:
1469         case EM_K1OM:
1470           rtype = elf_x86_64_reloc_type (type);
1471           break;
1472
1473         case EM_S370:
1474           rtype = i370_reloc_type (type);
1475           break;
1476
1477         case EM_S390_OLD:
1478         case EM_S390:
1479           rtype = elf_s390_reloc_type (type);
1480           break;
1481
1482         case EM_SCORE:
1483           rtype = elf_score_reloc_type (type);
1484           break;
1485
1486         case EM_XSTORMY16:
1487           rtype = elf_xstormy16_reloc_type (type);
1488           break;
1489
1490         case EM_CRX:
1491           rtype = elf_crx_reloc_type (type);
1492           break;
1493
1494         case EM_VAX:
1495           rtype = elf_vax_reloc_type (type);
1496           break;
1497
1498         case EM_VISIUM:
1499           rtype = elf_visium_reloc_type (type);
1500           break;
1501
1502         case EM_BPF:
1503           rtype = elf_bpf_reloc_type (type);
1504           break;
1505
1506         case EM_ADAPTEVA_EPIPHANY:
1507           rtype = elf_epiphany_reloc_type (type);
1508           break;
1509
1510         case EM_IP2K:
1511         case EM_IP2K_OLD:
1512           rtype = elf_ip2k_reloc_type (type);
1513           break;
1514
1515         case EM_IQ2000:
1516           rtype = elf_iq2000_reloc_type (type);
1517           break;
1518
1519         case EM_XTENSA_OLD:
1520         case EM_XTENSA:
1521           rtype = elf_xtensa_reloc_type (type);
1522           break;
1523
1524         case EM_LATTICEMICO32:
1525           rtype = elf_lm32_reloc_type (type);
1526           break;
1527
1528         case EM_M32C_OLD:
1529         case EM_M32C:
1530           rtype = elf_m32c_reloc_type (type);
1531           break;
1532
1533         case EM_MT:
1534           rtype = elf_mt_reloc_type (type);
1535           break;
1536
1537         case EM_BLACKFIN:
1538           rtype = elf_bfin_reloc_type (type);
1539           break;
1540
1541         case EM_CYGNUS_MEP:
1542           rtype = elf_mep_reloc_type (type);
1543           break;
1544
1545         case EM_CR16:
1546           rtype = elf_cr16_reloc_type (type);
1547           break;
1548
1549         case EM_MICROBLAZE:
1550         case EM_MICROBLAZE_OLD:
1551           rtype = elf_microblaze_reloc_type (type);
1552           break;
1553
1554         case EM_RL78:
1555           rtype = elf_rl78_reloc_type (type);
1556           break;
1557
1558         case EM_RX:
1559           rtype = elf_rx_reloc_type (type);
1560           break;
1561
1562         case EM_METAG:
1563           rtype = elf_metag_reloc_type (type);
1564           break;
1565
1566         case EM_XC16X:
1567         case EM_C166:
1568           rtype = elf_xc16x_reloc_type (type);
1569           break;
1570
1571         case EM_TI_C6000:
1572           rtype = elf_tic6x_reloc_type (type);
1573           break;
1574
1575         case EM_TILEGX:
1576           rtype = elf_tilegx_reloc_type (type);
1577           break;
1578
1579         case EM_TILEPRO:
1580           rtype = elf_tilepro_reloc_type (type);
1581           break;
1582
1583         case EM_WEBASSEMBLY:
1584           rtype = elf_wasm32_reloc_type (type);
1585           break;
1586
1587         case EM_XGATE:
1588           rtype = elf_xgate_reloc_type (type);
1589           break;
1590
1591         case EM_ALTERA_NIOS2:
1592           rtype = elf_nios2_reloc_type (type);
1593           break;
1594
1595         case EM_TI_PRU:
1596           rtype = elf_pru_reloc_type (type);
1597           break;
1598
1599         case EM_NFP:
1600           if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1601             rtype = elf_nfp3200_reloc_type (type);
1602           else
1603             rtype = elf_nfp_reloc_type (type);
1604           break;
1605         }
1606
1607       if (rtype == NULL)
1608         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1609       else
1610         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1611
1612       if (filedata->file_header.e_machine == EM_ALPHA
1613           && rtype != NULL
1614           && streq (rtype, "R_ALPHA_LITUSE")
1615           && is_rela)
1616         {
1617           switch (rels[i].r_addend)
1618             {
1619             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1620             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1621             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1622             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1623             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1624             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1625             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1626             default: rtype = NULL;
1627             }
1628
1629           if (rtype)
1630             printf (" (%s)", rtype);
1631           else
1632             {
1633               putchar (' ');
1634               printf (_("<unknown addend: %lx>"),
1635                       (unsigned long) rels[i].r_addend);
1636               res = FALSE;
1637             }
1638         }
1639       else if (symtab_index)
1640         {
1641           if (symtab == NULL || symtab_index >= nsyms)
1642             {
1643               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1644               res = FALSE;
1645             }
1646           else
1647             {
1648               Elf_Internal_Sym * psym;
1649               const char * version_string;
1650               enum versioned_symbol_info sym_info;
1651               unsigned short vna_other;
1652
1653               psym = symtab + symtab_index;
1654
1655               version_string
1656                 = get_symbol_version_string (filedata, is_dynsym,
1657                                              strtab, strtablen,
1658                                              symtab_index,
1659                                              psym,
1660                                              &sym_info,
1661                                              &vna_other);
1662
1663               printf (" ");
1664
1665               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1666                 {
1667                   const char * name;
1668                   unsigned int len;
1669                   unsigned int width = is_32bit_elf ? 8 : 14;
1670
1671                   /* Relocations against GNU_IFUNC symbols do not use the value
1672                      of the symbol as the address to relocate against.  Instead
1673                      they invoke the function named by the symbol and use its
1674                      result as the address for relocation.
1675
1676                      To indicate this to the user, do not display the value of
1677                      the symbol in the "Symbols's Value" field.  Instead show
1678                      its name followed by () as a hint that the symbol is
1679                      invoked.  */
1680
1681                   if (strtab == NULL
1682                       || psym->st_name == 0
1683                       || psym->st_name >= strtablen)
1684                     name = "??";
1685                   else
1686                     name = strtab + psym->st_name;
1687
1688                   len = print_symbol (width, name);
1689                   if (version_string)
1690                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1691                             version_string);
1692                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1693                 }
1694               else
1695                 {
1696                   print_vma (psym->st_value, LONG_HEX);
1697
1698                   printf (is_32bit_elf ? "   " : " ");
1699                 }
1700
1701               if (psym->st_name == 0)
1702                 {
1703                   const char * sec_name = "<null>";
1704                   char name_buf[40];
1705
1706                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1707                     {
1708                       if (psym->st_shndx < filedata->file_header.e_shnum)
1709                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1710                       else if (psym->st_shndx == SHN_ABS)
1711                         sec_name = "ABS";
1712                       else if (psym->st_shndx == SHN_COMMON)
1713                         sec_name = "COMMON";
1714                       else if ((filedata->file_header.e_machine == EM_MIPS
1715                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1716                                || (filedata->file_header.e_machine == EM_TI_C6000
1717                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1718                         sec_name = "SCOMMON";
1719                       else if (filedata->file_header.e_machine == EM_MIPS
1720                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1721                         sec_name = "SUNDEF";
1722                       else if ((filedata->file_header.e_machine == EM_X86_64
1723                                 || filedata->file_header.e_machine == EM_L1OM
1724                                 || filedata->file_header.e_machine == EM_K1OM)
1725                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1726                         sec_name = "LARGE_COMMON";
1727                       else if (filedata->file_header.e_machine == EM_IA_64
1728                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1729                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1730                         sec_name = "ANSI_COM";
1731                       else if (is_ia64_vms (filedata)
1732                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1733                         sec_name = "VMS_SYMVEC";
1734                       else
1735                         {
1736                           sprintf (name_buf, "<section 0x%x>",
1737                                    (unsigned int) psym->st_shndx);
1738                           sec_name = name_buf;
1739                         }
1740                     }
1741                   print_symbol (22, sec_name);
1742                 }
1743               else if (strtab == NULL)
1744                 printf (_("<string table index: %3ld>"), psym->st_name);
1745               else if (psym->st_name >= strtablen)
1746                 {
1747                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1748                   res = FALSE;
1749                 }
1750               else
1751                 {
1752                   print_symbol (22, strtab + psym->st_name);
1753                   if (version_string)
1754                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1755                             version_string);
1756                 }
1757
1758               if (is_rela)
1759                 {
1760                   bfd_vma off = rels[i].r_addend;
1761
1762                   if ((bfd_signed_vma) off < 0)
1763                     printf (" - %" BFD_VMA_FMT "x", - off);
1764                   else
1765                     printf (" + %" BFD_VMA_FMT "x", off);
1766                 }
1767             }
1768         }
1769       else if (is_rela)
1770         {
1771           bfd_vma off = rels[i].r_addend;
1772
1773           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1774           if ((bfd_signed_vma) off < 0)
1775             printf ("-%" BFD_VMA_FMT "x", - off);
1776           else
1777             printf ("%" BFD_VMA_FMT "x", off);
1778         }
1779
1780       if (filedata->file_header.e_machine == EM_SPARCV9
1781           && rtype != NULL
1782           && streq (rtype, "R_SPARC_OLO10"))
1783         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1784
1785       putchar ('\n');
1786
1787 #ifdef BFD64
1788       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1789         {
1790           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1791           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1792           const char * rtype2 = elf_mips_reloc_type (type2);
1793           const char * rtype3 = elf_mips_reloc_type (type3);
1794
1795           printf ("                    Type2: ");
1796
1797           if (rtype2 == NULL)
1798             printf (_("unrecognized: %-7lx"),
1799                     (unsigned long) type2 & 0xffffffff);
1800           else
1801             printf ("%-17.17s", rtype2);
1802
1803           printf ("\n                    Type3: ");
1804
1805           if (rtype3 == NULL)
1806             printf (_("unrecognized: %-7lx"),
1807                     (unsigned long) type3 & 0xffffffff);
1808           else
1809             printf ("%-17.17s", rtype3);
1810
1811           putchar ('\n');
1812         }
1813 #endif /* BFD64 */
1814     }
1815
1816   free (rels);
1817
1818   return res;
1819 }
1820
1821 static const char *
1822 get_aarch64_dynamic_type (unsigned long type)
1823 {
1824   switch (type)
1825     {
1826     case DT_AARCH64_BTI_PLT:  return "AARCH64_BTI_PLT";
1827     case DT_AARCH64_PAC_PLT:  return "AARCH64_PAC_PLT";
1828     case DT_AARCH64_VARIANT_PCS:  return "AARCH64_VARIANT_PCS";
1829     default:
1830       return NULL;
1831     }
1832 }
1833
1834 static const char *
1835 get_mips_dynamic_type (unsigned long type)
1836 {
1837   switch (type)
1838     {
1839     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1840     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1841     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1842     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1843     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1844     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1845     case DT_MIPS_MSYM: return "MIPS_MSYM";
1846     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1847     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1848     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1849     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1850     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1851     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1852     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1853     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1854     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1855     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1856     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1857     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1858     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1859     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1860     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1861     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1862     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1863     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1864     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1865     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1866     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1867     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1868     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1869     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1870     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1871     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1872     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1873     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1874     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1875     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1876     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1877     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1878     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1879     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1880     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1881     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1882     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1883     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1884     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1885     default:
1886       return NULL;
1887     }
1888 }
1889
1890 static const char *
1891 get_sparc64_dynamic_type (unsigned long type)
1892 {
1893   switch (type)
1894     {
1895     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1896     default:
1897       return NULL;
1898     }
1899 }
1900
1901 static const char *
1902 get_ppc_dynamic_type (unsigned long type)
1903 {
1904   switch (type)
1905     {
1906     case DT_PPC_GOT:    return "PPC_GOT";
1907     case DT_PPC_OPT:    return "PPC_OPT";
1908     default:
1909       return NULL;
1910     }
1911 }
1912
1913 static const char *
1914 get_ppc64_dynamic_type (unsigned long type)
1915 {
1916   switch (type)
1917     {
1918     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1919     case DT_PPC64_OPD:    return "PPC64_OPD";
1920     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1921     case DT_PPC64_OPT:    return "PPC64_OPT";
1922     default:
1923       return NULL;
1924     }
1925 }
1926
1927 static const char *
1928 get_parisc_dynamic_type (unsigned long type)
1929 {
1930   switch (type)
1931     {
1932     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1933     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1934     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1935     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1936     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1937     case DT_HP_PREINIT:         return "HP_PREINIT";
1938     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1939     case DT_HP_NEEDED:          return "HP_NEEDED";
1940     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1941     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1942     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1943     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1944     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1945     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1946     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1947     case DT_HP_FILTERED:        return "HP_FILTERED";
1948     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1949     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1950     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1951     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1952     case DT_PLT:                return "PLT";
1953     case DT_PLT_SIZE:           return "PLT_SIZE";
1954     case DT_DLT:                return "DLT";
1955     case DT_DLT_SIZE:           return "DLT_SIZE";
1956     default:
1957       return NULL;
1958     }
1959 }
1960
1961 static const char *
1962 get_ia64_dynamic_type (unsigned long type)
1963 {
1964   switch (type)
1965     {
1966     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1967     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1968     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1969     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1970     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1971     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1972     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1973     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1974     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1975     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1976     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1977     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1978     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1979     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1980     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1981     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1982     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1983     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1984     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1985     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1986     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1987     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1988     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1989     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1990     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1991     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1992     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1993     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1994     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1995     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1996     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1997     default:
1998       return NULL;
1999     }
2000 }
2001
2002 static const char *
2003 get_solaris_section_type (unsigned long type)
2004 {
2005   switch (type)
2006     {
2007     case 0x6fffffee: return "SUNW_ancillary";
2008     case 0x6fffffef: return "SUNW_capchain";
2009     case 0x6ffffff0: return "SUNW_capinfo";
2010     case 0x6ffffff1: return "SUNW_symsort";
2011     case 0x6ffffff2: return "SUNW_tlssort";
2012     case 0x6ffffff3: return "SUNW_LDYNSYM";
2013     case 0x6ffffff4: return "SUNW_dof";
2014     case 0x6ffffff5: return "SUNW_cap";
2015     case 0x6ffffff6: return "SUNW_SIGNATURE";
2016     case 0x6ffffff7: return "SUNW_ANNOTATE";
2017     case 0x6ffffff8: return "SUNW_DEBUGSTR";
2018     case 0x6ffffff9: return "SUNW_DEBUG";
2019     case 0x6ffffffa: return "SUNW_move";
2020     case 0x6ffffffb: return "SUNW_COMDAT";
2021     case 0x6ffffffc: return "SUNW_syminfo";
2022     case 0x6ffffffd: return "SUNW_verdef";
2023     case 0x6ffffffe: return "SUNW_verneed";
2024     case 0x6fffffff: return "SUNW_versym";
2025     case 0x70000000: return "SPARC_GOTDATA";
2026     default: return NULL;
2027     }
2028 }
2029
2030 static const char *
2031 get_alpha_dynamic_type (unsigned long type)
2032 {
2033   switch (type)
2034     {
2035     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2036     default: return NULL;
2037     }
2038 }
2039
2040 static const char *
2041 get_score_dynamic_type (unsigned long type)
2042 {
2043   switch (type)
2044     {
2045     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2046     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
2047     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
2048     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
2049     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
2050     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
2051     default:                    return NULL;
2052     }
2053 }
2054
2055 static const char *
2056 get_tic6x_dynamic_type (unsigned long type)
2057 {
2058   switch (type)
2059     {
2060     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2061     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2062     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2063     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2064     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2065     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2066     default:                   return NULL;
2067     }
2068 }
2069
2070 static const char *
2071 get_nios2_dynamic_type (unsigned long type)
2072 {
2073   switch (type)
2074     {
2075     case DT_NIOS2_GP: return "NIOS2_GP";
2076     default:          return NULL;
2077     }
2078 }
2079
2080 static const char *
2081 get_solaris_dynamic_type (unsigned long type)
2082 {
2083   switch (type)
2084     {
2085     case 0x6000000d: return "SUNW_AUXILIARY";
2086     case 0x6000000e: return "SUNW_RTLDINF";
2087     case 0x6000000f: return "SUNW_FILTER";
2088     case 0x60000010: return "SUNW_CAP";
2089     case 0x60000011: return "SUNW_SYMTAB";
2090     case 0x60000012: return "SUNW_SYMSZ";
2091     case 0x60000013: return "SUNW_SORTENT";
2092     case 0x60000014: return "SUNW_SYMSORT";
2093     case 0x60000015: return "SUNW_SYMSORTSZ";
2094     case 0x60000016: return "SUNW_TLSSORT";
2095     case 0x60000017: return "SUNW_TLSSORTSZ";
2096     case 0x60000018: return "SUNW_CAPINFO";
2097     case 0x60000019: return "SUNW_STRPAD";
2098     case 0x6000001a: return "SUNW_CAPCHAIN";
2099     case 0x6000001b: return "SUNW_LDMACH";
2100     case 0x6000001d: return "SUNW_CAPCHAINENT";
2101     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2102     case 0x60000021: return "SUNW_PARENT";
2103     case 0x60000023: return "SUNW_ASLR";
2104     case 0x60000025: return "SUNW_RELAX";
2105     case 0x60000029: return "SUNW_NXHEAP";
2106     case 0x6000002b: return "SUNW_NXSTACK";
2107
2108     case 0x70000001: return "SPARC_REGISTER";
2109     case 0x7ffffffd: return "AUXILIARY";
2110     case 0x7ffffffe: return "USED";
2111     case 0x7fffffff: return "FILTER";
2112
2113     default: return NULL;
2114     }
2115 }
2116
2117 static const char *
2118 get_dynamic_type (Filedata * filedata, unsigned long type)
2119 {
2120   static char buff[64];
2121
2122   switch (type)
2123     {
2124     case DT_NULL:       return "NULL";
2125     case DT_NEEDED:     return "NEEDED";
2126     case DT_PLTRELSZ:   return "PLTRELSZ";
2127     case DT_PLTGOT:     return "PLTGOT";
2128     case DT_HASH:       return "HASH";
2129     case DT_STRTAB:     return "STRTAB";
2130     case DT_SYMTAB:     return "SYMTAB";
2131     case DT_RELA:       return "RELA";
2132     case DT_RELASZ:     return "RELASZ";
2133     case DT_RELAENT:    return "RELAENT";
2134     case DT_STRSZ:      return "STRSZ";
2135     case DT_SYMENT:     return "SYMENT";
2136     case DT_INIT:       return "INIT";
2137     case DT_FINI:       return "FINI";
2138     case DT_SONAME:     return "SONAME";
2139     case DT_RPATH:      return "RPATH";
2140     case DT_SYMBOLIC:   return "SYMBOLIC";
2141     case DT_REL:        return "REL";
2142     case DT_RELSZ:      return "RELSZ";
2143     case DT_RELENT:     return "RELENT";
2144     case DT_PLTREL:     return "PLTREL";
2145     case DT_DEBUG:      return "DEBUG";
2146     case DT_TEXTREL:    return "TEXTREL";
2147     case DT_JMPREL:     return "JMPREL";
2148     case DT_BIND_NOW:   return "BIND_NOW";
2149     case DT_INIT_ARRAY: return "INIT_ARRAY";
2150     case DT_FINI_ARRAY: return "FINI_ARRAY";
2151     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2152     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2153     case DT_RUNPATH:    return "RUNPATH";
2154     case DT_FLAGS:      return "FLAGS";
2155
2156     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2157     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2158     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2159
2160     case DT_CHECKSUM:   return "CHECKSUM";
2161     case DT_PLTPADSZ:   return "PLTPADSZ";
2162     case DT_MOVEENT:    return "MOVEENT";
2163     case DT_MOVESZ:     return "MOVESZ";
2164     case DT_FEATURE:    return "FEATURE";
2165     case DT_POSFLAG_1:  return "POSFLAG_1";
2166     case DT_SYMINSZ:    return "SYMINSZ";
2167     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2168
2169     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2170     case DT_CONFIG:     return "CONFIG";
2171     case DT_DEPAUDIT:   return "DEPAUDIT";
2172     case DT_AUDIT:      return "AUDIT";
2173     case DT_PLTPAD:     return "PLTPAD";
2174     case DT_MOVETAB:    return "MOVETAB";
2175     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2176
2177     case DT_VERSYM:     return "VERSYM";
2178
2179     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2180     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2181     case DT_RELACOUNT:  return "RELACOUNT";
2182     case DT_RELCOUNT:   return "RELCOUNT";
2183     case DT_FLAGS_1:    return "FLAGS_1";
2184     case DT_VERDEF:     return "VERDEF";
2185     case DT_VERDEFNUM:  return "VERDEFNUM";
2186     case DT_VERNEED:    return "VERNEED";
2187     case DT_VERNEEDNUM: return "VERNEEDNUM";
2188
2189     case DT_AUXILIARY:  return "AUXILIARY";
2190     case DT_USED:       return "USED";
2191     case DT_FILTER:     return "FILTER";
2192
2193     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2194     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2195     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2196     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2197     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2198     case DT_GNU_HASH:   return "GNU_HASH";
2199
2200     default:
2201       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2202         {
2203           const char * result;
2204
2205           switch (filedata->file_header.e_machine)
2206             {
2207             case EM_AARCH64:
2208               result = get_aarch64_dynamic_type (type);
2209               break;
2210             case EM_MIPS:
2211             case EM_MIPS_RS3_LE:
2212               result = get_mips_dynamic_type (type);
2213               break;
2214             case EM_SPARCV9:
2215               result = get_sparc64_dynamic_type (type);
2216               break;
2217             case EM_PPC:
2218               result = get_ppc_dynamic_type (type);
2219               break;
2220             case EM_PPC64:
2221               result = get_ppc64_dynamic_type (type);
2222               break;
2223             case EM_IA_64:
2224               result = get_ia64_dynamic_type (type);
2225               break;
2226             case EM_ALPHA:
2227               result = get_alpha_dynamic_type (type);
2228               break;
2229             case EM_SCORE:
2230               result = get_score_dynamic_type (type);
2231               break;
2232             case EM_TI_C6000:
2233               result = get_tic6x_dynamic_type (type);
2234               break;
2235             case EM_ALTERA_NIOS2:
2236               result = get_nios2_dynamic_type (type);
2237               break;
2238             default:
2239               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2240                 result = get_solaris_dynamic_type (type);
2241               else
2242                 result = NULL;
2243               break;
2244             }
2245
2246           if (result != NULL)
2247             return result;
2248
2249           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2250         }
2251       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2252                || (filedata->file_header.e_machine == EM_PARISC
2253                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2254         {
2255           const char * result;
2256
2257           switch (filedata->file_header.e_machine)
2258             {
2259             case EM_PARISC:
2260               result = get_parisc_dynamic_type (type);
2261               break;
2262             case EM_IA_64:
2263               result = get_ia64_dynamic_type (type);
2264               break;
2265             default:
2266               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2267                 result = get_solaris_dynamic_type (type);
2268               else
2269                 result = NULL;
2270               break;
2271             }
2272
2273           if (result != NULL)
2274             return result;
2275
2276           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2277                     type);
2278         }
2279       else
2280         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2281
2282       return buff;
2283     }
2284 }
2285
2286 static char *
2287 get_file_type (unsigned e_type)
2288 {
2289   static char buff[32];
2290
2291   switch (e_type)
2292     {
2293     case ET_NONE: return _("NONE (None)");
2294     case ET_REL:  return _("REL (Relocatable file)");
2295     case ET_EXEC: return _("EXEC (Executable file)");
2296     case ET_DYN:  return _("DYN (Shared object file)");
2297     case ET_CORE: return _("CORE (Core file)");
2298
2299     default:
2300       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2301         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2302       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2303         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2304       else
2305         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2306       return buff;
2307     }
2308 }
2309
2310 static char *
2311 get_machine_name (unsigned e_machine)
2312 {
2313   static char buff[64]; /* XXX */
2314
2315   switch (e_machine)
2316     {
2317       /* Please keep this switch table sorted by increasing EM_ value.  */
2318       /* 0 */
2319     case EM_NONE:               return _("None");
2320     case EM_M32:                return "WE32100";
2321     case EM_SPARC:              return "Sparc";
2322     case EM_386:                return "Intel 80386";
2323     case EM_68K:                return "MC68000";
2324     case EM_88K:                return "MC88000";
2325     case EM_IAMCU:              return "Intel MCU";
2326     case EM_860:                return "Intel 80860";
2327     case EM_MIPS:               return "MIPS R3000";
2328     case EM_S370:               return "IBM System/370";
2329       /* 10 */
2330     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2331     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2332     case EM_PARISC:             return "HPPA";
2333     case EM_VPP550:             return "Fujitsu VPP500";
2334     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2335     case EM_960:                return "Intel 80960";
2336     case EM_PPC:                return "PowerPC";
2337       /* 20 */
2338     case EM_PPC64:              return "PowerPC64";
2339     case EM_S390_OLD:
2340     case EM_S390:               return "IBM S/390";
2341     case EM_SPU:                return "SPU";
2342       /* 30 */
2343     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2344     case EM_FR20:               return "Fujitsu FR20";
2345     case EM_RH32:               return "TRW RH32";
2346     case EM_MCORE:              return "MCORE";
2347       /* 40 */
2348     case EM_ARM:                return "ARM";
2349     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2350     case EM_SH:                 return "Renesas / SuperH SH";
2351     case EM_SPARCV9:            return "Sparc v9";
2352     case EM_TRICORE:            return "Siemens Tricore";
2353     case EM_ARC:                return "ARC";
2354     case EM_H8_300:             return "Renesas H8/300";
2355     case EM_H8_300H:            return "Renesas H8/300H";
2356     case EM_H8S:                return "Renesas H8S";
2357     case EM_H8_500:             return "Renesas H8/500";
2358       /* 50 */
2359     case EM_IA_64:              return "Intel IA-64";
2360     case EM_MIPS_X:             return "Stanford MIPS-X";
2361     case EM_COLDFIRE:           return "Motorola Coldfire";
2362     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2363     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2364     case EM_PCP:                return "Siemens PCP";
2365     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2366     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2367     case EM_STARCORE:           return "Motorola Star*Core processor";
2368     case EM_ME16:               return "Toyota ME16 processor";
2369       /* 60 */
2370     case EM_ST100:              return "STMicroelectronics ST100 processor";
2371     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2372     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2373     case EM_PDSP:               return "Sony DSP processor";
2374     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2375     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2376     case EM_FX66:               return "Siemens FX66 microcontroller";
2377     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2378     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2379     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2380       /* 70 */
2381     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2382     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2383     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2384     case EM_SVX:                return "Silicon Graphics SVx";
2385     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2386     case EM_VAX:                return "Digital VAX";
2387     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2388     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2389     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2390     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2391       /* 80 */
2392     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2393     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2394     case EM_PRISM:              return "Vitesse Prism";
2395     case EM_AVR_OLD:
2396     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2397     case EM_CYGNUS_FR30:
2398     case EM_FR30:               return "Fujitsu FR30";
2399     case EM_CYGNUS_D10V:
2400     case EM_D10V:               return "d10v";
2401     case EM_CYGNUS_D30V:
2402     case EM_D30V:               return "d30v";
2403     case EM_CYGNUS_V850:
2404     case EM_V850:               return "Renesas V850";
2405     case EM_CYGNUS_M32R:
2406     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2407     case EM_CYGNUS_MN10300:
2408     case EM_MN10300:            return "mn10300";
2409       /* 90 */
2410     case EM_CYGNUS_MN10200:
2411     case EM_MN10200:            return "mn10200";
2412     case EM_PJ:                 return "picoJava";
2413     case EM_OR1K:               return "OpenRISC 1000";
2414     case EM_ARC_COMPACT:        return "ARCompact";
2415     case EM_XTENSA_OLD:
2416     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2417     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2418     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2419     case EM_NS32K:              return "National Semiconductor 32000 series";
2420     case EM_TPC:                return "Tenor Network TPC processor";
2421     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2422       /* 100 */
2423     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2424     case EM_IP2K_OLD:
2425     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2426     case EM_MAX:                return "MAX Processor";
2427     case EM_CR:                 return "National Semiconductor CompactRISC";
2428     case EM_F2MC16:             return "Fujitsu F2MC16";
2429     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2430     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2431     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2432     case EM_SEP:                return "Sharp embedded microprocessor";
2433     case EM_ARCA:               return "Arca RISC microprocessor";
2434       /* 110 */
2435     case EM_UNICORE:            return "Unicore";
2436     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2437     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2438     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2439     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2440     case EM_XGATE:              return "Motorola XGATE embedded processor";
2441     case EM_C166:
2442     case EM_XC16X:              return "Infineon Technologies xc16x";
2443     case EM_M16C:               return "Renesas M16C series microprocessors";
2444     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2445     case EM_CE:                 return "Freescale Communication Engine RISC core";
2446       /* 120 */
2447     case EM_M32C:               return "Renesas M32c";
2448       /* 130 */
2449     case EM_TSK3000:            return "Altium TSK3000 core";
2450     case EM_RS08:               return "Freescale RS08 embedded processor";
2451     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2452     case EM_SCORE:              return "SUNPLUS S+Core";
2453     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2454     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2455     case EM_LATTICEMICO32:      return "Lattice Mico32";
2456     case EM_SE_C17:             return "Seiko Epson C17 family";
2457       /* 140 */
2458     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2459     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2460     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2461     case EM_TI_PRU:             return "TI PRU I/O processor";
2462       /* 160 */
2463     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2464     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2465     case EM_R32C:               return "Renesas R32C series microprocessors";
2466     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2467     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2468     case EM_8051:               return "Intel 8051 and variants";
2469     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2470     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2471     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2472     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2473       /* 170 */
2474     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2475     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2476     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2477     case EM_RX:                 return "Renesas RX";
2478     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2479     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2480     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2481     case EM_CR16:
2482     case EM_MICROBLAZE:
2483     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2484     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2485     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2486       /* 180 */
2487     case EM_L1OM:               return "Intel L1OM";
2488     case EM_K1OM:               return "Intel K1OM";
2489     case EM_INTEL182:           return "Intel (reserved)";
2490     case EM_AARCH64:            return "AArch64";
2491     case EM_ARM184:             return "ARM (reserved)";
2492     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2493     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2494     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2495     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2496       /* 190 */
2497     case EM_CUDA:               return "NVIDIA CUDA architecture";
2498     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2499     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2500     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2501     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2502     case EM_ARC_COMPACT2:       return "ARCv2";
2503     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2504     case EM_RL78:               return "Renesas RL78";
2505     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2506     case EM_78K0R:              return "Renesas 78K0R";
2507       /* 200 */
2508     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2509     case EM_BA1:                return "Beyond BA1 CPU architecture";
2510     case EM_BA2:                return "Beyond BA2 CPU architecture";
2511     case EM_XCORE:              return "XMOS xCORE processor family";
2512     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2513       /* 210 */
2514     case EM_KM32:               return "KM211 KM32 32-bit processor";
2515     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2516     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2517     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2518     case EM_KVARC:              return "KM211 KVARC processor";
2519     case EM_CDP:                return "Paneve CDP architecture family";
2520     case EM_COGE:               return "Cognitive Smart Memory Processor";
2521     case EM_COOL:               return "Bluechip Systems CoolEngine";
2522     case EM_NORC:               return "Nanoradio Optimized RISC";
2523     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2524       /* 220 */
2525     case EM_Z80:                return "Zilog Z80";
2526     case EM_VISIUM:             return "CDS VISIUMcore processor";
2527     case EM_FT32:               return "FTDI Chip FT32";
2528     case EM_MOXIE:              return "Moxie";
2529     case EM_AMDGPU:             return "AMD GPU";
2530     case EM_RISCV:              return "RISC-V";
2531     case EM_LANAI:              return "Lanai 32-bit processor";
2532     case EM_BPF:                return "Linux BPF";
2533     case EM_NFP:                return "Netronome Flow Processor";
2534
2535       /* Large numbers...  */
2536     case EM_MT:                 return "Morpho Techologies MT processor";
2537     case EM_ALPHA:              return "Alpha";
2538     case EM_WEBASSEMBLY:        return "Web Assembly";
2539     case EM_DLX:                return "OpenDLX";
2540     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2541     case EM_IQ2000:             return "Vitesse IQ2000";
2542     case EM_M32C_OLD:
2543     case EM_NIOS32:             return "Altera Nios";
2544     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2545     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2546     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2547     case EM_S12Z:               return "Freescale S12Z";
2548     case EM_CSKY:               return "C-SKY";
2549
2550     default:
2551       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2552       return buff;
2553     }
2554 }
2555
2556 static void
2557 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2558 {
2559   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2560      other compilers don't a specific architecture type in the e_flags, and
2561      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2562      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2563      architectures.
2564
2565      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2566      but also sets a specific architecture type in the e_flags field.
2567
2568      However, when decoding the flags we don't worry if we see an
2569      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2570      ARCEM architecture type.  */
2571
2572   switch (e_flags & EF_ARC_MACH_MSK)
2573     {
2574       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2575     case EF_ARC_CPU_ARCV2EM:
2576       strcat (buf, ", ARC EM");
2577       break;
2578     case EF_ARC_CPU_ARCV2HS:
2579       strcat (buf, ", ARC HS");
2580       break;
2581
2582       /* We only expect these to occur for EM_ARC_COMPACT.  */
2583     case E_ARC_MACH_ARC600:
2584       strcat (buf, ", ARC600");
2585       break;
2586     case E_ARC_MACH_ARC601:
2587       strcat (buf, ", ARC601");
2588       break;
2589     case E_ARC_MACH_ARC700:
2590       strcat (buf, ", ARC700");
2591       break;
2592
2593       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2594          new ELF with new architecture being read by an old version of
2595          readelf, or (c) An ELF built with non-GNU compiler that does not
2596          set the architecture in the e_flags.  */
2597     default:
2598       if (e_machine == EM_ARC_COMPACT)
2599         strcat (buf, ", Unknown ARCompact");
2600       else
2601         strcat (buf, ", Unknown ARC");
2602       break;
2603     }
2604
2605   switch (e_flags & EF_ARC_OSABI_MSK)
2606     {
2607     case E_ARC_OSABI_ORIG:
2608       strcat (buf, ", (ABI:legacy)");
2609       break;
2610     case E_ARC_OSABI_V2:
2611       strcat (buf, ", (ABI:v2)");
2612       break;
2613       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2614     case E_ARC_OSABI_V3:
2615       strcat (buf, ", v3 no-legacy-syscalls ABI");
2616       break;
2617     case E_ARC_OSABI_V4:
2618       strcat (buf, ", v4 ABI");
2619       break;
2620     default:
2621       strcat (buf, ", unrecognised ARC OSABI flag");
2622       break;
2623     }
2624 }
2625
2626 static void
2627 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2628 {
2629   unsigned eabi;
2630   bfd_boolean unknown = FALSE;
2631
2632   eabi = EF_ARM_EABI_VERSION (e_flags);
2633   e_flags &= ~ EF_ARM_EABIMASK;
2634
2635   /* Handle "generic" ARM flags.  */
2636   if (e_flags & EF_ARM_RELEXEC)
2637     {
2638       strcat (buf, ", relocatable executable");
2639       e_flags &= ~ EF_ARM_RELEXEC;
2640     }
2641
2642   if (e_flags & EF_ARM_PIC)
2643     {
2644       strcat (buf, ", position independent");
2645       e_flags &= ~ EF_ARM_PIC;
2646     }
2647
2648   /* Now handle EABI specific flags.  */
2649   switch (eabi)
2650     {
2651     default:
2652       strcat (buf, ", <unrecognized EABI>");
2653       if (e_flags)
2654         unknown = TRUE;
2655       break;
2656
2657     case EF_ARM_EABI_VER1:
2658       strcat (buf, ", Version1 EABI");
2659       while (e_flags)
2660         {
2661           unsigned flag;
2662
2663           /* Process flags one bit at a time.  */
2664           flag = e_flags & - e_flags;
2665           e_flags &= ~ flag;
2666
2667           switch (flag)
2668             {
2669             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2670               strcat (buf, ", sorted symbol tables");
2671               break;
2672
2673             default:
2674               unknown = TRUE;
2675               break;
2676             }
2677         }
2678       break;
2679
2680     case EF_ARM_EABI_VER2:
2681       strcat (buf, ", Version2 EABI");
2682       while (e_flags)
2683         {
2684           unsigned flag;
2685
2686           /* Process flags one bit at a time.  */
2687           flag = e_flags & - e_flags;
2688           e_flags &= ~ flag;
2689
2690           switch (flag)
2691             {
2692             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2693               strcat (buf, ", sorted symbol tables");
2694               break;
2695
2696             case EF_ARM_DYNSYMSUSESEGIDX:
2697               strcat (buf, ", dynamic symbols use segment index");
2698               break;
2699
2700             case EF_ARM_MAPSYMSFIRST:
2701               strcat (buf, ", mapping symbols precede others");
2702               break;
2703
2704             default:
2705               unknown = TRUE;
2706               break;
2707             }
2708         }
2709       break;
2710
2711     case EF_ARM_EABI_VER3:
2712       strcat (buf, ", Version3 EABI");
2713       break;
2714
2715     case EF_ARM_EABI_VER4:
2716       strcat (buf, ", Version4 EABI");
2717       while (e_flags)
2718         {
2719           unsigned flag;
2720
2721           /* Process flags one bit at a time.  */
2722           flag = e_flags & - e_flags;
2723           e_flags &= ~ flag;
2724
2725           switch (flag)
2726             {
2727             case EF_ARM_BE8:
2728               strcat (buf, ", BE8");
2729               break;
2730
2731             case EF_ARM_LE8:
2732               strcat (buf, ", LE8");
2733               break;
2734
2735             default:
2736               unknown = TRUE;
2737               break;
2738             }
2739         }
2740       break;
2741
2742     case EF_ARM_EABI_VER5:
2743       strcat (buf, ", Version5 EABI");
2744       while (e_flags)
2745         {
2746           unsigned flag;
2747
2748           /* Process flags one bit at a time.  */
2749           flag = e_flags & - e_flags;
2750           e_flags &= ~ flag;
2751
2752           switch (flag)
2753             {
2754             case EF_ARM_BE8:
2755               strcat (buf, ", BE8");
2756               break;
2757
2758             case EF_ARM_LE8:
2759               strcat (buf, ", LE8");
2760               break;
2761
2762             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2763               strcat (buf, ", soft-float ABI");
2764               break;
2765
2766             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2767               strcat (buf, ", hard-float ABI");
2768               break;
2769
2770             default:
2771               unknown = TRUE;
2772               break;
2773             }
2774         }
2775       break;
2776
2777     case EF_ARM_EABI_UNKNOWN:
2778       strcat (buf, ", GNU EABI");
2779       while (e_flags)
2780         {
2781           unsigned flag;
2782
2783           /* Process flags one bit at a time.  */
2784           flag = e_flags & - e_flags;
2785           e_flags &= ~ flag;
2786
2787           switch (flag)
2788             {
2789             case EF_ARM_INTERWORK:
2790               strcat (buf, ", interworking enabled");
2791               break;
2792
2793             case EF_ARM_APCS_26:
2794               strcat (buf, ", uses APCS/26");
2795               break;
2796
2797             case EF_ARM_APCS_FLOAT:
2798               strcat (buf, ", uses APCS/float");
2799               break;
2800
2801             case EF_ARM_PIC:
2802               strcat (buf, ", position independent");
2803               break;
2804
2805             case EF_ARM_ALIGN8:
2806               strcat (buf, ", 8 bit structure alignment");
2807               break;
2808
2809             case EF_ARM_NEW_ABI:
2810               strcat (buf, ", uses new ABI");
2811               break;
2812
2813             case EF_ARM_OLD_ABI:
2814               strcat (buf, ", uses old ABI");
2815               break;
2816
2817             case EF_ARM_SOFT_FLOAT:
2818               strcat (buf, ", software FP");
2819               break;
2820
2821             case EF_ARM_VFP_FLOAT:
2822               strcat (buf, ", VFP");
2823               break;
2824
2825             case EF_ARM_MAVERICK_FLOAT:
2826               strcat (buf, ", Maverick FP");
2827               break;
2828
2829             default:
2830               unknown = TRUE;
2831               break;
2832             }
2833         }
2834     }
2835
2836   if (unknown)
2837     strcat (buf,_(", <unknown>"));
2838 }
2839
2840 static void
2841 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2842 {
2843   --size; /* Leave space for null terminator.  */
2844
2845   switch (e_flags & EF_AVR_MACH)
2846     {
2847     case E_AVR_MACH_AVR1:
2848       strncat (buf, ", avr:1", size);
2849       break;
2850     case E_AVR_MACH_AVR2:
2851       strncat (buf, ", avr:2", size);
2852       break;
2853     case E_AVR_MACH_AVR25:
2854       strncat (buf, ", avr:25", size);
2855       break;
2856     case E_AVR_MACH_AVR3:
2857       strncat (buf, ", avr:3", size);
2858       break;
2859     case E_AVR_MACH_AVR31:
2860       strncat (buf, ", avr:31", size);
2861       break;
2862     case E_AVR_MACH_AVR35:
2863       strncat (buf, ", avr:35", size);
2864       break;
2865     case E_AVR_MACH_AVR4:
2866       strncat (buf, ", avr:4", size);
2867       break;
2868     case E_AVR_MACH_AVR5:
2869       strncat (buf, ", avr:5", size);
2870       break;
2871     case E_AVR_MACH_AVR51:
2872       strncat (buf, ", avr:51", size);
2873       break;
2874     case E_AVR_MACH_AVR6:
2875       strncat (buf, ", avr:6", size);
2876       break;
2877     case E_AVR_MACH_AVRTINY:
2878       strncat (buf, ", avr:100", size);
2879       break;
2880     case E_AVR_MACH_XMEGA1:
2881       strncat (buf, ", avr:101", size);
2882       break;
2883     case E_AVR_MACH_XMEGA2:
2884       strncat (buf, ", avr:102", size);
2885       break;
2886     case E_AVR_MACH_XMEGA3:
2887       strncat (buf, ", avr:103", size);
2888       break;
2889     case E_AVR_MACH_XMEGA4:
2890       strncat (buf, ", avr:104", size);
2891       break;
2892     case E_AVR_MACH_XMEGA5:
2893       strncat (buf, ", avr:105", size);
2894       break;
2895     case E_AVR_MACH_XMEGA6:
2896       strncat (buf, ", avr:106", size);
2897       break;
2898     case E_AVR_MACH_XMEGA7:
2899       strncat (buf, ", avr:107", size);
2900       break;
2901     default:
2902       strncat (buf, ", avr:<unknown>", size);
2903       break;
2904     }
2905
2906   size -= strlen (buf);
2907   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2908     strncat (buf, ", link-relax", size);
2909 }
2910
2911 static void
2912 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2913 {
2914   unsigned abi;
2915   unsigned arch;
2916   unsigned config;
2917   unsigned version;
2918   bfd_boolean has_fpu = FALSE;
2919   unsigned int r = 0;
2920
2921   static const char *ABI_STRINGS[] =
2922   {
2923     "ABI v0", /* use r5 as return register; only used in N1213HC */
2924     "ABI v1", /* use r0 as return register */
2925     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2926     "ABI v2fp", /* for FPU */
2927     "AABI",
2928     "ABI2 FP+"
2929   };
2930   static const char *VER_STRINGS[] =
2931   {
2932     "Andes ELF V1.3 or older",
2933     "Andes ELF V1.3.1",
2934     "Andes ELF V1.4"
2935   };
2936   static const char *ARCH_STRINGS[] =
2937   {
2938     "",
2939     "Andes Star v1.0",
2940     "Andes Star v2.0",
2941     "Andes Star v3.0",
2942     "Andes Star v3.0m"
2943   };
2944
2945   abi = EF_NDS_ABI & e_flags;
2946   arch = EF_NDS_ARCH & e_flags;
2947   config = EF_NDS_INST & e_flags;
2948   version = EF_NDS32_ELF_VERSION & e_flags;
2949
2950   memset (buf, 0, size);
2951
2952   switch (abi)
2953     {
2954     case E_NDS_ABI_V0:
2955     case E_NDS_ABI_V1:
2956     case E_NDS_ABI_V2:
2957     case E_NDS_ABI_V2FP:
2958     case E_NDS_ABI_AABI:
2959     case E_NDS_ABI_V2FP_PLUS:
2960       /* In case there are holes in the array.  */
2961       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2962       break;
2963
2964     default:
2965       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2966       break;
2967     }
2968
2969   switch (version)
2970     {
2971     case E_NDS32_ELF_VER_1_2:
2972     case E_NDS32_ELF_VER_1_3:
2973     case E_NDS32_ELF_VER_1_4:
2974       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2975       break;
2976
2977     default:
2978       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2979       break;
2980     }
2981
2982   if (E_NDS_ABI_V0 == abi)
2983     {
2984       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2985       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2986       if (arch == E_NDS_ARCH_STAR_V1_0)
2987         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2988       return;
2989     }
2990
2991   switch (arch)
2992     {
2993     case E_NDS_ARCH_STAR_V1_0:
2994     case E_NDS_ARCH_STAR_V2_0:
2995     case E_NDS_ARCH_STAR_V3_0:
2996     case E_NDS_ARCH_STAR_V3_M:
2997       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2998       break;
2999
3000     default:
3001       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
3002       /* ARCH version determines how the e_flags are interpreted.
3003          If it is unknown, we cannot proceed.  */
3004       return;
3005     }
3006
3007   /* Newer ABI; Now handle architecture specific flags.  */
3008   if (arch == E_NDS_ARCH_STAR_V1_0)
3009     {
3010       if (config & E_NDS32_HAS_MFUSR_PC_INST)
3011         r += snprintf (buf + r, size -r, ", MFUSR_PC");
3012
3013       if (!(config & E_NDS32_HAS_NO_MAC_INST))
3014         r += snprintf (buf + r, size -r, ", MAC");
3015
3016       if (config & E_NDS32_HAS_DIV_INST)
3017         r += snprintf (buf + r, size -r, ", DIV");
3018
3019       if (config & E_NDS32_HAS_16BIT_INST)
3020         r += snprintf (buf + r, size -r, ", 16b");
3021     }
3022   else
3023     {
3024       if (config & E_NDS32_HAS_MFUSR_PC_INST)
3025         {
3026           if (version <= E_NDS32_ELF_VER_1_3)
3027             r += snprintf (buf + r, size -r, ", [B8]");
3028           else
3029             r += snprintf (buf + r, size -r, ", EX9");
3030         }
3031
3032       if (config & E_NDS32_HAS_MAC_DX_INST)
3033         r += snprintf (buf + r, size -r, ", MAC_DX");
3034
3035       if (config & E_NDS32_HAS_DIV_DX_INST)
3036         r += snprintf (buf + r, size -r, ", DIV_DX");
3037
3038       if (config & E_NDS32_HAS_16BIT_INST)
3039         {
3040           if (version <= E_NDS32_ELF_VER_1_3)
3041             r += snprintf (buf + r, size -r, ", 16b");
3042           else
3043             r += snprintf (buf + r, size -r, ", IFC");
3044         }
3045     }
3046
3047   if (config & E_NDS32_HAS_EXT_INST)
3048     r += snprintf (buf + r, size -r, ", PERF1");
3049
3050   if (config & E_NDS32_HAS_EXT2_INST)
3051     r += snprintf (buf + r, size -r, ", PERF2");
3052
3053   if (config & E_NDS32_HAS_FPU_INST)
3054     {
3055       has_fpu = TRUE;
3056       r += snprintf (buf + r, size -r, ", FPU_SP");
3057     }
3058
3059   if (config & E_NDS32_HAS_FPU_DP_INST)
3060     {
3061       has_fpu = TRUE;
3062       r += snprintf (buf + r, size -r, ", FPU_DP");
3063     }
3064
3065   if (config & E_NDS32_HAS_FPU_MAC_INST)
3066     {
3067       has_fpu = TRUE;
3068       r += snprintf (buf + r, size -r, ", FPU_MAC");
3069     }
3070
3071   if (has_fpu)
3072     {
3073       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3074         {
3075         case E_NDS32_FPU_REG_8SP_4DP:
3076           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3077           break;
3078         case E_NDS32_FPU_REG_16SP_8DP:
3079           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3080           break;
3081         case E_NDS32_FPU_REG_32SP_16DP:
3082           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3083           break;
3084         case E_NDS32_FPU_REG_32SP_32DP:
3085           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3086           break;
3087         }
3088     }
3089
3090   if (config & E_NDS32_HAS_AUDIO_INST)
3091     r += snprintf (buf + r, size -r, ", AUDIO");
3092
3093   if (config & E_NDS32_HAS_STRING_INST)
3094     r += snprintf (buf + r, size -r, ", STR");
3095
3096   if (config & E_NDS32_HAS_REDUCED_REGS)
3097     r += snprintf (buf + r, size -r, ", 16REG");
3098
3099   if (config & E_NDS32_HAS_VIDEO_INST)
3100     {
3101       if (version <= E_NDS32_ELF_VER_1_3)
3102         r += snprintf (buf + r, size -r, ", VIDEO");
3103       else
3104         r += snprintf (buf + r, size -r, ", SATURATION");
3105     }
3106
3107   if (config & E_NDS32_HAS_ENCRIPT_INST)
3108     r += snprintf (buf + r, size -r, ", ENCRP");
3109
3110   if (config & E_NDS32_HAS_L2C_INST)
3111     r += snprintf (buf + r, size -r, ", L2C");
3112 }
3113
3114 static char *
3115 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3116 {
3117   static char buf[1024];
3118
3119   buf[0] = '\0';
3120
3121   if (e_flags)
3122     {
3123       switch (e_machine)
3124         {
3125         default:
3126           break;
3127
3128         case EM_ARC_COMPACT2:
3129         case EM_ARC_COMPACT:
3130           decode_ARC_machine_flags (e_flags, e_machine, buf);
3131           break;
3132
3133         case EM_ARM:
3134           decode_ARM_machine_flags (e_flags, buf);
3135           break;
3136
3137         case EM_AVR:
3138           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3139           break;
3140
3141         case EM_BLACKFIN:
3142           if (e_flags & EF_BFIN_PIC)
3143             strcat (buf, ", PIC");
3144
3145           if (e_flags & EF_BFIN_FDPIC)
3146             strcat (buf, ", FDPIC");
3147
3148           if (e_flags & EF_BFIN_CODE_IN_L1)
3149             strcat (buf, ", code in L1");
3150
3151           if (e_flags & EF_BFIN_DATA_IN_L1)
3152             strcat (buf, ", data in L1");
3153
3154           break;
3155
3156         case EM_CYGNUS_FRV:
3157           switch (e_flags & EF_FRV_CPU_MASK)
3158             {
3159             case EF_FRV_CPU_GENERIC:
3160               break;
3161
3162             default:
3163               strcat (buf, ", fr???");
3164               break;
3165
3166             case EF_FRV_CPU_FR300:
3167               strcat (buf, ", fr300");
3168               break;
3169
3170             case EF_FRV_CPU_FR400:
3171               strcat (buf, ", fr400");
3172               break;
3173             case EF_FRV_CPU_FR405:
3174               strcat (buf, ", fr405");
3175               break;
3176
3177             case EF_FRV_CPU_FR450:
3178               strcat (buf, ", fr450");
3179               break;
3180
3181             case EF_FRV_CPU_FR500:
3182               strcat (buf, ", fr500");
3183               break;
3184             case EF_FRV_CPU_FR550:
3185               strcat (buf, ", fr550");
3186               break;
3187
3188             case EF_FRV_CPU_SIMPLE:
3189               strcat (buf, ", simple");
3190               break;
3191             case EF_FRV_CPU_TOMCAT:
3192               strcat (buf, ", tomcat");
3193               break;
3194             }
3195           break;
3196
3197         case EM_68K:
3198           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3199             strcat (buf, ", m68000");
3200           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3201             strcat (buf, ", cpu32");
3202           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3203             strcat (buf, ", fido_a");
3204           else
3205             {
3206               char const * isa = _("unknown");
3207               char const * mac = _("unknown mac");
3208               char const * additional = NULL;
3209
3210               switch (e_flags & EF_M68K_CF_ISA_MASK)
3211                 {
3212                 case EF_M68K_CF_ISA_A_NODIV:
3213                   isa = "A";
3214                   additional = ", nodiv";
3215                   break;
3216                 case EF_M68K_CF_ISA_A:
3217                   isa = "A";
3218                   break;
3219                 case EF_M68K_CF_ISA_A_PLUS:
3220                   isa = "A+";
3221                   break;
3222                 case EF_M68K_CF_ISA_B_NOUSP:
3223                   isa = "B";
3224                   additional = ", nousp";
3225                   break;
3226                 case EF_M68K_CF_ISA_B:
3227                   isa = "B";
3228                   break;
3229                 case EF_M68K_CF_ISA_C:
3230                   isa = "C";
3231                   break;
3232                 case EF_M68K_CF_ISA_C_NODIV:
3233                   isa = "C";
3234                   additional = ", nodiv";
3235                   break;
3236                 }
3237               strcat (buf, ", cf, isa ");
3238               strcat (buf, isa);
3239               if (additional)
3240                 strcat (buf, additional);
3241               if (e_flags & EF_M68K_CF_FLOAT)
3242                 strcat (buf, ", float");
3243               switch (e_flags & EF_M68K_CF_MAC_MASK)
3244                 {
3245                 case 0:
3246                   mac = NULL;
3247                   break;
3248                 case EF_M68K_CF_MAC:
3249                   mac = "mac";
3250                   break;
3251                 case EF_M68K_CF_EMAC:
3252                   mac = "emac";
3253                   break;
3254                 case EF_M68K_CF_EMAC_B:
3255                   mac = "emac_b";
3256                   break;
3257                 }
3258               if (mac)
3259                 {
3260                   strcat (buf, ", ");
3261                   strcat (buf, mac);
3262                 }
3263             }
3264           break;
3265
3266         case EM_CYGNUS_MEP:
3267           switch (e_flags & EF_MEP_CPU_MASK)
3268             {
3269             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3270             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3271             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3272             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3273             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3274             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3275             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3276             }
3277
3278           switch (e_flags & EF_MEP_COP_MASK)
3279             {
3280             case EF_MEP_COP_NONE: break;
3281             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3282             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3283             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3284             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3285             default: strcat (buf, _("<unknown MeP copro type>")); break;
3286             }
3287
3288           if (e_flags & EF_MEP_LIBRARY)
3289             strcat (buf, ", Built for Library");
3290
3291           if (e_flags & EF_MEP_INDEX_MASK)
3292             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3293                      e_flags & EF_MEP_INDEX_MASK);
3294
3295           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3296             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3297                      e_flags & ~ EF_MEP_ALL_FLAGS);
3298           break;
3299
3300         case EM_PPC:
3301           if (e_flags & EF_PPC_EMB)
3302             strcat (buf, ", emb");
3303
3304           if (e_flags & EF_PPC_RELOCATABLE)
3305             strcat (buf, _(", relocatable"));
3306
3307           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3308             strcat (buf, _(", relocatable-lib"));
3309           break;
3310
3311         case EM_PPC64:
3312           if (e_flags & EF_PPC64_ABI)
3313             {
3314               char abi[] = ", abiv0";
3315
3316               abi[6] += e_flags & EF_PPC64_ABI;
3317               strcat (buf, abi);
3318             }
3319           break;
3320
3321         case EM_V800:
3322           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3323             strcat (buf, ", RH850 ABI");
3324
3325           if (e_flags & EF_V800_850E3)
3326             strcat (buf, ", V3 architecture");
3327
3328           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3329             strcat (buf, ", FPU not used");
3330
3331           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3332             strcat (buf, ", regmode: COMMON");
3333
3334           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3335             strcat (buf, ", r4 not used");
3336
3337           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3338             strcat (buf, ", r30 not used");
3339
3340           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3341             strcat (buf, ", r5 not used");
3342
3343           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3344             strcat (buf, ", r2 not used");
3345
3346           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3347             {
3348               switch (e_flags & - e_flags)
3349                 {
3350                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3351                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3352                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3353                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3354                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3355                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3356                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3357                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3358                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3359                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3360                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3361                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3362                 default: break;
3363                 }
3364             }
3365           break;
3366
3367         case EM_V850:
3368         case EM_CYGNUS_V850:
3369           switch (e_flags & EF_V850_ARCH)
3370             {
3371             case E_V850E3V5_ARCH:
3372               strcat (buf, ", v850e3v5");
3373               break;
3374             case E_V850E2V3_ARCH:
3375               strcat (buf, ", v850e2v3");
3376               break;
3377             case E_V850E2_ARCH:
3378               strcat (buf, ", v850e2");
3379               break;
3380             case E_V850E1_ARCH:
3381               strcat (buf, ", v850e1");
3382               break;
3383             case E_V850E_ARCH:
3384               strcat (buf, ", v850e");
3385               break;
3386             case E_V850_ARCH:
3387               strcat (buf, ", v850");
3388               break;
3389             default:
3390               strcat (buf, _(", unknown v850 architecture variant"));
3391               break;
3392             }
3393           break;
3394
3395         case EM_M32R:
3396         case EM_CYGNUS_M32R:
3397           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3398             strcat (buf, ", m32r");
3399           break;
3400
3401         case EM_MIPS:
3402         case EM_MIPS_RS3_LE:
3403           if (e_flags & EF_MIPS_NOREORDER)
3404             strcat (buf, ", noreorder");
3405
3406           if (e_flags & EF_MIPS_PIC)
3407             strcat (buf, ", pic");
3408
3409           if (e_flags & EF_MIPS_CPIC)
3410             strcat (buf, ", cpic");
3411
3412           if (e_flags & EF_MIPS_UCODE)
3413             strcat (buf, ", ugen_reserved");
3414
3415           if (e_flags & EF_MIPS_ABI2)
3416             strcat (buf, ", abi2");
3417
3418           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3419             strcat (buf, ", odk first");
3420
3421           if (e_flags & EF_MIPS_32BITMODE)
3422             strcat (buf, ", 32bitmode");
3423
3424           if (e_flags & EF_MIPS_NAN2008)
3425             strcat (buf, ", nan2008");
3426
3427           if (e_flags & EF_MIPS_FP64)
3428             strcat (buf, ", fp64");
3429
3430           switch ((e_flags & EF_MIPS_MACH))
3431             {
3432             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3433             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3434             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3435             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3436             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3437             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3438             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3439             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3440             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3441             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3442             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3443             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3444             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3445             case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3446             case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3447             case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3448             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3449             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3450             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3451             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3452             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3453             case 0:
3454             /* We simply ignore the field in this case to avoid confusion:
3455                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3456                extension.  */
3457               break;
3458             default: strcat (buf, _(", unknown CPU")); break;
3459             }
3460
3461           switch ((e_flags & EF_MIPS_ABI))
3462             {
3463             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3464             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3465             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3466             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3467             case 0:
3468             /* We simply ignore the field in this case to avoid confusion:
3469                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3470                This means it is likely to be an o32 file, but not for
3471                sure.  */
3472               break;
3473             default: strcat (buf, _(", unknown ABI")); break;
3474             }
3475
3476           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3477             strcat (buf, ", mdmx");
3478
3479           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3480             strcat (buf, ", mips16");
3481
3482           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3483             strcat (buf, ", micromips");
3484
3485           switch ((e_flags & EF_MIPS_ARCH))
3486             {
3487             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3488             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3489             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3490             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3491             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3492             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3493             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3494             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3495             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3496             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3497             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3498             default: strcat (buf, _(", unknown ISA")); break;
3499             }
3500           break;
3501
3502         case EM_NDS32:
3503           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3504           break;
3505
3506         case EM_NFP:
3507           switch (EF_NFP_MACH (e_flags))
3508             {
3509             case E_NFP_MACH_3200:
3510               strcat (buf, ", NFP-32xx");
3511               break;
3512             case E_NFP_MACH_6000:
3513               strcat (buf, ", NFP-6xxx");
3514               break;
3515             }
3516           break;
3517
3518         case EM_RISCV:
3519           if (e_flags & EF_RISCV_RVC)
3520             strcat (buf, ", RVC");
3521
3522           if (e_flags & EF_RISCV_RVE)
3523             strcat (buf, ", RVE");
3524
3525           switch (e_flags & EF_RISCV_FLOAT_ABI)
3526             {
3527             case EF_RISCV_FLOAT_ABI_SOFT:
3528               strcat (buf, ", soft-float ABI");
3529               break;
3530
3531             case EF_RISCV_FLOAT_ABI_SINGLE:
3532               strcat (buf, ", single-float ABI");
3533               break;
3534
3535             case EF_RISCV_FLOAT_ABI_DOUBLE:
3536               strcat (buf, ", double-float ABI");
3537               break;
3538
3539             case EF_RISCV_FLOAT_ABI_QUAD:
3540               strcat (buf, ", quad-float ABI");
3541               break;
3542             }
3543           break;
3544
3545         case EM_SH:
3546           switch ((e_flags & EF_SH_MACH_MASK))
3547             {
3548             case EF_SH1: strcat (buf, ", sh1"); break;
3549             case EF_SH2: strcat (buf, ", sh2"); break;
3550             case EF_SH3: strcat (buf, ", sh3"); break;
3551             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3552             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3553             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3554             case EF_SH3E: strcat (buf, ", sh3e"); break;
3555             case EF_SH4: strcat (buf, ", sh4"); break;
3556             case EF_SH5: strcat (buf, ", sh5"); break;
3557             case EF_SH2E: strcat (buf, ", sh2e"); break;
3558             case EF_SH4A: strcat (buf, ", sh4a"); break;
3559             case EF_SH2A: strcat (buf, ", sh2a"); break;
3560             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3561             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3562             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3563             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3564             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3565             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3566             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3567             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3568             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3569             default: strcat (buf, _(", unknown ISA")); break;
3570             }
3571
3572           if (e_flags & EF_SH_PIC)
3573             strcat (buf, ", pic");
3574
3575           if (e_flags & EF_SH_FDPIC)
3576             strcat (buf, ", fdpic");
3577           break;
3578
3579         case EM_OR1K:
3580           if (e_flags & EF_OR1K_NODELAY)
3581             strcat (buf, ", no delay");
3582           break;
3583
3584         case EM_SPARCV9:
3585           if (e_flags & EF_SPARC_32PLUS)
3586             strcat (buf, ", v8+");
3587
3588           if (e_flags & EF_SPARC_SUN_US1)
3589             strcat (buf, ", ultrasparcI");
3590
3591           if (e_flags & EF_SPARC_SUN_US3)
3592             strcat (buf, ", ultrasparcIII");
3593
3594           if (e_flags & EF_SPARC_HAL_R1)
3595             strcat (buf, ", halr1");
3596
3597           if (e_flags & EF_SPARC_LEDATA)
3598             strcat (buf, ", ledata");
3599
3600           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3601             strcat (buf, ", tso");
3602
3603           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3604             strcat (buf, ", pso");
3605
3606           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3607             strcat (buf, ", rmo");
3608           break;
3609
3610         case EM_PARISC:
3611           switch (e_flags & EF_PARISC_ARCH)
3612             {
3613             case EFA_PARISC_1_0:
3614               strcpy (buf, ", PA-RISC 1.0");
3615               break;
3616             case EFA_PARISC_1_1:
3617               strcpy (buf, ", PA-RISC 1.1");
3618               break;
3619             case EFA_PARISC_2_0:
3620               strcpy (buf, ", PA-RISC 2.0");
3621               break;
3622             default:
3623               break;
3624             }
3625           if (e_flags & EF_PARISC_TRAPNIL)
3626             strcat (buf, ", trapnil");
3627           if (e_flags & EF_PARISC_EXT)
3628             strcat (buf, ", ext");
3629           if (e_flags & EF_PARISC_LSB)
3630             strcat (buf, ", lsb");
3631           if (e_flags & EF_PARISC_WIDE)
3632             strcat (buf, ", wide");
3633           if (e_flags & EF_PARISC_NO_KABP)
3634             strcat (buf, ", no kabp");
3635           if (e_flags & EF_PARISC_LAZYSWAP)
3636             strcat (buf, ", lazyswap");
3637           break;
3638
3639         case EM_PJ:
3640         case EM_PJ_OLD:
3641           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3642             strcat (buf, ", new calling convention");
3643
3644           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3645             strcat (buf, ", gnu calling convention");
3646           break;
3647
3648         case EM_IA_64:
3649           if ((e_flags & EF_IA_64_ABI64))
3650             strcat (buf, ", 64-bit");
3651           else
3652             strcat (buf, ", 32-bit");
3653           if ((e_flags & EF_IA_64_REDUCEDFP))
3654             strcat (buf, ", reduced fp model");
3655           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3656             strcat (buf, ", no function descriptors, constant gp");
3657           else if ((e_flags & EF_IA_64_CONS_GP))
3658             strcat (buf, ", constant gp");
3659           if ((e_flags & EF_IA_64_ABSOLUTE))
3660             strcat (buf, ", absolute");
3661           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3662             {
3663               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3664                 strcat (buf, ", vms_linkages");
3665               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3666                 {
3667                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3668                   break;
3669                 case EF_IA_64_VMS_COMCOD_WARNING:
3670                   strcat (buf, ", warning");
3671                   break;
3672                 case EF_IA_64_VMS_COMCOD_ERROR:
3673                   strcat (buf, ", error");
3674                   break;
3675                 case EF_IA_64_VMS_COMCOD_ABORT:
3676                   strcat (buf, ", abort");
3677                   break;
3678                 default:
3679                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3680                         e_flags & EF_IA_64_VMS_COMCOD);
3681                   strcat (buf, ", <unknown>");
3682                 }
3683             }
3684           break;
3685
3686         case EM_VAX:
3687           if ((e_flags & EF_VAX_NONPIC))
3688             strcat (buf, ", non-PIC");
3689           if ((e_flags & EF_VAX_DFLOAT))
3690             strcat (buf, ", D-Float");
3691           if ((e_flags & EF_VAX_GFLOAT))
3692             strcat (buf, ", G-Float");
3693           break;
3694
3695         case EM_VISIUM:
3696           if (e_flags & EF_VISIUM_ARCH_MCM)
3697             strcat (buf, ", mcm");
3698           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3699             strcat (buf, ", mcm24");
3700           if (e_flags & EF_VISIUM_ARCH_GR6)
3701             strcat (buf, ", gr6");
3702           break;
3703
3704         case EM_RL78:
3705           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3706             {
3707             case E_FLAG_RL78_ANY_CPU: break;
3708             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3709             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3710             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3711             }
3712           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3713             strcat (buf, ", 64-bit doubles");
3714           break;
3715
3716         case EM_RX:
3717           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3718             strcat (buf, ", 64-bit doubles");
3719           if (e_flags & E_FLAG_RX_DSP)
3720             strcat (buf, ", dsp");
3721           if (e_flags & E_FLAG_RX_PID)
3722             strcat (buf, ", pid");
3723           if (e_flags & E_FLAG_RX_ABI)
3724             strcat (buf, ", RX ABI");
3725           if (e_flags & E_FLAG_RX_SINSNS_SET)
3726             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3727                     ? ", uses String instructions" : ", bans String instructions");
3728           if (e_flags & E_FLAG_RX_V2)
3729             strcat (buf, ", V2");
3730           if (e_flags & E_FLAG_RX_V3)
3731             strcat (buf, ", V3");
3732           break;
3733
3734         case EM_S390:
3735           if (e_flags & EF_S390_HIGH_GPRS)
3736             strcat (buf, ", highgprs");
3737           break;
3738
3739         case EM_TI_C6000:
3740           if ((e_flags & EF_C6000_REL))
3741             strcat (buf, ", relocatable module");
3742           break;
3743
3744         case EM_MSP430:
3745           strcat (buf, _(": architecture variant: "));
3746           switch (e_flags & EF_MSP430_MACH)
3747             {
3748             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3749             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3750             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3751             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3752             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3753             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3754             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3755             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3756             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3757             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3758             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3759             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3760             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3761             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3762             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3763             default:
3764               strcat (buf, _(": unknown")); break;
3765             }
3766
3767           if (e_flags & ~ EF_MSP430_MACH)
3768             strcat (buf, _(": unknown extra flag bits also present"));
3769         }
3770     }
3771
3772   return buf;
3773 }
3774
3775 static const char *
3776 get_osabi_name (Filedata * filedata, unsigned int osabi)
3777 {
3778   static char buff[32];
3779
3780   switch (osabi)
3781     {
3782     case ELFOSABI_NONE:         return "UNIX - System V";
3783     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3784     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3785     case ELFOSABI_GNU:          return "UNIX - GNU";
3786     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3787     case ELFOSABI_AIX:          return "UNIX - AIX";
3788     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3789     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3790     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3791     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3792     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3793     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3794     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3795     case ELFOSABI_AROS:         return "AROS";
3796     case ELFOSABI_FENIXOS:      return "FenixOS";
3797     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3798     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3799     default:
3800       if (osabi >= 64)
3801         switch (filedata->file_header.e_machine)
3802           {
3803           case EM_ARM:
3804             switch (osabi)
3805               {
3806               case ELFOSABI_ARM:        return "ARM";
3807               case ELFOSABI_ARM_FDPIC:  return "ARM FDPIC";
3808               default:
3809                 break;
3810               }
3811             break;
3812
3813           case EM_MSP430:
3814           case EM_MSP430_OLD:
3815           case EM_VISIUM:
3816             switch (osabi)
3817               {
3818               case ELFOSABI_STANDALONE: return _("Standalone App");
3819               default:
3820                 break;
3821               }
3822             break;
3823
3824           case EM_TI_C6000:
3825             switch (osabi)
3826               {
3827               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3828               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3829               default:
3830                 break;
3831               }
3832             break;
3833
3834           default:
3835             break;
3836           }
3837       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3838       return buff;
3839     }
3840 }
3841
3842 static const char *
3843 get_aarch64_segment_type (unsigned long type)
3844 {
3845   switch (type)
3846     {
3847     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3848     default:                  return NULL;
3849     }
3850 }
3851
3852 static const char *
3853 get_arm_segment_type (unsigned long type)
3854 {
3855   switch (type)
3856     {
3857     case PT_ARM_EXIDX: return "EXIDX";
3858     default:           return NULL;
3859     }
3860 }
3861
3862 static const char *
3863 get_s390_segment_type (unsigned long type)
3864 {
3865   switch (type)
3866     {
3867     case PT_S390_PGSTE: return "S390_PGSTE";
3868     default:            return NULL;
3869     }
3870 }
3871
3872 static const char *
3873 get_mips_segment_type (unsigned long type)
3874 {
3875   switch (type)
3876     {
3877     case PT_MIPS_REGINFO:   return "REGINFO";
3878     case PT_MIPS_RTPROC:    return "RTPROC";
3879     case PT_MIPS_OPTIONS:   return "OPTIONS";
3880     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3881     default:                return NULL;
3882     }
3883 }
3884
3885 static const char *
3886 get_parisc_segment_type (unsigned long type)
3887 {
3888   switch (type)
3889     {
3890     case PT_HP_TLS:             return "HP_TLS";
3891     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3892     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3893     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3894     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3895     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3896     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3897     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3898     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3899     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3900     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3901     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3902     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3903     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3904     case PT_HP_STACK:           return "HP_STACK";
3905     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3906     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3907     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3908     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3909     default:                    return NULL;
3910     }
3911 }
3912
3913 static const char *
3914 get_ia64_segment_type (unsigned long type)
3915 {
3916   switch (type)
3917     {
3918     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3919     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3920     case PT_HP_TLS:             return "HP_TLS";
3921     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3922     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3923     case PT_IA_64_HP_STACK:     return "HP_STACK";
3924     default:                    return NULL;
3925     }
3926 }
3927
3928 static const char *
3929 get_tic6x_segment_type (unsigned long type)
3930 {
3931   switch (type)
3932     {
3933     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3934     default:               return NULL;
3935     }
3936 }
3937
3938 static const char *
3939 get_solaris_segment_type (unsigned long type)
3940 {
3941   switch (type)
3942     {
3943     case 0x6464e550: return "PT_SUNW_UNWIND";
3944     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3945     case 0x6ffffff7: return "PT_LOSUNW";
3946     case 0x6ffffffa: return "PT_SUNWBSS";
3947     case 0x6ffffffb: return "PT_SUNWSTACK";
3948     case 0x6ffffffc: return "PT_SUNWDTRACE";
3949     case 0x6ffffffd: return "PT_SUNWCAP";
3950     case 0x6fffffff: return "PT_HISUNW";
3951     default:         return NULL;
3952     }
3953 }
3954
3955 static const char *
3956 get_segment_type (Filedata * filedata, unsigned long p_type)
3957 {
3958   static char buff[32];
3959
3960   switch (p_type)
3961     {
3962     case PT_NULL:       return "NULL";
3963     case PT_LOAD:       return "LOAD";
3964     case PT_DYNAMIC:    return "DYNAMIC";
3965     case PT_INTERP:     return "INTERP";
3966     case PT_NOTE:       return "NOTE";
3967     case PT_SHLIB:      return "SHLIB";
3968     case PT_PHDR:       return "PHDR";
3969     case PT_TLS:        return "TLS";
3970     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3971     case PT_GNU_STACK:  return "GNU_STACK";
3972     case PT_GNU_RELRO:  return "GNU_RELRO";
3973     case PT_GNU_PROPERTY: return "GNU_PROPERTY";
3974
3975     default:
3976       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3977         {
3978           sprintf (buff, "GNU_MBIND+%#lx",
3979                    p_type - PT_GNU_MBIND_LO);
3980         }
3981       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3982         {
3983           const char * result;
3984
3985           switch (filedata->file_header.e_machine)
3986             {
3987             case EM_AARCH64:
3988               result = get_aarch64_segment_type (p_type);
3989               break;
3990             case EM_ARM:
3991               result = get_arm_segment_type (p_type);
3992               break;
3993             case EM_MIPS:
3994             case EM_MIPS_RS3_LE:
3995               result = get_mips_segment_type (p_type);
3996               break;
3997             case EM_PARISC:
3998               result = get_parisc_segment_type (p_type);
3999               break;
4000             case EM_IA_64:
4001               result = get_ia64_segment_type (p_type);
4002               break;
4003             case EM_TI_C6000:
4004               result = get_tic6x_segment_type (p_type);
4005               break;
4006             case EM_S390:
4007             case EM_S390_OLD:
4008               result = get_s390_segment_type (p_type);
4009               break;
4010             default:
4011               result = NULL;
4012               break;
4013             }
4014
4015           if (result != NULL)
4016             return result;
4017
4018           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
4019         }
4020       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
4021         {
4022           const char * result;
4023
4024           switch (filedata->file_header.e_machine)
4025             {
4026             case EM_PARISC:
4027               result = get_parisc_segment_type (p_type);
4028               break;
4029             case EM_IA_64:
4030               result = get_ia64_segment_type (p_type);
4031               break;
4032             default:
4033               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4034                 result = get_solaris_segment_type (p_type);
4035               else
4036                 result = NULL;
4037               break;
4038             }
4039
4040           if (result != NULL)
4041             return result;
4042
4043           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4044         }
4045       else
4046         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4047
4048       return buff;
4049     }
4050 }
4051
4052 static const char *
4053 get_arc_section_type_name (unsigned int sh_type)
4054 {
4055   switch (sh_type)
4056     {
4057     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
4058     default:
4059       break;
4060     }
4061   return NULL;
4062 }
4063
4064 static const char *
4065 get_mips_section_type_name (unsigned int sh_type)
4066 {
4067   switch (sh_type)
4068     {
4069     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
4070     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
4071     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
4072     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
4073     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
4074     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
4075     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
4076     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
4077     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
4078     case SHT_MIPS_RELD:          return "MIPS_RELD";
4079     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
4080     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
4081     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
4082     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
4083     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
4084     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
4085     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
4086     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
4087     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
4088     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4089     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4090     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4091     case SHT_MIPS_LINE:          return "MIPS_LINE";
4092     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4093     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4094     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4095     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4096     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4097     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4098     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4099     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4100     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4101     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4102     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4103     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4104     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4105     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4106     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4107     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4108     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4109     default:
4110       break;
4111     }
4112   return NULL;
4113 }
4114
4115 static const char *
4116 get_parisc_section_type_name (unsigned int sh_type)
4117 {
4118   switch (sh_type)
4119     {
4120     case SHT_PARISC_EXT:        return "PARISC_EXT";
4121     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4122     case SHT_PARISC_DOC:        return "PARISC_DOC";
4123     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4124     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4125     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4126     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4127     default:                    return NULL;
4128     }
4129 }
4130
4131 static const char *
4132 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4133 {
4134   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4135   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4136     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4137
4138   switch (sh_type)
4139     {
4140     case SHT_IA_64_EXT:                return "IA_64_EXT";
4141     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4142     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4143     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4144     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4145     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4146     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4147     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4148     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4149     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4150     default:
4151       break;
4152     }
4153   return NULL;
4154 }
4155
4156 static const char *
4157 get_x86_64_section_type_name (unsigned int sh_type)
4158 {
4159   switch (sh_type)
4160     {
4161     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4162     default:                    return NULL;
4163     }
4164 }
4165
4166 static const char *
4167 get_aarch64_section_type_name (unsigned int sh_type)
4168 {
4169   switch (sh_type)
4170     {
4171     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4172     default:                     return NULL;
4173     }
4174 }
4175
4176 static const char *
4177 get_arm_section_type_name (unsigned int sh_type)
4178 {
4179   switch (sh_type)
4180     {
4181     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4182     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4183     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4184     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4185     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4186     default:                      return NULL;
4187     }
4188 }
4189
4190 static const char *
4191 get_tic6x_section_type_name (unsigned int sh_type)
4192 {
4193   switch (sh_type)
4194     {
4195     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4196     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4197     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4198     case SHT_TI_ICODE:          return "TI_ICODE";
4199     case SHT_TI_XREF:           return "TI_XREF";
4200     case SHT_TI_HANDLER:        return "TI_HANDLER";
4201     case SHT_TI_INITINFO:       return "TI_INITINFO";
4202     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4203     default:                    return NULL;
4204     }
4205 }
4206
4207 static const char *
4208 get_msp430x_section_type_name (unsigned int sh_type)
4209 {
4210   switch (sh_type)
4211     {
4212     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4213     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4214     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4215     default:                      return NULL;
4216     }
4217 }
4218
4219 static const char *
4220 get_nfp_section_type_name (unsigned int sh_type)
4221 {
4222   switch (sh_type)
4223     {
4224     case SHT_NFP_MECONFIG:      return "NFP_MECONFIG";
4225     case SHT_NFP_INITREG:       return "NFP_INITREG";
4226     case SHT_NFP_UDEBUG:        return "NFP_UDEBUG";
4227     default:                    return NULL;
4228     }
4229 }
4230
4231 static const char *
4232 get_v850_section_type_name (unsigned int sh_type)
4233 {
4234   switch (sh_type)
4235     {
4236     case SHT_V850_SCOMMON:  return "V850 Small Common";
4237     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4238     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4239     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4240     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4241     default:                return NULL;
4242     }
4243 }
4244
4245 static const char *
4246 get_riscv_section_type_name (unsigned int sh_type)
4247 {
4248   switch (sh_type)
4249     {
4250     case SHT_RISCV_ATTRIBUTES:  return "RISCV_ATTRIBUTES";
4251     default: return NULL;
4252     }
4253 }
4254
4255 static const char *
4256 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4257 {
4258   static char buff[32];
4259   const char * result;
4260
4261   switch (sh_type)
4262     {
4263     case SHT_NULL:              return "NULL";
4264     case SHT_PROGBITS:          return "PROGBITS";
4265     case SHT_SYMTAB:            return "SYMTAB";
4266     case SHT_STRTAB:            return "STRTAB";
4267     case SHT_RELA:              return "RELA";
4268     case SHT_HASH:              return "HASH";
4269     case SHT_DYNAMIC:           return "DYNAMIC";
4270     case SHT_NOTE:              return "NOTE";
4271     case SHT_NOBITS:            return "NOBITS";
4272     case SHT_REL:               return "REL";
4273     case SHT_SHLIB:             return "SHLIB";
4274     case SHT_DYNSYM:            return "DYNSYM";
4275     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4276     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4277     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4278     case SHT_GNU_HASH:          return "GNU_HASH";
4279     case SHT_GROUP:             return "GROUP";
4280     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICES";
4281     case SHT_GNU_verdef:        return "VERDEF";
4282     case SHT_GNU_verneed:       return "VERNEED";
4283     case SHT_GNU_versym:        return "VERSYM";
4284     case 0x6ffffff0:            return "VERSYM";
4285     case 0x6ffffffc:            return "VERDEF";
4286     case 0x7ffffffd:            return "AUXILIARY";
4287     case 0x7fffffff:            return "FILTER";
4288     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4289
4290     default:
4291       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4292         {
4293           switch (filedata->file_header.e_machine)
4294             {
4295             case EM_ARC:
4296             case EM_ARC_COMPACT:
4297             case EM_ARC_COMPACT2:
4298               result = get_arc_section_type_name (sh_type);
4299               break;
4300             case EM_MIPS:
4301             case EM_MIPS_RS3_LE:
4302               result = get_mips_section_type_name (sh_type);
4303               break;
4304             case EM_PARISC:
4305               result = get_parisc_section_type_name (sh_type);
4306               break;
4307             case EM_IA_64:
4308               result = get_ia64_section_type_name (filedata, sh_type);
4309               break;
4310             case EM_X86_64:
4311             case EM_L1OM:
4312             case EM_K1OM:
4313               result = get_x86_64_section_type_name (sh_type);
4314               break;
4315             case EM_AARCH64:
4316               result = get_aarch64_section_type_name (sh_type);
4317               break;
4318             case EM_ARM:
4319               result = get_arm_section_type_name (sh_type);
4320               break;
4321             case EM_TI_C6000:
4322               result = get_tic6x_section_type_name (sh_type);
4323               break;
4324             case EM_MSP430:
4325               result = get_msp430x_section_type_name (sh_type);
4326               break;
4327             case EM_NFP:
4328               result = get_nfp_section_type_name (sh_type);
4329               break;
4330             case EM_V800:
4331             case EM_V850:
4332             case EM_CYGNUS_V850:
4333               result = get_v850_section_type_name (sh_type);
4334               break;
4335             case EM_RISCV:
4336               result = get_riscv_section_type_name (sh_type);
4337               break;
4338             default:
4339               result = NULL;
4340               break;
4341             }
4342
4343           if (result != NULL)
4344             return result;
4345
4346           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4347         }
4348       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4349         {
4350           switch (filedata->file_header.e_machine)
4351             {
4352             case EM_IA_64:
4353               result = get_ia64_section_type_name (filedata, sh_type);
4354               break;
4355             default:
4356               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4357                 result = get_solaris_section_type (sh_type);
4358               else
4359                 {
4360                   switch (sh_type)
4361                     {
4362                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4363                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4364                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4365                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4366                     default:
4367                       result = NULL;
4368                       break;
4369                     }
4370                 }
4371               break;
4372             }
4373
4374           if (result != NULL)
4375             return result;
4376
4377           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4378         }
4379       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4380         {
4381           switch (filedata->file_header.e_machine)
4382             {
4383             case EM_V800:
4384             case EM_V850:
4385             case EM_CYGNUS_V850:
4386               result = get_v850_section_type_name (sh_type);
4387               break;
4388             default:
4389               result = NULL;
4390               break;
4391             }
4392
4393           if (result != NULL)
4394             return result;
4395
4396           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4397         }
4398       else
4399         /* This message is probably going to be displayed in a 15
4400            character wide field, so put the hex value first.  */
4401         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4402
4403       return buff;
4404     }
4405 }
4406
4407 #define OPTION_DEBUG_DUMP       512
4408 #define OPTION_DYN_SYMS         513
4409 #define OPTION_DWARF_DEPTH      514
4410 #define OPTION_DWARF_START      515
4411 #define OPTION_DWARF_CHECK      516
4412 #ifdef HAVE_LIBCTF
4413 #define OPTION_CTF_DUMP         517
4414 #define OPTION_CTF_PARENT       518
4415 #define OPTION_CTF_SYMBOLS      519
4416 #define OPTION_CTF_STRINGS      520
4417 #endif
4418
4419 static struct option options[] =
4420 {
4421   {"all",              no_argument, 0, 'a'},
4422   {"file-header",      no_argument, 0, 'h'},
4423   {"program-headers",  no_argument, 0, 'l'},
4424   {"headers",          no_argument, 0, 'e'},
4425   {"histogram",        no_argument, 0, 'I'},
4426   {"segments",         no_argument, 0, 'l'},
4427   {"sections",         no_argument, 0, 'S'},
4428   {"section-headers",  no_argument, 0, 'S'},
4429   {"section-groups",   no_argument, 0, 'g'},
4430   {"section-details",  no_argument, 0, 't'},
4431   {"full-section-name",no_argument, 0, 'N'},
4432   {"symbols",          no_argument, 0, 's'},
4433   {"syms",             no_argument, 0, 's'},
4434   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4435   {"relocs",           no_argument, 0, 'r'},
4436   {"notes",            no_argument, 0, 'n'},
4437   {"dynamic",          no_argument, 0, 'd'},
4438   {"arch-specific",    no_argument, 0, 'A'},
4439   {"version-info",     no_argument, 0, 'V'},
4440   {"use-dynamic",      no_argument, 0, 'D'},
4441   {"unwind",           no_argument, 0, 'u'},
4442   {"archive-index",    no_argument, 0, 'c'},
4443   {"hex-dump",         required_argument, 0, 'x'},
4444   {"relocated-dump",   required_argument, 0, 'R'},
4445   {"string-dump",      required_argument, 0, 'p'},
4446   {"decompress",       no_argument, 0, 'z'},
4447 #ifdef SUPPORT_DISASSEMBLY
4448   {"instruction-dump", required_argument, 0, 'i'},
4449 #endif
4450   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4451
4452   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4453   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4454   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4455
4456 #ifdef HAVE_LIBCTF
4457   {"ctf",              required_argument, 0, OPTION_CTF_DUMP},
4458
4459   {"ctf-symbols",      required_argument, 0, OPTION_CTF_SYMBOLS},
4460   {"ctf-strings",      required_argument, 0, OPTION_CTF_STRINGS},
4461   {"ctf-parent",       required_argument, 0, OPTION_CTF_PARENT},
4462 #endif
4463
4464   {"version",          no_argument, 0, 'v'},
4465   {"wide",             no_argument, 0, 'W'},
4466   {"help",             no_argument, 0, 'H'},
4467   {0,                  no_argument, 0, 0}
4468 };
4469
4470 static void
4471 usage (FILE * stream)
4472 {
4473   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4474   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4475   fprintf (stream, _(" Options are:\n\
4476   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4477   -h --file-header       Display the ELF file header\n\
4478   -l --program-headers   Display the program headers\n\
4479      --segments          An alias for --program-headers\n\
4480   -S --section-headers   Display the sections' header\n\
4481      --sections          An alias for --section-headers\n\
4482   -g --section-groups    Display the section groups\n\
4483   -t --section-details   Display the section details\n\
4484   -e --headers           Equivalent to: -h -l -S\n\
4485   -s --syms              Display the symbol table\n\
4486      --symbols           An alias for --syms\n\
4487   --dyn-syms             Display the dynamic symbol table\n\
4488   -n --notes             Display the core notes (if present)\n\
4489   -r --relocs            Display the relocations (if present)\n\
4490   -u --unwind            Display the unwind info (if present)\n\
4491   -d --dynamic           Display the dynamic section (if present)\n\
4492   -V --version-info      Display the version sections (if present)\n\
4493   -A --arch-specific     Display architecture specific information (if any)\n\
4494   -c --archive-index     Display the symbol/file index in an archive\n\
4495   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4496   -x --hex-dump=<number|name>\n\
4497                          Dump the contents of section <number|name> as bytes\n\
4498   -p --string-dump=<number|name>\n\
4499                          Dump the contents of section <number|name> as strings\n\
4500   -R --relocated-dump=<number|name>\n\
4501                          Dump the contents of section <number|name> as relocated bytes\n\
4502   -z --decompress        Decompress section before dumping it\n\
4503   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4504   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4505                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4506                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4507                =addr,=cu_index,=links,=follow-links]\n\
4508                          Display the contents of DWARF debug sections\n"));
4509   fprintf (stream, _("\
4510   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4511   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4512                          or deeper\n"));
4513 #ifdef HAVE_LIBCTF
4514   fprintf (stream, _("\
4515   --ctf=<number|name>    Display CTF info from section <number|name>\n\
4516   --ctf-parent=<number|name>\n\
4517                          Use section <number|name> as the CTF parent\n\n\
4518   --ctf-symbols=<number|name>\n\
4519                          Use section <number|name> as the CTF external symtab\n\n\
4520   --ctf-strings=<number|name>\n\
4521                          Use section <number|name> as the CTF external strtab\n\n"));
4522 #endif
4523
4524 #ifdef SUPPORT_DISASSEMBLY
4525   fprintf (stream, _("\
4526   -i --instruction-dump=<number|name>\n\
4527                          Disassemble the contents of section <number|name>\n"));
4528 #endif
4529   fprintf (stream, _("\
4530   -I --histogram         Display histogram of bucket list lengths\n\
4531   -W --wide              Allow output width to exceed 80 characters\n\
4532   @<file>                Read options from <file>\n\
4533   -H --help              Display this information\n\
4534   -v --version           Display the version number of readelf\n"));
4535
4536   if (REPORT_BUGS_TO[0] && stream == stdout)
4537     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4538
4539   exit (stream == stdout ? 0 : 1);
4540 }
4541
4542 /* Record the fact that the user wants the contents of section number
4543    SECTION to be displayed using the method(s) encoded as flags bits
4544    in TYPE.  Note, TYPE can be zero if we are creating the array for
4545    the first time.  */
4546
4547 static void
4548 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4549 {
4550   if (section >= filedata->num_dump_sects)
4551     {
4552       dump_type * new_dump_sects;
4553
4554       new_dump_sects = (dump_type *) calloc (section + 1,
4555                                              sizeof (* new_dump_sects));
4556
4557       if (new_dump_sects == NULL)
4558         error (_("Out of memory allocating dump request table.\n"));
4559       else
4560         {
4561           if (filedata->dump_sects)
4562             {
4563               /* Copy current flag settings.  */
4564               memcpy (new_dump_sects, filedata->dump_sects,
4565                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4566
4567               free (filedata->dump_sects);
4568             }
4569
4570           filedata->dump_sects = new_dump_sects;
4571           filedata->num_dump_sects = section + 1;
4572         }
4573     }
4574
4575   if (filedata->dump_sects)
4576     filedata->dump_sects[section] |= type;
4577 }
4578
4579 /* Request a dump by section name.  */
4580
4581 static void
4582 request_dump_byname (const char * section, dump_type type)
4583 {
4584   struct dump_list_entry * new_request;
4585
4586   new_request = (struct dump_list_entry *)
4587       malloc (sizeof (struct dump_list_entry));
4588   if (!new_request)
4589     error (_("Out of memory allocating dump request table.\n"));
4590
4591   new_request->name = strdup (section);
4592   if (!new_request->name)
4593     error (_("Out of memory allocating dump request table.\n"));
4594
4595   new_request->type = type;
4596
4597   new_request->next = dump_sects_byname;
4598   dump_sects_byname = new_request;
4599 }
4600
4601 static inline void
4602 request_dump (Filedata * filedata, dump_type type)
4603 {
4604   int section;
4605   char * cp;
4606
4607   do_dump++;
4608   section = strtoul (optarg, & cp, 0);
4609
4610   if (! *cp && section >= 0)
4611     request_dump_bynumber (filedata, section, type);
4612   else
4613     request_dump_byname (optarg, type);
4614 }
4615
4616 static void
4617 parse_args (Filedata * filedata, int argc, char ** argv)
4618 {
4619   int c;
4620
4621   if (argc < 2)
4622     usage (stderr);
4623
4624   while ((c = getopt_long
4625           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4626     {
4627       switch (c)
4628         {
4629         case 0:
4630           /* Long options.  */
4631           break;
4632         case 'H':
4633           usage (stdout);
4634           break;
4635
4636         case 'a':
4637           do_syms = TRUE;
4638           do_reloc = TRUE;
4639           do_unwind = TRUE;
4640           do_dynamic = TRUE;
4641           do_header = TRUE;
4642           do_sections = TRUE;
4643           do_section_groups = TRUE;
4644           do_segments = TRUE;
4645           do_version = TRUE;
4646           do_histogram = TRUE;
4647           do_arch = TRUE;
4648           do_notes = TRUE;
4649           break;
4650         case 'g':
4651           do_section_groups = TRUE;
4652           break;
4653         case 't':
4654         case 'N':
4655           do_sections = TRUE;
4656           do_section_details = TRUE;
4657           break;
4658         case 'e':
4659           do_header = TRUE;
4660           do_sections = TRUE;
4661           do_segments = TRUE;
4662           break;
4663         case 'A':
4664           do_arch = TRUE;
4665           break;
4666         case 'D':
4667           do_using_dynamic = TRUE;
4668           break;
4669         case 'r':
4670           do_reloc = TRUE;
4671           break;
4672         case 'u':
4673           do_unwind = TRUE;
4674           break;
4675         case 'h':
4676           do_header = TRUE;
4677           break;
4678         case 'l':
4679           do_segments = TRUE;
4680           break;
4681         case 's':
4682           do_syms = TRUE;
4683           break;
4684         case 'S':
4685           do_sections = TRUE;
4686           break;
4687         case 'd':
4688           do_dynamic = TRUE;
4689           break;
4690         case 'I':
4691           do_histogram = TRUE;
4692           break;
4693         case 'n':
4694           do_notes = TRUE;
4695           break;
4696         case 'c':
4697           do_archive_index = TRUE;
4698           break;
4699         case 'x':
4700           request_dump (filedata, HEX_DUMP);
4701           break;
4702         case 'p':
4703           request_dump (filedata, STRING_DUMP);
4704           break;
4705         case 'R':
4706           request_dump (filedata, RELOC_DUMP);
4707           break;
4708         case 'z':
4709           decompress_dumps = TRUE;
4710           break;
4711         case 'w':
4712           do_dump = TRUE;
4713           if (optarg == 0)
4714             {
4715               do_debugging = TRUE;
4716               dwarf_select_sections_all ();
4717             }
4718           else
4719             {
4720               do_debugging = FALSE;
4721               dwarf_select_sections_by_letters (optarg);
4722             }
4723           break;
4724         case OPTION_DEBUG_DUMP:
4725           do_dump = TRUE;
4726           if (optarg == 0)
4727             do_debugging = TRUE;
4728           else
4729             {
4730               do_debugging = FALSE;
4731               dwarf_select_sections_by_names (optarg);
4732             }
4733           break;
4734         case OPTION_DWARF_DEPTH:
4735           {
4736             char *cp;
4737
4738             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4739           }
4740           break;
4741         case OPTION_DWARF_START:
4742           {
4743             char *cp;
4744
4745             dwarf_start_die = strtoul (optarg, & cp, 0);
4746           }
4747           break;
4748         case OPTION_DWARF_CHECK:
4749           dwarf_check = TRUE;
4750           break;
4751 #ifdef HAVE_LIBCTF
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 #endif
4766         case OPTION_DYN_SYMS:
4767           do_dyn_syms = TRUE;
4768           break;
4769 #ifdef SUPPORT_DISASSEMBLY
4770         case 'i':
4771           request_dump (filedata, DISASS_DUMP);
4772           break;
4773 #endif
4774         case 'v':
4775           print_version (program_name);
4776           break;
4777         case 'V':
4778           do_version = TRUE;
4779           break;
4780         case 'W':
4781           do_wide = TRUE;
4782           break;
4783         default:
4784           /* xgettext:c-format */
4785           error (_("Invalid option '-%c'\n"), c);
4786           /* Fall through.  */
4787         case '?':
4788           usage (stderr);
4789         }
4790     }
4791
4792   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4793       && !do_segments && !do_header && !do_dump && !do_version
4794       && !do_histogram && !do_debugging && !do_arch && !do_notes
4795       && !do_section_groups && !do_archive_index
4796       && !do_dyn_syms)
4797     usage (stderr);
4798 }
4799
4800 static const char *
4801 get_elf_class (unsigned int elf_class)
4802 {
4803   static char buff[32];
4804
4805   switch (elf_class)
4806     {
4807     case ELFCLASSNONE: return _("none");
4808     case ELFCLASS32:   return "ELF32";
4809     case ELFCLASS64:   return "ELF64";
4810     default:
4811       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4812       return buff;
4813     }
4814 }
4815
4816 static const char *
4817 get_data_encoding (unsigned int encoding)
4818 {
4819   static char buff[32];
4820
4821   switch (encoding)
4822     {
4823     case ELFDATANONE: return _("none");
4824     case ELFDATA2LSB: return _("2's complement, little endian");
4825     case ELFDATA2MSB: return _("2's complement, big endian");
4826     default:
4827       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4828       return buff;
4829     }
4830 }
4831
4832 /* Decode the data held in 'filedata->file_header'.  */
4833
4834 static bfd_boolean
4835 process_file_header (Filedata * filedata)
4836 {
4837   Elf_Internal_Ehdr * header = & filedata->file_header;
4838
4839   if (   header->e_ident[EI_MAG0] != ELFMAG0
4840       || header->e_ident[EI_MAG1] != ELFMAG1
4841       || header->e_ident[EI_MAG2] != ELFMAG2
4842       || header->e_ident[EI_MAG3] != ELFMAG3)
4843     {
4844       error
4845         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4846       return FALSE;
4847     }
4848
4849   init_dwarf_regnames (header->e_machine);
4850
4851   if (do_header)
4852     {
4853       unsigned i;
4854
4855       printf (_("ELF Header:\n"));
4856       printf (_("  Magic:   "));
4857       for (i = 0; i < EI_NIDENT; i++)
4858         printf ("%2.2x ", header->e_ident[i]);
4859       printf ("\n");
4860       printf (_("  Class:                             %s\n"),
4861               get_elf_class (header->e_ident[EI_CLASS]));
4862       printf (_("  Data:                              %s\n"),
4863               get_data_encoding (header->e_ident[EI_DATA]));
4864       printf (_("  Version:                           %d%s\n"),
4865               header->e_ident[EI_VERSION],
4866               (header->e_ident[EI_VERSION] == EV_CURRENT
4867                ? _(" (current)")
4868                : (header->e_ident[EI_VERSION] != EV_NONE
4869                   ? _(" <unknown>")
4870                   : "")));
4871       printf (_("  OS/ABI:                            %s\n"),
4872               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4873       printf (_("  ABI Version:                       %d\n"),
4874               header->e_ident[EI_ABIVERSION]);
4875       printf (_("  Type:                              %s\n"),
4876               get_file_type (header->e_type));
4877       printf (_("  Machine:                           %s\n"),
4878               get_machine_name (header->e_machine));
4879       printf (_("  Version:                           0x%lx\n"),
4880               header->e_version);
4881
4882       printf (_("  Entry point address:               "));
4883       print_vma (header->e_entry, PREFIX_HEX);
4884       printf (_("\n  Start of program headers:          "));
4885       print_vma (header->e_phoff, DEC);
4886       printf (_(" (bytes into file)\n  Start of section headers:          "));
4887       print_vma (header->e_shoff, DEC);
4888       printf (_(" (bytes into file)\n"));
4889
4890       printf (_("  Flags:                             0x%lx%s\n"),
4891               header->e_flags,
4892               get_machine_flags (filedata, header->e_flags, header->e_machine));
4893       printf (_("  Size of this header:               %u (bytes)\n"),
4894               header->e_ehsize);
4895       printf (_("  Size of program headers:           %u (bytes)\n"),
4896               header->e_phentsize);
4897       printf (_("  Number of program headers:         %u"),
4898               header->e_phnum);
4899       if (filedata->section_headers != NULL
4900           && header->e_phnum == PN_XNUM
4901           && filedata->section_headers[0].sh_info != 0)
4902         {
4903           header->e_phnum = filedata->section_headers[0].sh_info;
4904           printf (" (%u)", header->e_phnum);
4905         }
4906       putc ('\n', stdout);
4907       printf (_("  Size of section headers:           %u (bytes)\n"),
4908               header->e_shentsize);
4909       printf (_("  Number of section headers:         %u"),
4910               header->e_shnum);
4911       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4912         {
4913           header->e_shnum = filedata->section_headers[0].sh_size;
4914           printf (" (%u)", header->e_shnum);
4915         }
4916       putc ('\n', stdout);
4917       printf (_("  Section header string table index: %u"),
4918               header->e_shstrndx);
4919       if (filedata->section_headers != NULL
4920           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4921         {
4922           header->e_shstrndx = filedata->section_headers[0].sh_link;
4923           printf (" (%u)", header->e_shstrndx);
4924         }
4925       if (header->e_shstrndx != SHN_UNDEF
4926           && header->e_shstrndx >= header->e_shnum)
4927         {
4928           header->e_shstrndx = SHN_UNDEF;
4929           printf (_(" <corrupt: out of range>"));
4930         }
4931       putc ('\n', stdout);
4932     }
4933
4934   if (filedata->section_headers != NULL)
4935     {
4936       if (header->e_phnum == PN_XNUM
4937           && filedata->section_headers[0].sh_info != 0)
4938         header->e_phnum = filedata->section_headers[0].sh_info;
4939       if (header->e_shnum == SHN_UNDEF)
4940         header->e_shnum = filedata->section_headers[0].sh_size;
4941       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4942         header->e_shstrndx = filedata->section_headers[0].sh_link;
4943       if (header->e_shstrndx >= header->e_shnum)
4944         header->e_shstrndx = SHN_UNDEF;
4945       free (filedata->section_headers);
4946       filedata->section_headers = NULL;
4947     }
4948
4949   return TRUE;
4950 }
4951
4952 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4953    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4954
4955 static bfd_boolean
4956 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4957 {
4958   Elf32_External_Phdr * phdrs;
4959   Elf32_External_Phdr * external;
4960   Elf_Internal_Phdr *   internal;
4961   unsigned int i;
4962   unsigned int size = filedata->file_header.e_phentsize;
4963   unsigned int num  = filedata->file_header.e_phnum;
4964
4965   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4966   if (size == 0 || num == 0)
4967     return FALSE;
4968   if (size < sizeof * phdrs)
4969     {
4970       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4971       return FALSE;
4972     }
4973   if (size > sizeof * phdrs)
4974     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4975
4976   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4977                                             size, num, _("program headers"));
4978   if (phdrs == NULL)
4979     return FALSE;
4980
4981   for (i = 0, internal = pheaders, external = phdrs;
4982        i < filedata->file_header.e_phnum;
4983        i++, internal++, external++)
4984     {
4985       internal->p_type   = BYTE_GET (external->p_type);
4986       internal->p_offset = BYTE_GET (external->p_offset);
4987       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4988       internal->p_paddr  = BYTE_GET (external->p_paddr);
4989       internal->p_filesz = BYTE_GET (external->p_filesz);
4990       internal->p_memsz  = BYTE_GET (external->p_memsz);
4991       internal->p_flags  = BYTE_GET (external->p_flags);
4992       internal->p_align  = BYTE_GET (external->p_align);
4993     }
4994
4995   free (phdrs);
4996   return TRUE;
4997 }
4998
4999 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5000    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
5001
5002 static bfd_boolean
5003 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
5004 {
5005   Elf64_External_Phdr * phdrs;
5006   Elf64_External_Phdr * external;
5007   Elf_Internal_Phdr *   internal;
5008   unsigned int i;
5009   unsigned int size = filedata->file_header.e_phentsize;
5010   unsigned int num  = filedata->file_header.e_phnum;
5011
5012   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5013   if (size == 0 || num == 0)
5014     return FALSE;
5015   if (size < sizeof * phdrs)
5016     {
5017       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5018       return FALSE;
5019     }
5020   if (size > sizeof * phdrs)
5021     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5022
5023   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5024                                             size, num, _("program headers"));
5025   if (!phdrs)
5026     return FALSE;
5027
5028   for (i = 0, internal = pheaders, external = phdrs;
5029        i < filedata->file_header.e_phnum;
5030        i++, internal++, external++)
5031     {
5032       internal->p_type   = BYTE_GET (external->p_type);
5033       internal->p_flags  = BYTE_GET (external->p_flags);
5034       internal->p_offset = BYTE_GET (external->p_offset);
5035       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
5036       internal->p_paddr  = BYTE_GET (external->p_paddr);
5037       internal->p_filesz = BYTE_GET (external->p_filesz);
5038       internal->p_memsz  = BYTE_GET (external->p_memsz);
5039       internal->p_align  = BYTE_GET (external->p_align);
5040     }
5041
5042   free (phdrs);
5043   return TRUE;
5044 }
5045
5046 /* Returns TRUE if the program headers were read into `program_headers'.  */
5047
5048 static bfd_boolean
5049 get_program_headers (Filedata * filedata)
5050 {
5051   Elf_Internal_Phdr * phdrs;
5052
5053   /* Check cache of prior read.  */
5054   if (filedata->program_headers != NULL)
5055     return TRUE;
5056
5057   /* Be kind to memory checkers by looking for
5058      e_phnum values which we know must be invalid.  */
5059   if (filedata->file_header.e_phnum
5060       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
5061       >= filedata->file_size)
5062     {
5063       error (_("Too many program headers - %#x - the file is not that big\n"),
5064              filedata->file_header.e_phnum);
5065       return FALSE;
5066     }
5067
5068   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
5069                                          sizeof (Elf_Internal_Phdr));
5070   if (phdrs == NULL)
5071     {
5072       error (_("Out of memory reading %u program headers\n"),
5073              filedata->file_header.e_phnum);
5074       return FALSE;
5075     }
5076
5077   if (is_32bit_elf
5078       ? get_32bit_program_headers (filedata, phdrs)
5079       : get_64bit_program_headers (filedata, phdrs))
5080     {
5081       filedata->program_headers = phdrs;
5082       return TRUE;
5083     }
5084
5085   free (phdrs);
5086   return FALSE;
5087 }
5088
5089 /* Returns TRUE if the program headers were loaded.  */
5090
5091 static bfd_boolean
5092 process_program_headers (Filedata * filedata)
5093 {
5094   Elf_Internal_Phdr * segment;
5095   unsigned int i;
5096   Elf_Internal_Phdr * previous_load = NULL;
5097
5098   if (filedata->file_header.e_phnum == 0)
5099     {
5100       /* PR binutils/12467.  */
5101       if (filedata->file_header.e_phoff != 0)
5102         {
5103           warn (_("possibly corrupt ELF header - it has a non-zero program"
5104                   " header offset, but no program headers\n"));
5105           return FALSE;
5106         }
5107       else if (do_segments)
5108         printf (_("\nThere are no program headers in this file.\n"));
5109       return TRUE;
5110     }
5111
5112   if (do_segments && !do_header)
5113     {
5114       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5115       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5116       printf (ngettext ("There is %d program header, starting at offset %s\n",
5117                         "There are %d program headers, starting at offset %s\n",
5118                         filedata->file_header.e_phnum),
5119               filedata->file_header.e_phnum,
5120               bfd_vmatoa ("u", filedata->file_header.e_phoff));
5121     }
5122
5123   if (! get_program_headers (filedata))
5124     return TRUE;
5125
5126   if (do_segments)
5127     {
5128       if (filedata->file_header.e_phnum > 1)
5129         printf (_("\nProgram Headers:\n"));
5130       else
5131         printf (_("\nProgram Headers:\n"));
5132
5133       if (is_32bit_elf)
5134         printf
5135           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
5136       else if (do_wide)
5137         printf
5138           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
5139       else
5140         {
5141           printf
5142             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
5143           printf
5144             (_("                 FileSiz            MemSiz              Flags  Align\n"));
5145         }
5146     }
5147
5148   dynamic_addr = 0;
5149   dynamic_size = 0;
5150
5151   for (i = 0, segment = filedata->program_headers;
5152        i < filedata->file_header.e_phnum;
5153        i++, segment++)
5154     {
5155       if (do_segments)
5156         {
5157           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
5158
5159           if (is_32bit_elf)
5160             {
5161               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5162               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5163               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5164               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5165               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5166               printf ("%c%c%c ",
5167                       (segment->p_flags & PF_R ? 'R' : ' '),
5168                       (segment->p_flags & PF_W ? 'W' : ' '),
5169                       (segment->p_flags & PF_X ? 'E' : ' '));
5170               printf ("%#lx", (unsigned long) segment->p_align);
5171             }
5172           else if (do_wide)
5173             {
5174               if ((unsigned long) segment->p_offset == segment->p_offset)
5175                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5176               else
5177                 {
5178                   print_vma (segment->p_offset, FULL_HEX);
5179                   putchar (' ');
5180                 }
5181
5182               print_vma (segment->p_vaddr, FULL_HEX);
5183               putchar (' ');
5184               print_vma (segment->p_paddr, FULL_HEX);
5185               putchar (' ');
5186
5187               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5188                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5189               else
5190                 {
5191                   print_vma (segment->p_filesz, FULL_HEX);
5192                   putchar (' ');
5193                 }
5194
5195               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5196                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5197               else
5198                 {
5199                   print_vma (segment->p_memsz, FULL_HEX);
5200                 }
5201
5202               printf (" %c%c%c ",
5203                       (segment->p_flags & PF_R ? 'R' : ' '),
5204                       (segment->p_flags & PF_W ? 'W' : ' '),
5205                       (segment->p_flags & PF_X ? 'E' : ' '));
5206
5207               if ((unsigned long) segment->p_align == segment->p_align)
5208                 printf ("%#lx", (unsigned long) segment->p_align);
5209               else
5210                 {
5211                   print_vma (segment->p_align, PREFIX_HEX);
5212                 }
5213             }
5214           else
5215             {
5216               print_vma (segment->p_offset, FULL_HEX);
5217               putchar (' ');
5218               print_vma (segment->p_vaddr, FULL_HEX);
5219               putchar (' ');
5220               print_vma (segment->p_paddr, FULL_HEX);
5221               printf ("\n                 ");
5222               print_vma (segment->p_filesz, FULL_HEX);
5223               putchar (' ');
5224               print_vma (segment->p_memsz, FULL_HEX);
5225               printf ("  %c%c%c    ",
5226                       (segment->p_flags & PF_R ? 'R' : ' '),
5227                       (segment->p_flags & PF_W ? 'W' : ' '),
5228                       (segment->p_flags & PF_X ? 'E' : ' '));
5229               print_vma (segment->p_align, PREFIX_HEX);
5230             }
5231
5232           putc ('\n', stdout);
5233         }
5234
5235       switch (segment->p_type)
5236         {
5237         case PT_LOAD:
5238 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5239          required by the ELF standard, several programs, including the Linux
5240          kernel, make use of non-ordered segments.  */
5241           if (previous_load
5242               && previous_load->p_vaddr > segment->p_vaddr)
5243             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5244 #endif
5245           if (segment->p_memsz < segment->p_filesz)
5246             error (_("the segment's file size is larger than its memory size\n"));
5247           previous_load = segment;
5248           break;
5249
5250         case PT_PHDR:
5251           /* PR 20815 - Verify that the program header is loaded into memory.  */
5252           if (i > 0 && previous_load != NULL)
5253             error (_("the PHDR segment must occur before any LOAD segment\n"));
5254           if (filedata->file_header.e_machine != EM_PARISC)
5255             {
5256               unsigned int j;
5257
5258               for (j = 1; j < filedata->file_header.e_phnum; j++)
5259                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5260                     && (filedata->program_headers[j].p_vaddr
5261                         + filedata->program_headers[j].p_memsz)
5262                     >= (segment->p_vaddr + segment->p_filesz))
5263                   break;
5264               if (j == filedata->file_header.e_phnum)
5265                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5266             }
5267           break;
5268
5269         case PT_DYNAMIC:
5270           if (dynamic_addr)
5271             error (_("more than one dynamic segment\n"));
5272
5273           /* By default, assume that the .dynamic section is the first
5274              section in the DYNAMIC segment.  */
5275           dynamic_addr = segment->p_offset;
5276           dynamic_size = segment->p_filesz;
5277
5278           /* Try to locate the .dynamic section. If there is
5279              a section header table, we can easily locate it.  */
5280           if (filedata->section_headers != NULL)
5281             {
5282               Elf_Internal_Shdr * sec;
5283
5284               sec = find_section (filedata, ".dynamic");
5285               if (sec == NULL || sec->sh_size == 0)
5286                 {
5287                   /* A corresponding .dynamic section is expected, but on
5288                      IA-64/OpenVMS it is OK for it to be missing.  */
5289                   if (!is_ia64_vms (filedata))
5290                     error (_("no .dynamic section in the dynamic segment\n"));
5291                   break;
5292                 }
5293
5294               if (sec->sh_type == SHT_NOBITS)
5295                 {
5296                   dynamic_size = 0;
5297                   break;
5298                 }
5299
5300               dynamic_addr = sec->sh_offset;
5301               dynamic_size = sec->sh_size;
5302
5303               if (dynamic_addr < segment->p_offset
5304                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5305                 warn (_("the .dynamic section is not contained"
5306                         " within the dynamic segment\n"));
5307               else if (dynamic_addr > segment->p_offset)
5308                 warn (_("the .dynamic section is not the first section"
5309                         " in the dynamic segment.\n"));
5310             }
5311
5312           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5313              segment.  Check this after matching against the section headers
5314              so we don't warn on debuginfo file (which have NOBITS .dynamic
5315              sections).  */
5316           if (dynamic_addr > filedata->file_size
5317               || dynamic_size > filedata->file_size - dynamic_addr)
5318             {
5319               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5320               dynamic_addr = dynamic_size = 0;
5321             }
5322           break;
5323
5324         case PT_INTERP:
5325           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5326                      SEEK_SET))
5327             error (_("Unable to find program interpreter name\n"));
5328           else
5329             {
5330               char fmt [32];
5331               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5332
5333               if (ret >= (int) sizeof (fmt) || ret < 0)
5334                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5335
5336               program_interpreter[0] = 0;
5337               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5338                 error (_("Unable to read program interpreter name\n"));
5339
5340               if (do_segments)
5341                 printf (_("      [Requesting program interpreter: %s]\n"),
5342                     program_interpreter);
5343             }
5344           break;
5345         }
5346     }
5347
5348   if (do_segments
5349       && filedata->section_headers != NULL
5350       && filedata->string_table != NULL)
5351     {
5352       printf (_("\n Section to Segment mapping:\n"));
5353       printf (_("  Segment Sections...\n"));
5354
5355       for (i = 0; i < filedata->file_header.e_phnum; i++)
5356         {
5357           unsigned int j;
5358           Elf_Internal_Shdr * section;
5359
5360           segment = filedata->program_headers + i;
5361           section = filedata->section_headers + 1;
5362
5363           printf ("   %2.2d     ", i);
5364
5365           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5366             {
5367               if (!ELF_TBSS_SPECIAL (section, segment)
5368                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5369                 printf ("%s ", printable_section_name (filedata, section));
5370             }
5371
5372           putc ('\n',stdout);
5373         }
5374     }
5375
5376   return TRUE;
5377 }
5378
5379
5380 /* Find the file offset corresponding to VMA by using the program headers.  */
5381
5382 static long
5383 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5384 {
5385   Elf_Internal_Phdr * seg;
5386
5387   if (! get_program_headers (filedata))
5388     {
5389       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5390       return (long) vma;
5391     }
5392
5393   for (seg = filedata->program_headers;
5394        seg < filedata->program_headers + filedata->file_header.e_phnum;
5395        ++seg)
5396     {
5397       if (seg->p_type != PT_LOAD)
5398         continue;
5399
5400       if (vma >= (seg->p_vaddr & -seg->p_align)
5401           && vma + size <= seg->p_vaddr + seg->p_filesz)
5402         return vma - seg->p_vaddr + seg->p_offset;
5403     }
5404
5405   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5406         (unsigned long) vma);
5407   return (long) vma;
5408 }
5409
5410
5411 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5412    If PROBE is true, this is just a probe and we do not generate any error
5413    messages if the load fails.  */
5414
5415 static bfd_boolean
5416 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5417 {
5418   Elf32_External_Shdr * shdrs;
5419   Elf_Internal_Shdr *   internal;
5420   unsigned int          i;
5421   unsigned int          size = filedata->file_header.e_shentsize;
5422   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5423
5424   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5425   if (size == 0 || num == 0)
5426     return FALSE;
5427   if (size < sizeof * shdrs)
5428     {
5429       if (! probe)
5430         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5431       return FALSE;
5432     }
5433   if (!probe && size > sizeof * shdrs)
5434     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5435
5436   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5437                                             size, num,
5438                                             probe ? NULL : _("section headers"));
5439   if (shdrs == NULL)
5440     return FALSE;
5441
5442   free (filedata->section_headers);
5443   filedata->section_headers = (Elf_Internal_Shdr *)
5444     cmalloc (num, sizeof (Elf_Internal_Shdr));
5445   if (filedata->section_headers == NULL)
5446     {
5447       if (!probe)
5448         error (_("Out of memory reading %u section headers\n"), num);
5449       free (shdrs);
5450       return FALSE;
5451     }
5452
5453   for (i = 0, internal = filedata->section_headers;
5454        i < num;
5455        i++, internal++)
5456     {
5457       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5458       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5459       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5460       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5461       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5462       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5463       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5464       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5465       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5466       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5467       if (!probe && internal->sh_link > num)
5468         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5469       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5470         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5471     }
5472
5473   free (shdrs);
5474   return TRUE;
5475 }
5476
5477 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5478
5479 static bfd_boolean
5480 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5481 {
5482   Elf64_External_Shdr *  shdrs;
5483   Elf_Internal_Shdr *    internal;
5484   unsigned int           i;
5485   unsigned int           size = filedata->file_header.e_shentsize;
5486   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5487
5488   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5489   if (size == 0 || num == 0)
5490     return FALSE;
5491
5492   if (size < sizeof * shdrs)
5493     {
5494       if (! probe)
5495         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5496       return FALSE;
5497     }
5498
5499   if (! probe && size > sizeof * shdrs)
5500     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5501
5502   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5503                                             filedata->file_header.e_shoff,
5504                                             size, num,
5505                                             probe ? NULL : _("section headers"));
5506   if (shdrs == NULL)
5507     return FALSE;
5508
5509   free (filedata->section_headers);
5510   filedata->section_headers = (Elf_Internal_Shdr *)
5511     cmalloc (num, sizeof (Elf_Internal_Shdr));
5512   if (filedata->section_headers == NULL)
5513     {
5514       if (! probe)
5515         error (_("Out of memory reading %u section headers\n"), num);
5516       free (shdrs);
5517       return FALSE;
5518     }
5519
5520   for (i = 0, internal = filedata->section_headers;
5521        i < num;
5522        i++, internal++)
5523     {
5524       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5525       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5526       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5527       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5528       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5529       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5530       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5531       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5532       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5533       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5534       if (!probe && internal->sh_link > num)
5535         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5536       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5537         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5538     }
5539
5540   free (shdrs);
5541   return TRUE;
5542 }
5543
5544 static Elf_Internal_Sym *
5545 get_32bit_elf_symbols (Filedata *           filedata,
5546                        Elf_Internal_Shdr *  section,
5547                        unsigned long *      num_syms_return)
5548 {
5549   unsigned long number = 0;
5550   Elf32_External_Sym * esyms = NULL;
5551   Elf_External_Sym_Shndx * shndx = NULL;
5552   Elf_Internal_Sym * isyms = NULL;
5553   Elf_Internal_Sym * psym;
5554   unsigned int j;
5555   elf_section_list * entry;
5556
5557   if (section->sh_size == 0)
5558     {
5559       if (num_syms_return != NULL)
5560         * num_syms_return = 0;
5561       return NULL;
5562     }
5563
5564   /* Run some sanity checks first.  */
5565   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5566     {
5567       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5568              printable_section_name (filedata, section),
5569              (unsigned long) section->sh_entsize);
5570       goto exit_point;
5571     }
5572
5573   if (section->sh_size > filedata->file_size)
5574     {
5575       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5576              printable_section_name (filedata, section),
5577              (unsigned long) section->sh_size);
5578       goto exit_point;
5579     }
5580
5581   number = section->sh_size / section->sh_entsize;
5582
5583   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5584     {
5585       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5586              (unsigned long) section->sh_size,
5587              printable_section_name (filedata, section),
5588              (unsigned long) section->sh_entsize);
5589       goto exit_point;
5590     }
5591
5592   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5593                                            section->sh_size, _("symbols"));
5594   if (esyms == NULL)
5595     goto exit_point;
5596
5597   shndx = NULL;
5598   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5599     {
5600       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5601         continue;
5602
5603       if (shndx != NULL)
5604         {
5605           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5606           free (shndx);
5607         }
5608
5609       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5610                                                    entry->hdr->sh_offset,
5611                                                    1, entry->hdr->sh_size,
5612                                                    _("symbol table section indices"));
5613       if (shndx == NULL)
5614         goto exit_point;
5615
5616       /* PR17531: file: heap-buffer-overflow */
5617       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5618         {
5619           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5620                  printable_section_name (filedata, entry->hdr),
5621                  (unsigned long) entry->hdr->sh_size,
5622                  (unsigned long) section->sh_size);
5623           goto exit_point;
5624         }
5625     }
5626
5627   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5628
5629   if (isyms == NULL)
5630     {
5631       error (_("Out of memory reading %lu symbols\n"),
5632              (unsigned long) number);
5633       goto exit_point;
5634     }
5635
5636   for (j = 0, psym = isyms; j < number; j++, psym++)
5637     {
5638       psym->st_name  = BYTE_GET (esyms[j].st_name);
5639       psym->st_value = BYTE_GET (esyms[j].st_value);
5640       psym->st_size  = BYTE_GET (esyms[j].st_size);
5641       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5642       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5643         psym->st_shndx
5644           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5645       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5646         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5647       psym->st_info  = BYTE_GET (esyms[j].st_info);
5648       psym->st_other = BYTE_GET (esyms[j].st_other);
5649     }
5650
5651  exit_point:
5652   free (shndx);
5653   free (esyms);
5654
5655   if (num_syms_return != NULL)
5656     * num_syms_return = isyms == NULL ? 0 : number;
5657
5658   return isyms;
5659 }
5660
5661 static Elf_Internal_Sym *
5662 get_64bit_elf_symbols (Filedata *           filedata,
5663                        Elf_Internal_Shdr *  section,
5664                        unsigned long *      num_syms_return)
5665 {
5666   unsigned long number = 0;
5667   Elf64_External_Sym * esyms = NULL;
5668   Elf_External_Sym_Shndx * shndx = NULL;
5669   Elf_Internal_Sym * isyms = NULL;
5670   Elf_Internal_Sym * psym;
5671   unsigned int j;
5672   elf_section_list * entry;
5673
5674   if (section->sh_size == 0)
5675     {
5676       if (num_syms_return != NULL)
5677         * num_syms_return = 0;
5678       return NULL;
5679     }
5680
5681   /* Run some sanity checks first.  */
5682   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5683     {
5684       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5685              printable_section_name (filedata, section),
5686              (unsigned long) section->sh_entsize);
5687       goto exit_point;
5688     }
5689
5690   if (section->sh_size > filedata->file_size)
5691     {
5692       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5693              printable_section_name (filedata, section),
5694              (unsigned long) section->sh_size);
5695       goto exit_point;
5696     }
5697
5698   number = section->sh_size / section->sh_entsize;
5699
5700   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5701     {
5702       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5703              (unsigned long) section->sh_size,
5704              printable_section_name (filedata, section),
5705              (unsigned long) section->sh_entsize);
5706       goto exit_point;
5707     }
5708
5709   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5710                                            section->sh_size, _("symbols"));
5711   if (!esyms)
5712     goto exit_point;
5713
5714   shndx = NULL;
5715   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5716     {
5717       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5718         continue;
5719
5720       if (shndx != NULL)
5721         {
5722           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5723           free (shndx);
5724         }
5725
5726       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5727                                                    entry->hdr->sh_offset,
5728                                                    1, entry->hdr->sh_size,
5729                                                    _("symbol table section indices"));
5730       if (shndx == NULL)
5731         goto exit_point;
5732
5733       /* PR17531: file: heap-buffer-overflow */
5734       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5735         {
5736           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5737                  printable_section_name (filedata, entry->hdr),
5738                  (unsigned long) entry->hdr->sh_size,
5739                  (unsigned long) section->sh_size);
5740           goto exit_point;
5741         }
5742     }
5743
5744   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5745
5746   if (isyms == NULL)
5747     {
5748       error (_("Out of memory reading %lu symbols\n"),
5749              (unsigned long) number);
5750       goto exit_point;
5751     }
5752
5753   for (j = 0, psym = isyms; j < number; j++, psym++)
5754     {
5755       psym->st_name  = BYTE_GET (esyms[j].st_name);
5756       psym->st_info  = BYTE_GET (esyms[j].st_info);
5757       psym->st_other = BYTE_GET (esyms[j].st_other);
5758       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5759
5760       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5761         psym->st_shndx
5762           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5763       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5764         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5765
5766       psym->st_value = BYTE_GET (esyms[j].st_value);
5767       psym->st_size  = BYTE_GET (esyms[j].st_size);
5768     }
5769
5770  exit_point:
5771   free (shndx);
5772   free (esyms);
5773
5774   if (num_syms_return != NULL)
5775     * num_syms_return = isyms == NULL ? 0 : number;
5776
5777   return isyms;
5778 }
5779
5780 static const char *
5781 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5782 {
5783   static char buff[1024];
5784   char * p = buff;
5785   unsigned int field_size = is_32bit_elf ? 8 : 16;
5786   signed int sindex;
5787   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5788   bfd_vma os_flags = 0;
5789   bfd_vma proc_flags = 0;
5790   bfd_vma unknown_flags = 0;
5791   static const struct
5792     {
5793       const char * str;
5794       unsigned int len;
5795     }
5796   flags [] =
5797     {
5798       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5799       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5800       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5801       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5802       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5803       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5804       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5805       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5806       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5807       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5808       /* IA-64 specific.  */
5809       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5810       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5811       /* IA-64 OpenVMS specific.  */
5812       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5813       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5814       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5815       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5816       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5817       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5818       /* Generic.  */
5819       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5820       /* SPARC specific.  */
5821       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5822       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5823       /* ARM specific.  */
5824       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5825       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5826       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5827       /* GNU specific.  */
5828       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5829       /* VLE specific.  */
5830       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5831     };
5832
5833   if (do_section_details)
5834     {
5835       sprintf (buff, "[%*.*lx]: ",
5836                field_size, field_size, (unsigned long) sh_flags);
5837       p += field_size + 4;
5838     }
5839
5840   while (sh_flags)
5841     {
5842       bfd_vma flag;
5843
5844       flag = sh_flags & - sh_flags;
5845       sh_flags &= ~ flag;
5846
5847       if (do_section_details)
5848         {
5849           switch (flag)
5850             {
5851             case SHF_WRITE:             sindex = 0; break;
5852             case SHF_ALLOC:             sindex = 1; break;
5853             case SHF_EXECINSTR:         sindex = 2; break;
5854             case SHF_MERGE:             sindex = 3; break;
5855             case SHF_STRINGS:           sindex = 4; break;
5856             case SHF_INFO_LINK:         sindex = 5; break;
5857             case SHF_LINK_ORDER:        sindex = 6; break;
5858             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5859             case SHF_GROUP:             sindex = 8; break;
5860             case SHF_TLS:               sindex = 9; break;
5861             case SHF_EXCLUDE:           sindex = 18; break;
5862             case SHF_COMPRESSED:        sindex = 20; break;
5863             case SHF_GNU_MBIND:         sindex = 24; break;
5864
5865             default:
5866               sindex = -1;
5867               switch (filedata->file_header.e_machine)
5868                 {
5869                 case EM_IA_64:
5870                   if (flag == SHF_IA_64_SHORT)
5871                     sindex = 10;
5872                   else if (flag == SHF_IA_64_NORECOV)
5873                     sindex = 11;
5874 #ifdef BFD64
5875                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5876                     switch (flag)
5877                       {
5878                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5879                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5880                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5881                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5882                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5883                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5884                       default:                        break;
5885                       }
5886 #endif
5887                   break;
5888
5889                 case EM_386:
5890                 case EM_IAMCU:
5891                 case EM_X86_64:
5892                 case EM_L1OM:
5893                 case EM_K1OM:
5894                 case EM_OLD_SPARCV9:
5895                 case EM_SPARC32PLUS:
5896                 case EM_SPARCV9:
5897                 case EM_SPARC:
5898                   if (flag == SHF_ORDERED)
5899                     sindex = 19;
5900                   break;
5901
5902                 case EM_ARM:
5903                   switch (flag)
5904                     {
5905                     case SHF_ENTRYSECT: sindex = 21; break;
5906                     case SHF_ARM_PURECODE: sindex = 22; break;
5907                     case SHF_COMDEF: sindex = 23; break;
5908                     default: break;
5909                     }
5910                   break;
5911                 case EM_PPC:
5912                   if (flag == SHF_PPC_VLE)
5913                     sindex = 25;
5914                   break;
5915
5916                 default:
5917                   break;
5918                 }
5919             }
5920
5921           if (sindex != -1)
5922             {
5923               if (p != buff + field_size + 4)
5924                 {
5925                   if (size < (10 + 2))
5926                     {
5927                       warn (_("Internal error: not enough buffer room for section flag info"));
5928                       return _("<unknown>");
5929                     }
5930                   size -= 2;
5931                   *p++ = ',';
5932                   *p++ = ' ';
5933                 }
5934
5935               size -= flags [sindex].len;
5936               p = stpcpy (p, flags [sindex].str);
5937             }
5938           else if (flag & SHF_MASKOS)
5939             os_flags |= flag;
5940           else if (flag & SHF_MASKPROC)
5941             proc_flags |= flag;
5942           else
5943             unknown_flags |= flag;
5944         }
5945       else
5946         {
5947           switch (flag)
5948             {
5949             case SHF_WRITE:             *p = 'W'; break;
5950             case SHF_ALLOC:             *p = 'A'; break;
5951             case SHF_EXECINSTR:         *p = 'X'; break;
5952             case SHF_MERGE:             *p = 'M'; break;
5953             case SHF_STRINGS:           *p = 'S'; break;
5954             case SHF_INFO_LINK:         *p = 'I'; break;
5955             case SHF_LINK_ORDER:        *p = 'L'; break;
5956             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5957             case SHF_GROUP:             *p = 'G'; break;
5958             case SHF_TLS:               *p = 'T'; break;
5959             case SHF_EXCLUDE:           *p = 'E'; break;
5960             case SHF_COMPRESSED:        *p = 'C'; break;
5961             case SHF_GNU_MBIND:         *p = 'D'; break;
5962
5963             default:
5964               if ((filedata->file_header.e_machine == EM_X86_64
5965                    || filedata->file_header.e_machine == EM_L1OM
5966                    || filedata->file_header.e_machine == EM_K1OM)
5967                   && flag == SHF_X86_64_LARGE)
5968                 *p = 'l';
5969               else if (filedata->file_header.e_machine == EM_ARM
5970                        && flag == SHF_ARM_PURECODE)
5971                   *p = 'y';
5972               else if (filedata->file_header.e_machine == EM_PPC
5973                        && flag == SHF_PPC_VLE)
5974                   *p = 'v';
5975               else if (flag & SHF_MASKOS)
5976                 {
5977                   *p = 'o';
5978                   sh_flags &= ~ SHF_MASKOS;
5979                 }
5980               else if (flag & SHF_MASKPROC)
5981                 {
5982                   *p = 'p';
5983                   sh_flags &= ~ SHF_MASKPROC;
5984                 }
5985               else
5986                 *p = 'x';
5987               break;
5988             }
5989           p++;
5990         }
5991     }
5992
5993   if (do_section_details)
5994     {
5995       if (os_flags)
5996         {
5997           size -= 5 + field_size;
5998           if (p != buff + field_size + 4)
5999             {
6000               if (size < (2 + 1))
6001                 {
6002                   warn (_("Internal error: not enough buffer room for section flag info"));
6003                   return _("<unknown>");
6004                 }
6005               size -= 2;
6006               *p++ = ',';
6007               *p++ = ' ';
6008             }
6009           sprintf (p, "OS (%*.*lx)", field_size, field_size,
6010                    (unsigned long) os_flags);
6011           p += 5 + field_size;
6012         }
6013       if (proc_flags)
6014         {
6015           size -= 7 + field_size;
6016           if (p != buff + field_size + 4)
6017             {
6018               if (size < (2 + 1))
6019                 {
6020                   warn (_("Internal error: not enough buffer room for section flag info"));
6021                   return _("<unknown>");
6022                 }
6023               size -= 2;
6024               *p++ = ',';
6025               *p++ = ' ';
6026             }
6027           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
6028                    (unsigned long) proc_flags);
6029           p += 7 + field_size;
6030         }
6031       if (unknown_flags)
6032         {
6033           size -= 10 + field_size;
6034           if (p != buff + field_size + 4)
6035             {
6036               if (size < (2 + 1))
6037                 {
6038                   warn (_("Internal error: not enough buffer room for section flag info"));
6039                   return _("<unknown>");
6040                 }
6041               size -= 2;
6042               *p++ = ',';
6043               *p++ = ' ';
6044             }
6045           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
6046                    (unsigned long) unknown_flags);
6047           p += 10 + field_size;
6048         }
6049     }
6050
6051   *p = '\0';
6052   return buff;
6053 }
6054
6055 static unsigned int
6056 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
6057 {
6058   if (is_32bit_elf)
6059     {
6060       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
6061
6062       if (size < sizeof (* echdr))
6063         {
6064           error (_("Compressed section is too small even for a compression header\n"));
6065           return 0;
6066         }
6067
6068       chdr->ch_type = BYTE_GET (echdr->ch_type);
6069       chdr->ch_size = BYTE_GET (echdr->ch_size);
6070       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6071       return sizeof (*echdr);
6072     }
6073   else
6074     {
6075       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
6076
6077       if (size < sizeof (* echdr))
6078         {
6079           error (_("Compressed section is too small even for a compression header\n"));
6080           return 0;
6081         }
6082
6083       chdr->ch_type = BYTE_GET (echdr->ch_type);
6084       chdr->ch_size = BYTE_GET (echdr->ch_size);
6085       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6086       return sizeof (*echdr);
6087     }
6088 }
6089
6090 static bfd_boolean
6091 process_section_headers (Filedata * filedata)
6092 {
6093   Elf_Internal_Shdr * section;
6094   unsigned int i;
6095
6096   filedata->section_headers = NULL;
6097
6098   if (filedata->file_header.e_shnum == 0)
6099     {
6100       /* PR binutils/12467.  */
6101       if (filedata->file_header.e_shoff != 0)
6102         {
6103           warn (_("possibly corrupt ELF file header - it has a non-zero"
6104                   " section header offset, but no section headers\n"));
6105           return FALSE;
6106         }
6107       else if (do_sections)
6108         printf (_("\nThere are no sections in this file.\n"));
6109
6110       return TRUE;
6111     }
6112
6113   if (do_sections && !do_header)
6114     printf (ngettext ("There is %d section header, "
6115                       "starting at offset 0x%lx:\n",
6116                       "There are %d section headers, "
6117                       "starting at offset 0x%lx:\n",
6118                       filedata->file_header.e_shnum),
6119             filedata->file_header.e_shnum,
6120             (unsigned long) filedata->file_header.e_shoff);
6121
6122   if (is_32bit_elf)
6123     {
6124       if (! get_32bit_section_headers (filedata, FALSE))
6125         return FALSE;
6126     }
6127   else
6128     {
6129       if (! get_64bit_section_headers (filedata, FALSE))
6130         return FALSE;
6131     }
6132
6133   /* Read in the string table, so that we have names to display.  */
6134   if (filedata->file_header.e_shstrndx != SHN_UNDEF
6135        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6136     {
6137       section = filedata->section_headers + filedata->file_header.e_shstrndx;
6138
6139       if (section->sh_size != 0)
6140         {
6141           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6142                                                       1, section->sh_size,
6143                                                       _("string table"));
6144
6145           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6146         }
6147     }
6148
6149   /* Scan the sections for the dynamic symbol table
6150      and dynamic string table and debug sections.  */
6151   dynamic_symbols = NULL;
6152   dynamic_strings = NULL;
6153   dynamic_syminfo = NULL;
6154   symtab_shndx_list = NULL;
6155
6156   eh_addr_size = is_32bit_elf ? 4 : 8;
6157   switch (filedata->file_header.e_machine)
6158     {
6159     case EM_MIPS:
6160     case EM_MIPS_RS3_LE:
6161       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6162          FDE addresses.  However, the ABI also has a semi-official ILP32
6163          variant for which the normal FDE address size rules apply.
6164
6165          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6166          section, where XX is the size of longs in bits.  Unfortunately,
6167          earlier compilers provided no way of distinguishing ILP32 objects
6168          from LP64 objects, so if there's any doubt, we should assume that
6169          the official LP64 form is being used.  */
6170       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6171           && find_section (filedata, ".gcc_compiled_long32") == NULL)
6172         eh_addr_size = 8;
6173       break;
6174
6175     case EM_H8_300:
6176     case EM_H8_300H:
6177       switch (filedata->file_header.e_flags & EF_H8_MACH)
6178         {
6179         case E_H8_MACH_H8300:
6180         case E_H8_MACH_H8300HN:
6181         case E_H8_MACH_H8300SN:
6182         case E_H8_MACH_H8300SXN:
6183           eh_addr_size = 2;
6184           break;
6185         case E_H8_MACH_H8300H:
6186         case E_H8_MACH_H8300S:
6187         case E_H8_MACH_H8300SX:
6188           eh_addr_size = 4;
6189           break;
6190         }
6191       break;
6192
6193     case EM_M32C_OLD:
6194     case EM_M32C:
6195       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6196         {
6197         case EF_M32C_CPU_M16C:
6198           eh_addr_size = 2;
6199           break;
6200         }
6201       break;
6202     }
6203
6204 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6205   do                                                                    \
6206     {                                                                   \
6207       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6208       if (section->sh_entsize != expected_entsize)                      \
6209         {                                                               \
6210           char buf[40];                                                 \
6211           sprintf_vma (buf, section->sh_entsize);                       \
6212           /* Note: coded this way so that there is a single string for  \
6213              translation.  */ \
6214           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6215           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6216                    (unsigned) expected_entsize);                        \
6217           section->sh_entsize = expected_entsize;                       \
6218         }                                                               \
6219     }                                                                   \
6220   while (0)
6221
6222 #define CHECK_ENTSIZE(section, i, type)                                 \
6223   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6224                         sizeof (Elf64_External_##type))
6225
6226   for (i = 0, section = filedata->section_headers;
6227        i < filedata->file_header.e_shnum;
6228        i++, section++)
6229     {
6230       char * name = SECTION_NAME (section);
6231
6232       if (section->sh_type == SHT_DYNSYM)
6233         {
6234           if (dynamic_symbols != NULL)
6235             {
6236               error (_("File contains multiple dynamic symbol tables\n"));
6237               continue;
6238             }
6239
6240           CHECK_ENTSIZE (section, i, Sym);
6241           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6242         }
6243       else if (section->sh_type == SHT_STRTAB
6244                && streq (name, ".dynstr"))
6245         {
6246           if (dynamic_strings != NULL)
6247             {
6248               error (_("File contains multiple dynamic string tables\n"));
6249               continue;
6250             }
6251
6252           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6253                                                1, section->sh_size,
6254                                                _("dynamic strings"));
6255           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6256         }
6257       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6258         {
6259           elf_section_list * entry = xmalloc (sizeof * entry);
6260
6261           entry->hdr = section;
6262           entry->next = symtab_shndx_list;
6263           symtab_shndx_list = entry;
6264         }
6265       else if (section->sh_type == SHT_SYMTAB)
6266         CHECK_ENTSIZE (section, i, Sym);
6267       else if (section->sh_type == SHT_GROUP)
6268         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6269       else if (section->sh_type == SHT_REL)
6270         CHECK_ENTSIZE (section, i, Rel);
6271       else if (section->sh_type == SHT_RELA)
6272         CHECK_ENTSIZE (section, i, Rela);
6273       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6274                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6275                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6276                 || do_debug_str || do_debug_loc || do_debug_ranges
6277                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6278                && (const_strneq (name, ".debug_")
6279                    || const_strneq (name, ".zdebug_")))
6280         {
6281           if (name[1] == 'z')
6282             name += sizeof (".zdebug_") - 1;
6283           else
6284             name += sizeof (".debug_") - 1;
6285
6286           if (do_debugging
6287               || (do_debug_info     && const_strneq (name, "info"))
6288               || (do_debug_info     && const_strneq (name, "types"))
6289               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6290               || (do_debug_lines    && strcmp (name, "line") == 0)
6291               || (do_debug_lines    && const_strneq (name, "line."))
6292               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6293               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6294               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6295               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6296               || (do_debug_aranges  && const_strneq (name, "aranges"))
6297               || (do_debug_ranges   && const_strneq (name, "ranges"))
6298               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6299               || (do_debug_frames   && const_strneq (name, "frame"))
6300               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6301               || (do_debug_macinfo  && const_strneq (name, "macro"))
6302               || (do_debug_str      && const_strneq (name, "str"))
6303               || (do_debug_loc      && const_strneq (name, "loc"))
6304               || (do_debug_loc      && const_strneq (name, "loclists"))
6305               || (do_debug_addr     && const_strneq (name, "addr"))
6306               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6307               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6308               )
6309             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6310         }
6311       /* Linkonce section to be combined with .debug_info at link time.  */
6312       else if ((do_debugging || do_debug_info)
6313                && const_strneq (name, ".gnu.linkonce.wi."))
6314         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6315       else if (do_debug_frames && streq (name, ".eh_frame"))
6316         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6317       else if (do_gdb_index && (streq (name, ".gdb_index")
6318                                 || streq (name, ".debug_names")))
6319         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6320       /* Trace sections for Itanium VMS.  */
6321       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6322                 || do_trace_aranges)
6323                && const_strneq (name, ".trace_"))
6324         {
6325           name += sizeof (".trace_") - 1;
6326
6327           if (do_debugging
6328               || (do_trace_info     && streq (name, "info"))
6329               || (do_trace_abbrevs  && streq (name, "abbrev"))
6330               || (do_trace_aranges  && streq (name, "aranges"))
6331               )
6332             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6333         }
6334       else if ((do_debugging || do_debug_links)
6335                && (const_strneq (name, ".gnu_debuglink")
6336                    || const_strneq (name, ".gnu_debugaltlink")))
6337         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6338     }
6339
6340   if (! do_sections)
6341     return TRUE;
6342
6343   if (filedata->file_header.e_shnum > 1)
6344     printf (_("\nSection Headers:\n"));
6345   else
6346     printf (_("\nSection Header:\n"));
6347
6348   if (is_32bit_elf)
6349     {
6350       if (do_section_details)
6351         {
6352           printf (_("  [Nr] Name\n"));
6353           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6354         }
6355       else
6356         printf
6357           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6358     }
6359   else if (do_wide)
6360     {
6361       if (do_section_details)
6362         {
6363           printf (_("  [Nr] Name\n"));
6364           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6365         }
6366       else
6367         printf
6368           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6369     }
6370   else
6371     {
6372       if (do_section_details)
6373         {
6374           printf (_("  [Nr] Name\n"));
6375           printf (_("       Type              Address          Offset            Link\n"));
6376           printf (_("       Size              EntSize          Info              Align\n"));
6377         }
6378       else
6379         {
6380           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6381           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6382         }
6383     }
6384
6385   if (do_section_details)
6386     printf (_("       Flags\n"));
6387
6388   for (i = 0, section = filedata->section_headers;
6389        i < filedata->file_header.e_shnum;
6390        i++, section++)
6391     {
6392       /* Run some sanity checks on the section header.  */
6393
6394       /* Check the sh_link field.  */
6395       switch (section->sh_type)
6396         {
6397         case SHT_REL:
6398         case SHT_RELA:
6399           if (section->sh_link == 0
6400               && (filedata->file_header.e_type == ET_EXEC
6401                   || filedata->file_header.e_type == ET_DYN))
6402             /* A dynamic relocation section where all entries use a
6403                zero symbol index need not specify a symtab section.  */
6404             break;
6405           /* Fall through.  */
6406         case SHT_SYMTAB_SHNDX:
6407         case SHT_GROUP:
6408         case SHT_HASH:
6409         case SHT_GNU_HASH:
6410         case SHT_GNU_versym:
6411           if (section->sh_link == 0
6412               || section->sh_link >= filedata->file_header.e_shnum
6413               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6414                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6415             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6416                   i, section->sh_link);
6417           break;
6418
6419         case SHT_DYNAMIC:
6420         case SHT_SYMTAB:
6421         case SHT_DYNSYM:
6422         case SHT_GNU_verneed:
6423         case SHT_GNU_verdef:
6424         case SHT_GNU_LIBLIST:
6425           if (section->sh_link == 0
6426               || section->sh_link >= filedata->file_header.e_shnum
6427               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6428             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6429                   i, section->sh_link);
6430           break;
6431
6432         case SHT_INIT_ARRAY:
6433         case SHT_FINI_ARRAY:
6434         case SHT_PREINIT_ARRAY:
6435           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6436             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6437                   i, section->sh_link);
6438           break;
6439
6440         default:
6441           /* FIXME: Add support for target specific section types.  */
6442 #if 0     /* Currently we do not check other section types as there are too
6443              many special cases.  Stab sections for example have a type
6444              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6445              section.  */
6446           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6447             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6448                   i, section->sh_link);
6449 #endif
6450           break;
6451         }
6452
6453       /* Check the sh_info field.  */
6454       switch (section->sh_type)
6455         {
6456         case SHT_REL:
6457         case SHT_RELA:
6458           if (section->sh_info == 0
6459               && (filedata->file_header.e_type == ET_EXEC
6460                   || filedata->file_header.e_type == ET_DYN))
6461             /* Dynamic relocations apply to segments, so they do not
6462                need to specify the section they relocate.  */
6463             break;
6464           if (section->sh_info == 0
6465               || section->sh_info >= filedata->file_header.e_shnum
6466               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6467                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6468                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6469                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6470                   && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6471                   && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6472                   /* FIXME: Are other section types valid ?  */
6473                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6474             warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6475                   i, section->sh_info);
6476           break;
6477
6478         case SHT_DYNAMIC:
6479         case SHT_HASH:
6480         case SHT_SYMTAB_SHNDX:
6481         case SHT_INIT_ARRAY:
6482         case SHT_FINI_ARRAY:
6483         case SHT_PREINIT_ARRAY:
6484           if (section->sh_info != 0)
6485             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6486                   i, section->sh_info);
6487           break;
6488
6489         case SHT_GROUP:
6490         case SHT_SYMTAB:
6491         case SHT_DYNSYM:
6492           /* A symbol index - we assume that it is valid.  */
6493           break;
6494
6495         default:
6496           /* FIXME: Add support for target specific section types.  */
6497           if (section->sh_type == SHT_NOBITS)
6498             /* NOBITS section headers with non-zero sh_info fields can be
6499                created when a binary is stripped of everything but its debug
6500                information.  The stripped sections have their headers
6501                preserved but their types set to SHT_NOBITS.  So do not check
6502                this type of section.  */
6503             ;
6504           else if (section->sh_flags & SHF_INFO_LINK)
6505             {
6506               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6507                 warn (_("[%2u]: Expected link to another section in info field"), i);
6508             }
6509           else if (section->sh_type < SHT_LOOS
6510                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6511                    && section->sh_info != 0)
6512             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6513                   i, section->sh_info);
6514           break;
6515         }
6516
6517       /* Check the sh_size field.  */
6518       if (section->sh_size > filedata->file_size
6519           && section->sh_type != SHT_NOBITS
6520           && section->sh_type != SHT_NULL
6521           && section->sh_type < SHT_LOOS)
6522         warn (_("Size of section %u is larger than the entire file!\n"), i);
6523
6524       printf ("  [%2u] ", i);
6525       if (do_section_details)
6526         printf ("%s\n      ", printable_section_name (filedata, section));
6527       else
6528         print_symbol (-17, SECTION_NAME (section));
6529
6530       printf (do_wide ? " %-15s " : " %-15.15s ",
6531               get_section_type_name (filedata, section->sh_type));
6532
6533       if (is_32bit_elf)
6534         {
6535           const char * link_too_big = NULL;
6536
6537           print_vma (section->sh_addr, LONG_HEX);
6538
6539           printf ( " %6.6lx %6.6lx %2.2lx",
6540                    (unsigned long) section->sh_offset,
6541                    (unsigned long) section->sh_size,
6542                    (unsigned long) section->sh_entsize);
6543
6544           if (do_section_details)
6545             fputs ("  ", stdout);
6546           else
6547             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6548
6549           if (section->sh_link >= filedata->file_header.e_shnum)
6550             {
6551               link_too_big = "";
6552               /* The sh_link value is out of range.  Normally this indicates
6553                  an error but it can have special values in Solaris binaries.  */
6554               switch (filedata->file_header.e_machine)
6555                 {
6556                 case EM_386:
6557                 case EM_IAMCU:
6558                 case EM_X86_64:
6559                 case EM_L1OM:
6560                 case EM_K1OM:
6561                 case EM_OLD_SPARCV9:
6562                 case EM_SPARC32PLUS:
6563                 case EM_SPARCV9:
6564                 case EM_SPARC:
6565                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6566                     link_too_big = "BEFORE";
6567                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6568                     link_too_big = "AFTER";
6569                   break;
6570                 default:
6571                   break;
6572                 }
6573             }
6574
6575           if (do_section_details)
6576             {
6577               if (link_too_big != NULL && * link_too_big)
6578                 printf ("<%s> ", link_too_big);
6579               else
6580                 printf ("%2u ", section->sh_link);
6581               printf ("%3u %2lu\n", section->sh_info,
6582                       (unsigned long) section->sh_addralign);
6583             }
6584           else
6585             printf ("%2u %3u %2lu\n",
6586                     section->sh_link,
6587                     section->sh_info,
6588                     (unsigned long) section->sh_addralign);
6589
6590           if (link_too_big && ! * link_too_big)
6591             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6592                   i, section->sh_link);
6593         }
6594       else if (do_wide)
6595         {
6596           print_vma (section->sh_addr, LONG_HEX);
6597
6598           if ((long) section->sh_offset == section->sh_offset)
6599             printf (" %6.6lx", (unsigned long) section->sh_offset);
6600           else
6601             {
6602               putchar (' ');
6603               print_vma (section->sh_offset, LONG_HEX);
6604             }
6605
6606           if ((unsigned long) section->sh_size == section->sh_size)
6607             printf (" %6.6lx", (unsigned long) section->sh_size);
6608           else
6609             {
6610               putchar (' ');
6611               print_vma (section->sh_size, LONG_HEX);
6612             }
6613
6614           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6615             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6616           else
6617             {
6618               putchar (' ');
6619               print_vma (section->sh_entsize, LONG_HEX);
6620             }
6621
6622           if (do_section_details)
6623             fputs ("  ", stdout);
6624           else
6625             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6626
6627           printf ("%2u %3u ", section->sh_link, section->sh_info);
6628
6629           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6630             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6631           else
6632             {
6633               print_vma (section->sh_addralign, DEC);
6634               putchar ('\n');
6635             }
6636         }
6637       else if (do_section_details)
6638         {
6639           putchar (' ');
6640           print_vma (section->sh_addr, LONG_HEX);
6641           if ((long) section->sh_offset == section->sh_offset)
6642             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6643           else
6644             {
6645               printf ("  ");
6646               print_vma (section->sh_offset, LONG_HEX);
6647             }
6648           printf ("  %u\n       ", section->sh_link);
6649           print_vma (section->sh_size, LONG_HEX);
6650           putchar (' ');
6651           print_vma (section->sh_entsize, LONG_HEX);
6652
6653           printf ("  %-16u  %lu\n",
6654                   section->sh_info,
6655                   (unsigned long) section->sh_addralign);
6656         }
6657       else
6658         {
6659           putchar (' ');
6660           print_vma (section->sh_addr, LONG_HEX);
6661           if ((long) section->sh_offset == section->sh_offset)
6662             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6663           else
6664             {
6665               printf ("  ");
6666               print_vma (section->sh_offset, LONG_HEX);
6667             }
6668           printf ("\n       ");
6669           print_vma (section->sh_size, LONG_HEX);
6670           printf ("  ");
6671           print_vma (section->sh_entsize, LONG_HEX);
6672
6673           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6674
6675           printf ("     %2u   %3u     %lu\n",
6676                   section->sh_link,
6677                   section->sh_info,
6678                   (unsigned long) section->sh_addralign);
6679         }
6680
6681       if (do_section_details)
6682         {
6683           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6684           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6685             {
6686               /* Minimum section size is 12 bytes for 32-bit compression
6687                  header + 12 bytes for compressed data header.  */
6688               unsigned char buf[24];
6689
6690               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6691               if (get_data (&buf, filedata, section->sh_offset, 1,
6692                             sizeof (buf), _("compression header")))
6693                 {
6694                   Elf_Internal_Chdr chdr;
6695
6696                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6697
6698                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6699                     printf ("       ZLIB, ");
6700                   else
6701                     printf (_("       [<unknown>: 0x%x], "),
6702                             chdr.ch_type);
6703                   print_vma (chdr.ch_size, LONG_HEX);
6704                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6705                 }
6706             }
6707         }
6708     }
6709
6710   if (!do_section_details)
6711     {
6712       /* The ordering of the letters shown here matches the ordering of the
6713          corresponding SHF_xxx values, and hence the order in which these
6714          letters will be displayed to the user.  */
6715       printf (_("Key to Flags:\n\
6716   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6717   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6718   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6719       if (filedata->file_header.e_machine == EM_X86_64
6720           || filedata->file_header.e_machine == EM_L1OM
6721           || filedata->file_header.e_machine == EM_K1OM)
6722         printf (_("l (large), "));
6723       else if (filedata->file_header.e_machine == EM_ARM)
6724         printf (_("y (purecode), "));
6725       else if (filedata->file_header.e_machine == EM_PPC)
6726         printf (_("v (VLE), "));
6727       printf ("p (processor specific)\n");
6728     }
6729
6730   return TRUE;
6731 }
6732
6733 static const char *
6734 get_group_flags (unsigned int flags)
6735 {
6736   static char buff[128];
6737
6738   if (flags == 0)
6739     return "";
6740   else if (flags == GRP_COMDAT)
6741     return "COMDAT ";
6742
6743   snprintf (buff, 14, _("[0x%x: "), flags);
6744
6745   flags &= ~ GRP_COMDAT;
6746   if (flags & GRP_MASKOS)
6747     {
6748       strcat (buff, "<OS specific>");
6749       flags &= ~ GRP_MASKOS;
6750     }
6751
6752   if (flags & GRP_MASKPROC)
6753     {
6754       strcat (buff, "<PROC specific>");
6755       flags &= ~ GRP_MASKPROC;
6756     }
6757
6758   if (flags)
6759     strcat (buff, "<unknown>");
6760
6761   strcat (buff, "]");
6762   return buff;
6763 }
6764
6765 static bfd_boolean
6766 process_section_groups (Filedata * filedata)
6767 {
6768   Elf_Internal_Shdr * section;
6769   unsigned int i;
6770   struct group * group;
6771   Elf_Internal_Shdr * symtab_sec;
6772   Elf_Internal_Shdr * strtab_sec;
6773   Elf_Internal_Sym * symtab;
6774   unsigned long num_syms;
6775   char * strtab;
6776   size_t strtab_size;
6777
6778   /* Don't process section groups unless needed.  */
6779   if (!do_unwind && !do_section_groups)
6780     return TRUE;
6781
6782   if (filedata->file_header.e_shnum == 0)
6783     {
6784       if (do_section_groups)
6785         printf (_("\nThere are no sections to group in this file.\n"));
6786
6787       return TRUE;
6788     }
6789
6790   if (filedata->section_headers == NULL)
6791     {
6792       error (_("Section headers are not available!\n"));
6793       /* PR 13622: This can happen with a corrupt ELF header.  */
6794       return FALSE;
6795     }
6796
6797   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6798                                                      sizeof (struct group *));
6799
6800   if (section_headers_groups == NULL)
6801     {
6802       error (_("Out of memory reading %u section group headers\n"),
6803              filedata->file_header.e_shnum);
6804       return FALSE;
6805     }
6806
6807   /* Scan the sections for the group section.  */
6808   group_count = 0;
6809   for (i = 0, section = filedata->section_headers;
6810        i < filedata->file_header.e_shnum;
6811        i++, section++)
6812     if (section->sh_type == SHT_GROUP)
6813       group_count++;
6814
6815   if (group_count == 0)
6816     {
6817       if (do_section_groups)
6818         printf (_("\nThere are no section groups in this file.\n"));
6819
6820       return TRUE;
6821     }
6822
6823   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6824
6825   if (section_groups == NULL)
6826     {
6827       error (_("Out of memory reading %lu groups\n"),
6828              (unsigned long) group_count);
6829       return FALSE;
6830     }
6831
6832   symtab_sec = NULL;
6833   strtab_sec = NULL;
6834   symtab = NULL;
6835   num_syms = 0;
6836   strtab = NULL;
6837   strtab_size = 0;
6838   for (i = 0, section = filedata->section_headers, group = section_groups;
6839        i < filedata->file_header.e_shnum;
6840        i++, section++)
6841     {
6842       if (section->sh_type == SHT_GROUP)
6843         {
6844           const char * name = printable_section_name (filedata, section);
6845           const char * group_name;
6846           unsigned char * start;
6847           unsigned char * indices;
6848           unsigned int entry, j, size;
6849           Elf_Internal_Shdr * sec;
6850           Elf_Internal_Sym * sym;
6851
6852           /* Get the symbol table.  */
6853           if (section->sh_link >= filedata->file_header.e_shnum
6854               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6855                   != SHT_SYMTAB))
6856             {
6857               error (_("Bad sh_link in group section `%s'\n"), name);
6858               continue;
6859             }
6860
6861           if (symtab_sec != sec)
6862             {
6863               symtab_sec = sec;
6864               if (symtab)
6865                 free (symtab);
6866               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6867             }
6868
6869           if (symtab == NULL)
6870             {
6871               error (_("Corrupt header in group section `%s'\n"), name);
6872               continue;
6873             }
6874
6875           if (section->sh_info >= num_syms)
6876             {
6877               error (_("Bad sh_info in group section `%s'\n"), name);
6878               continue;
6879             }
6880
6881           sym = symtab + section->sh_info;
6882
6883           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6884             {
6885               if (sym->st_shndx == 0
6886                   || sym->st_shndx >= filedata->file_header.e_shnum)
6887                 {
6888                   error (_("Bad sh_info in group section `%s'\n"), name);
6889                   continue;
6890                 }
6891
6892               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6893               strtab_sec = NULL;
6894               if (strtab)
6895                 free (strtab);
6896               strtab = NULL;
6897               strtab_size = 0;
6898             }
6899           else
6900             {
6901               /* Get the string table.  */
6902               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6903                 {
6904                   strtab_sec = NULL;
6905                   if (strtab)
6906                     free (strtab);
6907                   strtab = NULL;
6908                   strtab_size = 0;
6909                 }
6910               else if (strtab_sec
6911                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6912                 {
6913                   strtab_sec = sec;
6914                   if (strtab)
6915                     free (strtab);
6916
6917                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6918                                               1, strtab_sec->sh_size,
6919                                               _("string table"));
6920                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6921                 }
6922               group_name = sym->st_name < strtab_size
6923                 ? strtab + sym->st_name : _("<corrupt>");
6924             }
6925
6926           /* PR 17531: file: loop.  */
6927           if (section->sh_entsize > section->sh_size)
6928             {
6929               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6930                      printable_section_name (filedata, section),
6931                      (unsigned long) section->sh_entsize,
6932                      (unsigned long) section->sh_size);
6933               continue;
6934             }
6935
6936           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6937                                               1, section->sh_size,
6938                                               _("section data"));
6939           if (start == NULL)
6940             continue;
6941
6942           indices = start;
6943           size = (section->sh_size / section->sh_entsize) - 1;
6944           entry = byte_get (indices, 4);
6945           indices += 4;
6946
6947           if (do_section_groups)
6948             {
6949               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6950                       get_group_flags (entry), i, name, group_name, size);
6951
6952               printf (_("   [Index]    Name\n"));
6953             }
6954
6955           group->group_index = i;
6956
6957           for (j = 0; j < size; j++)
6958             {
6959               struct group_list * g;
6960
6961               entry = byte_get (indices, 4);
6962               indices += 4;
6963
6964               if (entry >= filedata->file_header.e_shnum)
6965                 {
6966                   static unsigned num_group_errors = 0;
6967
6968                   if (num_group_errors ++ < 10)
6969                     {
6970                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6971                              entry, i, filedata->file_header.e_shnum - 1);
6972                       if (num_group_errors == 10)
6973                         warn (_("Further error messages about overlarge group section indices suppressed\n"));
6974                     }
6975                   continue;
6976                 }
6977
6978               if (section_headers_groups [entry] != NULL)
6979                 {
6980                   if (entry)
6981                     {
6982                       static unsigned num_errs = 0;
6983
6984                       if (num_errs ++ < 10)
6985                         {
6986                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6987                                  entry, i,
6988                                  section_headers_groups [entry]->group_index);
6989                           if (num_errs == 10)
6990                             warn (_("Further error messages about already contained group sections suppressed\n"));
6991                         }
6992                       continue;
6993                     }
6994                   else
6995                     {
6996                       /* Intel C/C++ compiler may put section 0 in a
6997                          section group.  We just warn it the first time
6998                          and ignore it afterwards.  */
6999                       static bfd_boolean warned = FALSE;
7000                       if (!warned)
7001                         {
7002                           error (_("section 0 in group section [%5u]\n"),
7003                                  section_headers_groups [entry]->group_index);
7004                           warned = TRUE;
7005                         }
7006                     }
7007                 }
7008
7009               section_headers_groups [entry] = group;
7010
7011               if (do_section_groups)
7012                 {
7013                   sec = filedata->section_headers + entry;
7014                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
7015                 }
7016
7017               g = (struct group_list *) xmalloc (sizeof (struct group_list));
7018               g->section_index = entry;
7019               g->next = group->root;
7020               group->root = g;
7021             }
7022
7023           if (start)
7024             free (start);
7025
7026           group++;
7027         }
7028     }
7029
7030   if (symtab)
7031     free (symtab);
7032   if (strtab)
7033     free (strtab);
7034   return TRUE;
7035 }
7036
7037 /* Data used to display dynamic fixups.  */
7038
7039 struct ia64_vms_dynfixup
7040 {
7041   bfd_vma needed_ident;         /* Library ident number.  */
7042   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
7043   bfd_vma fixup_needed;         /* Index of the library.  */
7044   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
7045   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
7046 };
7047
7048 /* Data used to display dynamic relocations.  */
7049
7050 struct ia64_vms_dynimgrela
7051 {
7052   bfd_vma img_rela_cnt;         /* Number of relocations.  */
7053   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
7054 };
7055
7056 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7057    library).  */
7058
7059 static bfd_boolean
7060 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
7061                               struct ia64_vms_dynfixup *  fixup,
7062                               const char *                strtab,
7063                               unsigned int                strtab_sz)
7064 {
7065   Elf64_External_VMS_IMAGE_FIXUP * imfs;
7066   long i;
7067   const char * lib_name;
7068
7069   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
7070                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
7071                    _("dynamic section image fixups"));
7072   if (!imfs)
7073     return FALSE;
7074
7075   if (fixup->needed < strtab_sz)
7076     lib_name = strtab + fixup->needed;
7077   else
7078     {
7079       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7080             (unsigned long) fixup->needed);
7081       lib_name = "???";
7082     }
7083   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7084           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
7085   printf
7086     (_("Seg Offset           Type                             SymVec DataType\n"));
7087
7088   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
7089     {
7090       unsigned int type;
7091       const char *rtype;
7092
7093       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
7094       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7095       type = BYTE_GET (imfs [i].type);
7096       rtype = elf_ia64_reloc_type (type);
7097       if (rtype == NULL)
7098         printf (" 0x%08x                       ", type);
7099       else
7100         printf (" %-32s ", rtype);
7101       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7102       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7103     }
7104
7105   free (imfs);
7106   return TRUE;
7107 }
7108
7109 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
7110
7111 static bfd_boolean
7112 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7113 {
7114   Elf64_External_VMS_IMAGE_RELA *imrs;
7115   long i;
7116
7117   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7118                    1, imgrela->img_rela_cnt * sizeof (*imrs),
7119                    _("dynamic section image relocations"));
7120   if (!imrs)
7121     return FALSE;
7122
7123   printf (_("\nImage relocs\n"));
7124   printf
7125     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
7126
7127   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7128     {
7129       unsigned int type;
7130       const char *rtype;
7131
7132       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7133       printf ("%08" BFD_VMA_FMT "x ",
7134               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7135       type = BYTE_GET (imrs [i].type);
7136       rtype = elf_ia64_reloc_type (type);
7137       if (rtype == NULL)
7138         printf ("0x%08x                      ", type);
7139       else
7140         printf ("%-31s ", rtype);
7141       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7142       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7143       printf ("%08" BFD_VMA_FMT "x\n",
7144               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7145     }
7146
7147   free (imrs);
7148   return TRUE;
7149 }
7150
7151 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
7152
7153 static bfd_boolean
7154 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7155 {
7156   struct ia64_vms_dynfixup fixup;
7157   struct ia64_vms_dynimgrela imgrela;
7158   Elf_Internal_Dyn *entry;
7159   bfd_vma strtab_off = 0;
7160   bfd_vma strtab_sz = 0;
7161   char *strtab = NULL;
7162   bfd_boolean res = TRUE;
7163
7164   memset (&fixup, 0, sizeof (fixup));
7165   memset (&imgrela, 0, sizeof (imgrela));
7166
7167   /* Note: the order of the entries is specified by the OpenVMS specs.  */
7168   for (entry = dynamic_section;
7169        entry < dynamic_section + dynamic_nent;
7170        entry++)
7171     {
7172       switch (entry->d_tag)
7173         {
7174         case DT_IA_64_VMS_STRTAB_OFFSET:
7175           strtab_off = entry->d_un.d_val;
7176           break;
7177         case DT_STRSZ:
7178           strtab_sz = entry->d_un.d_val;
7179           if (strtab == NULL)
7180             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7181                                1, strtab_sz, _("dynamic string section"));
7182           break;
7183
7184         case DT_IA_64_VMS_NEEDED_IDENT:
7185           fixup.needed_ident = entry->d_un.d_val;
7186           break;
7187         case DT_NEEDED:
7188           fixup.needed = entry->d_un.d_val;
7189           break;
7190         case DT_IA_64_VMS_FIXUP_NEEDED:
7191           fixup.fixup_needed = entry->d_un.d_val;
7192           break;
7193         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7194           fixup.fixup_rela_cnt = entry->d_un.d_val;
7195           break;
7196         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7197           fixup.fixup_rela_off = entry->d_un.d_val;
7198           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7199             res = FALSE;
7200           break;
7201         case DT_IA_64_VMS_IMG_RELA_CNT:
7202           imgrela.img_rela_cnt = entry->d_un.d_val;
7203           break;
7204         case DT_IA_64_VMS_IMG_RELA_OFF:
7205           imgrela.img_rela_off = entry->d_un.d_val;
7206           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7207             res = FALSE;
7208           break;
7209
7210         default:
7211           break;
7212         }
7213     }
7214
7215   if (strtab != NULL)
7216     free (strtab);
7217
7218   return res;
7219 }
7220
7221 static struct
7222 {
7223   const char * name;
7224   int reloc;
7225   int size;
7226   int rela;
7227 }
7228   dynamic_relocations [] =
7229 {
7230   { "REL", DT_REL, DT_RELSZ, FALSE },
7231   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7232   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7233 };
7234
7235 /* Process the reloc section.  */
7236
7237 static bfd_boolean
7238 process_relocs (Filedata * filedata)
7239 {
7240   unsigned long rel_size;
7241   unsigned long rel_offset;
7242
7243   if (!do_reloc)
7244     return TRUE;
7245
7246   if (do_using_dynamic)
7247     {
7248       int          is_rela;
7249       const char * name;
7250       bfd_boolean  has_dynamic_reloc;
7251       unsigned int i;
7252
7253       has_dynamic_reloc = FALSE;
7254
7255       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7256         {
7257           is_rela = dynamic_relocations [i].rela;
7258           name = dynamic_relocations [i].name;
7259           rel_size = dynamic_info [dynamic_relocations [i].size];
7260           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7261
7262           if (rel_size)
7263             has_dynamic_reloc = TRUE;
7264
7265           if (is_rela == UNKNOWN)
7266             {
7267               if (dynamic_relocations [i].reloc == DT_JMPREL)
7268                 switch (dynamic_info[DT_PLTREL])
7269                   {
7270                   case DT_REL:
7271                     is_rela = FALSE;
7272                     break;
7273                   case DT_RELA:
7274                     is_rela = TRUE;
7275                     break;
7276                   }
7277             }
7278
7279           if (rel_size)
7280             {
7281               printf
7282                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7283                  name, rel_offset, rel_size);
7284
7285               dump_relocations (filedata,
7286                                 offset_from_vma (filedata, rel_offset, rel_size),
7287                                 rel_size,
7288                                 dynamic_symbols, num_dynamic_syms,
7289                                 dynamic_strings, dynamic_strings_length,
7290                                 is_rela, TRUE /* is_dynamic */);
7291             }
7292         }
7293
7294       if (is_ia64_vms (filedata))
7295         if (process_ia64_vms_dynamic_relocs (filedata))
7296           has_dynamic_reloc = TRUE;
7297
7298       if (! has_dynamic_reloc)
7299         printf (_("\nThere are no dynamic relocations in this file.\n"));
7300     }
7301   else
7302     {
7303       Elf_Internal_Shdr * section;
7304       unsigned long i;
7305       bfd_boolean found = FALSE;
7306
7307       for (i = 0, section = filedata->section_headers;
7308            i < filedata->file_header.e_shnum;
7309            i++, section++)
7310         {
7311           if (   section->sh_type != SHT_RELA
7312               && section->sh_type != SHT_REL)
7313             continue;
7314
7315           rel_offset = section->sh_offset;
7316           rel_size   = section->sh_size;
7317
7318           if (rel_size)
7319             {
7320               Elf_Internal_Shdr * strsec;
7321               int is_rela;
7322               unsigned long num_rela;
7323
7324               printf (_("\nRelocation section "));
7325
7326               if (filedata->string_table == NULL)
7327                 printf ("%d", section->sh_name);
7328               else
7329                 printf ("'%s'", printable_section_name (filedata, section));
7330
7331               num_rela = rel_size / section->sh_entsize;
7332               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7333                                 " at offset 0x%lx contains %lu entries:\n",
7334                                 num_rela),
7335                       rel_offset, num_rela);
7336
7337               is_rela = section->sh_type == SHT_RELA;
7338
7339               if (section->sh_link != 0
7340                   && section->sh_link < filedata->file_header.e_shnum)
7341                 {
7342                   Elf_Internal_Shdr * symsec;
7343                   Elf_Internal_Sym *  symtab;
7344                   unsigned long nsyms;
7345                   unsigned long strtablen = 0;
7346                   char * strtab = NULL;
7347
7348                   symsec = filedata->section_headers + section->sh_link;
7349                   if (symsec->sh_type != SHT_SYMTAB
7350                       && symsec->sh_type != SHT_DYNSYM)
7351                     continue;
7352
7353                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7354
7355                   if (symtab == NULL)
7356                     continue;
7357
7358                   if (symsec->sh_link != 0
7359                       && symsec->sh_link < filedata->file_header.e_shnum)
7360                     {
7361                       strsec = filedata->section_headers + symsec->sh_link;
7362
7363                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7364                                                   1, strsec->sh_size,
7365                                                   _("string table"));
7366                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7367                     }
7368
7369                   dump_relocations (filedata, rel_offset, rel_size,
7370                                     symtab, nsyms, strtab, strtablen,
7371                                     is_rela,
7372                                     symsec->sh_type == SHT_DYNSYM);
7373                   if (strtab)
7374                     free (strtab);
7375                   free (symtab);
7376                 }
7377               else
7378                 dump_relocations (filedata, rel_offset, rel_size,
7379                                   NULL, 0, NULL, 0, is_rela,
7380                                   FALSE /* is_dynamic */);
7381
7382               found = TRUE;
7383             }
7384         }
7385
7386       if (! found)
7387         {
7388           /* Users sometimes forget the -D option, so try to be helpful.  */
7389           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7390             {
7391               if (dynamic_info [dynamic_relocations [i].size])
7392                 {
7393                   printf (_("\nThere are no static relocations in this file."));
7394                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7395
7396                   break;
7397                 }
7398             }
7399           if (i == ARRAY_SIZE (dynamic_relocations))
7400             printf (_("\nThere are no relocations in this file.\n"));
7401         }
7402     }
7403
7404   return TRUE;
7405 }
7406
7407 /* An absolute address consists of a section and an offset.  If the
7408    section is NULL, the offset itself is the address, otherwise, the
7409    address equals to LOAD_ADDRESS(section) + offset.  */
7410
7411 struct absaddr
7412 {
7413   unsigned short section;
7414   bfd_vma offset;
7415 };
7416
7417 #define ABSADDR(a) \
7418   ((a).section \
7419    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7420    : (a).offset)
7421
7422 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7423    name, if found, and the offset from the symbol to ADDR.  */
7424
7425 static void
7426 find_symbol_for_address (Filedata *          filedata,
7427                          Elf_Internal_Sym *  symtab,
7428                          unsigned long       nsyms,
7429                          const char *        strtab,
7430                          unsigned long       strtab_size,
7431                          struct absaddr      addr,
7432                          const char **       symname,
7433                          bfd_vma *           offset)
7434 {
7435   bfd_vma dist = 0x100000;
7436   Elf_Internal_Sym * sym;
7437   Elf_Internal_Sym * beg;
7438   Elf_Internal_Sym * end;
7439   Elf_Internal_Sym * best = NULL;
7440
7441   REMOVE_ARCH_BITS (addr.offset);
7442   beg = symtab;
7443   end = symtab + nsyms;
7444
7445   while (beg < end)
7446     {
7447       bfd_vma value;
7448
7449       sym = beg + (end - beg) / 2;
7450
7451       value = sym->st_value;
7452       REMOVE_ARCH_BITS (value);
7453
7454       if (sym->st_name != 0
7455           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7456           && addr.offset >= value
7457           && addr.offset - value < dist)
7458         {
7459           best = sym;
7460           dist = addr.offset - value;
7461           if (!dist)
7462             break;
7463         }
7464
7465       if (addr.offset < value)
7466         end = sym;
7467       else
7468         beg = sym + 1;
7469     }
7470
7471   if (best)
7472     {
7473       *symname = (best->st_name >= strtab_size
7474                   ? _("<corrupt>") : strtab + best->st_name);
7475       *offset = dist;
7476       return;
7477     }
7478
7479   *symname = NULL;
7480   *offset = addr.offset;
7481 }
7482
7483 static /* signed */ int
7484 symcmp (const void *p, const void *q)
7485 {
7486   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7487   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7488
7489   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7490 }
7491
7492 /* Process the unwind section.  */
7493
7494 #include "unwind-ia64.h"
7495
7496 struct ia64_unw_table_entry
7497 {
7498   struct absaddr start;
7499   struct absaddr end;
7500   struct absaddr info;
7501 };
7502
7503 struct ia64_unw_aux_info
7504 {
7505   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7506   unsigned long                 table_len;      /* Length of unwind table.  */
7507   unsigned char *               info;           /* Unwind info.  */
7508   unsigned long                 info_size;      /* Size of unwind info.  */
7509   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7510   bfd_vma                       seg_base;       /* Starting address of segment.  */
7511   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7512   unsigned long                 nsyms;          /* Number of symbols.  */
7513   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7514   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7515   char *                        strtab;         /* The string table.  */
7516   unsigned long                 strtab_size;    /* Size of string table.  */
7517 };
7518
7519 static bfd_boolean
7520 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7521 {
7522   struct ia64_unw_table_entry * tp;
7523   unsigned long j, nfuns;
7524   int in_body;
7525   bfd_boolean res = TRUE;
7526
7527   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7528   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7529     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7530       aux->funtab[nfuns++] = aux->symtab[j];
7531   aux->nfuns = nfuns;
7532   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7533
7534   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7535     {
7536       bfd_vma stamp;
7537       bfd_vma offset;
7538       const unsigned char * dp;
7539       const unsigned char * head;
7540       const unsigned char * end;
7541       const char * procname;
7542
7543       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7544                                aux->strtab_size, tp->start, &procname, &offset);
7545
7546       fputs ("\n<", stdout);
7547
7548       if (procname)
7549         {
7550           fputs (procname, stdout);
7551
7552           if (offset)
7553             printf ("+%lx", (unsigned long) offset);
7554         }
7555
7556       fputs (">: [", stdout);
7557       print_vma (tp->start.offset, PREFIX_HEX);
7558       fputc ('-', stdout);
7559       print_vma (tp->end.offset, PREFIX_HEX);
7560       printf ("], info at +0x%lx\n",
7561               (unsigned long) (tp->info.offset - aux->seg_base));
7562
7563       /* PR 17531: file: 86232b32.  */
7564       if (aux->info == NULL)
7565         continue;
7566
7567       /* PR 17531: file: 0997b4d1.  */
7568       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7569         {
7570           warn (_("Invalid offset %lx in table entry %ld\n"),
7571                 (long) tp->info.offset, (long) (tp - aux->table));
7572           res = FALSE;
7573           continue;
7574         }
7575
7576       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7577       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7578
7579       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7580               (unsigned) UNW_VER (stamp),
7581               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7582               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7583               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7584               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7585
7586       if (UNW_VER (stamp) != 1)
7587         {
7588           printf (_("\tUnknown version.\n"));
7589           continue;
7590         }
7591
7592       in_body = 0;
7593       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7594       /* PR 17531: file: 16ceda89.  */
7595       if (end > aux->info + aux->info_size)
7596         end = aux->info + aux->info_size;
7597       for (dp = head + 8; dp < end;)
7598         dp = unw_decode (dp, in_body, & in_body, end);
7599     }
7600
7601   free (aux->funtab);
7602
7603   return res;
7604 }
7605
7606 static bfd_boolean
7607 slurp_ia64_unwind_table (Filedata *                  filedata,
7608                          struct ia64_unw_aux_info *  aux,
7609                          Elf_Internal_Shdr *         sec)
7610 {
7611   unsigned long size, nrelas, i;
7612   Elf_Internal_Phdr * seg;
7613   struct ia64_unw_table_entry * tep;
7614   Elf_Internal_Shdr * relsec;
7615   Elf_Internal_Rela * rela;
7616   Elf_Internal_Rela * rp;
7617   unsigned char * table;
7618   unsigned char * tp;
7619   Elf_Internal_Sym * sym;
7620   const char * relname;
7621
7622   aux->table_len = 0;
7623
7624   /* First, find the starting address of the segment that includes
7625      this section: */
7626
7627   if (filedata->file_header.e_phnum)
7628     {
7629       if (! get_program_headers (filedata))
7630           return FALSE;
7631
7632       for (seg = filedata->program_headers;
7633            seg < filedata->program_headers + filedata->file_header.e_phnum;
7634            ++seg)
7635         {
7636           if (seg->p_type != PT_LOAD)
7637             continue;
7638
7639           if (sec->sh_addr >= seg->p_vaddr
7640               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7641             {
7642               aux->seg_base = seg->p_vaddr;
7643               break;
7644             }
7645         }
7646     }
7647
7648   /* Second, build the unwind table from the contents of the unwind section:  */
7649   size = sec->sh_size;
7650   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7651                                       _("unwind table"));
7652   if (!table)
7653     return FALSE;
7654
7655   aux->table_len = size / (3 * eh_addr_size);
7656   aux->table = (struct ia64_unw_table_entry *)
7657     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7658   tep = aux->table;
7659
7660   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7661     {
7662       tep->start.section = SHN_UNDEF;
7663       tep->end.section   = SHN_UNDEF;
7664       tep->info.section  = SHN_UNDEF;
7665       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7666       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7667       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7668       tep->start.offset += aux->seg_base;
7669       tep->end.offset   += aux->seg_base;
7670       tep->info.offset  += aux->seg_base;
7671     }
7672   free (table);
7673
7674   /* Third, apply any relocations to the unwind table:  */
7675   for (relsec = filedata->section_headers;
7676        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7677        ++relsec)
7678     {
7679       if (relsec->sh_type != SHT_RELA
7680           || relsec->sh_info >= filedata->file_header.e_shnum
7681           || filedata->section_headers + relsec->sh_info != sec)
7682         continue;
7683
7684       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7685                               & rela, & nrelas))
7686         {
7687           free (aux->table);
7688           aux->table = NULL;
7689           aux->table_len = 0;
7690           return FALSE;
7691         }
7692
7693       for (rp = rela; rp < rela + nrelas; ++rp)
7694         {
7695           unsigned int sym_ndx;
7696           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7697           relname = elf_ia64_reloc_type (r_type);
7698
7699           /* PR 17531: file: 9fa67536.  */
7700           if (relname == NULL)
7701             {
7702               warn (_("Skipping unknown relocation type: %u\n"), r_type);
7703               continue;
7704             }
7705
7706           if (! const_strneq (relname, "R_IA64_SEGREL"))
7707             {
7708               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7709               continue;
7710             }
7711
7712           i = rp->r_offset / (3 * eh_addr_size);
7713
7714           /* PR 17531: file: 5bc8d9bf.  */
7715           if (i >= aux->table_len)
7716             {
7717               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7718               continue;
7719             }
7720
7721           sym_ndx = get_reloc_symindex (rp->r_info);
7722           if (sym_ndx >= aux->nsyms)
7723             {
7724               warn (_("Skipping reloc with invalid symbol index: %u\n"),
7725                     sym_ndx);
7726               continue;
7727             }
7728           sym = aux->symtab + sym_ndx;
7729
7730           switch (rp->r_offset / eh_addr_size % 3)
7731             {
7732             case 0:
7733               aux->table[i].start.section = sym->st_shndx;
7734               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7735               break;
7736             case 1:
7737               aux->table[i].end.section   = sym->st_shndx;
7738               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7739               break;
7740             case 2:
7741               aux->table[i].info.section  = sym->st_shndx;
7742               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7743               break;
7744             default:
7745               break;
7746             }
7747         }
7748
7749       free (rela);
7750     }
7751
7752   return TRUE;
7753 }
7754
7755 static bfd_boolean
7756 ia64_process_unwind (Filedata * filedata)
7757 {
7758   Elf_Internal_Shdr * sec;
7759   Elf_Internal_Shdr * unwsec = NULL;
7760   Elf_Internal_Shdr * strsec;
7761   unsigned long i, unwcount = 0, unwstart = 0;
7762   struct ia64_unw_aux_info aux;
7763   bfd_boolean res = TRUE;
7764
7765   memset (& aux, 0, sizeof (aux));
7766
7767   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7768     {
7769       if (sec->sh_type == SHT_SYMTAB
7770           && sec->sh_link < filedata->file_header.e_shnum)
7771         {
7772           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7773
7774           strsec = filedata->section_headers + sec->sh_link;
7775           if (aux.strtab != NULL)
7776             {
7777               error (_("Multiple auxillary string tables encountered\n"));
7778               free (aux.strtab);
7779               res = FALSE;
7780             }
7781           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7782                                           1, strsec->sh_size,
7783                                           _("string table"));
7784           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7785         }
7786       else if (sec->sh_type == SHT_IA_64_UNWIND)
7787         unwcount++;
7788     }
7789
7790   if (!unwcount)
7791     printf (_("\nThere are no unwind sections in this file.\n"));
7792
7793   while (unwcount-- > 0)
7794     {
7795       char * suffix;
7796       size_t len, len2;
7797
7798       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7799            i < filedata->file_header.e_shnum; ++i, ++sec)
7800         if (sec->sh_type == SHT_IA_64_UNWIND)
7801           {
7802             unwsec = sec;
7803             break;
7804           }
7805       /* We have already counted the number of SHT_IA64_UNWIND
7806          sections so the loop above should never fail.  */
7807       assert (unwsec != NULL);
7808
7809       unwstart = i + 1;
7810       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7811
7812       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7813         {
7814           /* We need to find which section group it is in.  */
7815           struct group_list * g;
7816
7817           if (section_headers_groups == NULL
7818               || section_headers_groups [i] == NULL)
7819             i = filedata->file_header.e_shnum;
7820           else
7821             {
7822               g = section_headers_groups [i]->root;
7823
7824               for (; g != NULL; g = g->next)
7825                 {
7826                   sec = filedata->section_headers + g->section_index;
7827
7828                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7829                     break;
7830                 }
7831
7832               if (g == NULL)
7833                 i = filedata->file_header.e_shnum;
7834             }
7835         }
7836       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7837         {
7838           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7839           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7840           suffix = SECTION_NAME (unwsec) + len;
7841           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7842                ++i, ++sec)
7843             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7844                 && streq (SECTION_NAME (sec) + len2, suffix))
7845               break;
7846         }
7847       else
7848         {
7849           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7850              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7851           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7852           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7853           suffix = "";
7854           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7855             suffix = SECTION_NAME (unwsec) + len;
7856           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7857                ++i, ++sec)
7858             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7859                 && streq (SECTION_NAME (sec) + len2, suffix))
7860               break;
7861         }
7862
7863       if (i == filedata->file_header.e_shnum)
7864         {
7865           printf (_("\nCould not find unwind info section for "));
7866
7867           if (filedata->string_table == NULL)
7868             printf ("%d", unwsec->sh_name);
7869           else
7870             printf ("'%s'", printable_section_name (filedata, unwsec));
7871         }
7872       else
7873         {
7874           aux.info_addr = sec->sh_addr;
7875           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7876                                                  sec->sh_size,
7877                                                  _("unwind info"));
7878           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7879
7880           printf (_("\nUnwind section "));
7881
7882           if (filedata->string_table == NULL)
7883             printf ("%d", unwsec->sh_name);
7884           else
7885             printf ("'%s'", printable_section_name (filedata, unwsec));
7886
7887           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7888                   (unsigned long) unwsec->sh_offset,
7889                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7890
7891           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7892               && aux.table_len > 0)
7893             dump_ia64_unwind (filedata, & aux);
7894
7895           if (aux.table)
7896             free ((char *) aux.table);
7897           if (aux.info)
7898             free ((char *) aux.info);
7899           aux.table = NULL;
7900           aux.info = NULL;
7901         }
7902     }
7903
7904   if (aux.symtab)
7905     free (aux.symtab);
7906   if (aux.strtab)
7907     free ((char *) aux.strtab);
7908
7909   return res;
7910 }
7911
7912 struct hppa_unw_table_entry
7913 {
7914   struct absaddr start;
7915   struct absaddr end;
7916   unsigned int Cannot_unwind:1;                 /* 0 */
7917   unsigned int Millicode:1;                     /* 1 */
7918   unsigned int Millicode_save_sr0:1;            /* 2 */
7919   unsigned int Region_description:2;            /* 3..4 */
7920   unsigned int reserved1:1;                     /* 5 */
7921   unsigned int Entry_SR:1;                      /* 6 */
7922   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7923   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7924   unsigned int Args_stored:1;                   /* 16 */
7925   unsigned int Variable_Frame:1;                /* 17 */
7926   unsigned int Separate_Package_Body:1;         /* 18 */
7927   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7928   unsigned int Stack_Overflow_Check:1;          /* 20 */
7929   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7930   unsigned int Ada_Region:1;                    /* 22 */
7931   unsigned int cxx_info:1;                      /* 23 */
7932   unsigned int cxx_try_catch:1;                 /* 24 */
7933   unsigned int sched_entry_seq:1;               /* 25 */
7934   unsigned int reserved2:1;                     /* 26 */
7935   unsigned int Save_SP:1;                       /* 27 */
7936   unsigned int Save_RP:1;                       /* 28 */
7937   unsigned int Save_MRP_in_frame:1;             /* 29 */
7938   unsigned int extn_ptr_defined:1;              /* 30 */
7939   unsigned int Cleanup_defined:1;               /* 31 */
7940
7941   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7942   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7943   unsigned int Large_frame:1;                   /* 2 */
7944   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7945   unsigned int reserved4:1;                     /* 4 */
7946   unsigned int Total_frame_size:27;             /* 5..31 */
7947 };
7948
7949 struct hppa_unw_aux_info
7950 {
7951   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7952   unsigned long                  table_len;     /* Length of unwind table.  */
7953   bfd_vma                        seg_base;      /* Starting address of segment.  */
7954   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7955   unsigned long                  nsyms;         /* Number of symbols.  */
7956   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7957   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7958   char *                         strtab;        /* The string table.  */
7959   unsigned long                  strtab_size;   /* Size of string table.  */
7960 };
7961
7962 static bfd_boolean
7963 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7964 {
7965   struct hppa_unw_table_entry * tp;
7966   unsigned long j, nfuns;
7967   bfd_boolean res = TRUE;
7968
7969   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7970   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7971     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7972       aux->funtab[nfuns++] = aux->symtab[j];
7973   aux->nfuns = nfuns;
7974   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7975
7976   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7977     {
7978       bfd_vma offset;
7979       const char * procname;
7980
7981       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7982                                aux->strtab_size, tp->start, &procname,
7983                                &offset);
7984
7985       fputs ("\n<", stdout);
7986
7987       if (procname)
7988         {
7989           fputs (procname, stdout);
7990
7991           if (offset)
7992             printf ("+%lx", (unsigned long) offset);
7993         }
7994
7995       fputs (">: [", stdout);
7996       print_vma (tp->start.offset, PREFIX_HEX);
7997       fputc ('-', stdout);
7998       print_vma (tp->end.offset, PREFIX_HEX);
7999       printf ("]\n\t");
8000
8001 #define PF(_m) if (tp->_m) printf (#_m " ");
8002 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8003       PF(Cannot_unwind);
8004       PF(Millicode);
8005       PF(Millicode_save_sr0);
8006       /* PV(Region_description);  */
8007       PF(Entry_SR);
8008       PV(Entry_FR);
8009       PV(Entry_GR);
8010       PF(Args_stored);
8011       PF(Variable_Frame);
8012       PF(Separate_Package_Body);
8013       PF(Frame_Extension_Millicode);
8014       PF(Stack_Overflow_Check);
8015       PF(Two_Instruction_SP_Increment);
8016       PF(Ada_Region);
8017       PF(cxx_info);
8018       PF(cxx_try_catch);
8019       PF(sched_entry_seq);
8020       PF(Save_SP);
8021       PF(Save_RP);
8022       PF(Save_MRP_in_frame);
8023       PF(extn_ptr_defined);
8024       PF(Cleanup_defined);
8025       PF(MPE_XL_interrupt_marker);
8026       PF(HP_UX_interrupt_marker);
8027       PF(Large_frame);
8028       PF(Pseudo_SP_Set);
8029       PV(Total_frame_size);
8030 #undef PF
8031 #undef PV
8032     }
8033
8034   printf ("\n");
8035
8036   free (aux->funtab);
8037
8038   return res;
8039 }
8040
8041 static bfd_boolean
8042 slurp_hppa_unwind_table (Filedata *                  filedata,
8043                          struct hppa_unw_aux_info *  aux,
8044                          Elf_Internal_Shdr *         sec)
8045 {
8046   unsigned long size, unw_ent_size, nentries, nrelas, i;
8047   Elf_Internal_Phdr * seg;
8048   struct hppa_unw_table_entry * tep;
8049   Elf_Internal_Shdr * relsec;
8050   Elf_Internal_Rela * rela;
8051   Elf_Internal_Rela * rp;
8052   unsigned char * table;
8053   unsigned char * tp;
8054   Elf_Internal_Sym * sym;
8055   const char * relname;
8056
8057   /* First, find the starting address of the segment that includes
8058      this section.  */
8059   if (filedata->file_header.e_phnum)
8060     {
8061       if (! get_program_headers (filedata))
8062         return FALSE;
8063
8064       for (seg = filedata->program_headers;
8065            seg < filedata->program_headers + filedata->file_header.e_phnum;
8066            ++seg)
8067         {
8068           if (seg->p_type != PT_LOAD)
8069             continue;
8070
8071           if (sec->sh_addr >= seg->p_vaddr
8072               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
8073             {
8074               aux->seg_base = seg->p_vaddr;
8075               break;
8076             }
8077         }
8078     }
8079
8080   /* Second, build the unwind table from the contents of the unwind
8081      section.  */
8082   size = sec->sh_size;
8083   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
8084                                       _("unwind table"));
8085   if (!table)
8086     return FALSE;
8087
8088   unw_ent_size = 16;
8089   nentries = size / unw_ent_size;
8090   size = unw_ent_size * nentries;
8091
8092   tep = aux->table = (struct hppa_unw_table_entry *)
8093       xcmalloc (nentries, sizeof (aux->table[0]));
8094
8095   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8096     {
8097       unsigned int tmp1, tmp2;
8098
8099       tep->start.section = SHN_UNDEF;
8100       tep->end.section   = SHN_UNDEF;
8101
8102       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8103       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8104       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8105       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8106
8107       tep->start.offset += aux->seg_base;
8108       tep->end.offset   += aux->seg_base;
8109
8110       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8111       tep->Millicode = (tmp1 >> 30) & 0x1;
8112       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8113       tep->Region_description = (tmp1 >> 27) & 0x3;
8114       tep->reserved1 = (tmp1 >> 26) & 0x1;
8115       tep->Entry_SR = (tmp1 >> 25) & 0x1;
8116       tep->Entry_FR = (tmp1 >> 21) & 0xf;
8117       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8118       tep->Args_stored = (tmp1 >> 15) & 0x1;
8119       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8120       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8121       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8122       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8123       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8124       tep->Ada_Region = (tmp1 >> 9) & 0x1;
8125       tep->cxx_info = (tmp1 >> 8) & 0x1;
8126       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8127       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8128       tep->reserved2 = (tmp1 >> 5) & 0x1;
8129       tep->Save_SP = (tmp1 >> 4) & 0x1;
8130       tep->Save_RP = (tmp1 >> 3) & 0x1;
8131       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8132       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8133       tep->Cleanup_defined = tmp1 & 0x1;
8134
8135       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8136       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8137       tep->Large_frame = (tmp2 >> 29) & 0x1;
8138       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8139       tep->reserved4 = (tmp2 >> 27) & 0x1;
8140       tep->Total_frame_size = tmp2 & 0x7ffffff;
8141     }
8142   free (table);
8143
8144   /* Third, apply any relocations to the unwind table.  */
8145   for (relsec = filedata->section_headers;
8146        relsec < filedata->section_headers + filedata->file_header.e_shnum;
8147        ++relsec)
8148     {
8149       if (relsec->sh_type != SHT_RELA
8150           || relsec->sh_info >= filedata->file_header.e_shnum
8151           || filedata->section_headers + relsec->sh_info != sec)
8152         continue;
8153
8154       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8155                               & rela, & nrelas))
8156         return FALSE;
8157
8158       for (rp = rela; rp < rela + nrelas; ++rp)
8159         {
8160           unsigned int sym_ndx;
8161           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8162           relname = elf_hppa_reloc_type (r_type);
8163
8164           if (relname == NULL)
8165             {
8166               warn (_("Skipping unknown relocation type: %u\n"), r_type);
8167               continue;
8168             }
8169
8170           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
8171           if (! const_strneq (relname, "R_PARISC_SEGREL"))
8172             {
8173               warn (_("Skipping unexpected relocation type: %s\n"), relname);
8174               continue;
8175             }
8176
8177           i = rp->r_offset / unw_ent_size;
8178           if (i >= aux->table_len)
8179             {
8180               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8181               continue;
8182             }
8183
8184           sym_ndx = get_reloc_symindex (rp->r_info);
8185           if (sym_ndx >= aux->nsyms)
8186             {
8187               warn (_("Skipping reloc with invalid symbol index: %u\n"),
8188                     sym_ndx);
8189               continue;
8190             }
8191           sym = aux->symtab + sym_ndx;
8192
8193           switch ((rp->r_offset % unw_ent_size) / 4)
8194             {
8195             case 0:
8196               aux->table[i].start.section = sym->st_shndx;
8197               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
8198               break;
8199             case 1:
8200               aux->table[i].end.section   = sym->st_shndx;
8201               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
8202               break;
8203             default:
8204               break;
8205             }
8206         }
8207
8208       free (rela);
8209     }
8210
8211   aux->table_len = nentries;
8212
8213   return TRUE;
8214 }
8215
8216 static bfd_boolean
8217 hppa_process_unwind (Filedata * filedata)
8218 {
8219   struct hppa_unw_aux_info aux;
8220   Elf_Internal_Shdr * unwsec = NULL;
8221   Elf_Internal_Shdr * strsec;
8222   Elf_Internal_Shdr * sec;
8223   unsigned long i;
8224   bfd_boolean res = TRUE;
8225
8226   if (filedata->string_table == NULL)
8227     return FALSE;
8228
8229   memset (& aux, 0, sizeof (aux));
8230
8231   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8232     {
8233       if (sec->sh_type == SHT_SYMTAB
8234           && sec->sh_link < filedata->file_header.e_shnum)
8235         {
8236           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8237
8238           strsec = filedata->section_headers + sec->sh_link;
8239           if (aux.strtab != NULL)
8240             {
8241               error (_("Multiple auxillary string tables encountered\n"));
8242               free (aux.strtab);
8243               res = FALSE;
8244             }
8245           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8246                                           1, strsec->sh_size,
8247                                           _("string table"));
8248           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8249         }
8250       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8251         unwsec = sec;
8252     }
8253
8254   if (!unwsec)
8255     printf (_("\nThere are no unwind sections in this file.\n"));
8256
8257   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8258     {
8259       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8260         {
8261           unsigned long num_unwind = sec->sh_size / 16;
8262
8263           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8264                             "contains %lu entry:\n",
8265                             "\nUnwind section '%s' at offset 0x%lx "
8266                             "contains %lu entries:\n",
8267                             num_unwind),
8268                   printable_section_name (filedata, sec),
8269                   (unsigned long) sec->sh_offset,
8270                   num_unwind);
8271
8272           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8273             res = FALSE;
8274
8275           if (res && aux.table_len > 0)
8276             {
8277               if (! dump_hppa_unwind (filedata, &aux))
8278                 res = FALSE;
8279             }
8280
8281           if (aux.table)
8282             free ((char *) aux.table);
8283           aux.table = NULL;
8284         }
8285     }
8286
8287   if (aux.symtab)
8288     free (aux.symtab);
8289   if (aux.strtab)
8290     free ((char *) aux.strtab);
8291
8292   return res;
8293 }
8294
8295 struct arm_section
8296 {
8297   unsigned char *      data;            /* The unwind data.  */
8298   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8299   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8300   unsigned long        nrelas;          /* The number of relocations.  */
8301   unsigned int         rel_type;        /* REL or RELA ?  */
8302   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8303 };
8304
8305 struct arm_unw_aux_info
8306 {
8307   Filedata *          filedata;         /* The file containing the unwind sections.  */
8308   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8309   unsigned long       nsyms;            /* Number of symbols.  */
8310   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8311   unsigned long       nfuns;            /* Number of these symbols.  */
8312   char *              strtab;           /* The file's string table.  */
8313   unsigned long       strtab_size;      /* Size of string table.  */
8314 };
8315
8316 static const char *
8317 arm_print_vma_and_name (Filedata *                 filedata,
8318                         struct arm_unw_aux_info *  aux,
8319                         bfd_vma                    fn,
8320                         struct absaddr             addr)
8321 {
8322   const char *procname;
8323   bfd_vma sym_offset;
8324
8325   if (addr.section == SHN_UNDEF)
8326     addr.offset = fn;
8327
8328   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8329                            aux->strtab_size, addr, &procname,
8330                            &sym_offset);
8331
8332   print_vma (fn, PREFIX_HEX);
8333
8334   if (procname)
8335     {
8336       fputs (" <", stdout);
8337       fputs (procname, stdout);
8338
8339       if (sym_offset)
8340         printf ("+0x%lx", (unsigned long) sym_offset);
8341       fputc ('>', stdout);
8342     }
8343
8344   return procname;
8345 }
8346
8347 static void
8348 arm_free_section (struct arm_section *arm_sec)
8349 {
8350   if (arm_sec->data != NULL)
8351     free (arm_sec->data);
8352
8353   if (arm_sec->rela != NULL)
8354     free (arm_sec->rela);
8355 }
8356
8357 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8358       cached section and install SEC instead.
8359    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8360       and return its valued in * WORDP, relocating if necessary.
8361    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8362       relocation's offset in ADDR.
8363    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8364       into the string table of the symbol associated with the reloc.  If no
8365       reloc was applied store -1 there.
8366    5) Return TRUE upon success, FALSE otherwise.  */
8367
8368 static bfd_boolean
8369 get_unwind_section_word (Filedata *                 filedata,
8370                          struct arm_unw_aux_info *  aux,
8371                          struct arm_section *       arm_sec,
8372                          Elf_Internal_Shdr *        sec,
8373                          bfd_vma                    word_offset,
8374                          unsigned int *             wordp,
8375                          struct absaddr *           addr,
8376                          bfd_vma *                  sym_name)
8377 {
8378   Elf_Internal_Rela *rp;
8379   Elf_Internal_Sym *sym;
8380   const char * relname;
8381   unsigned int word;
8382   bfd_boolean wrapped;
8383
8384   if (sec == NULL || arm_sec == NULL)
8385     return FALSE;
8386
8387   addr->section = SHN_UNDEF;
8388   addr->offset = 0;
8389
8390   if (sym_name != NULL)
8391     *sym_name = (bfd_vma) -1;
8392
8393   /* If necessary, update the section cache.  */
8394   if (sec != arm_sec->sec)
8395     {
8396       Elf_Internal_Shdr *relsec;
8397
8398       arm_free_section (arm_sec);
8399
8400       arm_sec->sec = sec;
8401       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8402                                 sec->sh_size, _("unwind data"));
8403       arm_sec->rela = NULL;
8404       arm_sec->nrelas = 0;
8405
8406       for (relsec = filedata->section_headers;
8407            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8408            ++relsec)
8409         {
8410           if (relsec->sh_info >= filedata->file_header.e_shnum
8411               || filedata->section_headers + relsec->sh_info != sec
8412               /* PR 15745: Check the section type as well.  */
8413               || (relsec->sh_type != SHT_REL
8414                   && relsec->sh_type != SHT_RELA))
8415             continue;
8416
8417           arm_sec->rel_type = relsec->sh_type;
8418           if (relsec->sh_type == SHT_REL)
8419             {
8420               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8421                                      relsec->sh_size,
8422                                      & arm_sec->rela, & arm_sec->nrelas))
8423                 return FALSE;
8424             }
8425           else /* relsec->sh_type == SHT_RELA */
8426             {
8427               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8428                                       relsec->sh_size,
8429                                       & arm_sec->rela, & arm_sec->nrelas))
8430                 return FALSE;
8431             }
8432           break;
8433         }
8434
8435       arm_sec->next_rela = arm_sec->rela;
8436     }
8437
8438   /* If there is no unwind data we can do nothing.  */
8439   if (arm_sec->data == NULL)
8440     return FALSE;
8441
8442   /* If the offset is invalid then fail.  */
8443   if (/* PR 21343 *//* PR 18879 */
8444       sec->sh_size < 4
8445       || word_offset > (sec->sh_size - 4)
8446       || ((bfd_signed_vma) word_offset) < 0)
8447     return FALSE;
8448
8449   /* Get the word at the required offset.  */
8450   word = byte_get (arm_sec->data + word_offset, 4);
8451
8452   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8453   if (arm_sec->rela == NULL)
8454     {
8455       * wordp = word;
8456       return TRUE;
8457     }
8458
8459   /* Look through the relocs to find the one that applies to the provided offset.  */
8460   wrapped = FALSE;
8461   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8462     {
8463       bfd_vma prelval, offset;
8464
8465       if (rp->r_offset > word_offset && !wrapped)
8466         {
8467           rp = arm_sec->rela;
8468           wrapped = TRUE;
8469         }
8470       if (rp->r_offset > word_offset)
8471         break;
8472
8473       if (rp->r_offset & 3)
8474         {
8475           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8476                 (unsigned long) rp->r_offset);
8477           continue;
8478         }
8479
8480       if (rp->r_offset < word_offset)
8481         continue;
8482
8483       /* PR 17531: file: 027-161405-0.004  */
8484       if (aux->symtab == NULL)
8485         continue;
8486
8487       if (arm_sec->rel_type == SHT_REL)
8488         {
8489           offset = word & 0x7fffffff;
8490           if (offset & 0x40000000)
8491             offset |= ~ (bfd_vma) 0x7fffffff;
8492         }
8493       else if (arm_sec->rel_type == SHT_RELA)
8494         offset = rp->r_addend;
8495       else
8496         {
8497           error (_("Unknown section relocation type %d encountered\n"),
8498                  arm_sec->rel_type);
8499           break;
8500         }
8501
8502       /* PR 17531 file: 027-1241568-0.004.  */
8503       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8504         {
8505           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8506                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8507           break;
8508         }
8509
8510       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8511       offset += sym->st_value;
8512       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8513
8514       /* Check that we are processing the expected reloc type.  */
8515       if (filedata->file_header.e_machine == EM_ARM)
8516         {
8517           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8518           if (relname == NULL)
8519             {
8520               warn (_("Skipping unknown ARM relocation type: %d\n"),
8521                     (int) ELF32_R_TYPE (rp->r_info));
8522               continue;
8523             }
8524
8525           if (streq (relname, "R_ARM_NONE"))
8526               continue;
8527
8528           if (! streq (relname, "R_ARM_PREL31"))
8529             {
8530               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8531               continue;
8532             }
8533         }
8534       else if (filedata->file_header.e_machine == EM_TI_C6000)
8535         {
8536           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8537           if (relname == NULL)
8538             {
8539               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8540                     (int) ELF32_R_TYPE (rp->r_info));
8541               continue;
8542             }
8543
8544           if (streq (relname, "R_C6000_NONE"))
8545             continue;
8546
8547           if (! streq (relname, "R_C6000_PREL31"))
8548             {
8549               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8550               continue;
8551             }
8552
8553           prelval >>= 1;
8554         }
8555       else
8556         {
8557           /* This function currently only supports ARM and TI unwinders.  */
8558           warn (_("Only TI and ARM unwinders are currently supported\n"));
8559           break;
8560         }
8561
8562       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8563       addr->section = sym->st_shndx;
8564       addr->offset = offset;
8565
8566       if (sym_name)
8567         * sym_name = sym->st_name;
8568       break;
8569     }
8570
8571   *wordp = word;
8572   arm_sec->next_rela = rp;
8573
8574   return TRUE;
8575 }
8576
8577 static const char *tic6x_unwind_regnames[16] =
8578 {
8579   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8580   "A14", "A13", "A12", "A11", "A10",
8581   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8582 };
8583
8584 static void
8585 decode_tic6x_unwind_regmask (unsigned int mask)
8586 {
8587   int i;
8588
8589   for (i = 12; mask; mask >>= 1, i--)
8590     {
8591       if (mask & 1)
8592         {
8593           fputs (tic6x_unwind_regnames[i], stdout);
8594           if (mask > 1)
8595             fputs (", ", stdout);
8596         }
8597     }
8598 }
8599
8600 #define ADVANCE                                                 \
8601   if (remaining == 0 && more_words)                             \
8602     {                                                           \
8603       data_offset += 4;                                         \
8604       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8605                                      data_offset, & word, & addr, NULL))        \
8606         return FALSE;                                           \
8607       remaining = 4;                                            \
8608       more_words--;                                             \
8609     }                                                           \
8610
8611 #define GET_OP(OP)                      \
8612   ADVANCE;                              \
8613   if (remaining)                        \
8614     {                                   \
8615       remaining--;                      \
8616       (OP) = word >> 24;                \
8617       word <<= 8;                       \
8618     }                                   \
8619   else                                  \
8620     {                                   \
8621       printf (_("[Truncated opcode]\n"));       \
8622       return FALSE;                     \
8623     }                                   \
8624   printf ("0x%02x ", OP)
8625
8626 static bfd_boolean
8627 decode_arm_unwind_bytecode (Filedata *                 filedata,
8628                             struct arm_unw_aux_info *  aux,
8629                             unsigned int               word,
8630                             unsigned int               remaining,
8631                             unsigned int               more_words,
8632                             bfd_vma                    data_offset,
8633                             Elf_Internal_Shdr *        data_sec,
8634                             struct arm_section *       data_arm_sec)
8635 {
8636   struct absaddr addr;
8637   bfd_boolean res = TRUE;
8638
8639   /* Decode the unwinding instructions.  */
8640   while (1)
8641     {
8642       unsigned int op, op2;
8643
8644       ADVANCE;
8645       if (remaining == 0)
8646         break;
8647       remaining--;
8648       op = word >> 24;
8649       word <<= 8;
8650
8651       printf ("  0x%02x ", op);
8652
8653       if ((op & 0xc0) == 0x00)
8654         {
8655           int offset = ((op & 0x3f) << 2) + 4;
8656
8657           printf ("     vsp = vsp + %d", offset);
8658         }
8659       else if ((op & 0xc0) == 0x40)
8660         {
8661           int offset = ((op & 0x3f) << 2) + 4;
8662
8663           printf ("     vsp = vsp - %d", offset);
8664         }
8665       else if ((op & 0xf0) == 0x80)
8666         {
8667           GET_OP (op2);
8668           if (op == 0x80 && op2 == 0)
8669             printf (_("Refuse to unwind"));
8670           else
8671             {
8672               unsigned int mask = ((op & 0x0f) << 8) | op2;
8673               bfd_boolean first = TRUE;
8674               int i;
8675
8676               printf ("pop {");
8677               for (i = 0; i < 12; i++)
8678                 if (mask & (1 << i))
8679                   {
8680                     if (first)
8681                       first = FALSE;
8682                     else
8683                       printf (", ");
8684                     printf ("r%d", 4 + i);
8685                   }
8686               printf ("}");
8687             }
8688         }
8689       else if ((op & 0xf0) == 0x90)
8690         {
8691           if (op == 0x9d || op == 0x9f)
8692             printf (_("     [Reserved]"));
8693           else
8694             printf ("     vsp = r%d", op & 0x0f);
8695         }
8696       else if ((op & 0xf0) == 0xa0)
8697         {
8698           int end = 4 + (op & 0x07);
8699           bfd_boolean first = TRUE;
8700           int i;
8701
8702           printf ("     pop {");
8703           for (i = 4; i <= end; i++)
8704             {
8705               if (first)
8706                 first = FALSE;
8707               else
8708                 printf (", ");
8709               printf ("r%d", i);
8710             }
8711           if (op & 0x08)
8712             {
8713               if (!first)
8714                 printf (", ");
8715               printf ("r14");
8716             }
8717           printf ("}");
8718         }
8719       else if (op == 0xb0)
8720         printf (_("     finish"));
8721       else if (op == 0xb1)
8722         {
8723           GET_OP (op2);
8724           if (op2 == 0 || (op2 & 0xf0) != 0)
8725             printf (_("[Spare]"));
8726           else
8727             {
8728               unsigned int mask = op2 & 0x0f;
8729               bfd_boolean first = TRUE;
8730               int i;
8731
8732               printf ("pop {");
8733               for (i = 0; i < 12; i++)
8734                 if (mask & (1 << i))
8735                   {
8736                     if (first)
8737                       first = FALSE;
8738                     else
8739                       printf (", ");
8740                     printf ("r%d", i);
8741                   }
8742               printf ("}");
8743             }
8744         }
8745       else if (op == 0xb2)
8746         {
8747           unsigned char buf[9];
8748           unsigned int i, len;
8749           unsigned long offset;
8750
8751           for (i = 0; i < sizeof (buf); i++)
8752             {
8753               GET_OP (buf[i]);
8754               if ((buf[i] & 0x80) == 0)
8755                 break;
8756             }
8757           if (i == sizeof (buf))
8758             {
8759               error (_("corrupt change to vsp"));
8760               res = FALSE;
8761             }
8762           else
8763             {
8764               offset = read_uleb128 (buf, &len, buf + i + 1);
8765               assert (len == i + 1);
8766               offset = offset * 4 + 0x204;
8767               printf ("vsp = vsp + %ld", offset);
8768             }
8769         }
8770       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8771         {
8772           unsigned int first, last;
8773
8774           GET_OP (op2);
8775           first = op2 >> 4;
8776           last = op2 & 0x0f;
8777           if (op == 0xc8)
8778             first = first + 16;
8779           printf ("pop {D%d", first);
8780           if (last)
8781             printf ("-D%d", first + last);
8782           printf ("}");
8783         }
8784       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8785         {
8786           unsigned int count = op & 0x07;
8787
8788           printf ("pop {D8");
8789           if (count)
8790             printf ("-D%d", 8 + count);
8791           printf ("}");
8792         }
8793       else if (op >= 0xc0 && op <= 0xc5)
8794         {
8795           unsigned int count = op & 0x07;
8796
8797           printf ("     pop {wR10");
8798           if (count)
8799             printf ("-wR%d", 10 + count);
8800           printf ("}");
8801         }
8802       else if (op == 0xc6)
8803         {
8804           unsigned int first, last;
8805
8806           GET_OP (op2);
8807           first = op2 >> 4;
8808           last = op2 & 0x0f;
8809           printf ("pop {wR%d", first);
8810           if (last)
8811             printf ("-wR%d", first + last);
8812           printf ("}");
8813         }
8814       else if (op == 0xc7)
8815         {
8816           GET_OP (op2);
8817           if (op2 == 0 || (op2 & 0xf0) != 0)
8818             printf (_("[Spare]"));
8819           else
8820             {
8821               unsigned int mask = op2 & 0x0f;
8822               bfd_boolean first = TRUE;
8823               int i;
8824
8825               printf ("pop {");
8826               for (i = 0; i < 4; i++)
8827                 if (mask & (1 << i))
8828                   {
8829                     if (first)
8830                       first = FALSE;
8831                     else
8832                       printf (", ");
8833                     printf ("wCGR%d", i);
8834                   }
8835               printf ("}");
8836             }
8837         }
8838       else
8839         {
8840           printf (_("     [unsupported opcode]"));
8841           res = FALSE;
8842         }
8843
8844       printf ("\n");
8845     }
8846
8847   return res;
8848 }
8849
8850 static bfd_boolean
8851 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8852                               struct arm_unw_aux_info *  aux,
8853                               unsigned int               word,
8854                               unsigned int               remaining,
8855                               unsigned int               more_words,
8856                               bfd_vma                    data_offset,
8857                               Elf_Internal_Shdr *        data_sec,
8858                               struct arm_section *       data_arm_sec)
8859 {
8860   struct absaddr addr;
8861
8862   /* Decode the unwinding instructions.  */
8863   while (1)
8864     {
8865       unsigned int op, op2;
8866
8867       ADVANCE;
8868       if (remaining == 0)
8869         break;
8870       remaining--;
8871       op = word >> 24;
8872       word <<= 8;
8873
8874       printf ("  0x%02x ", op);
8875
8876       if ((op & 0xc0) == 0x00)
8877         {
8878           int offset = ((op & 0x3f) << 3) + 8;
8879           printf ("     sp = sp + %d", offset);
8880         }
8881       else if ((op & 0xc0) == 0x80)
8882         {
8883           GET_OP (op2);
8884           if (op == 0x80 && op2 == 0)
8885             printf (_("Refuse to unwind"));
8886           else
8887             {
8888               unsigned int mask = ((op & 0x1f) << 8) | op2;
8889               if (op & 0x20)
8890                 printf ("pop compact {");
8891               else
8892                 printf ("pop {");
8893
8894               decode_tic6x_unwind_regmask (mask);
8895               printf("}");
8896             }
8897         }
8898       else if ((op & 0xf0) == 0xc0)
8899         {
8900           unsigned int reg;
8901           unsigned int nregs;
8902           unsigned int i;
8903           const char *name;
8904           struct
8905           {
8906             unsigned int offset;
8907             unsigned int reg;
8908           } regpos[16];
8909
8910           /* Scan entire instruction first so that GET_OP output is not
8911              interleaved with disassembly.  */
8912           nregs = 0;
8913           for (i = 0; nregs < (op & 0xf); i++)
8914             {
8915               GET_OP (op2);
8916               reg = op2 >> 4;
8917               if (reg != 0xf)
8918                 {
8919                   regpos[nregs].offset = i * 2;
8920                   regpos[nregs].reg = reg;
8921                   nregs++;
8922                 }
8923
8924               reg = op2 & 0xf;
8925               if (reg != 0xf)
8926                 {
8927                   regpos[nregs].offset = i * 2 + 1;
8928                   regpos[nregs].reg = reg;
8929                   nregs++;
8930                 }
8931             }
8932
8933           printf (_("pop frame {"));
8934           if (nregs == 0)
8935             {
8936               printf (_("*corrupt* - no registers specified"));
8937             }
8938           else
8939             {
8940               reg = nregs - 1;
8941               for (i = i * 2; i > 0; i--)
8942                 {
8943                   if (regpos[reg].offset == i - 1)
8944                     {
8945                       name = tic6x_unwind_regnames[regpos[reg].reg];
8946                       if (reg > 0)
8947                         reg--;
8948                     }
8949                   else
8950                     name = _("[pad]");
8951
8952                   fputs (name, stdout);
8953                   if (i > 1)
8954                     printf (", ");
8955                 }
8956             }
8957
8958           printf ("}");
8959         }
8960       else if (op == 0xd0)
8961         printf ("     MOV FP, SP");
8962       else if (op == 0xd1)
8963         printf ("     __c6xabi_pop_rts");
8964       else if (op == 0xd2)
8965         {
8966           unsigned char buf[9];
8967           unsigned int i, len;
8968           unsigned long offset;
8969
8970           for (i = 0; i < sizeof (buf); i++)
8971             {
8972               GET_OP (buf[i]);
8973               if ((buf[i] & 0x80) == 0)
8974                 break;
8975             }
8976           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8977           if (i == sizeof (buf))
8978             {
8979               warn (_("Corrupt stack pointer adjustment detected\n"));
8980               return FALSE;
8981             }
8982
8983           offset = read_uleb128 (buf, &len, buf + i + 1);
8984           assert (len == i + 1);
8985           offset = offset * 8 + 0x408;
8986           printf (_("sp = sp + %ld"), offset);
8987         }
8988       else if ((op & 0xf0) == 0xe0)
8989         {
8990           if ((op & 0x0f) == 7)
8991             printf ("     RETURN");
8992           else
8993             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8994         }
8995       else
8996         {
8997           printf (_("     [unsupported opcode]"));
8998         }
8999       putchar ('\n');
9000     }
9001
9002   return TRUE;
9003 }
9004
9005 static bfd_vma
9006 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
9007 {
9008   bfd_vma offset;
9009
9010   offset = word & 0x7fffffff;
9011   if (offset & 0x40000000)
9012     offset |= ~ (bfd_vma) 0x7fffffff;
9013
9014   if (filedata->file_header.e_machine == EM_TI_C6000)
9015     offset <<= 1;
9016
9017   return offset + where;
9018 }
9019
9020 static bfd_boolean
9021 decode_arm_unwind (Filedata *                 filedata,
9022                    struct arm_unw_aux_info *  aux,
9023                    unsigned int               word,
9024                    unsigned int               remaining,
9025                    bfd_vma                    data_offset,
9026                    Elf_Internal_Shdr *        data_sec,
9027                    struct arm_section *       data_arm_sec)
9028 {
9029   int per_index;
9030   unsigned int more_words = 0;
9031   struct absaddr addr;
9032   bfd_vma sym_name = (bfd_vma) -1;
9033   bfd_boolean res = TRUE;
9034
9035   if (remaining == 0)
9036     {
9037       /* Fetch the first word.
9038          Note - when decoding an object file the address extracted
9039          here will always be 0.  So we also pass in the sym_name
9040          parameter so that we can find the symbol associated with
9041          the personality routine.  */
9042       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
9043                                      & word, & addr, & sym_name))
9044         return FALSE;
9045
9046       remaining = 4;
9047     }
9048
9049   if ((word & 0x80000000) == 0)
9050     {
9051       /* Expand prel31 for personality routine.  */
9052       bfd_vma fn;
9053       const char *procname;
9054
9055       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
9056       printf (_("  Personality routine: "));
9057       if (fn == 0
9058           && addr.section == SHN_UNDEF && addr.offset == 0
9059           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
9060         {
9061           procname = aux->strtab + sym_name;
9062           print_vma (fn, PREFIX_HEX);
9063           if (procname)
9064             {
9065               fputs (" <", stdout);
9066               fputs (procname, stdout);
9067               fputc ('>', stdout);
9068             }
9069         }
9070       else
9071         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
9072       fputc ('\n', stdout);
9073
9074       /* The GCC personality routines use the standard compact
9075          encoding, starting with one byte giving the number of
9076          words.  */
9077       if (procname != NULL
9078           && (const_strneq (procname, "__gcc_personality_v0")
9079               || const_strneq (procname, "__gxx_personality_v0")
9080               || const_strneq (procname, "__gcj_personality_v0")
9081               || const_strneq (procname, "__gnu_objc_personality_v0")))
9082         {
9083           remaining = 0;
9084           more_words = 1;
9085           ADVANCE;
9086           if (!remaining)
9087             {
9088               printf (_("  [Truncated data]\n"));
9089               return FALSE;
9090             }
9091           more_words = word >> 24;
9092           word <<= 8;
9093           remaining--;
9094           per_index = -1;
9095         }
9096       else
9097         return TRUE;
9098     }
9099   else
9100     {
9101       /* ARM EHABI Section 6.3:
9102
9103          An exception-handling table entry for the compact model looks like:
9104
9105            31 30-28 27-24 23-0
9106            -- ----- ----- ----
9107             1   0   index Data for personalityRoutine[index]    */
9108
9109       if (filedata->file_header.e_machine == EM_ARM
9110           && (word & 0x70000000))
9111         {
9112           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9113           res = FALSE;
9114         }
9115
9116       per_index = (word >> 24) & 0x7f;
9117       printf (_("  Compact model index: %d\n"), per_index);
9118       if (per_index == 0)
9119         {
9120           more_words = 0;
9121           word <<= 8;
9122           remaining--;
9123         }
9124       else if (per_index < 3)
9125         {
9126           more_words = (word >> 16) & 0xff;
9127           word <<= 16;
9128           remaining -= 2;
9129         }
9130     }
9131
9132   switch (filedata->file_header.e_machine)
9133     {
9134     case EM_ARM:
9135       if (per_index < 3)
9136         {
9137           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9138                                             data_offset, data_sec, data_arm_sec))
9139             res = FALSE;
9140         }
9141       else
9142         {
9143           warn (_("Unknown ARM compact model index encountered\n"));
9144           printf (_("  [reserved]\n"));
9145           res = FALSE;
9146         }
9147       break;
9148
9149     case EM_TI_C6000:
9150       if (per_index < 3)
9151         {
9152           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9153                                               data_offset, data_sec, data_arm_sec))
9154             res = FALSE;
9155         }
9156       else if (per_index < 5)
9157         {
9158           if (((word >> 17) & 0x7f) == 0x7f)
9159             printf (_("  Restore stack from frame pointer\n"));
9160           else
9161             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
9162           printf (_("  Registers restored: "));
9163           if (per_index == 4)
9164             printf (" (compact) ");
9165           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9166           putchar ('\n');
9167           printf (_("  Return register: %s\n"),
9168                   tic6x_unwind_regnames[word & 0xf]);
9169         }
9170       else
9171         printf (_("  [reserved (%d)]\n"), per_index);
9172       break;
9173
9174     default:
9175       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9176              filedata->file_header.e_machine);
9177       res = FALSE;
9178     }
9179
9180   /* Decode the descriptors.  Not implemented.  */
9181
9182   return res;
9183 }
9184
9185 static bfd_boolean
9186 dump_arm_unwind (Filedata *                 filedata,
9187                  struct arm_unw_aux_info *  aux,
9188                  Elf_Internal_Shdr *        exidx_sec)
9189 {
9190   struct arm_section exidx_arm_sec, extab_arm_sec;
9191   unsigned int i, exidx_len;
9192   unsigned long j, nfuns;
9193   bfd_boolean res = TRUE;
9194
9195   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9196   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9197   exidx_len = exidx_sec->sh_size / 8;
9198
9199   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9200   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9201     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9202       aux->funtab[nfuns++] = aux->symtab[j];
9203   aux->nfuns = nfuns;
9204   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9205
9206   for (i = 0; i < exidx_len; i++)
9207     {
9208       unsigned int exidx_fn, exidx_entry;
9209       struct absaddr fn_addr, entry_addr;
9210       bfd_vma fn;
9211
9212       fputc ('\n', stdout);
9213
9214       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9215                                      8 * i, & exidx_fn, & fn_addr, NULL)
9216           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9217                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9218         {
9219           free (aux->funtab);
9220           arm_free_section (& exidx_arm_sec);
9221           arm_free_section (& extab_arm_sec);
9222           return FALSE;
9223         }
9224
9225       /* ARM EHABI, Section 5:
9226          An index table entry consists of 2 words.
9227          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9228       if (exidx_fn & 0x80000000)
9229         {
9230           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9231           res = FALSE;
9232         }
9233
9234       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9235
9236       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9237       fputs (": ", stdout);
9238
9239       if (exidx_entry == 1)
9240         {
9241           print_vma (exidx_entry, PREFIX_HEX);
9242           fputs (" [cantunwind]\n", stdout);
9243         }
9244       else if (exidx_entry & 0x80000000)
9245         {
9246           print_vma (exidx_entry, PREFIX_HEX);
9247           fputc ('\n', stdout);
9248           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9249         }
9250       else
9251         {
9252           bfd_vma table, table_offset = 0;
9253           Elf_Internal_Shdr *table_sec;
9254
9255           fputs ("@", stdout);
9256           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9257           print_vma (table, PREFIX_HEX);
9258           printf ("\n");
9259
9260           /* Locate the matching .ARM.extab.  */
9261           if (entry_addr.section != SHN_UNDEF
9262               && entry_addr.section < filedata->file_header.e_shnum)
9263             {
9264               table_sec = filedata->section_headers + entry_addr.section;
9265               table_offset = entry_addr.offset;
9266               /* PR 18879 */
9267               if (table_offset > table_sec->sh_size
9268                   || ((bfd_signed_vma) table_offset) < 0)
9269                 {
9270                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9271                         (unsigned long) table_offset,
9272                         printable_section_name (filedata, table_sec));
9273                   res = FALSE;
9274                   continue;
9275                 }
9276             }
9277           else
9278             {
9279               table_sec = find_section_by_address (filedata, table);
9280               if (table_sec != NULL)
9281                 table_offset = table - table_sec->sh_addr;
9282             }
9283
9284           if (table_sec == NULL)
9285             {
9286               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9287                     (unsigned long) table);
9288               res = FALSE;
9289               continue;
9290             }
9291
9292           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9293                                    &extab_arm_sec))
9294             res = FALSE;
9295         }
9296     }
9297
9298   printf ("\n");
9299
9300   free (aux->funtab);
9301   arm_free_section (&exidx_arm_sec);
9302   arm_free_section (&extab_arm_sec);
9303
9304   return res;
9305 }
9306
9307 /* Used for both ARM and C6X unwinding tables.  */
9308
9309 static bfd_boolean
9310 arm_process_unwind (Filedata * filedata)
9311 {
9312   struct arm_unw_aux_info aux;
9313   Elf_Internal_Shdr *unwsec = NULL;
9314   Elf_Internal_Shdr *strsec;
9315   Elf_Internal_Shdr *sec;
9316   unsigned long i;
9317   unsigned int sec_type;
9318   bfd_boolean res = TRUE;
9319
9320   switch (filedata->file_header.e_machine)
9321     {
9322     case EM_ARM:
9323       sec_type = SHT_ARM_EXIDX;
9324       break;
9325
9326     case EM_TI_C6000:
9327       sec_type = SHT_C6000_UNWIND;
9328       break;
9329
9330     default:
9331       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9332              filedata->file_header.e_machine);
9333       return FALSE;
9334     }
9335
9336   if (filedata->string_table == NULL)
9337     return FALSE;
9338
9339   memset (& aux, 0, sizeof (aux));
9340   aux.filedata = filedata;
9341
9342   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9343     {
9344       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9345         {
9346           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9347
9348           strsec = filedata->section_headers + sec->sh_link;
9349
9350           /* PR binutils/17531 file: 011-12666-0.004.  */
9351           if (aux.strtab != NULL)
9352             {
9353               error (_("Multiple string tables found in file.\n"));
9354               free (aux.strtab);
9355               res = FALSE;
9356             }
9357           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9358                                  1, strsec->sh_size, _("string table"));
9359           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9360         }
9361       else if (sec->sh_type == sec_type)
9362         unwsec = sec;
9363     }
9364
9365   if (unwsec == NULL)
9366     printf (_("\nThere are no unwind sections in this file.\n"));
9367   else
9368     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9369       {
9370         if (sec->sh_type == sec_type)
9371           {
9372             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9373             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9374                               "contains %lu entry:\n",
9375                               "\nUnwind section '%s' at offset 0x%lx "
9376                               "contains %lu entries:\n",
9377                               num_unwind),
9378                     printable_section_name (filedata, sec),
9379                     (unsigned long) sec->sh_offset,
9380                     num_unwind);
9381
9382             if (! dump_arm_unwind (filedata, &aux, sec))
9383               res = FALSE;
9384           }
9385       }
9386
9387   if (aux.symtab)
9388     free (aux.symtab);
9389   if (aux.strtab)
9390     free ((char *) aux.strtab);
9391
9392   return res;
9393 }
9394
9395 static bfd_boolean
9396 process_unwind (Filedata * filedata)
9397 {
9398   struct unwind_handler
9399   {
9400     unsigned int machtype;
9401     bfd_boolean (* handler)(Filedata *);
9402   } handlers[] =
9403   {
9404     { EM_ARM, arm_process_unwind },
9405     { EM_IA_64, ia64_process_unwind },
9406     { EM_PARISC, hppa_process_unwind },
9407     { EM_TI_C6000, arm_process_unwind },
9408     { 0, NULL }
9409   };
9410   int i;
9411
9412   if (!do_unwind)
9413     return TRUE;
9414
9415   for (i = 0; handlers[i].handler != NULL; i++)
9416     if (filedata->file_header.e_machine == handlers[i].machtype)
9417       return handlers[i].handler (filedata);
9418
9419   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9420           get_machine_name (filedata->file_header.e_machine));
9421   return TRUE;
9422 }
9423
9424 static void
9425 dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
9426 {
9427   switch (entry->d_tag)
9428     {
9429     case DT_AARCH64_BTI_PLT:
9430     case DT_AARCH64_PAC_PLT:
9431       break;
9432     default:
9433       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9434       break;
9435     }
9436   putchar ('\n');
9437 }
9438
9439 static void
9440 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9441 {
9442   switch (entry->d_tag)
9443     {
9444     case DT_MIPS_FLAGS:
9445       if (entry->d_un.d_val == 0)
9446         printf (_("NONE"));
9447       else
9448         {
9449           static const char * opts[] =
9450           {
9451             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9452             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9453             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9454             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9455             "RLD_ORDER_SAFE"
9456           };
9457           unsigned int cnt;
9458           bfd_boolean first = TRUE;
9459
9460           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9461             if (entry->d_un.d_val & (1 << cnt))
9462               {
9463                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9464                 first = FALSE;
9465               }
9466         }
9467       break;
9468
9469     case DT_MIPS_IVERSION:
9470       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9471         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9472       else
9473         {
9474           char buf[40];
9475           sprintf_vma (buf, entry->d_un.d_ptr);
9476           /* Note: coded this way so that there is a single string for translation.  */
9477           printf (_("<corrupt: %s>"), buf);
9478         }
9479       break;
9480
9481     case DT_MIPS_TIME_STAMP:
9482       {
9483         char timebuf[128];
9484         struct tm * tmp;
9485         time_t atime = entry->d_un.d_val;
9486
9487         tmp = gmtime (&atime);
9488         /* PR 17531: file: 6accc532.  */
9489         if (tmp == NULL)
9490           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9491         else
9492           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9493                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9494                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9495         printf (_("Time Stamp: %s"), timebuf);
9496       }
9497       break;
9498
9499     case DT_MIPS_RLD_VERSION:
9500     case DT_MIPS_LOCAL_GOTNO:
9501     case DT_MIPS_CONFLICTNO:
9502     case DT_MIPS_LIBLISTNO:
9503     case DT_MIPS_SYMTABNO:
9504     case DT_MIPS_UNREFEXTNO:
9505     case DT_MIPS_HIPAGENO:
9506     case DT_MIPS_DELTA_CLASS_NO:
9507     case DT_MIPS_DELTA_INSTANCE_NO:
9508     case DT_MIPS_DELTA_RELOC_NO:
9509     case DT_MIPS_DELTA_SYM_NO:
9510     case DT_MIPS_DELTA_CLASSSYM_NO:
9511     case DT_MIPS_COMPACT_SIZE:
9512       print_vma (entry->d_un.d_val, DEC);
9513       break;
9514
9515     default:
9516       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9517     }
9518     putchar ('\n');
9519 }
9520
9521 static void
9522 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9523 {
9524   switch (entry->d_tag)
9525     {
9526     case DT_HP_DLD_FLAGS:
9527       {
9528         static struct
9529         {
9530           long int bit;
9531           const char * str;
9532         }
9533         flags[] =
9534         {
9535           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9536           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9537           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9538           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9539           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9540           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9541           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9542           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9543           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9544           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9545           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9546           { DT_HP_GST, "HP_GST" },
9547           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9548           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9549           { DT_HP_NODELETE, "HP_NODELETE" },
9550           { DT_HP_GROUP, "HP_GROUP" },
9551           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9552         };
9553         bfd_boolean first = TRUE;
9554         size_t cnt;
9555         bfd_vma val = entry->d_un.d_val;
9556
9557         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9558           if (val & flags[cnt].bit)
9559             {
9560               if (! first)
9561                 putchar (' ');
9562               fputs (flags[cnt].str, stdout);
9563               first = FALSE;
9564               val ^= flags[cnt].bit;
9565             }
9566
9567         if (val != 0 || first)
9568           {
9569             if (! first)
9570               putchar (' ');
9571             print_vma (val, HEX);
9572           }
9573       }
9574       break;
9575
9576     default:
9577       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9578       break;
9579     }
9580   putchar ('\n');
9581 }
9582
9583 #ifdef BFD64
9584
9585 /* VMS vs Unix time offset and factor.  */
9586
9587 #define VMS_EPOCH_OFFSET 35067168000000000LL
9588 #define VMS_GRANULARITY_FACTOR 10000000
9589
9590 /* Display a VMS time in a human readable format.  */
9591
9592 static void
9593 print_vms_time (bfd_int64_t vmstime)
9594 {
9595   struct tm *tm;
9596   time_t unxtime;
9597
9598   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9599   tm = gmtime (&unxtime);
9600   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9601           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9602           tm->tm_hour, tm->tm_min, tm->tm_sec);
9603 }
9604 #endif /* BFD64 */
9605
9606 static void
9607 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9608 {
9609   switch (entry->d_tag)
9610     {
9611     case DT_IA_64_PLT_RESERVE:
9612       /* First 3 slots reserved.  */
9613       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9614       printf (" -- ");
9615       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9616       break;
9617
9618     case DT_IA_64_VMS_LINKTIME:
9619 #ifdef BFD64
9620       print_vms_time (entry->d_un.d_val);
9621 #endif
9622       break;
9623
9624     case DT_IA_64_VMS_LNKFLAGS:
9625       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9626       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9627         printf (" CALL_DEBUG");
9628       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9629         printf (" NOP0BUFS");
9630       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9631         printf (" P0IMAGE");
9632       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9633         printf (" MKTHREADS");
9634       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9635         printf (" UPCALLS");
9636       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9637         printf (" IMGSTA");
9638       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9639         printf (" INITIALIZE");
9640       if (entry->d_un.d_val & VMS_LF_MAIN)
9641         printf (" MAIN");
9642       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9643         printf (" EXE_INIT");
9644       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9645         printf (" TBK_IN_IMG");
9646       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9647         printf (" DBG_IN_IMG");
9648       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9649         printf (" TBK_IN_DSF");
9650       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9651         printf (" DBG_IN_DSF");
9652       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9653         printf (" SIGNATURES");
9654       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9655         printf (" REL_SEG_OFF");
9656       break;
9657
9658     default:
9659       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9660       break;
9661     }
9662   putchar ('\n');
9663 }
9664
9665 static bfd_boolean
9666 get_32bit_dynamic_section (Filedata * filedata)
9667 {
9668   Elf32_External_Dyn * edyn;
9669   Elf32_External_Dyn * ext;
9670   Elf_Internal_Dyn * entry;
9671
9672   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9673                                           dynamic_size, _("dynamic section"));
9674   if (!edyn)
9675     return FALSE;
9676
9677   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9678      might not have the luxury of section headers.  Look for the DT_NULL
9679      terminator to determine the number of entries.  */
9680   for (ext = edyn, dynamic_nent = 0;
9681        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9682        ext++)
9683     {
9684       dynamic_nent++;
9685       if (BYTE_GET (ext->d_tag) == DT_NULL)
9686         break;
9687     }
9688
9689   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9690                                                   sizeof (* entry));
9691   if (dynamic_section == NULL)
9692     {
9693       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9694              (unsigned long) dynamic_nent);
9695       free (edyn);
9696       return FALSE;
9697     }
9698
9699   for (ext = edyn, entry = dynamic_section;
9700        entry < dynamic_section + dynamic_nent;
9701        ext++, entry++)
9702     {
9703       entry->d_tag      = BYTE_GET (ext->d_tag);
9704       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9705     }
9706
9707   free (edyn);
9708
9709   return TRUE;
9710 }
9711
9712 static bfd_boolean
9713 get_64bit_dynamic_section (Filedata * filedata)
9714 {
9715   Elf64_External_Dyn * edyn;
9716   Elf64_External_Dyn * ext;
9717   Elf_Internal_Dyn * entry;
9718
9719   /* Read in the data.  */
9720   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9721                                           dynamic_size, _("dynamic section"));
9722   if (!edyn)
9723     return FALSE;
9724
9725   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9726      might not have the luxury of section headers.  Look for the DT_NULL
9727      terminator to determine the number of entries.  */
9728   for (ext = edyn, dynamic_nent = 0;
9729        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9730        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9731        ext++)
9732     {
9733       dynamic_nent++;
9734       if (BYTE_GET (ext->d_tag) == DT_NULL)
9735         break;
9736     }
9737
9738   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9739                                                   sizeof (* entry));
9740   if (dynamic_section == NULL)
9741     {
9742       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9743              (unsigned long) dynamic_nent);
9744       free (edyn);
9745       return FALSE;
9746     }
9747
9748   /* Convert from external to internal formats.  */
9749   for (ext = edyn, entry = dynamic_section;
9750        entry < dynamic_section + dynamic_nent;
9751        ext++, entry++)
9752     {
9753       entry->d_tag      = BYTE_GET (ext->d_tag);
9754       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9755     }
9756
9757   free (edyn);
9758
9759   return TRUE;
9760 }
9761
9762 static void
9763 print_dynamic_flags (bfd_vma flags)
9764 {
9765   bfd_boolean first = TRUE;
9766
9767   while (flags)
9768     {
9769       bfd_vma flag;
9770
9771       flag = flags & - flags;
9772       flags &= ~ flag;
9773
9774       if (first)
9775         first = FALSE;
9776       else
9777         putc (' ', stdout);
9778
9779       switch (flag)
9780         {
9781         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9782         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9783         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9784         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9785         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9786         default:                fputs (_("unknown"), stdout); break;
9787         }
9788     }
9789   puts ("");
9790 }
9791
9792 /* Parse and display the contents of the dynamic section.  */
9793
9794 static bfd_boolean
9795 process_dynamic_section (Filedata * filedata)
9796 {
9797   Elf_Internal_Dyn * entry;
9798
9799   if (dynamic_size == 0)
9800     {
9801       if (do_dynamic)
9802         printf (_("\nThere is no dynamic section in this file.\n"));
9803
9804       return TRUE;
9805     }
9806
9807   if (is_32bit_elf)
9808     {
9809       if (! get_32bit_dynamic_section (filedata))
9810         return FALSE;
9811     }
9812   else
9813     {
9814       if (! get_64bit_dynamic_section (filedata))
9815         return FALSE;
9816     }
9817
9818   /* Find the appropriate symbol table.  */
9819   if (dynamic_symbols == NULL)
9820     {
9821       for (entry = dynamic_section;
9822            entry < dynamic_section + dynamic_nent;
9823            ++entry)
9824         {
9825           Elf_Internal_Shdr section;
9826
9827           if (entry->d_tag != DT_SYMTAB)
9828             continue;
9829
9830           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9831
9832           /* Since we do not know how big the symbol table is,
9833              we default to reading in the entire file (!) and
9834              processing that.  This is overkill, I know, but it
9835              should work.  */
9836           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9837           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9838             {
9839               /* See PR 21379 for a reproducer.  */
9840               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9841               return FALSE;
9842             }
9843
9844           if (archive_file_offset != 0)
9845             section.sh_size = archive_file_size - section.sh_offset;
9846           else
9847             section.sh_size = filedata->file_size - section.sh_offset;
9848
9849           if (is_32bit_elf)
9850             section.sh_entsize = sizeof (Elf32_External_Sym);
9851           else
9852             section.sh_entsize = sizeof (Elf64_External_Sym);
9853           section.sh_name = filedata->string_table_length;
9854
9855           if (dynamic_symbols != NULL)
9856             {
9857               error (_("Multiple dynamic symbol table sections found\n"));
9858               free (dynamic_symbols);
9859             }
9860           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9861           if (num_dynamic_syms < 1)
9862             {
9863               error (_("Unable to determine the number of symbols to load\n"));
9864               continue;
9865             }
9866         }
9867     }
9868
9869   /* Similarly find a string table.  */
9870   if (dynamic_strings == NULL)
9871     {
9872       for (entry = dynamic_section;
9873            entry < dynamic_section + dynamic_nent;
9874            ++entry)
9875         {
9876           unsigned long offset;
9877           long str_tab_len;
9878
9879           if (entry->d_tag != DT_STRTAB)
9880             continue;
9881
9882           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9883
9884           /* Since we do not know how big the string table is,
9885              we default to reading in the entire file (!) and
9886              processing that.  This is overkill, I know, but it
9887              should work.  */
9888
9889           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9890
9891           if (archive_file_offset != 0)
9892             str_tab_len = archive_file_size - offset;
9893           else
9894             str_tab_len = filedata->file_size - offset;
9895
9896           if (str_tab_len < 1)
9897             {
9898               error
9899                 (_("Unable to determine the length of the dynamic string table\n"));
9900               continue;
9901             }
9902
9903           if (dynamic_strings != NULL)
9904             {
9905               error (_("Multiple dynamic string tables found\n"));
9906               free (dynamic_strings);
9907             }
9908
9909           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9910                                                str_tab_len,
9911                                                _("dynamic string table"));
9912           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9913         }
9914     }
9915
9916   /* And find the syminfo section if available.  */
9917   if (dynamic_syminfo == NULL)
9918     {
9919       unsigned long syminsz = 0;
9920
9921       for (entry = dynamic_section;
9922            entry < dynamic_section + dynamic_nent;
9923            ++entry)
9924         {
9925           if (entry->d_tag == DT_SYMINENT)
9926             {
9927               /* Note: these braces are necessary to avoid a syntax
9928                  error from the SunOS4 C compiler.  */
9929               /* PR binutils/17531: A corrupt file can trigger this test.
9930                  So do not use an assert, instead generate an error message.  */
9931               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9932                 error (_("Bad value (%d) for SYMINENT entry\n"),
9933                        (int) entry->d_un.d_val);
9934             }
9935           else if (entry->d_tag == DT_SYMINSZ)
9936             syminsz = entry->d_un.d_val;
9937           else if (entry->d_tag == DT_SYMINFO)
9938             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9939                                                       syminsz);
9940         }
9941
9942       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9943         {
9944           Elf_External_Syminfo * extsyminfo;
9945           Elf_External_Syminfo * extsym;
9946           Elf_Internal_Syminfo * syminfo;
9947
9948           /* There is a syminfo section.  Read the data.  */
9949           extsyminfo = (Elf_External_Syminfo *)
9950               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9951                         _("symbol information"));
9952           if (!extsyminfo)
9953             return FALSE;
9954
9955           if (dynamic_syminfo != NULL)
9956             {
9957               error (_("Multiple dynamic symbol information sections found\n"));
9958               free (dynamic_syminfo);
9959             }
9960           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9961           if (dynamic_syminfo == NULL)
9962             {
9963               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9964                      (unsigned long) syminsz);
9965               return FALSE;
9966             }
9967
9968           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9969           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9970                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9971                ++syminfo, ++extsym)
9972             {
9973               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9974               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9975             }
9976
9977           free (extsyminfo);
9978         }
9979     }
9980
9981   if (do_dynamic && dynamic_addr)
9982     printf (ngettext ("\nDynamic section at offset 0x%lx "
9983                       "contains %lu entry:\n",
9984                       "\nDynamic section at offset 0x%lx "
9985                       "contains %lu entries:\n",
9986                       dynamic_nent),
9987             dynamic_addr, (unsigned long) dynamic_nent);
9988   if (do_dynamic)
9989     printf (_("  Tag        Type                         Name/Value\n"));
9990
9991   for (entry = dynamic_section;
9992        entry < dynamic_section + dynamic_nent;
9993        entry++)
9994     {
9995       if (do_dynamic)
9996         {
9997           const char * dtype;
9998
9999           putchar (' ');
10000           print_vma (entry->d_tag, FULL_HEX);
10001           dtype = get_dynamic_type (filedata, entry->d_tag);
10002           printf (" (%s)%*s", dtype,
10003                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
10004         }
10005
10006       switch (entry->d_tag)
10007         {
10008         case DT_FLAGS:
10009           if (do_dynamic)
10010             print_dynamic_flags (entry->d_un.d_val);
10011           break;
10012
10013         case DT_AUXILIARY:
10014         case DT_FILTER:
10015         case DT_CONFIG:
10016         case DT_DEPAUDIT:
10017         case DT_AUDIT:
10018           if (do_dynamic)
10019             {
10020               switch (entry->d_tag)
10021                 {
10022                 case DT_AUXILIARY:
10023                   printf (_("Auxiliary library"));
10024                   break;
10025
10026                 case DT_FILTER:
10027                   printf (_("Filter library"));
10028                   break;
10029
10030                 case DT_CONFIG:
10031                   printf (_("Configuration file"));
10032                   break;
10033
10034                 case DT_DEPAUDIT:
10035                   printf (_("Dependency audit library"));
10036                   break;
10037
10038                 case DT_AUDIT:
10039                   printf (_("Audit library"));
10040                   break;
10041                 }
10042
10043               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10044                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
10045               else
10046                 {
10047                   printf (": ");
10048                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10049                   putchar ('\n');
10050                 }
10051             }
10052           break;
10053
10054         case DT_FEATURE:
10055           if (do_dynamic)
10056             {
10057               printf (_("Flags:"));
10058
10059               if (entry->d_un.d_val == 0)
10060                 printf (_(" None\n"));
10061               else
10062                 {
10063                   unsigned long int val = entry->d_un.d_val;
10064
10065                   if (val & DTF_1_PARINIT)
10066                     {
10067                       printf (" PARINIT");
10068                       val ^= DTF_1_PARINIT;
10069                     }
10070                   if (val & DTF_1_CONFEXP)
10071                     {
10072                       printf (" CONFEXP");
10073                       val ^= DTF_1_CONFEXP;
10074                     }
10075                   if (val != 0)
10076                     printf (" %lx", val);
10077                   puts ("");
10078                 }
10079             }
10080           break;
10081
10082         case DT_POSFLAG_1:
10083           if (do_dynamic)
10084             {
10085               printf (_("Flags:"));
10086
10087               if (entry->d_un.d_val == 0)
10088                 printf (_(" None\n"));
10089               else
10090                 {
10091                   unsigned long int val = entry->d_un.d_val;
10092
10093                   if (val & DF_P1_LAZYLOAD)
10094                     {
10095                       printf (" LAZYLOAD");
10096                       val ^= DF_P1_LAZYLOAD;
10097                     }
10098                   if (val & DF_P1_GROUPPERM)
10099                     {
10100                       printf (" GROUPPERM");
10101                       val ^= DF_P1_GROUPPERM;
10102                     }
10103                   if (val != 0)
10104                     printf (" %lx", val);
10105                   puts ("");
10106                 }
10107             }
10108           break;
10109
10110         case DT_FLAGS_1:
10111           if (do_dynamic)
10112             {
10113               printf (_("Flags:"));
10114               if (entry->d_un.d_val == 0)
10115                 printf (_(" None\n"));
10116               else
10117                 {
10118                   unsigned long int val = entry->d_un.d_val;
10119
10120                   if (val & DF_1_NOW)
10121                     {
10122                       printf (" NOW");
10123                       val ^= DF_1_NOW;
10124                     }
10125                   if (val & DF_1_GLOBAL)
10126                     {
10127                       printf (" GLOBAL");
10128                       val ^= DF_1_GLOBAL;
10129                     }
10130                   if (val & DF_1_GROUP)
10131                     {
10132                       printf (" GROUP");
10133                       val ^= DF_1_GROUP;
10134                     }
10135                   if (val & DF_1_NODELETE)
10136                     {
10137                       printf (" NODELETE");
10138                       val ^= DF_1_NODELETE;
10139                     }
10140                   if (val & DF_1_LOADFLTR)
10141                     {
10142                       printf (" LOADFLTR");
10143                       val ^= DF_1_LOADFLTR;
10144                     }
10145                   if (val & DF_1_INITFIRST)
10146                     {
10147                       printf (" INITFIRST");
10148                       val ^= DF_1_INITFIRST;
10149                     }
10150                   if (val & DF_1_NOOPEN)
10151                     {
10152                       printf (" NOOPEN");
10153                       val ^= DF_1_NOOPEN;
10154                     }
10155                   if (val & DF_1_ORIGIN)
10156                     {
10157                       printf (" ORIGIN");
10158                       val ^= DF_1_ORIGIN;
10159                     }
10160                   if (val & DF_1_DIRECT)
10161                     {
10162                       printf (" DIRECT");
10163                       val ^= DF_1_DIRECT;
10164                     }
10165                   if (val & DF_1_TRANS)
10166                     {
10167                       printf (" TRANS");
10168                       val ^= DF_1_TRANS;
10169                     }
10170                   if (val & DF_1_INTERPOSE)
10171                     {
10172                       printf (" INTERPOSE");
10173                       val ^= DF_1_INTERPOSE;
10174                     }
10175                   if (val & DF_1_NODEFLIB)
10176                     {
10177                       printf (" NODEFLIB");
10178                       val ^= DF_1_NODEFLIB;
10179                     }
10180                   if (val & DF_1_NODUMP)
10181                     {
10182                       printf (" NODUMP");
10183                       val ^= DF_1_NODUMP;
10184                     }
10185                   if (val & DF_1_CONFALT)
10186                     {
10187                       printf (" CONFALT");
10188                       val ^= DF_1_CONFALT;
10189                     }
10190                   if (val & DF_1_ENDFILTEE)
10191                     {
10192                       printf (" ENDFILTEE");
10193                       val ^= DF_1_ENDFILTEE;
10194                     }
10195                   if (val & DF_1_DISPRELDNE)
10196                     {
10197                       printf (" DISPRELDNE");
10198                       val ^= DF_1_DISPRELDNE;
10199                     }
10200                   if (val & DF_1_DISPRELPND)
10201                     {
10202                       printf (" DISPRELPND");
10203                       val ^= DF_1_DISPRELPND;
10204                     }
10205                   if (val & DF_1_NODIRECT)
10206                     {
10207                       printf (" NODIRECT");
10208                       val ^= DF_1_NODIRECT;
10209                     }
10210                   if (val & DF_1_IGNMULDEF)
10211                     {
10212                       printf (" IGNMULDEF");
10213                       val ^= DF_1_IGNMULDEF;
10214                     }
10215                   if (val & DF_1_NOKSYMS)
10216                     {
10217                       printf (" NOKSYMS");
10218                       val ^= DF_1_NOKSYMS;
10219                     }
10220                   if (val & DF_1_NOHDR)
10221                     {
10222                       printf (" NOHDR");
10223                       val ^= DF_1_NOHDR;
10224                     }
10225                   if (val & DF_1_EDITED)
10226                     {
10227                       printf (" EDITED");
10228                       val ^= DF_1_EDITED;
10229                     }
10230                   if (val & DF_1_NORELOC)
10231                     {
10232                       printf (" NORELOC");
10233                       val ^= DF_1_NORELOC;
10234                     }
10235                   if (val & DF_1_SYMINTPOSE)
10236                     {
10237                       printf (" SYMINTPOSE");
10238                       val ^= DF_1_SYMINTPOSE;
10239                     }
10240                   if (val & DF_1_GLOBAUDIT)
10241                     {
10242                       printf (" GLOBAUDIT");
10243                       val ^= DF_1_GLOBAUDIT;
10244                     }
10245                   if (val & DF_1_SINGLETON)
10246                     {
10247                       printf (" SINGLETON");
10248                       val ^= DF_1_SINGLETON;
10249                     }
10250                   if (val & DF_1_STUB)
10251                     {
10252                       printf (" STUB");
10253                       val ^= DF_1_STUB;
10254                     }
10255                   if (val & DF_1_PIE)
10256                     {
10257                       printf (" PIE");
10258                       val ^= DF_1_PIE;
10259                     }
10260                   if (val & DF_1_KMOD)
10261                     {
10262                       printf (" KMOD");
10263                       val ^= DF_1_KMOD;
10264                     }
10265                   if (val & DF_1_WEAKFILTER)
10266                     {
10267                       printf (" WEAKFILTER");
10268                       val ^= DF_1_WEAKFILTER;
10269                     }
10270                   if (val & DF_1_NOCOMMON)
10271                     {
10272                       printf (" NOCOMMON");
10273                       val ^= DF_1_NOCOMMON;
10274                     }
10275                   if (val != 0)
10276                     printf (" %lx", val);
10277                   puts ("");
10278                 }
10279             }
10280           break;
10281
10282         case DT_PLTREL:
10283           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10284           if (do_dynamic)
10285             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10286           break;
10287
10288         case DT_NULL    :
10289         case DT_NEEDED  :
10290         case DT_PLTGOT  :
10291         case DT_HASH    :
10292         case DT_STRTAB  :
10293         case DT_SYMTAB  :
10294         case DT_RELA    :
10295         case DT_INIT    :
10296         case DT_FINI    :
10297         case DT_SONAME  :
10298         case DT_RPATH   :
10299         case DT_SYMBOLIC:
10300         case DT_REL     :
10301         case DT_DEBUG   :
10302         case DT_TEXTREL :
10303         case DT_JMPREL  :
10304         case DT_RUNPATH :
10305           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10306
10307           if (do_dynamic)
10308             {
10309               char * name;
10310
10311               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10312                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10313               else
10314                 name = NULL;
10315
10316               if (name)
10317                 {
10318                   switch (entry->d_tag)
10319                     {
10320                     case DT_NEEDED:
10321                       printf (_("Shared library: [%s]"), name);
10322
10323                       if (streq (name, program_interpreter))
10324                         printf (_(" program interpreter"));
10325                       break;
10326
10327                     case DT_SONAME:
10328                       printf (_("Library soname: [%s]"), name);
10329                       break;
10330
10331                     case DT_RPATH:
10332                       printf (_("Library rpath: [%s]"), name);
10333                       break;
10334
10335                     case DT_RUNPATH:
10336                       printf (_("Library runpath: [%s]"), name);
10337                       break;
10338
10339                     default:
10340                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10341                       break;
10342                     }
10343                 }
10344               else
10345                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10346
10347               putchar ('\n');
10348             }
10349           break;
10350
10351         case DT_PLTRELSZ:
10352         case DT_RELASZ  :
10353         case DT_STRSZ   :
10354         case DT_RELSZ   :
10355         case DT_RELAENT :
10356         case DT_SYMENT  :
10357         case DT_RELENT  :
10358           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10359           /* Fall through.  */
10360         case DT_PLTPADSZ:
10361         case DT_MOVEENT :
10362         case DT_MOVESZ  :
10363         case DT_INIT_ARRAYSZ:
10364         case DT_FINI_ARRAYSZ:
10365         case DT_GNU_CONFLICTSZ:
10366         case DT_GNU_LIBLISTSZ:
10367           if (do_dynamic)
10368             {
10369               print_vma (entry->d_un.d_val, UNSIGNED);
10370               printf (_(" (bytes)\n"));
10371             }
10372           break;
10373
10374         case DT_VERDEFNUM:
10375         case DT_VERNEEDNUM:
10376         case DT_RELACOUNT:
10377         case DT_RELCOUNT:
10378           if (do_dynamic)
10379             {
10380               print_vma (entry->d_un.d_val, UNSIGNED);
10381               putchar ('\n');
10382             }
10383           break;
10384
10385         case DT_SYMINSZ:
10386         case DT_SYMINENT:
10387         case DT_SYMINFO:
10388         case DT_USED:
10389         case DT_INIT_ARRAY:
10390         case DT_FINI_ARRAY:
10391           if (do_dynamic)
10392             {
10393               if (entry->d_tag == DT_USED
10394                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10395                 {
10396                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10397
10398                   if (*name)
10399                     {
10400                       printf (_("Not needed object: [%s]\n"), name);
10401                       break;
10402                     }
10403                 }
10404
10405               print_vma (entry->d_un.d_val, PREFIX_HEX);
10406               putchar ('\n');
10407             }
10408           break;
10409
10410         case DT_BIND_NOW:
10411           /* The value of this entry is ignored.  */
10412           if (do_dynamic)
10413             putchar ('\n');
10414           break;
10415
10416         case DT_GNU_PRELINKED:
10417           if (do_dynamic)
10418             {
10419               struct tm * tmp;
10420               time_t atime = entry->d_un.d_val;
10421
10422               tmp = gmtime (&atime);
10423               /* PR 17533 file: 041-1244816-0.004.  */
10424               if (tmp == NULL)
10425                 printf (_("<corrupt time val: %lx"),
10426                         (unsigned long) atime);
10427               else
10428                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10429                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10430                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10431
10432             }
10433           break;
10434
10435         case DT_GNU_HASH:
10436           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10437           if (do_dynamic)
10438             {
10439               print_vma (entry->d_un.d_val, PREFIX_HEX);
10440               putchar ('\n');
10441             }
10442           break;
10443
10444         default:
10445           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10446             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10447               entry->d_un.d_val;
10448
10449           if (do_dynamic)
10450             {
10451               switch (filedata->file_header.e_machine)
10452                 {
10453                 case EM_AARCH64:
10454                   dynamic_section_aarch64_val (entry);
10455                   break;
10456                 case EM_MIPS:
10457                 case EM_MIPS_RS3_LE:
10458                   dynamic_section_mips_val (entry);
10459                   break;
10460                 case EM_PARISC:
10461                   dynamic_section_parisc_val (entry);
10462                   break;
10463                 case EM_IA_64:
10464                   dynamic_section_ia64_val (entry);
10465                   break;
10466                 default:
10467                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10468                   putchar ('\n');
10469                 }
10470             }
10471           break;
10472         }
10473     }
10474
10475   return TRUE;
10476 }
10477
10478 static char *
10479 get_ver_flags (unsigned int flags)
10480 {
10481   static char buff[128];
10482
10483   buff[0] = 0;
10484
10485   if (flags == 0)
10486     return _("none");
10487
10488   if (flags & VER_FLG_BASE)
10489     strcat (buff, "BASE");
10490
10491   if (flags & VER_FLG_WEAK)
10492     {
10493       if (flags & VER_FLG_BASE)
10494         strcat (buff, " | ");
10495
10496       strcat (buff, "WEAK");
10497     }
10498
10499   if (flags & VER_FLG_INFO)
10500     {
10501       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10502         strcat (buff, " | ");
10503
10504       strcat (buff, "INFO");
10505     }
10506
10507   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10508     {
10509       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10510         strcat (buff, " | ");
10511
10512       strcat (buff, _("<unknown>"));
10513     }
10514
10515   return buff;
10516 }
10517
10518 /* Display the contents of the version sections.  */
10519
10520 static bfd_boolean
10521 process_version_sections (Filedata * filedata)
10522 {
10523   Elf_Internal_Shdr * section;
10524   unsigned i;
10525   bfd_boolean found = FALSE;
10526
10527   if (! do_version)
10528     return TRUE;
10529
10530   for (i = 0, section = filedata->section_headers;
10531        i < filedata->file_header.e_shnum;
10532        i++, section++)
10533     {
10534       switch (section->sh_type)
10535         {
10536         case SHT_GNU_verdef:
10537           {
10538             Elf_External_Verdef * edefs;
10539             unsigned long idx;
10540             unsigned long cnt;
10541             char * endbuf;
10542
10543             found = TRUE;
10544
10545             printf (ngettext ("\nVersion definition section '%s' "
10546                               "contains %u entry:\n",
10547                               "\nVersion definition section '%s' "
10548                               "contains %u entries:\n",
10549                               section->sh_info),
10550                     printable_section_name (filedata, section),
10551                     section->sh_info);
10552
10553             printf (_(" Addr: 0x"));
10554             printf_vma (section->sh_addr);
10555             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10556                     (unsigned long) section->sh_offset, section->sh_link,
10557                     printable_section_name_from_index (filedata, section->sh_link));
10558
10559             edefs = (Elf_External_Verdef *)
10560                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10561                           _("version definition section"));
10562             if (!edefs)
10563               break;
10564             endbuf = (char *) edefs + section->sh_size;
10565
10566             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10567               {
10568                 char * vstart;
10569                 Elf_External_Verdef * edef;
10570                 Elf_Internal_Verdef ent;
10571                 Elf_External_Verdaux * eaux;
10572                 Elf_Internal_Verdaux aux;
10573                 unsigned long isum;
10574                 int j;
10575
10576                 vstart = ((char *) edefs) + idx;
10577                 if (vstart + sizeof (*edef) > endbuf)
10578                   break;
10579
10580                 edef = (Elf_External_Verdef *) vstart;
10581
10582                 ent.vd_version = BYTE_GET (edef->vd_version);
10583                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10584                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10585                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10586                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10587                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10588                 ent.vd_next    = BYTE_GET (edef->vd_next);
10589
10590                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10591                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10592
10593                 printf (_("  Index: %d  Cnt: %d  "),
10594                         ent.vd_ndx, ent.vd_cnt);
10595
10596                 /* Check for overflow.  */
10597                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10598                   break;
10599
10600                 vstart += ent.vd_aux;
10601
10602                 if (vstart + sizeof (*eaux) > endbuf)
10603                   break;
10604                 eaux = (Elf_External_Verdaux *) vstart;
10605
10606                 aux.vda_name = BYTE_GET (eaux->vda_name);
10607                 aux.vda_next = BYTE_GET (eaux->vda_next);
10608
10609                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10610                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10611                 else
10612                   printf (_("Name index: %ld\n"), aux.vda_name);
10613
10614                 isum = idx + ent.vd_aux;
10615
10616                 for (j = 1; j < ent.vd_cnt; j++)
10617                   {
10618                     if (aux.vda_next < sizeof (*eaux)
10619                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10620                       {
10621                         warn (_("Invalid vda_next field of %lx\n"),
10622                               aux.vda_next);
10623                         j = ent.vd_cnt;
10624                         break;
10625                       }
10626                     /* Check for overflow.  */
10627                     if (aux.vda_next > (size_t) (endbuf - vstart))
10628                       break;
10629
10630                     isum   += aux.vda_next;
10631                     vstart += aux.vda_next;
10632
10633                     if (vstart + sizeof (*eaux) > endbuf)
10634                       break;
10635                     eaux = (Elf_External_Verdaux *) vstart;
10636
10637                     aux.vda_name = BYTE_GET (eaux->vda_name);
10638                     aux.vda_next = BYTE_GET (eaux->vda_next);
10639
10640                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10641                       printf (_("  %#06lx: Parent %d: %s\n"),
10642                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10643                     else
10644                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10645                               isum, j, aux.vda_name);
10646                   }
10647
10648                 if (j < ent.vd_cnt)
10649                   printf (_("  Version def aux past end of section\n"));
10650
10651                 /* PR 17531:
10652                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10653                 if (ent.vd_next < sizeof (*edef)
10654                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10655                   {
10656                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10657                     cnt = section->sh_info;
10658                     break;
10659                   }
10660                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10661                   break;
10662
10663                 idx += ent.vd_next;
10664               }
10665
10666             if (cnt < section->sh_info)
10667               printf (_("  Version definition past end of section\n"));
10668
10669             free (edefs);
10670           }
10671           break;
10672
10673         case SHT_GNU_verneed:
10674           {
10675             Elf_External_Verneed * eneed;
10676             unsigned long idx;
10677             unsigned long cnt;
10678             char * endbuf;
10679
10680             found = TRUE;
10681
10682             printf (ngettext ("\nVersion needs section '%s' "
10683                               "contains %u entry:\n",
10684                               "\nVersion needs section '%s' "
10685                               "contains %u entries:\n",
10686                               section->sh_info),
10687                     printable_section_name (filedata, section), section->sh_info);
10688
10689             printf (_(" Addr: 0x"));
10690             printf_vma (section->sh_addr);
10691             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10692                     (unsigned long) section->sh_offset, section->sh_link,
10693                     printable_section_name_from_index (filedata, section->sh_link));
10694
10695             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10696                                                        section->sh_offset, 1,
10697                                                        section->sh_size,
10698                                                        _("Version Needs section"));
10699             if (!eneed)
10700               break;
10701             endbuf = (char *) eneed + section->sh_size;
10702
10703             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10704               {
10705                 Elf_External_Verneed * entry;
10706                 Elf_Internal_Verneed ent;
10707                 unsigned long isum;
10708                 int j;
10709                 char * vstart;
10710
10711                 vstart = ((char *) eneed) + idx;
10712                 if (vstart + sizeof (*entry) > endbuf)
10713                   break;
10714
10715                 entry = (Elf_External_Verneed *) vstart;
10716
10717                 ent.vn_version = BYTE_GET (entry->vn_version);
10718                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10719                 ent.vn_file    = BYTE_GET (entry->vn_file);
10720                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10721                 ent.vn_next    = BYTE_GET (entry->vn_next);
10722
10723                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10724
10725                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10726                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10727                 else
10728                   printf (_("  File: %lx"), ent.vn_file);
10729
10730                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10731
10732                 /* Check for overflow.  */
10733                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10734                   break;
10735                 vstart += ent.vn_aux;
10736
10737                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10738                   {
10739                     Elf_External_Vernaux * eaux;
10740                     Elf_Internal_Vernaux aux;
10741
10742                     if (vstart + sizeof (*eaux) > endbuf)
10743                       break;
10744                     eaux = (Elf_External_Vernaux *) vstart;
10745
10746                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10747                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10748                     aux.vna_other = BYTE_GET (eaux->vna_other);
10749                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10750                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10751
10752                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10753                       printf (_("  %#06lx:   Name: %s"),
10754                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10755                     else
10756                       printf (_("  %#06lx:   Name index: %lx"),
10757                               isum, aux.vna_name);
10758
10759                     printf (_("  Flags: %s  Version: %d\n"),
10760                             get_ver_flags (aux.vna_flags), aux.vna_other);
10761
10762                     if (aux.vna_next < sizeof (*eaux)
10763                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10764                       {
10765                         warn (_("Invalid vna_next field of %lx\n"),
10766                               aux.vna_next);
10767                         j = ent.vn_cnt;
10768                         break;
10769                       }
10770                     /* Check for overflow.  */
10771                     if (aux.vna_next > (size_t) (endbuf - vstart))
10772                       break;
10773                     isum   += aux.vna_next;
10774                     vstart += aux.vna_next;
10775                   }
10776
10777                 if (j < ent.vn_cnt)
10778                   warn (_("Missing Version Needs auxillary information\n"));
10779
10780                 if (ent.vn_next < sizeof (*entry)
10781                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10782                   {
10783                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10784                     cnt = section->sh_info;
10785                     break;
10786                   }
10787                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10788                   break;
10789                 idx += ent.vn_next;
10790               }
10791
10792             if (cnt < section->sh_info)
10793               warn (_("Missing Version Needs information\n"));
10794
10795             free (eneed);
10796           }
10797           break;
10798
10799         case SHT_GNU_versym:
10800           {
10801             Elf_Internal_Shdr * link_section;
10802             size_t total;
10803             unsigned int cnt;
10804             unsigned char * edata;
10805             unsigned short * data;
10806             char * strtab;
10807             Elf_Internal_Sym * symbols;
10808             Elf_Internal_Shdr * string_sec;
10809             unsigned long num_syms;
10810             long off;
10811
10812             if (section->sh_link >= filedata->file_header.e_shnum)
10813               break;
10814
10815             link_section = filedata->section_headers + section->sh_link;
10816             total = section->sh_size / sizeof (Elf_External_Versym);
10817
10818             if (link_section->sh_link >= filedata->file_header.e_shnum)
10819               break;
10820
10821             found = TRUE;
10822
10823             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10824             if (symbols == NULL)
10825               break;
10826
10827             string_sec = filedata->section_headers + link_section->sh_link;
10828
10829             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10830                                         string_sec->sh_size,
10831                                         _("version string table"));
10832             if (!strtab)
10833               {
10834                 free (symbols);
10835                 break;
10836               }
10837
10838             printf (ngettext ("\nVersion symbols section '%s' "
10839                               "contains %lu entry:\n",
10840                               "\nVersion symbols section '%s' "
10841                               "contains %lu entries:\n",
10842                               total),
10843                     printable_section_name (filedata, section), (unsigned long) total);
10844
10845             printf (_(" Addr: 0x"));
10846             printf_vma (section->sh_addr);
10847             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10848                     (unsigned long) section->sh_offset, section->sh_link,
10849                     printable_section_name (filedata, link_section));
10850
10851             off = offset_from_vma (filedata,
10852                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10853                                    total * sizeof (short));
10854             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10855                                                 sizeof (short),
10856                                                 _("version symbol data"));
10857             if (!edata)
10858               {
10859                 free (strtab);
10860                 free (symbols);
10861                 break;
10862               }
10863
10864             data = (short unsigned int *) cmalloc (total, sizeof (short));
10865
10866             for (cnt = total; cnt --;)
10867               data[cnt] = byte_get (edata + cnt * sizeof (short),
10868                                     sizeof (short));
10869
10870             free (edata);
10871
10872             for (cnt = 0; cnt < total; cnt += 4)
10873               {
10874                 int j, nn;
10875                 char *name;
10876                 char *invalid = _("*invalid*");
10877
10878                 printf ("  %03x:", cnt);
10879
10880                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10881                   switch (data[cnt + j])
10882                     {
10883                     case 0:
10884                       fputs (_("   0 (*local*)    "), stdout);
10885                       break;
10886
10887                     case 1:
10888                       fputs (_("   1 (*global*)   "), stdout);
10889                       break;
10890
10891                     default:
10892                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10893                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10894
10895                       /* If this index value is greater than the size of the symbols
10896                          array, break to avoid an out-of-bounds read.  */
10897                       if ((unsigned long)(cnt + j) >= num_syms)
10898                         {
10899                           warn (_("invalid index into symbol array\n"));
10900                           break;
10901                         }
10902
10903                       name = NULL;
10904                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10905                         {
10906                           Elf_Internal_Verneed ivn;
10907                           unsigned long offset;
10908
10909                           offset = offset_from_vma
10910                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10911                              sizeof (Elf_External_Verneed));
10912
10913                           do
10914                             {
10915                               Elf_Internal_Vernaux ivna;
10916                               Elf_External_Verneed evn;
10917                               Elf_External_Vernaux evna;
10918                               unsigned long a_off;
10919
10920                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10921                                             _("version need")) == NULL)
10922                                 break;
10923
10924                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10925                               ivn.vn_next = BYTE_GET (evn.vn_next);
10926
10927                               a_off = offset + ivn.vn_aux;
10928
10929                               do
10930                                 {
10931                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10932                                                 1, _("version need aux (2)")) == NULL)
10933                                     {
10934                                       ivna.vna_next  = 0;
10935                                       ivna.vna_other = 0;
10936                                     }
10937                                   else
10938                                     {
10939                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10940                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10941                                     }
10942
10943                                   a_off += ivna.vna_next;
10944                                 }
10945                               while (ivna.vna_other != data[cnt + j]
10946                                      && ivna.vna_next != 0);
10947
10948                               if (ivna.vna_other == data[cnt + j])
10949                                 {
10950                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10951
10952                                   if (ivna.vna_name >= string_sec->sh_size)
10953                                     name = invalid;
10954                                   else
10955                                     name = strtab + ivna.vna_name;
10956                                   break;
10957                                 }
10958
10959                               offset += ivn.vn_next;
10960                             }
10961                           while (ivn.vn_next);
10962                         }
10963
10964                       if (data[cnt + j] != 0x8001
10965                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10966                         {
10967                           Elf_Internal_Verdef ivd;
10968                           Elf_External_Verdef evd;
10969                           unsigned long offset;
10970
10971                           offset = offset_from_vma
10972                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10973                              sizeof evd);
10974
10975                           do
10976                             {
10977                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10978                                             _("version def")) == NULL)
10979                                 {
10980                                   ivd.vd_next = 0;
10981                                   /* PR 17531: file: 046-1082287-0.004.  */
10982                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10983                                   break;
10984                                 }
10985                               else
10986                                 {
10987                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10988                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10989                                 }
10990
10991                               offset += ivd.vd_next;
10992                             }
10993                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10994                                  && ivd.vd_next != 0);
10995
10996                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10997                             {
10998                               Elf_External_Verdaux evda;
10999                               Elf_Internal_Verdaux ivda;
11000
11001                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11002
11003                               if (get_data (&evda, filedata,
11004                                             offset - ivd.vd_next + ivd.vd_aux,
11005                                             sizeof (evda), 1,
11006                                             _("version def aux")) == NULL)
11007                                 break;
11008
11009                               ivda.vda_name = BYTE_GET (evda.vda_name);
11010
11011                               if (ivda.vda_name >= string_sec->sh_size)
11012                                 name = invalid;
11013                               else if (name != NULL && name != invalid)
11014                                 name = _("*both*");
11015                               else
11016                                 name = strtab + ivda.vda_name;
11017                             }
11018                         }
11019                       if (name != NULL)
11020                         nn += printf ("(%s%-*s",
11021                                       name,
11022                                       12 - (int) strlen (name),
11023                                       ")");
11024
11025                       if (nn < 18)
11026                         printf ("%*c", 18 - nn, ' ');
11027                     }
11028
11029                 putchar ('\n');
11030               }
11031
11032             free (data);
11033             free (strtab);
11034             free (symbols);
11035           }
11036           break;
11037
11038         default:
11039           break;
11040         }
11041     }
11042
11043   if (! found)
11044     printf (_("\nNo version information found in this file.\n"));
11045
11046   return TRUE;
11047 }
11048
11049 static const char *
11050 get_symbol_binding (Filedata * filedata, unsigned int binding)
11051 {
11052   static char buff[32];
11053
11054   switch (binding)
11055     {
11056     case STB_LOCAL:     return "LOCAL";
11057     case STB_GLOBAL:    return "GLOBAL";
11058     case STB_WEAK:      return "WEAK";
11059     default:
11060       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
11061         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
11062                   binding);
11063       else if (binding >= STB_LOOS && binding <= STB_HIOS)
11064         {
11065           if (binding == STB_GNU_UNIQUE
11066               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11067                   /* GNU is still using the default value 0.  */
11068                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
11069             return "UNIQUE";
11070           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
11071         }
11072       else
11073         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
11074       return buff;
11075     }
11076 }
11077
11078 static const char *
11079 get_symbol_type (Filedata * filedata, unsigned int type)
11080 {
11081   static char buff[32];
11082
11083   switch (type)
11084     {
11085     case STT_NOTYPE:    return "NOTYPE";
11086     case STT_OBJECT:    return "OBJECT";
11087     case STT_FUNC:      return "FUNC";
11088     case STT_SECTION:   return "SECTION";
11089     case STT_FILE:      return "FILE";
11090     case STT_COMMON:    return "COMMON";
11091     case STT_TLS:       return "TLS";
11092     case STT_RELC:      return "RELC";
11093     case STT_SRELC:     return "SRELC";
11094     default:
11095       if (type >= STT_LOPROC && type <= STT_HIPROC)
11096         {
11097           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
11098             return "THUMB_FUNC";
11099
11100           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
11101             return "REGISTER";
11102
11103           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
11104             return "PARISC_MILLI";
11105
11106           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
11107         }
11108       else if (type >= STT_LOOS && type <= STT_HIOS)
11109         {
11110           if (filedata->file_header.e_machine == EM_PARISC)
11111             {
11112               if (type == STT_HP_OPAQUE)
11113                 return "HP_OPAQUE";
11114               if (type == STT_HP_STUB)
11115                 return "HP_STUB";
11116             }
11117
11118           if (type == STT_GNU_IFUNC
11119               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11120                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
11121                   /* GNU is still using the default value 0.  */
11122                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
11123             return "IFUNC";
11124
11125           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11126         }
11127       else
11128         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11129       return buff;
11130     }
11131 }
11132
11133 static const char *
11134 get_symbol_visibility (unsigned int visibility)
11135 {
11136   switch (visibility)
11137     {
11138     case STV_DEFAULT:   return "DEFAULT";
11139     case STV_INTERNAL:  return "INTERNAL";
11140     case STV_HIDDEN:    return "HIDDEN";
11141     case STV_PROTECTED: return "PROTECTED";
11142     default:
11143       error (_("Unrecognized visibility value: %u"), visibility);
11144       return _("<unknown>");
11145     }
11146 }
11147
11148 static const char *
11149 get_solaris_symbol_visibility (unsigned int visibility)
11150 {
11151   switch (visibility)
11152     {
11153     case 4: return "EXPORTED";
11154     case 5: return "SINGLETON";
11155     case 6: return "ELIMINATE";
11156     default: return get_symbol_visibility (visibility);
11157     }
11158 }
11159
11160 static const char *
11161 get_aarch64_symbol_other (unsigned int other)
11162 {
11163   static char buf[32];
11164
11165   if (other & STO_AARCH64_VARIANT_PCS)
11166     {
11167       other &= ~STO_AARCH64_VARIANT_PCS;
11168       if (other == 0)
11169         return "VARIANT_PCS";
11170       snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other);
11171       return buf;
11172     }
11173   return NULL;
11174 }
11175
11176 static const char *
11177 get_mips_symbol_other (unsigned int other)
11178 {
11179   switch (other)
11180     {
11181     case STO_OPTIONAL:      return "OPTIONAL";
11182     case STO_MIPS_PLT:      return "MIPS PLT";
11183     case STO_MIPS_PIC:      return "MIPS PIC";
11184     case STO_MICROMIPS:     return "MICROMIPS";
11185     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
11186     case STO_MIPS16:        return "MIPS16";
11187     default:                return NULL;
11188     }
11189 }
11190
11191 static const char *
11192 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11193 {
11194   if (is_ia64_vms (filedata))
11195     {
11196       static char res[32];
11197
11198       res[0] = 0;
11199
11200       /* Function types is for images and .STB files only.  */
11201       switch (filedata->file_header.e_type)
11202         {
11203         case ET_DYN:
11204         case ET_EXEC:
11205           switch (VMS_ST_FUNC_TYPE (other))
11206             {
11207             case VMS_SFT_CODE_ADDR:
11208               strcat (res, " CA");
11209               break;
11210             case VMS_SFT_SYMV_IDX:
11211               strcat (res, " VEC");
11212               break;
11213             case VMS_SFT_FD:
11214               strcat (res, " FD");
11215               break;
11216             case VMS_SFT_RESERVE:
11217               strcat (res, " RSV");
11218               break;
11219             default:
11220               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11221                     VMS_ST_FUNC_TYPE (other));
11222               strcat (res, " <unknown>");
11223               break;
11224             }
11225           break;
11226         default:
11227           break;
11228         }
11229       switch (VMS_ST_LINKAGE (other))
11230         {
11231         case VMS_STL_IGNORE:
11232           strcat (res, " IGN");
11233           break;
11234         case VMS_STL_RESERVE:
11235           strcat (res, " RSV");
11236           break;
11237         case VMS_STL_STD:
11238           strcat (res, " STD");
11239           break;
11240         case VMS_STL_LNK:
11241           strcat (res, " LNK");
11242           break;
11243         default:
11244           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11245                 VMS_ST_LINKAGE (other));
11246           strcat (res, " <unknown>");
11247           break;
11248         }
11249
11250       if (res[0] != 0)
11251         return res + 1;
11252       else
11253         return res;
11254     }
11255   return NULL;
11256 }
11257
11258 static const char *
11259 get_ppc64_symbol_other (unsigned int other)
11260 {
11261   if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11262     return NULL;
11263
11264   other >>= STO_PPC64_LOCAL_BIT;
11265   if (other <= 6)
11266     {
11267       static char buf[32];
11268       if (other >= 2)
11269         other = ppc64_decode_local_entry (other);
11270       snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11271       return buf;
11272     }
11273   return NULL;
11274 }
11275
11276 static const char *
11277 get_symbol_other (Filedata * filedata, unsigned int other)
11278 {
11279   const char * result = NULL;
11280   static char buff [32];
11281
11282   if (other == 0)
11283     return "";
11284
11285   switch (filedata->file_header.e_machine)
11286     {
11287     case EM_AARCH64:
11288       result = get_aarch64_symbol_other (other);
11289       break;
11290     case EM_MIPS:
11291       result = get_mips_symbol_other (other);
11292       break;
11293     case EM_IA_64:
11294       result = get_ia64_symbol_other (filedata, other);
11295       break;
11296     case EM_PPC64:
11297       result = get_ppc64_symbol_other (other);
11298       break;
11299     default:
11300       result = NULL;
11301       break;
11302     }
11303
11304   if (result)
11305     return result;
11306
11307   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11308   return buff;
11309 }
11310
11311 static const char *
11312 get_symbol_index_type (Filedata * filedata, unsigned int type)
11313 {
11314   static char buff[32];
11315
11316   switch (type)
11317     {
11318     case SHN_UNDEF:     return "UND";
11319     case SHN_ABS:       return "ABS";
11320     case SHN_COMMON:    return "COM";
11321     default:
11322       if (type == SHN_IA_64_ANSI_COMMON
11323           && filedata->file_header.e_machine == EM_IA_64
11324           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11325         return "ANSI_COM";
11326       else if ((filedata->file_header.e_machine == EM_X86_64
11327                 || filedata->file_header.e_machine == EM_L1OM
11328                 || filedata->file_header.e_machine == EM_K1OM)
11329                && type == SHN_X86_64_LCOMMON)
11330         return "LARGE_COM";
11331       else if ((type == SHN_MIPS_SCOMMON
11332                 && filedata->file_header.e_machine == EM_MIPS)
11333                || (type == SHN_TIC6X_SCOMMON
11334                    && filedata->file_header.e_machine == EM_TI_C6000))
11335         return "SCOM";
11336       else if (type == SHN_MIPS_SUNDEFINED
11337                && filedata->file_header.e_machine == EM_MIPS)
11338         return "SUND";
11339       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11340         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11341       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11342         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11343       else if (type >= SHN_LORESERVE)
11344         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11345       else if (type >= filedata->file_header.e_shnum)
11346         sprintf (buff, _("bad section index[%3d]"), type);
11347       else
11348         sprintf (buff, "%3d", type);
11349       break;
11350     }
11351
11352   return buff;
11353 }
11354
11355 static bfd_vma *
11356 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11357 {
11358   unsigned char * e_data;
11359   bfd_vma * i_data;
11360
11361   /* If the size_t type is smaller than the bfd_size_type, eg because
11362      you are building a 32-bit tool on a 64-bit host, then make sure
11363      that when (number) is cast to (size_t) no information is lost.  */
11364   if (sizeof (size_t) < sizeof (bfd_size_type)
11365       && (bfd_size_type) ((size_t) number) != number)
11366     {
11367       error (_("Size truncation prevents reading %s elements of size %u\n"),
11368              bfd_vmatoa ("u", number), ent_size);
11369       return NULL;
11370     }
11371
11372   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11373      attempting to allocate memory when the read is bound to fail.  */
11374   if (ent_size * number > filedata->file_size)
11375     {
11376       error (_("Invalid number of dynamic entries: %s\n"),
11377              bfd_vmatoa ("u", number));
11378       return NULL;
11379     }
11380
11381   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11382   if (e_data == NULL)
11383     {
11384       error (_("Out of memory reading %s dynamic entries\n"),
11385              bfd_vmatoa ("u", number));
11386       return NULL;
11387     }
11388
11389   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11390     {
11391       error (_("Unable to read in %s bytes of dynamic data\n"),
11392              bfd_vmatoa ("u", number * ent_size));
11393       free (e_data);
11394       return NULL;
11395     }
11396
11397   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11398   if (i_data == NULL)
11399     {
11400       error (_("Out of memory allocating space for %s dynamic entries\n"),
11401              bfd_vmatoa ("u", number));
11402       free (e_data);
11403       return NULL;
11404     }
11405
11406   while (number--)
11407     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11408
11409   free (e_data);
11410
11411   return i_data;
11412 }
11413
11414 static void
11415 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11416 {
11417   Elf_Internal_Sym * psym;
11418   int n;
11419
11420   n = print_vma (si, DEC_5);
11421   if (n < 5)
11422     fputs (&"     "[n], stdout);
11423   printf (" %3lu: ", hn);
11424
11425   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11426     {
11427       printf (_("<No info available for dynamic symbol number %lu>\n"),
11428               (unsigned long) si);
11429       return;
11430     }
11431
11432   psym = dynamic_symbols + si;
11433   print_vma (psym->st_value, LONG_HEX);
11434   putchar (' ');
11435   print_vma (psym->st_size, DEC_5);
11436
11437   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11438   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11439
11440   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11441     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11442   else
11443     {
11444       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11445
11446       printf (" %-7s",  get_symbol_visibility (vis));
11447       /* Check to see if any other bits in the st_other field are set.
11448          Note - displaying this information disrupts the layout of the
11449          table being generated, but for the moment this case is very
11450          rare.  */
11451       if (psym->st_other ^ vis)
11452         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11453     }
11454
11455   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11456   if (VALID_DYNAMIC_NAME (psym->st_name))
11457     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11458   else
11459     printf (_(" <corrupt: %14ld>"), psym->st_name);
11460   putchar ('\n');
11461 }
11462
11463 static const char *
11464 get_symbol_version_string (Filedata *                   filedata,
11465                            bfd_boolean                  is_dynsym,
11466                            const char *                 strtab,
11467                            unsigned long int            strtab_size,
11468                            unsigned int                 si,
11469                            Elf_Internal_Sym *           psym,
11470                            enum versioned_symbol_info * sym_info,
11471                            unsigned short *             vna_other)
11472 {
11473   unsigned char data[2];
11474   unsigned short vers_data;
11475   unsigned long offset;
11476   unsigned short max_vd_ndx;
11477
11478   if (!is_dynsym
11479       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11480     return NULL;
11481
11482   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11483                             sizeof data + si * sizeof (vers_data));
11484
11485   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11486                 sizeof (data), 1, _("version data")) == NULL)
11487     return NULL;
11488
11489   vers_data = byte_get (data, 2);
11490
11491   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11492     return NULL;
11493
11494   max_vd_ndx = 0;
11495
11496   /* Usually we'd only see verdef for defined symbols, and verneed for
11497      undefined symbols.  However, symbols defined by the linker in
11498      .dynbss for variables copied from a shared library in order to
11499      avoid text relocations are defined yet have verneed.  We could
11500      use a heuristic to detect the special case, for example, check
11501      for verneed first on symbols defined in SHT_NOBITS sections, but
11502      it is simpler and more reliable to just look for both verdef and
11503      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11504
11505   if (psym->st_shndx != SHN_UNDEF
11506       && vers_data != 0x8001
11507       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11508     {
11509       Elf_Internal_Verdef ivd;
11510       Elf_Internal_Verdaux ivda;
11511       Elf_External_Verdaux evda;
11512       unsigned long off;
11513
11514       off = offset_from_vma (filedata,
11515                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11516                              sizeof (Elf_External_Verdef));
11517
11518       do
11519         {
11520           Elf_External_Verdef evd;
11521
11522           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11523                         _("version def")) == NULL)
11524             {
11525               ivd.vd_ndx = 0;
11526               ivd.vd_aux = 0;
11527               ivd.vd_next = 0;
11528               ivd.vd_flags = 0;
11529             }
11530           else
11531             {
11532               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11533               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11534               ivd.vd_next = BYTE_GET (evd.vd_next);
11535               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11536             }
11537
11538           if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11539             max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11540
11541           off += ivd.vd_next;
11542         }
11543       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11544
11545       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11546         {
11547           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11548             return NULL;
11549
11550           off -= ivd.vd_next;
11551           off += ivd.vd_aux;
11552
11553           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11554                         _("version def aux")) != NULL)
11555             {
11556               ivda.vda_name = BYTE_GET (evda.vda_name);
11557
11558               if (psym->st_name != ivda.vda_name)
11559                 {
11560                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11561                                ? symbol_hidden : symbol_public);
11562                   return (ivda.vda_name < strtab_size
11563                           ? strtab + ivda.vda_name : _("<corrupt>"));
11564                 }
11565             }
11566         }
11567     }
11568
11569   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11570     {
11571       Elf_External_Verneed evn;
11572       Elf_Internal_Verneed ivn;
11573       Elf_Internal_Vernaux ivna;
11574
11575       offset = offset_from_vma (filedata,
11576                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11577                                 sizeof evn);
11578       do
11579         {
11580           unsigned long vna_off;
11581
11582           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11583                         _("version need")) == NULL)
11584             {
11585               ivna.vna_next = 0;
11586               ivna.vna_other = 0;
11587               ivna.vna_name = 0;
11588               break;
11589             }
11590
11591           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11592           ivn.vn_next = BYTE_GET (evn.vn_next);
11593
11594           vna_off = offset + ivn.vn_aux;
11595
11596           do
11597             {
11598               Elf_External_Vernaux evna;
11599
11600               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11601                             _("version need aux (3)")) == NULL)
11602                 {
11603                   ivna.vna_next = 0;
11604                   ivna.vna_other = 0;
11605                   ivna.vna_name = 0;
11606                 }
11607               else
11608                 {
11609                   ivna.vna_other = BYTE_GET (evna.vna_other);
11610                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11611                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11612                 }
11613
11614               vna_off += ivna.vna_next;
11615             }
11616           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11617
11618           if (ivna.vna_other == vers_data)
11619             break;
11620
11621           offset += ivn.vn_next;
11622         }
11623       while (ivn.vn_next != 0);
11624
11625       if (ivna.vna_other == vers_data)
11626         {
11627           *sym_info = symbol_undefined;
11628           *vna_other = ivna.vna_other;
11629           return (ivna.vna_name < strtab_size
11630                   ? strtab + ivna.vna_name : _("<corrupt>"));
11631         }
11632       else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11633                && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11634         return _("<corrupt>");
11635     }
11636   return NULL;
11637 }
11638
11639 /* Dump the symbol table.  */
11640 static bfd_boolean
11641 process_symbol_table (Filedata * filedata)
11642 {
11643   Elf_Internal_Shdr * section;
11644   bfd_size_type nbuckets = 0;
11645   bfd_size_type nchains = 0;
11646   bfd_vma * buckets = NULL;
11647   bfd_vma * chains = NULL;
11648   bfd_vma ngnubuckets = 0;
11649   bfd_vma * gnubuckets = NULL;
11650   bfd_vma * gnuchains = NULL;
11651   bfd_vma gnusymidx = 0;
11652   bfd_size_type ngnuchains = 0;
11653
11654   if (!do_syms && !do_dyn_syms && !do_histogram)
11655     return TRUE;
11656
11657   if (dynamic_info[DT_HASH]
11658       && (do_histogram
11659           || (do_using_dynamic
11660               && !do_dyn_syms
11661               && dynamic_strings != NULL)))
11662     {
11663       unsigned char nb[8];
11664       unsigned char nc[8];
11665       unsigned int hash_ent_size = 4;
11666
11667       if ((filedata->file_header.e_machine == EM_ALPHA
11668            || filedata->file_header.e_machine == EM_S390
11669            || filedata->file_header.e_machine == EM_S390_OLD)
11670           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11671         hash_ent_size = 8;
11672
11673       if (fseek (filedata->handle,
11674                  (archive_file_offset
11675                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11676                                      sizeof nb + sizeof nc)),
11677                  SEEK_SET))
11678         {
11679           error (_("Unable to seek to start of dynamic information\n"));
11680           goto no_hash;
11681         }
11682
11683       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11684         {
11685           error (_("Failed to read in number of buckets\n"));
11686           goto no_hash;
11687         }
11688
11689       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11690         {
11691           error (_("Failed to read in number of chains\n"));
11692           goto no_hash;
11693         }
11694
11695       nbuckets = byte_get (nb, hash_ent_size);
11696       nchains  = byte_get (nc, hash_ent_size);
11697
11698       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11699       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11700
11701     no_hash:
11702       if (buckets == NULL || chains == NULL)
11703         {
11704           if (do_using_dynamic)
11705             return FALSE;
11706           free (buckets);
11707           free (chains);
11708           buckets = NULL;
11709           chains = NULL;
11710           nbuckets = 0;
11711           nchains = 0;
11712         }
11713     }
11714
11715   if (dynamic_info_DT_GNU_HASH
11716       && (do_histogram
11717           || (do_using_dynamic
11718               && !do_dyn_syms
11719               && dynamic_strings != NULL)))
11720     {
11721       unsigned char nb[16];
11722       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11723       bfd_vma buckets_vma;
11724
11725       if (fseek (filedata->handle,
11726                  (archive_file_offset
11727                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11728                                      sizeof nb)),
11729                  SEEK_SET))
11730         {
11731           error (_("Unable to seek to start of dynamic information\n"));
11732           goto no_gnu_hash;
11733         }
11734
11735       if (fread (nb, 16, 1, filedata->handle) != 1)
11736         {
11737           error (_("Failed to read in number of buckets\n"));
11738           goto no_gnu_hash;
11739         }
11740
11741       ngnubuckets = byte_get (nb, 4);
11742       gnusymidx = byte_get (nb + 4, 4);
11743       bitmaskwords = byte_get (nb + 8, 4);
11744       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11745       if (is_32bit_elf)
11746         buckets_vma += bitmaskwords * 4;
11747       else
11748         buckets_vma += bitmaskwords * 8;
11749
11750       if (fseek (filedata->handle,
11751                  (archive_file_offset
11752                   + offset_from_vma (filedata, buckets_vma, 4)),
11753                  SEEK_SET))
11754         {
11755           error (_("Unable to seek to start of dynamic information\n"));
11756           goto no_gnu_hash;
11757         }
11758
11759       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11760
11761       if (gnubuckets == NULL)
11762         goto no_gnu_hash;
11763
11764       for (i = 0; i < ngnubuckets; i++)
11765         if (gnubuckets[i] != 0)
11766           {
11767             if (gnubuckets[i] < gnusymidx)
11768               return FALSE;
11769
11770             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11771               maxchain = gnubuckets[i];
11772           }
11773
11774       if (maxchain == 0xffffffff)
11775         goto no_gnu_hash;
11776
11777       maxchain -= gnusymidx;
11778
11779       if (fseek (filedata->handle,
11780                  (archive_file_offset
11781                   + offset_from_vma (filedata, buckets_vma
11782                                            + 4 * (ngnubuckets + maxchain), 4)),
11783                  SEEK_SET))
11784         {
11785           error (_("Unable to seek to start of dynamic information\n"));
11786           goto no_gnu_hash;
11787         }
11788
11789       do
11790         {
11791           if (fread (nb, 4, 1, filedata->handle) != 1)
11792             {
11793               error (_("Failed to determine last chain length\n"));
11794               goto no_gnu_hash;
11795             }
11796
11797           if (maxchain + 1 == 0)
11798             goto no_gnu_hash;
11799
11800           ++maxchain;
11801         }
11802       while ((byte_get (nb, 4) & 1) == 0);
11803
11804       if (fseek (filedata->handle,
11805                  (archive_file_offset
11806                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11807                  SEEK_SET))
11808         {
11809           error (_("Unable to seek to start of dynamic information\n"));
11810           goto no_gnu_hash;
11811         }
11812
11813       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11814       ngnuchains = maxchain;
11815
11816     no_gnu_hash:
11817       if (gnuchains == NULL)
11818         {
11819           free (gnubuckets);
11820           gnubuckets = NULL;
11821           ngnubuckets = 0;
11822           if (do_using_dynamic)
11823             return FALSE;
11824         }
11825     }
11826
11827   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11828       && do_syms
11829       && do_using_dynamic
11830       && dynamic_strings != NULL
11831       && dynamic_symbols != NULL)
11832     {
11833       unsigned long hn;
11834
11835       if (dynamic_info[DT_HASH])
11836         {
11837           bfd_vma si;
11838           char *visited;
11839
11840           printf (_("\nSymbol table for image:\n"));
11841           if (is_32bit_elf)
11842             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11843           else
11844             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11845
11846           visited = xcmalloc (nchains, 1);
11847           memset (visited, 0, nchains);
11848           for (hn = 0; hn < nbuckets; hn++)
11849             {
11850               for (si = buckets[hn]; si > 0; si = chains[si])
11851                 {
11852                   print_dynamic_symbol (filedata, si, hn);
11853                   if (si >= nchains || visited[si])
11854                     {
11855                       error (_("histogram chain is corrupt\n"));
11856                       break;
11857                     }
11858                   visited[si] = 1;
11859                 }
11860             }
11861           free (visited);
11862         }
11863
11864       if (dynamic_info_DT_GNU_HASH)
11865         {
11866           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11867           if (is_32bit_elf)
11868             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11869           else
11870             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11871
11872           for (hn = 0; hn < ngnubuckets; ++hn)
11873             if (gnubuckets[hn] != 0)
11874               {
11875                 bfd_vma si = gnubuckets[hn];
11876                 bfd_vma off = si - gnusymidx;
11877
11878                 do
11879                   {
11880                     print_dynamic_symbol (filedata, si, hn);
11881                     si++;
11882                   }
11883                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11884               }
11885         }
11886     }
11887   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11888            && filedata->section_headers != NULL)
11889     {
11890       unsigned int i;
11891
11892       for (i = 0, section = filedata->section_headers;
11893            i < filedata->file_header.e_shnum;
11894            i++, section++)
11895         {
11896           unsigned int si;
11897           char * strtab = NULL;
11898           unsigned long int strtab_size = 0;
11899           Elf_Internal_Sym * symtab;
11900           Elf_Internal_Sym * psym;
11901           unsigned long num_syms;
11902
11903           if ((section->sh_type != SHT_SYMTAB
11904                && section->sh_type != SHT_DYNSYM)
11905               || (!do_syms
11906                   && section->sh_type == SHT_SYMTAB))
11907             continue;
11908
11909           if (section->sh_entsize == 0)
11910             {
11911               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11912                       printable_section_name (filedata, section));
11913               continue;
11914             }
11915
11916           num_syms = section->sh_size / section->sh_entsize;
11917           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11918                             "\nSymbol table '%s' contains %lu entries:\n",
11919                             num_syms),
11920                   printable_section_name (filedata, section),
11921                   num_syms);
11922
11923           if (is_32bit_elf)
11924             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11925           else
11926             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11927
11928           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11929           if (symtab == NULL)
11930             continue;
11931
11932           if (section->sh_link == filedata->file_header.e_shstrndx)
11933             {
11934               strtab = filedata->string_table;
11935               strtab_size = filedata->string_table_length;
11936             }
11937           else if (section->sh_link < filedata->file_header.e_shnum)
11938             {
11939               Elf_Internal_Shdr * string_sec;
11940
11941               string_sec = filedata->section_headers + section->sh_link;
11942
11943               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11944                                           1, string_sec->sh_size,
11945                                           _("string table"));
11946               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11947             }
11948
11949           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11950             {
11951               const char *version_string;
11952               enum versioned_symbol_info sym_info;
11953               unsigned short vna_other;
11954
11955               printf ("%6d: ", si);
11956               print_vma (psym->st_value, LONG_HEX);
11957               putchar (' ');
11958               print_vma (psym->st_size, DEC_5);
11959               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11960               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11961               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11962                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11963               else
11964                 {
11965                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11966
11967                   printf (" %-7s", get_symbol_visibility (vis));
11968                   /* Check to see if any other bits in the st_other field are set.
11969                      Note - displaying this information disrupts the layout of the
11970                      table being generated, but for the moment this case is very rare.  */
11971                   if (psym->st_other ^ vis)
11972                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11973                 }
11974               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11975               print_symbol (25, psym->st_name < strtab_size
11976                             ? strtab + psym->st_name : _("<corrupt>"));
11977
11978               version_string
11979                 = get_symbol_version_string (filedata,
11980                                              section->sh_type == SHT_DYNSYM,
11981                                              strtab, strtab_size, si,
11982                                              psym, &sym_info, &vna_other);
11983               if (version_string)
11984                 {
11985                   if (sym_info == symbol_undefined)
11986                     printf ("@%s (%d)", version_string, vna_other);
11987                   else
11988                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11989                             version_string);
11990                 }
11991
11992               putchar ('\n');
11993
11994               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11995                   && si >= section->sh_info
11996                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11997                   && filedata->file_header.e_machine != EM_MIPS
11998                   /* Solaris binaries have been found to violate this requirement as
11999                      well.  Not sure if this is a bug or an ABI requirement.  */
12000                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
12001                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12002                       si, printable_section_name (filedata, section), section->sh_info);
12003             }
12004
12005           free (symtab);
12006           if (strtab != filedata->string_table)
12007             free (strtab);
12008         }
12009     }
12010   else if (do_syms)
12011     printf
12012       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12013
12014   if (do_histogram && buckets != NULL)
12015     {
12016       unsigned long * lengths;
12017       unsigned long * counts;
12018       unsigned long hn;
12019       bfd_vma si;
12020       unsigned long maxlength = 0;
12021       unsigned long nzero_counts = 0;
12022       unsigned long nsyms = 0;
12023       char *visited;
12024
12025       printf (ngettext ("\nHistogram for bucket list length "
12026                         "(total of %lu bucket):\n",
12027                         "\nHistogram for bucket list length "
12028                         "(total of %lu buckets):\n",
12029                         (unsigned long) nbuckets),
12030               (unsigned long) nbuckets);
12031
12032       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
12033       if (lengths == NULL)
12034         {
12035           error (_("Out of memory allocating space for histogram buckets\n"));
12036           return FALSE;
12037         }
12038       visited = xcmalloc (nchains, 1);
12039       memset (visited, 0, nchains);
12040
12041       printf (_(" Length  Number     %% of total  Coverage\n"));
12042       for (hn = 0; hn < nbuckets; ++hn)
12043         {
12044           for (si = buckets[hn]; si > 0; si = chains[si])
12045             {
12046               ++nsyms;
12047               if (maxlength < ++lengths[hn])
12048                 ++maxlength;
12049               if (si >= nchains || visited[si])
12050                 {
12051                   error (_("histogram chain is corrupt\n"));
12052                   break;
12053                 }
12054               visited[si] = 1;
12055             }
12056         }
12057       free (visited);
12058
12059       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12060       if (counts == NULL)
12061         {
12062           free (lengths);
12063           error (_("Out of memory allocating space for histogram counts\n"));
12064           return FALSE;
12065         }
12066
12067       for (hn = 0; hn < nbuckets; ++hn)
12068         ++counts[lengths[hn]];
12069
12070       if (nbuckets > 0)
12071         {
12072           unsigned long i;
12073           printf ("      0  %-10lu (%5.1f%%)\n",
12074                   counts[0], (counts[0] * 100.0) / nbuckets);
12075           for (i = 1; i <= maxlength; ++i)
12076             {
12077               nzero_counts += counts[i] * i;
12078               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
12079                       i, counts[i], (counts[i] * 100.0) / nbuckets,
12080                       (nzero_counts * 100.0) / nsyms);
12081             }
12082         }
12083
12084       free (counts);
12085       free (lengths);
12086     }
12087
12088   if (buckets != NULL)
12089     {
12090       free (buckets);
12091       free (chains);
12092     }
12093
12094   if (do_histogram && gnubuckets != NULL)
12095     {
12096       unsigned long * lengths;
12097       unsigned long * counts;
12098       unsigned long hn;
12099       unsigned long maxlength = 0;
12100       unsigned long nzero_counts = 0;
12101       unsigned long nsyms = 0;
12102
12103       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
12104                         "(total of %lu bucket):\n",
12105                         "\nHistogram for `.gnu.hash' bucket list length "
12106                         "(total of %lu buckets):\n",
12107                         (unsigned long) ngnubuckets),
12108               (unsigned long) ngnubuckets);
12109
12110       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
12111       if (lengths == NULL)
12112         {
12113           error (_("Out of memory allocating space for gnu histogram buckets\n"));
12114           return FALSE;
12115         }
12116
12117       printf (_(" Length  Number     %% of total  Coverage\n"));
12118
12119       for (hn = 0; hn < ngnubuckets; ++hn)
12120         if (gnubuckets[hn] != 0)
12121           {
12122             bfd_vma off, length = 1;
12123
12124             for (off = gnubuckets[hn] - gnusymidx;
12125                  /* PR 17531 file: 010-77222-0.004.  */
12126                  off < ngnuchains && (gnuchains[off] & 1) == 0;
12127                  ++off)
12128               ++length;
12129             lengths[hn] = length;
12130             if (length > maxlength)
12131               maxlength = length;
12132             nsyms += length;
12133           }
12134
12135       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12136       if (counts == NULL)
12137         {
12138           free (lengths);
12139           error (_("Out of memory allocating space for gnu histogram counts\n"));
12140           return FALSE;
12141         }
12142
12143       for (hn = 0; hn < ngnubuckets; ++hn)
12144         ++counts[lengths[hn]];
12145
12146       if (ngnubuckets > 0)
12147         {
12148           unsigned long j;
12149           printf ("      0  %-10lu (%5.1f%%)\n",
12150                   counts[0], (counts[0] * 100.0) / ngnubuckets);
12151           for (j = 1; j <= maxlength; ++j)
12152             {
12153               nzero_counts += counts[j] * j;
12154               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
12155                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
12156                       (nzero_counts * 100.0) / nsyms);
12157             }
12158         }
12159
12160       free (counts);
12161       free (lengths);
12162       free (gnubuckets);
12163       free (gnuchains);
12164     }
12165
12166   return TRUE;
12167 }
12168
12169 static bfd_boolean
12170 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12171 {
12172   unsigned int i;
12173
12174   if (dynamic_syminfo == NULL
12175       || !do_dynamic)
12176     /* No syminfo, this is ok.  */
12177     return TRUE;
12178
12179   /* There better should be a dynamic symbol section.  */
12180   if (dynamic_symbols == NULL || dynamic_strings == NULL)
12181     return FALSE;
12182
12183   if (dynamic_addr)
12184     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12185                       "contains %d entry:\n",
12186                       "\nDynamic info segment at offset 0x%lx "
12187                       "contains %d entries:\n",
12188                       dynamic_syminfo_nent),
12189             dynamic_syminfo_offset, dynamic_syminfo_nent);
12190
12191   printf (_(" Num: Name                           BoundTo     Flags\n"));
12192   for (i = 0; i < dynamic_syminfo_nent; ++i)
12193     {
12194       unsigned short int flags = dynamic_syminfo[i].si_flags;
12195
12196       printf ("%4d: ", i);
12197       if (i >= num_dynamic_syms)
12198         printf (_("<corrupt index>"));
12199       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12200         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12201       else
12202         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12203       putchar (' ');
12204
12205       switch (dynamic_syminfo[i].si_boundto)
12206         {
12207         case SYMINFO_BT_SELF:
12208           fputs ("SELF       ", stdout);
12209           break;
12210         case SYMINFO_BT_PARENT:
12211           fputs ("PARENT     ", stdout);
12212           break;
12213         default:
12214           if (dynamic_syminfo[i].si_boundto > 0
12215               && dynamic_syminfo[i].si_boundto < dynamic_nent
12216               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12217             {
12218               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12219               putchar (' ' );
12220             }
12221           else
12222             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12223           break;
12224         }
12225
12226       if (flags & SYMINFO_FLG_DIRECT)
12227         printf (" DIRECT");
12228       if (flags & SYMINFO_FLG_PASSTHRU)
12229         printf (" PASSTHRU");
12230       if (flags & SYMINFO_FLG_COPY)
12231         printf (" COPY");
12232       if (flags & SYMINFO_FLG_LAZYLOAD)
12233         printf (" LAZYLOAD");
12234
12235       puts ("");
12236     }
12237
12238   return TRUE;
12239 }
12240
12241 #define IN_RANGE(START,END,ADDR,OFF)            \
12242   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12243
12244 /* Check to see if the given reloc needs to be handled in a target specific
12245    manner.  If so then process the reloc and return TRUE otherwise return
12246    FALSE.
12247
12248    If called with reloc == NULL, then this is a signal that reloc processing
12249    for the current section has finished, and any saved state should be
12250    discarded.  */
12251
12252 static bfd_boolean
12253 target_specific_reloc_handling (Filedata *           filedata,
12254                                 Elf_Internal_Rela *  reloc,
12255                                 unsigned char *      start,
12256                                 unsigned char *      end,
12257                                 Elf_Internal_Sym *   symtab,
12258                                 unsigned long        num_syms)
12259 {
12260   unsigned int reloc_type = 0;
12261   unsigned long sym_index = 0;
12262
12263   if (reloc)
12264     {
12265       reloc_type = get_reloc_type (filedata, reloc->r_info);
12266       sym_index = get_reloc_symindex (reloc->r_info);
12267     }
12268
12269   switch (filedata->file_header.e_machine)
12270     {
12271     case EM_MSP430:
12272     case EM_MSP430_OLD:
12273       {
12274         static Elf_Internal_Sym * saved_sym = NULL;
12275
12276         if (reloc == NULL)
12277           {
12278             saved_sym = NULL;
12279             return TRUE;
12280           }
12281
12282         switch (reloc_type)
12283           {
12284           case 10: /* R_MSP430_SYM_DIFF */
12285             if (uses_msp430x_relocs (filedata))
12286               break;
12287             /* Fall through.  */
12288           case 21: /* R_MSP430X_SYM_DIFF */
12289             /* PR 21139.  */
12290             if (sym_index >= num_syms)
12291               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12292                      sym_index);
12293             else
12294               saved_sym = symtab + sym_index;
12295             return TRUE;
12296
12297           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12298           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12299             goto handle_sym_diff;
12300
12301           case 5: /* R_MSP430_16_BYTE */
12302           case 9: /* R_MSP430_8 */
12303             if (uses_msp430x_relocs (filedata))
12304               break;
12305             goto handle_sym_diff;
12306
12307           case 2: /* R_MSP430_ABS16 */
12308           case 15: /* R_MSP430X_ABS16 */
12309             if (! uses_msp430x_relocs (filedata))
12310               break;
12311             goto handle_sym_diff;
12312
12313           handle_sym_diff:
12314             if (saved_sym != NULL)
12315               {
12316                 int reloc_size = reloc_type == 1 ? 4 : 2;
12317                 bfd_vma value;
12318
12319                 if (sym_index >= num_syms)
12320                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12321                          sym_index);
12322                 else
12323                   {
12324                     value = reloc->r_addend + (symtab[sym_index].st_value
12325                                                - saved_sym->st_value);
12326
12327                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12328                       byte_put (start + reloc->r_offset, value, reloc_size);
12329                     else
12330                       /* PR 21137 */
12331                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12332                              (long) reloc->r_offset);
12333                   }
12334
12335                 saved_sym = NULL;
12336                 return TRUE;
12337               }
12338             break;
12339
12340           default:
12341             if (saved_sym != NULL)
12342               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12343             break;
12344           }
12345         break;
12346       }
12347
12348     case EM_MN10300:
12349     case EM_CYGNUS_MN10300:
12350       {
12351         static Elf_Internal_Sym * saved_sym = NULL;
12352
12353         if (reloc == NULL)
12354           {
12355             saved_sym = NULL;
12356             return TRUE;
12357           }
12358
12359         switch (reloc_type)
12360           {
12361           case 34: /* R_MN10300_ALIGN */
12362             return TRUE;
12363           case 33: /* R_MN10300_SYM_DIFF */
12364             if (sym_index >= num_syms)
12365               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12366                      sym_index);
12367             else
12368               saved_sym = symtab + sym_index;
12369             return TRUE;
12370
12371           case 1: /* R_MN10300_32 */
12372           case 2: /* R_MN10300_16 */
12373             if (saved_sym != NULL)
12374               {
12375                 int reloc_size = reloc_type == 1 ? 4 : 2;
12376                 bfd_vma value;
12377
12378                 if (sym_index >= num_syms)
12379                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12380                          sym_index);
12381                 else
12382                   {
12383                     value = reloc->r_addend + (symtab[sym_index].st_value
12384                                                - saved_sym->st_value);
12385
12386                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12387                       byte_put (start + reloc->r_offset, value, reloc_size);
12388                     else
12389                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12390                              (long) reloc->r_offset);
12391                   }
12392
12393                 saved_sym = NULL;
12394                 return TRUE;
12395               }
12396             break;
12397           default:
12398             if (saved_sym != NULL)
12399               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12400             break;
12401           }
12402         break;
12403       }
12404
12405     case EM_RL78:
12406       {
12407         static bfd_vma saved_sym1 = 0;
12408         static bfd_vma saved_sym2 = 0;
12409         static bfd_vma value;
12410
12411         if (reloc == NULL)
12412           {
12413             saved_sym1 = saved_sym2 = 0;
12414             return TRUE;
12415           }
12416
12417         switch (reloc_type)
12418           {
12419           case 0x80: /* R_RL78_SYM.  */
12420             saved_sym1 = saved_sym2;
12421             if (sym_index >= num_syms)
12422               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12423                      sym_index);
12424             else
12425               {
12426                 saved_sym2 = symtab[sym_index].st_value;
12427                 saved_sym2 += reloc->r_addend;
12428               }
12429             return TRUE;
12430
12431           case 0x83: /* R_RL78_OPsub.  */
12432             value = saved_sym1 - saved_sym2;
12433             saved_sym2 = saved_sym1 = 0;
12434             return TRUE;
12435             break;
12436
12437           case 0x41: /* R_RL78_ABS32.  */
12438             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12439               byte_put (start + reloc->r_offset, value, 4);
12440             else
12441               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12442                      (long) reloc->r_offset);
12443             value = 0;
12444             return TRUE;
12445
12446           case 0x43: /* R_RL78_ABS16.  */
12447             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12448               byte_put (start + reloc->r_offset, value, 2);
12449             else
12450               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12451                      (long) reloc->r_offset);
12452             value = 0;
12453             return TRUE;
12454
12455           default:
12456             break;
12457           }
12458         break;
12459       }
12460     }
12461
12462   return FALSE;
12463 }
12464
12465 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12466    DWARF debug sections.  This is a target specific test.  Note - we do not
12467    go through the whole including-target-headers-multiple-times route, (as
12468    we have already done with <elf/h8.h>) because this would become very
12469    messy and even then this function would have to contain target specific
12470    information (the names of the relocs instead of their numeric values).
12471    FIXME: This is not the correct way to solve this problem.  The proper way
12472    is to have target specific reloc sizing and typing functions created by
12473    the reloc-macros.h header, in the same way that it already creates the
12474    reloc naming functions.  */
12475
12476 static bfd_boolean
12477 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12478 {
12479   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12480   switch (filedata->file_header.e_machine)
12481     {
12482     case EM_386:
12483     case EM_IAMCU:
12484       return reloc_type == 1; /* R_386_32.  */
12485     case EM_68K:
12486       return reloc_type == 1; /* R_68K_32.  */
12487     case EM_860:
12488       return reloc_type == 1; /* R_860_32.  */
12489     case EM_960:
12490       return reloc_type == 2; /* R_960_32.  */
12491     case EM_AARCH64:
12492       return (reloc_type == 258
12493               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12494     case EM_BPF:
12495       return reloc_type == 11; /* R_BPF_DATA_32 */
12496     case EM_ADAPTEVA_EPIPHANY:
12497       return reloc_type == 3;
12498     case EM_ALPHA:
12499       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12500     case EM_ARC:
12501       return reloc_type == 1; /* R_ARC_32.  */
12502     case EM_ARC_COMPACT:
12503     case EM_ARC_COMPACT2:
12504       return reloc_type == 4; /* R_ARC_32.  */
12505     case EM_ARM:
12506       return reloc_type == 2; /* R_ARM_ABS32 */
12507     case EM_AVR_OLD:
12508     case EM_AVR:
12509       return reloc_type == 1;
12510     case EM_BLACKFIN:
12511       return reloc_type == 0x12; /* R_byte4_data.  */
12512     case EM_CRIS:
12513       return reloc_type == 3; /* R_CRIS_32.  */
12514     case EM_CR16:
12515       return reloc_type == 3; /* R_CR16_NUM32.  */
12516     case EM_CRX:
12517       return reloc_type == 15; /* R_CRX_NUM32.  */
12518     case EM_CSKY:
12519       return reloc_type == 1; /* R_CKCORE_ADDR32.  */
12520     case EM_CYGNUS_FRV:
12521       return reloc_type == 1;
12522     case EM_CYGNUS_D10V:
12523     case EM_D10V:
12524       return reloc_type == 6; /* R_D10V_32.  */
12525     case EM_CYGNUS_D30V:
12526     case EM_D30V:
12527       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12528     case EM_DLX:
12529       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12530     case EM_CYGNUS_FR30:
12531     case EM_FR30:
12532       return reloc_type == 3; /* R_FR30_32.  */
12533     case EM_FT32:
12534       return reloc_type == 1; /* R_FT32_32.  */
12535     case EM_H8S:
12536     case EM_H8_300:
12537     case EM_H8_300H:
12538       return reloc_type == 1; /* R_H8_DIR32.  */
12539     case EM_IA_64:
12540       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12541               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12542               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12543               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12544     case EM_IP2K_OLD:
12545     case EM_IP2K:
12546       return reloc_type == 2; /* R_IP2K_32.  */
12547     case EM_IQ2000:
12548       return reloc_type == 2; /* R_IQ2000_32.  */
12549     case EM_LATTICEMICO32:
12550       return reloc_type == 3; /* R_LM32_32.  */
12551     case EM_M32C_OLD:
12552     case EM_M32C:
12553       return reloc_type == 3; /* R_M32C_32.  */
12554     case EM_M32R:
12555       return reloc_type == 34; /* R_M32R_32_RELA.  */
12556     case EM_68HC11:
12557     case EM_68HC12:
12558       return reloc_type == 6; /* R_M68HC11_32.  */
12559     case EM_S12Z:
12560       return reloc_type == 7 || /* R_S12Z_EXT32 */
12561         reloc_type == 6;        /* R_S12Z_CW32.  */
12562     case EM_MCORE:
12563       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12564     case EM_CYGNUS_MEP:
12565       return reloc_type == 4; /* R_MEP_32.  */
12566     case EM_METAG:
12567       return reloc_type == 2; /* R_METAG_ADDR32.  */
12568     case EM_MICROBLAZE:
12569       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12570     case EM_MIPS:
12571       return reloc_type == 2; /* R_MIPS_32.  */
12572     case EM_MMIX:
12573       return reloc_type == 4; /* R_MMIX_32.  */
12574     case EM_CYGNUS_MN10200:
12575     case EM_MN10200:
12576       return reloc_type == 1; /* R_MN10200_32.  */
12577     case EM_CYGNUS_MN10300:
12578     case EM_MN10300:
12579       return reloc_type == 1; /* R_MN10300_32.  */
12580     case EM_MOXIE:
12581       return reloc_type == 1; /* R_MOXIE_32.  */
12582     case EM_MSP430_OLD:
12583     case EM_MSP430:
12584       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12585     case EM_MT:
12586       return reloc_type == 2; /* R_MT_32.  */
12587     case EM_NDS32:
12588       return reloc_type == 20; /* R_NDS32_RELA.  */
12589     case EM_ALTERA_NIOS2:
12590       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12591     case EM_NIOS32:
12592       return reloc_type == 1; /* R_NIOS_32.  */
12593     case EM_OR1K:
12594       return reloc_type == 1; /* R_OR1K_32.  */
12595     case EM_PARISC:
12596       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12597               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12598               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12599     case EM_PJ:
12600     case EM_PJ_OLD:
12601       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12602     case EM_PPC64:
12603       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12604     case EM_PPC:
12605       return reloc_type == 1; /* R_PPC_ADDR32.  */
12606     case EM_TI_PRU:
12607       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12608     case EM_RISCV:
12609       return reloc_type == 1; /* R_RISCV_32.  */
12610     case EM_RL78:
12611       return reloc_type == 1; /* R_RL78_DIR32.  */
12612     case EM_RX:
12613       return reloc_type == 1; /* R_RX_DIR32.  */
12614     case EM_S370:
12615       return reloc_type == 1; /* R_I370_ADDR31.  */
12616     case EM_S390_OLD:
12617     case EM_S390:
12618       return reloc_type == 4; /* R_S390_32.  */
12619     case EM_SCORE:
12620       return reloc_type == 8; /* R_SCORE_ABS32.  */
12621     case EM_SH:
12622       return reloc_type == 1; /* R_SH_DIR32.  */
12623     case EM_SPARC32PLUS:
12624     case EM_SPARCV9:
12625     case EM_SPARC:
12626       return reloc_type == 3 /* R_SPARC_32.  */
12627         || reloc_type == 23; /* R_SPARC_UA32.  */
12628     case EM_SPU:
12629       return reloc_type == 6; /* R_SPU_ADDR32 */
12630     case EM_TI_C6000:
12631       return reloc_type == 1; /* R_C6000_ABS32.  */
12632     case EM_TILEGX:
12633       return reloc_type == 2; /* R_TILEGX_32.  */
12634     case EM_TILEPRO:
12635       return reloc_type == 1; /* R_TILEPRO_32.  */
12636     case EM_CYGNUS_V850:
12637     case EM_V850:
12638       return reloc_type == 6; /* R_V850_ABS32.  */
12639     case EM_V800:
12640       return reloc_type == 0x33; /* R_V810_WORD.  */
12641     case EM_VAX:
12642       return reloc_type == 1; /* R_VAX_32.  */
12643     case EM_VISIUM:
12644       return reloc_type == 3;  /* R_VISIUM_32. */
12645     case EM_WEBASSEMBLY:
12646       return reloc_type == 1;  /* R_WASM32_32.  */
12647     case EM_X86_64:
12648     case EM_L1OM:
12649     case EM_K1OM:
12650       return reloc_type == 10; /* R_X86_64_32.  */
12651     case EM_XC16X:
12652     case EM_C166:
12653       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12654     case EM_XGATE:
12655       return reloc_type == 4; /* R_XGATE_32.  */
12656     case EM_XSTORMY16:
12657       return reloc_type == 1; /* R_XSTROMY16_32.  */
12658     case EM_XTENSA_OLD:
12659     case EM_XTENSA:
12660       return reloc_type == 1; /* R_XTENSA_32.  */
12661     default:
12662       {
12663         static unsigned int prev_warn = 0;
12664
12665         /* Avoid repeating the same warning multiple times.  */
12666         if (prev_warn != filedata->file_header.e_machine)
12667           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12668                  filedata->file_header.e_machine);
12669         prev_warn = filedata->file_header.e_machine;
12670         return FALSE;
12671       }
12672     }
12673 }
12674
12675 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12676    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12677
12678 static bfd_boolean
12679 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12680 {
12681   switch (filedata->file_header.e_machine)
12682   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12683     {
12684     case EM_386:
12685     case EM_IAMCU:
12686       return reloc_type == 2;  /* R_386_PC32.  */
12687     case EM_68K:
12688       return reloc_type == 4;  /* R_68K_PC32.  */
12689     case EM_AARCH64:
12690       return reloc_type == 261; /* R_AARCH64_PREL32 */
12691     case EM_ADAPTEVA_EPIPHANY:
12692       return reloc_type == 6;
12693     case EM_ALPHA:
12694       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12695     case EM_ARC_COMPACT:
12696     case EM_ARC_COMPACT2:
12697       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12698     case EM_ARM:
12699       return reloc_type == 3;  /* R_ARM_REL32 */
12700     case EM_AVR_OLD:
12701     case EM_AVR:
12702       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12703     case EM_MICROBLAZE:
12704       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12705     case EM_OR1K:
12706       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12707     case EM_PARISC:
12708       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12709     case EM_PPC:
12710       return reloc_type == 26; /* R_PPC_REL32.  */
12711     case EM_PPC64:
12712       return reloc_type == 26; /* R_PPC64_REL32.  */
12713     case EM_RISCV:
12714       return reloc_type == 57;  /* R_RISCV_32_PCREL.  */
12715     case EM_S390_OLD:
12716     case EM_S390:
12717       return reloc_type == 5;  /* R_390_PC32.  */
12718     case EM_SH:
12719       return reloc_type == 2;  /* R_SH_REL32.  */
12720     case EM_SPARC32PLUS:
12721     case EM_SPARCV9:
12722     case EM_SPARC:
12723       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12724     case EM_SPU:
12725       return reloc_type == 13; /* R_SPU_REL32.  */
12726     case EM_TILEGX:
12727       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12728     case EM_TILEPRO:
12729       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12730     case EM_VISIUM:
12731       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12732     case EM_X86_64:
12733     case EM_L1OM:
12734     case EM_K1OM:
12735       return reloc_type == 2;  /* R_X86_64_PC32.  */
12736     case EM_XTENSA_OLD:
12737     case EM_XTENSA:
12738       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12739     default:
12740       /* Do not abort or issue an error message here.  Not all targets use
12741          pc-relative 32-bit relocs in their DWARF debug information and we
12742          have already tested for target coverage in is_32bit_abs_reloc.  A
12743          more helpful warning message will be generated by apply_relocations
12744          anyway, so just return.  */
12745       return FALSE;
12746     }
12747 }
12748
12749 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12750    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12751
12752 static bfd_boolean
12753 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12754 {
12755   switch (filedata->file_header.e_machine)
12756     {
12757     case EM_AARCH64:
12758       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12759     case EM_ALPHA:
12760       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12761     case EM_IA_64:
12762       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12763               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12764     case EM_PARISC:
12765       return reloc_type == 80; /* R_PARISC_DIR64.  */
12766     case EM_PPC64:
12767       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12768     case EM_RISCV:
12769       return reloc_type == 2; /* R_RISCV_64.  */
12770     case EM_SPARC32PLUS:
12771     case EM_SPARCV9:
12772     case EM_SPARC:
12773       return reloc_type == 32 /* R_SPARC_64.  */
12774         || reloc_type == 54; /* R_SPARC_UA64.  */
12775     case EM_X86_64:
12776     case EM_L1OM:
12777     case EM_K1OM:
12778       return reloc_type == 1; /* R_X86_64_64.  */
12779     case EM_S390_OLD:
12780     case EM_S390:
12781       return reloc_type == 22;  /* R_S390_64.  */
12782     case EM_TILEGX:
12783       return reloc_type == 1; /* R_TILEGX_64.  */
12784     case EM_MIPS:
12785       return reloc_type == 18;  /* R_MIPS_64.  */
12786     default:
12787       return FALSE;
12788     }
12789 }
12790
12791 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12792    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12793
12794 static bfd_boolean
12795 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12796 {
12797   switch (filedata->file_header.e_machine)
12798     {
12799     case EM_AARCH64:
12800       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12801     case EM_ALPHA:
12802       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12803     case EM_IA_64:
12804       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12805               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12806     case EM_PARISC:
12807       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12808     case EM_PPC64:
12809       return reloc_type == 44; /* R_PPC64_REL64.  */
12810     case EM_SPARC32PLUS:
12811     case EM_SPARCV9:
12812     case EM_SPARC:
12813       return reloc_type == 46; /* R_SPARC_DISP64.  */
12814     case EM_X86_64:
12815     case EM_L1OM:
12816     case EM_K1OM:
12817       return reloc_type == 24; /* R_X86_64_PC64.  */
12818     case EM_S390_OLD:
12819     case EM_S390:
12820       return reloc_type == 23;  /* R_S390_PC64.  */
12821     case EM_TILEGX:
12822       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12823     default:
12824       return FALSE;
12825     }
12826 }
12827
12828 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12829    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12830
12831 static bfd_boolean
12832 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12833 {
12834   switch (filedata->file_header.e_machine)
12835     {
12836     case EM_CYGNUS_MN10200:
12837     case EM_MN10200:
12838       return reloc_type == 4; /* R_MN10200_24.  */
12839     case EM_FT32:
12840       return reloc_type == 5; /* R_FT32_20.  */
12841     default:
12842       return FALSE;
12843     }
12844 }
12845
12846 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12847    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12848
12849 static bfd_boolean
12850 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12851 {
12852   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12853   switch (filedata->file_header.e_machine)
12854     {
12855     case EM_ARC:
12856     case EM_ARC_COMPACT:
12857     case EM_ARC_COMPACT2:
12858       return reloc_type == 2; /* R_ARC_16.  */
12859     case EM_ADAPTEVA_EPIPHANY:
12860       return reloc_type == 5;
12861     case EM_AVR_OLD:
12862     case EM_AVR:
12863       return reloc_type == 4; /* R_AVR_16.  */
12864     case EM_CYGNUS_D10V:
12865     case EM_D10V:
12866       return reloc_type == 3; /* R_D10V_16.  */
12867     case EM_FT32:
12868       return reloc_type == 2; /* R_FT32_16.  */
12869     case EM_H8S:
12870     case EM_H8_300:
12871     case EM_H8_300H:
12872       return reloc_type == R_H8_DIR16;
12873     case EM_IP2K_OLD:
12874     case EM_IP2K:
12875       return reloc_type == 1; /* R_IP2K_16.  */
12876     case EM_M32C_OLD:
12877     case EM_M32C:
12878       return reloc_type == 1; /* R_M32C_16 */
12879     case EM_CYGNUS_MN10200:
12880     case EM_MN10200:
12881       return reloc_type == 2; /* R_MN10200_16.  */
12882     case EM_CYGNUS_MN10300:
12883     case EM_MN10300:
12884       return reloc_type == 2; /* R_MN10300_16.  */
12885     case EM_MSP430:
12886       if (uses_msp430x_relocs (filedata))
12887         return reloc_type == 2; /* R_MSP430_ABS16.  */
12888       /* Fall through.  */
12889     case EM_MSP430_OLD:
12890       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12891     case EM_NDS32:
12892       return reloc_type == 19; /* R_NDS32_RELA.  */
12893     case EM_ALTERA_NIOS2:
12894       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12895     case EM_NIOS32:
12896       return reloc_type == 9; /* R_NIOS_16.  */
12897     case EM_OR1K:
12898       return reloc_type == 2; /* R_OR1K_16.  */
12899     case EM_RISCV:
12900       return reloc_type == 55; /* R_RISCV_SET16.  */
12901     case EM_TI_PRU:
12902       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12903     case EM_TI_C6000:
12904       return reloc_type == 2; /* R_C6000_ABS16.  */
12905     case EM_VISIUM:
12906       return reloc_type == 2; /* R_VISIUM_16. */
12907     case EM_XC16X:
12908     case EM_C166:
12909       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12910     case EM_XGATE:
12911       return reloc_type == 3; /* R_XGATE_16.  */
12912     default:
12913       return FALSE;
12914     }
12915 }
12916
12917 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12918    a 8-bit absolute RELA relocation used in DWARF debug sections.  */
12919
12920 static bfd_boolean
12921 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12922 {
12923   switch (filedata->file_header.e_machine)
12924     {
12925     case EM_RISCV:
12926       return reloc_type == 54; /* R_RISCV_SET8.  */
12927     default:
12928       return FALSE;
12929     }
12930 }
12931
12932 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12933    a 6-bit absolute RELA relocation used in DWARF debug sections.  */
12934
12935 static bfd_boolean
12936 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12937 {
12938   switch (filedata->file_header.e_machine)
12939     {
12940     case EM_RISCV:
12941       return reloc_type == 53; /* R_RISCV_SET6.  */
12942     default:
12943       return FALSE;
12944     }
12945 }
12946
12947 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12948    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12949
12950 static bfd_boolean
12951 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12952 {
12953   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12954   switch (filedata->file_header.e_machine)
12955     {
12956     case EM_RISCV:
12957       return reloc_type == 35; /* R_RISCV_ADD32.  */
12958     default:
12959       return FALSE;
12960     }
12961 }
12962
12963 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12964    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12965
12966 static bfd_boolean
12967 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12968 {
12969   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12970   switch (filedata->file_header.e_machine)
12971     {
12972     case EM_RISCV:
12973       return reloc_type == 39; /* R_RISCV_SUB32.  */
12974     default:
12975       return FALSE;
12976     }
12977 }
12978
12979 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12980    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12981
12982 static bfd_boolean
12983 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12984 {
12985   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12986   switch (filedata->file_header.e_machine)
12987     {
12988     case EM_RISCV:
12989       return reloc_type == 36; /* R_RISCV_ADD64.  */
12990     default:
12991       return FALSE;
12992     }
12993 }
12994
12995 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12996    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12997
12998 static bfd_boolean
12999 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13000 {
13001   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13002   switch (filedata->file_header.e_machine)
13003     {
13004     case EM_RISCV:
13005       return reloc_type == 40; /* R_RISCV_SUB64.  */
13006     default:
13007       return FALSE;
13008     }
13009 }
13010
13011 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13012    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
13013
13014 static bfd_boolean
13015 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13016 {
13017   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13018   switch (filedata->file_header.e_machine)
13019     {
13020     case EM_RISCV:
13021       return reloc_type == 34; /* R_RISCV_ADD16.  */
13022     default:
13023       return FALSE;
13024     }
13025 }
13026
13027 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13028    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
13029
13030 static bfd_boolean
13031 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13032 {
13033   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13034   switch (filedata->file_header.e_machine)
13035     {
13036     case EM_RISCV:
13037       return reloc_type == 38; /* R_RISCV_SUB16.  */
13038     default:
13039       return FALSE;
13040     }
13041 }
13042
13043 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13044    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
13045
13046 static bfd_boolean
13047 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13048 {
13049   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13050   switch (filedata->file_header.e_machine)
13051     {
13052     case EM_RISCV:
13053       return reloc_type == 33; /* R_RISCV_ADD8.  */
13054     default:
13055       return FALSE;
13056     }
13057 }
13058
13059 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13060    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
13061
13062 static bfd_boolean
13063 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13064 {
13065   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13066   switch (filedata->file_header.e_machine)
13067     {
13068     case EM_RISCV:
13069       return reloc_type == 37; /* R_RISCV_SUB8.  */
13070     default:
13071       return FALSE;
13072     }
13073 }
13074
13075 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13076    a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
13077
13078 static bfd_boolean
13079 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13080 {
13081   switch (filedata->file_header.e_machine)
13082     {
13083     case EM_RISCV:
13084       return reloc_type == 52; /* R_RISCV_SUB6.  */
13085     default:
13086       return FALSE;
13087     }
13088 }
13089
13090 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13091    relocation entries (possibly formerly used for SHT_GROUP sections).  */
13092
13093 static bfd_boolean
13094 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
13095 {
13096   switch (filedata->file_header.e_machine)
13097     {
13098     case EM_386:     /* R_386_NONE.  */
13099     case EM_68K:     /* R_68K_NONE.  */
13100     case EM_ADAPTEVA_EPIPHANY:
13101     case EM_ALPHA:   /* R_ALPHA_NONE.  */
13102     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
13103     case EM_ARC:     /* R_ARC_NONE.  */
13104     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
13105     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
13106     case EM_ARM:     /* R_ARM_NONE.  */
13107     case EM_C166:    /* R_XC16X_NONE.  */
13108     case EM_CRIS:    /* R_CRIS_NONE.  */
13109     case EM_FT32:    /* R_FT32_NONE.  */
13110     case EM_IA_64:   /* R_IA64_NONE.  */
13111     case EM_K1OM:    /* R_X86_64_NONE.  */
13112     case EM_L1OM:    /* R_X86_64_NONE.  */
13113     case EM_M32R:    /* R_M32R_NONE.  */
13114     case EM_MIPS:    /* R_MIPS_NONE.  */
13115     case EM_MN10300: /* R_MN10300_NONE.  */
13116     case EM_MOXIE:   /* R_MOXIE_NONE.  */
13117     case EM_NIOS32:  /* R_NIOS_NONE.  */
13118     case EM_OR1K:    /* R_OR1K_NONE. */
13119     case EM_PARISC:  /* R_PARISC_NONE.  */
13120     case EM_PPC64:   /* R_PPC64_NONE.  */
13121     case EM_PPC:     /* R_PPC_NONE.  */
13122     case EM_RISCV:   /* R_RISCV_NONE.  */
13123     case EM_S390:    /* R_390_NONE.  */
13124     case EM_S390_OLD:
13125     case EM_SH:      /* R_SH_NONE.  */
13126     case EM_SPARC32PLUS:
13127     case EM_SPARC:   /* R_SPARC_NONE.  */
13128     case EM_SPARCV9:
13129     case EM_TILEGX:  /* R_TILEGX_NONE.  */
13130     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
13131     case EM_TI_C6000:/* R_C6000_NONE.  */
13132     case EM_X86_64:  /* R_X86_64_NONE.  */
13133     case EM_XC16X:
13134     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
13135       return reloc_type == 0;
13136
13137     case EM_AARCH64:
13138       return reloc_type == 0 || reloc_type == 256;
13139     case EM_AVR_OLD:
13140     case EM_AVR:
13141       return (reloc_type == 0 /* R_AVR_NONE.  */
13142               || reloc_type == 30 /* R_AVR_DIFF8.  */
13143               || reloc_type == 31 /* R_AVR_DIFF16.  */
13144               || reloc_type == 32 /* R_AVR_DIFF32.  */);
13145     case EM_METAG:
13146       return reloc_type == 3; /* R_METAG_NONE.  */
13147     case EM_NDS32:
13148       return (reloc_type == 0       /* R_XTENSA_NONE.  */
13149               || reloc_type == 204  /* R_NDS32_DIFF8.  */
13150               || reloc_type == 205  /* R_NDS32_DIFF16.  */
13151               || reloc_type == 206  /* R_NDS32_DIFF32.  */
13152               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
13153     case EM_TI_PRU:
13154       return (reloc_type == 0       /* R_PRU_NONE.  */
13155               || reloc_type == 65   /* R_PRU_DIFF8.  */
13156               || reloc_type == 66   /* R_PRU_DIFF16.  */
13157               || reloc_type == 67   /* R_PRU_DIFF32.  */);
13158     case EM_XTENSA_OLD:
13159     case EM_XTENSA:
13160       return (reloc_type == 0      /* R_XTENSA_NONE.  */
13161               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
13162               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
13163               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
13164     }
13165   return FALSE;
13166 }
13167
13168 /* Returns TRUE if there is a relocation against
13169    section NAME at OFFSET bytes.  */
13170
13171 bfd_boolean
13172 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13173 {
13174   Elf_Internal_Rela * relocs;
13175   Elf_Internal_Rela * rp;
13176
13177   if (dsec == NULL || dsec->reloc_info == NULL)
13178     return FALSE;
13179
13180   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13181
13182   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13183     if (rp->r_offset == offset)
13184       return TRUE;
13185
13186    return FALSE;
13187 }
13188
13189 /* Apply relocations to a section.
13190    Returns TRUE upon success, FALSE otherwise.
13191    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13192    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
13193    will be set to the number of relocs loaded.
13194
13195    Note: So far support has been added only for those relocations
13196    which can be found in debug sections. FIXME: Add support for
13197    more relocations ?  */
13198
13199 static bfd_boolean
13200 apply_relocations (Filedata *                 filedata,
13201                    const Elf_Internal_Shdr *  section,
13202                    unsigned char *            start,
13203                    bfd_size_type              size,
13204                    void **                    relocs_return,
13205                    unsigned long *            num_relocs_return)
13206 {
13207   Elf_Internal_Shdr * relsec;
13208   unsigned char * end = start + size;
13209
13210   if (relocs_return != NULL)
13211     {
13212       * (Elf_Internal_Rela **) relocs_return = NULL;
13213       * num_relocs_return = 0;
13214     }
13215
13216   if (filedata->file_header.e_type != ET_REL)
13217     /* No relocs to apply.  */
13218     return TRUE;
13219
13220   /* Find the reloc section associated with the section.  */
13221   for (relsec = filedata->section_headers;
13222        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13223        ++relsec)
13224     {
13225       bfd_boolean is_rela;
13226       unsigned long num_relocs;
13227       Elf_Internal_Rela * relocs;
13228       Elf_Internal_Rela * rp;
13229       Elf_Internal_Shdr * symsec;
13230       Elf_Internal_Sym * symtab;
13231       unsigned long num_syms;
13232       Elf_Internal_Sym * sym;
13233
13234       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13235           || relsec->sh_info >= filedata->file_header.e_shnum
13236           || filedata->section_headers + relsec->sh_info != section
13237           || relsec->sh_size == 0
13238           || relsec->sh_link >= filedata->file_header.e_shnum)
13239         continue;
13240
13241       is_rela = relsec->sh_type == SHT_RELA;
13242
13243       if (is_rela)
13244         {
13245           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13246                                   relsec->sh_size, & relocs, & num_relocs))
13247             return FALSE;
13248         }
13249       else
13250         {
13251           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13252                                  relsec->sh_size, & relocs, & num_relocs))
13253             return FALSE;
13254         }
13255
13256       /* SH uses RELA but uses in place value instead of the addend field.  */
13257       if (filedata->file_header.e_machine == EM_SH)
13258         is_rela = FALSE;
13259
13260       symsec = filedata->section_headers + relsec->sh_link;
13261       if (symsec->sh_type != SHT_SYMTAB
13262           && symsec->sh_type != SHT_DYNSYM)
13263         return FALSE;
13264       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13265
13266       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13267         {
13268           bfd_vma         addend;
13269           unsigned int    reloc_type;
13270           unsigned int    reloc_size;
13271           bfd_boolean     reloc_inplace = FALSE;
13272           bfd_boolean     reloc_subtract = FALSE;
13273           unsigned char * rloc;
13274           unsigned long   sym_index;
13275
13276           reloc_type = get_reloc_type (filedata, rp->r_info);
13277
13278           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13279             continue;
13280           else if (is_none_reloc (filedata, reloc_type))
13281             continue;
13282           else if (is_32bit_abs_reloc (filedata, reloc_type)
13283                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13284             reloc_size = 4;
13285           else if (is_64bit_abs_reloc (filedata, reloc_type)
13286                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13287             reloc_size = 8;
13288           else if (is_24bit_abs_reloc (filedata, reloc_type))
13289             reloc_size = 3;
13290           else if (is_16bit_abs_reloc (filedata, reloc_type))
13291             reloc_size = 2;
13292           else if (is_8bit_abs_reloc (filedata, reloc_type)
13293                    || is_6bit_abs_reloc (filedata, reloc_type))
13294             reloc_size = 1;
13295           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13296                                                                  reloc_type))
13297                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13298             {
13299               reloc_size = 4;
13300               reloc_inplace = TRUE;
13301             }
13302           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13303                                                                  reloc_type))
13304                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13305             {
13306               reloc_size = 8;
13307               reloc_inplace = TRUE;
13308             }
13309           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13310                                                                  reloc_type))
13311                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13312             {
13313               reloc_size = 2;
13314               reloc_inplace = TRUE;
13315             }
13316           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13317                                                                 reloc_type))
13318                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13319             {
13320               reloc_size = 1;
13321               reloc_inplace = TRUE;
13322             }
13323           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13324                                                                 reloc_type)))
13325             {
13326               reloc_size = 1;
13327               reloc_inplace = TRUE;
13328             }
13329           else
13330             {
13331               static unsigned int prev_reloc = 0;
13332
13333               if (reloc_type != prev_reloc)
13334                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13335                       reloc_type, printable_section_name (filedata, section));
13336               prev_reloc = reloc_type;
13337               continue;
13338             }
13339
13340           rloc = start + rp->r_offset;
13341           if ((rloc + reloc_size) > end || (rloc < start))
13342             {
13343               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13344                     (unsigned long) rp->r_offset,
13345                     printable_section_name (filedata, section));
13346               continue;
13347             }
13348
13349           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13350           if (sym_index >= num_syms)
13351             {
13352               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13353                     sym_index, printable_section_name (filedata, section));
13354               continue;
13355             }
13356           sym = symtab + sym_index;
13357
13358           /* If the reloc has a symbol associated with it,
13359              make sure that it is of an appropriate type.
13360
13361              Relocations against symbols without type can happen.
13362              Gcc -feliminate-dwarf2-dups may generate symbols
13363              without type for debug info.
13364
13365              Icc generates relocations against function symbols
13366              instead of local labels.
13367
13368              Relocations against object symbols can happen, eg when
13369              referencing a global array.  For an example of this see
13370              the _clz.o binary in libgcc.a.  */
13371           if (sym != symtab
13372               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13373               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13374             {
13375               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13376                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13377                     printable_section_name (filedata, relsec),
13378                     (long int)(rp - relocs));
13379               continue;
13380             }
13381
13382           addend = 0;
13383           if (is_rela)
13384             addend += rp->r_addend;
13385           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13386              partial_inplace.  */
13387           if (!is_rela
13388               || (filedata->file_header.e_machine == EM_XTENSA
13389                   && reloc_type == 1)
13390               || ((filedata->file_header.e_machine == EM_PJ
13391                    || filedata->file_header.e_machine == EM_PJ_OLD)
13392                   && reloc_type == 1)
13393               || ((filedata->file_header.e_machine == EM_D30V
13394                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13395                   && reloc_type == 12)
13396               || reloc_inplace)
13397             {
13398               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13399                 addend += byte_get (rloc, reloc_size) & 0x3f;
13400               else
13401                 addend += byte_get (rloc, reloc_size);
13402             }
13403
13404           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13405               || is_64bit_pcrel_reloc (filedata, reloc_type))
13406             {
13407               /* On HPPA, all pc-relative relocations are biased by 8.  */
13408               if (filedata->file_header.e_machine == EM_PARISC)
13409                 addend -= 8;
13410               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13411                         reloc_size);
13412             }
13413           else if (is_6bit_abs_reloc (filedata, reloc_type)
13414                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13415             {
13416               if (reloc_subtract)
13417                 addend -= sym->st_value;
13418               else
13419                 addend += sym->st_value;
13420               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13421               byte_put (rloc, addend, reloc_size);
13422             }
13423           else if (reloc_subtract)
13424             byte_put (rloc, addend - sym->st_value, reloc_size);
13425           else
13426             byte_put (rloc, addend + sym->st_value, reloc_size);
13427         }
13428
13429       free (symtab);
13430       /* Let the target specific reloc processing code know that
13431          we have finished with these relocs.  */
13432       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13433
13434       if (relocs_return)
13435         {
13436           * (Elf_Internal_Rela **) relocs_return = relocs;
13437           * num_relocs_return = num_relocs;
13438         }
13439       else
13440         free (relocs);
13441
13442       break;
13443     }
13444
13445   return TRUE;
13446 }
13447
13448 #ifdef SUPPORT_DISASSEMBLY
13449 static bfd_boolean
13450 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13451 {
13452   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13453
13454   /* FIXME: XXX -- to be done --- XXX */
13455
13456   return TRUE;
13457 }
13458 #endif
13459
13460 /* Reads in the contents of SECTION from FILE, returning a pointer
13461    to a malloc'ed buffer or NULL if something went wrong.  */
13462
13463 static char *
13464 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13465 {
13466   bfd_size_type num_bytes = section->sh_size;
13467
13468   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13469     {
13470       printf (_("Section '%s' has no data to dump.\n"),
13471               printable_section_name (filedata, section));
13472       return NULL;
13473     }
13474
13475   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13476                              _("section contents"));
13477 }
13478
13479 /* Uncompresses a section that was compressed using zlib, in place.  */
13480
13481 static bfd_boolean
13482 uncompress_section_contents (unsigned char **   buffer,
13483                              dwarf_size_type    uncompressed_size,
13484                              dwarf_size_type *  size)
13485 {
13486   dwarf_size_type compressed_size = *size;
13487   unsigned char * compressed_buffer = *buffer;
13488   unsigned char * uncompressed_buffer;
13489   z_stream strm;
13490   int rc;
13491
13492   /* It is possible the section consists of several compressed
13493      buffers concatenated together, so we uncompress in a loop.  */
13494   /* PR 18313: The state field in the z_stream structure is supposed
13495      to be invisible to the user (ie us), but some compilers will
13496      still complain about it being used without initialisation.  So
13497      we first zero the entire z_stream structure and then set the fields
13498      that we need.  */
13499   memset (& strm, 0, sizeof strm);
13500   strm.avail_in = compressed_size;
13501   strm.next_in = (Bytef *) compressed_buffer;
13502   strm.avail_out = uncompressed_size;
13503   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13504
13505   rc = inflateInit (& strm);
13506   while (strm.avail_in > 0)
13507     {
13508       if (rc != Z_OK)
13509         goto fail;
13510       strm.next_out = ((Bytef *) uncompressed_buffer
13511                        + (uncompressed_size - strm.avail_out));
13512       rc = inflate (&strm, Z_FINISH);
13513       if (rc != Z_STREAM_END)
13514         goto fail;
13515       rc = inflateReset (& strm);
13516     }
13517   rc = inflateEnd (& strm);
13518   if (rc != Z_OK
13519       || strm.avail_out != 0)
13520     goto fail;
13521
13522   *buffer = uncompressed_buffer;
13523   *size = uncompressed_size;
13524   return TRUE;
13525
13526  fail:
13527   free (uncompressed_buffer);
13528   /* Indicate decompression failure.  */
13529   *buffer = NULL;
13530   return FALSE;
13531 }
13532
13533 static bfd_boolean
13534 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13535 {
13536   Elf_Internal_Shdr *  relsec;
13537   bfd_size_type        num_bytes;
13538   unsigned char *      data;
13539   unsigned char *      end;
13540   unsigned char *      real_start;
13541   unsigned char *      start;
13542   bfd_boolean          some_strings_shown;
13543
13544   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13545   if (start == NULL)
13546     /* PR 21820: Do not fail if the section was empty.  */
13547     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13548
13549   num_bytes = section->sh_size;
13550
13551   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13552
13553   if (decompress_dumps)
13554     {
13555       dwarf_size_type new_size = num_bytes;
13556       dwarf_size_type uncompressed_size = 0;
13557
13558       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13559         {
13560           Elf_Internal_Chdr chdr;
13561           unsigned int compression_header_size
13562             = get_compression_header (& chdr, (unsigned char *) start,
13563                                       num_bytes);
13564
13565           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13566             {
13567               warn (_("section '%s' has unsupported compress type: %d\n"),
13568                     printable_section_name (filedata, section), chdr.ch_type);
13569               return FALSE;
13570             }
13571           uncompressed_size = chdr.ch_size;
13572           start += compression_header_size;
13573           new_size -= compression_header_size;
13574         }
13575       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13576         {
13577           /* Read the zlib header.  In this case, it should be "ZLIB"
13578              followed by the uncompressed section size, 8 bytes in
13579              big-endian order.  */
13580           uncompressed_size = start[4]; uncompressed_size <<= 8;
13581           uncompressed_size += start[5]; uncompressed_size <<= 8;
13582           uncompressed_size += start[6]; uncompressed_size <<= 8;
13583           uncompressed_size += start[7]; uncompressed_size <<= 8;
13584           uncompressed_size += start[8]; uncompressed_size <<= 8;
13585           uncompressed_size += start[9]; uncompressed_size <<= 8;
13586           uncompressed_size += start[10]; uncompressed_size <<= 8;
13587           uncompressed_size += start[11];
13588           start += 12;
13589           new_size -= 12;
13590         }
13591
13592       if (uncompressed_size)
13593         {
13594           if (uncompress_section_contents (& start,
13595                                            uncompressed_size, & new_size))
13596             num_bytes = new_size;
13597           else
13598             {
13599               error (_("Unable to decompress section %s\n"),
13600                      printable_section_name (filedata, section));
13601               return FALSE;
13602             }
13603         }
13604       else
13605         start = real_start;
13606     }
13607
13608   /* If the section being dumped has relocations against it the user might
13609      be expecting these relocations to have been applied.  Check for this
13610      case and issue a warning message in order to avoid confusion.
13611      FIXME: Maybe we ought to have an option that dumps a section with
13612      relocs applied ?  */
13613   for (relsec = filedata->section_headers;
13614        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13615        ++relsec)
13616     {
13617       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13618           || relsec->sh_info >= filedata->file_header.e_shnum
13619           || filedata->section_headers + relsec->sh_info != section
13620           || relsec->sh_size == 0
13621           || relsec->sh_link >= filedata->file_header.e_shnum)
13622         continue;
13623
13624       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13625       break;
13626     }
13627
13628   data = start;
13629   end  = start + num_bytes;
13630   some_strings_shown = FALSE;
13631
13632   while (data < end)
13633     {
13634       while (!ISPRINT (* data))
13635         if (++ data >= end)
13636           break;
13637
13638       if (data < end)
13639         {
13640           size_t maxlen = end - data;
13641
13642 #ifndef __MSVCRT__
13643           /* PR 11128: Use two separate invocations in order to work
13644              around bugs in the Solaris 8 implementation of printf.  */
13645           printf ("  [%6tx]  ", data - start);
13646 #else
13647           printf ("  [%6Ix]  ", (size_t) (data - start));
13648 #endif
13649           if (maxlen > 0)
13650             {
13651               print_symbol ((int) maxlen, (const char *) data);
13652               putchar ('\n');
13653               data += strnlen ((const char *) data, maxlen);
13654             }
13655           else
13656             {
13657               printf (_("<corrupt>\n"));
13658               data = end;
13659             }
13660           some_strings_shown = TRUE;
13661         }
13662     }
13663
13664   if (! some_strings_shown)
13665     printf (_("  No strings found in this section."));
13666
13667   free (real_start);
13668
13669   putchar ('\n');
13670   return TRUE;
13671 }
13672
13673 static bfd_boolean
13674 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13675                        Filedata *           filedata,
13676                        bfd_boolean          relocate)
13677 {
13678   Elf_Internal_Shdr * relsec;
13679   bfd_size_type       bytes;
13680   bfd_size_type       section_size;
13681   bfd_vma             addr;
13682   unsigned char *     data;
13683   unsigned char *     real_start;
13684   unsigned char *     start;
13685
13686   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13687   if (start == NULL)
13688     /* PR 21820: Do not fail if the section was empty.  */
13689     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13690
13691   section_size = section->sh_size;
13692
13693   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13694
13695   if (decompress_dumps)
13696     {
13697       dwarf_size_type new_size = section_size;
13698       dwarf_size_type uncompressed_size = 0;
13699
13700       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13701         {
13702           Elf_Internal_Chdr chdr;
13703           unsigned int compression_header_size
13704             = get_compression_header (& chdr, start, section_size);
13705
13706           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13707             {
13708               warn (_("section '%s' has unsupported compress type: %d\n"),
13709                     printable_section_name (filedata, section), chdr.ch_type);
13710               return FALSE;
13711             }
13712           uncompressed_size = chdr.ch_size;
13713           start += compression_header_size;
13714           new_size -= compression_header_size;
13715         }
13716       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13717         {
13718           /* Read the zlib header.  In this case, it should be "ZLIB"
13719              followed by the uncompressed section size, 8 bytes in
13720              big-endian order.  */
13721           uncompressed_size = start[4]; uncompressed_size <<= 8;
13722           uncompressed_size += start[5]; uncompressed_size <<= 8;
13723           uncompressed_size += start[6]; uncompressed_size <<= 8;
13724           uncompressed_size += start[7]; uncompressed_size <<= 8;
13725           uncompressed_size += start[8]; uncompressed_size <<= 8;
13726           uncompressed_size += start[9]; uncompressed_size <<= 8;
13727           uncompressed_size += start[10]; uncompressed_size <<= 8;
13728           uncompressed_size += start[11];
13729           start += 12;
13730           new_size -= 12;
13731         }
13732
13733       if (uncompressed_size)
13734         {
13735           if (uncompress_section_contents (& start, uncompressed_size,
13736                                            & new_size))
13737             {
13738               section_size = new_size;
13739             }
13740           else
13741             {
13742               error (_("Unable to decompress section %s\n"),
13743                      printable_section_name (filedata, section));
13744               /* FIXME: Print the section anyway ?  */
13745               return FALSE;
13746             }
13747         }
13748       else
13749         start = real_start;
13750     }
13751
13752   if (relocate)
13753     {
13754       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13755         return FALSE;
13756     }
13757   else
13758     {
13759       /* If the section being dumped has relocations against it the user might
13760          be expecting these relocations to have been applied.  Check for this
13761          case and issue a warning message in order to avoid confusion.
13762          FIXME: Maybe we ought to have an option that dumps a section with
13763          relocs applied ?  */
13764       for (relsec = filedata->section_headers;
13765            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13766            ++relsec)
13767         {
13768           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13769               || relsec->sh_info >= filedata->file_header.e_shnum
13770               || filedata->section_headers + relsec->sh_info != section
13771               || relsec->sh_size == 0
13772               || relsec->sh_link >= filedata->file_header.e_shnum)
13773             continue;
13774
13775           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13776           break;
13777         }
13778     }
13779
13780   addr = section->sh_addr;
13781   bytes = section_size;
13782   data = start;
13783
13784   while (bytes)
13785     {
13786       int j;
13787       int k;
13788       int lbytes;
13789
13790       lbytes = (bytes > 16 ? 16 : bytes);
13791
13792       printf ("  0x%8.8lx ", (unsigned long) addr);
13793
13794       for (j = 0; j < 16; j++)
13795         {
13796           if (j < lbytes)
13797             printf ("%2.2x", data[j]);
13798           else
13799             printf ("  ");
13800
13801           if ((j & 3) == 3)
13802             printf (" ");
13803         }
13804
13805       for (j = 0; j < lbytes; j++)
13806         {
13807           k = data[j];
13808           if (k >= ' ' && k < 0x7f)
13809             printf ("%c", k);
13810           else
13811             printf (".");
13812         }
13813
13814       putchar ('\n');
13815
13816       data  += lbytes;
13817       addr  += lbytes;
13818       bytes -= lbytes;
13819     }
13820
13821   free (real_start);
13822
13823   putchar ('\n');
13824   return TRUE;
13825 }
13826
13827 #ifdef HAVE_LIBCTF
13828 static ctf_sect_t *
13829 shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata)
13830 {
13831   buf->cts_name = SECTION_NAME (shdr);
13832   buf->cts_size = shdr->sh_size;
13833   buf->cts_entsize = shdr->sh_entsize;
13834
13835   return buf;
13836 }
13837
13838 /* Formatting callback function passed to ctf_dump.  Returns either the pointer
13839    it is passed, or a pointer to newly-allocated storage, in which case
13840    dump_ctf() will free it when it no longer needs it.  */
13841
13842 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
13843                                     char *s, void *arg)
13844 {
13845   char *spaces = arg;
13846   char *new_s;
13847
13848   if (asprintf (&new_s, "%s%s", spaces, s) < 0)
13849     return s;
13850   return new_s;
13851 }
13852
13853 static bfd_boolean
13854 dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
13855 {
13856   Elf_Internal_Shdr *  parent_sec = NULL;
13857   Elf_Internal_Shdr *  symtab_sec = NULL;
13858   Elf_Internal_Shdr *  strtab_sec = NULL;
13859   void *               data = NULL;
13860   void *               symdata = NULL;
13861   void *               strdata = NULL;
13862   void *               parentdata = NULL;
13863   ctf_sect_t           ctfsect, symsect, strsect, parentsect;
13864   ctf_sect_t *         symsectp = NULL;
13865   ctf_sect_t *         strsectp = NULL;
13866   ctf_file_t *         ctf = NULL;
13867   ctf_file_t *         parent = NULL;
13868
13869   const char *things[] = {"Labels", "Data objects", "Function objects",
13870                           "Variables", "Types", "Strings", ""};
13871   const char **thing;
13872   int err;
13873   bfd_boolean ret = FALSE;
13874   size_t i;
13875
13876   shdr_to_ctf_sect (&ctfsect, section, filedata);
13877   data = get_section_contents (section, filedata);
13878   ctfsect.cts_data = data;
13879
13880   if (dump_ctf_symtab_name)
13881     {
13882       if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL)
13883         {
13884           error (_("No symbol section named %s\n"), dump_ctf_symtab_name);
13885           goto fail;
13886         }
13887       if ((symdata = (void *) get_data (NULL, filedata,
13888                                         symtab_sec->sh_offset, 1,
13889                                         symtab_sec->sh_size,
13890                                         _("symbols"))) == NULL)
13891         goto fail;
13892       symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
13893       symsect.cts_data = symdata;
13894     }
13895   if (dump_ctf_strtab_name)
13896     {
13897       if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
13898         {
13899           error (_("No string table section named %s\n"),
13900                  dump_ctf_strtab_name);
13901           goto fail;
13902         }
13903       if ((strdata = (void *) get_data (NULL, filedata,
13904                                         strtab_sec->sh_offset, 1,
13905                                         strtab_sec->sh_size,
13906                                         _("strings"))) == NULL)
13907         goto fail;
13908       strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata);
13909       strsect.cts_data = strdata;
13910     }
13911   if (dump_ctf_parent_name)
13912     {
13913       if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL)
13914         {
13915           error (_("No CTF parent section named %s\n"), dump_ctf_parent_name);
13916           goto fail;
13917         }
13918       if ((parentdata = (void *) get_data (NULL, filedata,
13919                                            parent_sec->sh_offset, 1,
13920                                            parent_sec->sh_size,
13921                                            _("CTF parent"))) == NULL)
13922         goto fail;
13923       shdr_to_ctf_sect (&parentsect, parent_sec, filedata);
13924       parentsect.cts_data = parentdata;
13925     }
13926
13927   /* Load the CTF file and dump it.  */
13928
13929   if ((ctf = ctf_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL)
13930     {
13931       error (_("CTF open failure: %s\n"), ctf_errmsg (err));
13932       goto fail;
13933     }
13934
13935   if (parentdata)
13936     {
13937       if ((parent = ctf_bufopen (&parentsect, symsectp, strsectp, &err)) == NULL)
13938         {
13939           error (_("CTF open failure: %s\n"), ctf_errmsg (err));
13940           goto fail;
13941         }
13942
13943       ctf_import (ctf, parent);
13944     }
13945
13946   ret = TRUE;
13947
13948   printf (_("\nDump of CTF section '%s':\n"),
13949           printable_section_name (filedata, section));
13950
13951   for (i = 1, thing = things; *thing[0]; thing++, i++)
13952     {
13953       ctf_dump_state_t *s = NULL;
13954       char *item;
13955
13956       printf ("\n  %s:\n", *thing);
13957       while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
13958                                (void *) "    ")) != NULL)
13959         {
13960           printf ("%s\n", item);
13961           free (item);
13962         }
13963
13964       if (ctf_errno (ctf))
13965         {
13966           error (_("Iteration failed: %s, %s\n"), *thing,
13967                    ctf_errmsg (ctf_errno (ctf)));
13968           ret = FALSE;
13969         }
13970     }
13971
13972  fail:
13973   ctf_file_close (ctf);
13974   ctf_file_close (parent);
13975   free (parentdata);
13976   free (data);
13977   free (symdata);
13978   free (strdata);
13979   return ret;
13980 }
13981 #endif /* HAVE_LIBCTF */
13982
13983 static bfd_boolean
13984 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13985                              const Elf_Internal_Shdr *        sec,
13986                              void *                           data)
13987 {
13988   struct dwarf_section * section = &debug_displays [debug].section;
13989   char buf [64];
13990   Filedata * filedata = (Filedata *) data;
13991
13992   if (section->start != NULL)
13993     {
13994       /* If it is already loaded, do nothing.  */
13995       if (streq (section->filename, filedata->file_name))
13996         return TRUE;
13997       free (section->start);
13998     }
13999
14000   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
14001   section->address = sec->sh_addr;
14002   section->user_data = NULL;
14003   section->filename = filedata->file_name;
14004   section->start = (unsigned char *) get_data (NULL, filedata,
14005                                                sec->sh_offset, 1,
14006                                                sec->sh_size, buf);
14007   if (section->start == NULL)
14008     section->size = 0;
14009   else
14010     {
14011       unsigned char *start = section->start;
14012       dwarf_size_type size = sec->sh_size;
14013       dwarf_size_type uncompressed_size = 0;
14014
14015       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
14016         {
14017           Elf_Internal_Chdr chdr;
14018           unsigned int compression_header_size;
14019
14020           if (size < (is_32bit_elf
14021                       ? sizeof (Elf32_External_Chdr)
14022                       : sizeof (Elf64_External_Chdr)))
14023             {
14024               warn (_("compressed section %s is too small to contain a compression header"),
14025                     section->name);
14026               return FALSE;
14027             }
14028
14029           compression_header_size = get_compression_header (&chdr, start, size);
14030
14031           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
14032             {
14033               warn (_("section '%s' has unsupported compress type: %d\n"),
14034                     section->name, chdr.ch_type);
14035               return FALSE;
14036             }
14037           uncompressed_size = chdr.ch_size;
14038           start += compression_header_size;
14039           size -= compression_header_size;
14040         }
14041       else if (size > 12 && streq ((char *) start, "ZLIB"))
14042         {
14043           /* Read the zlib header.  In this case, it should be "ZLIB"
14044              followed by the uncompressed section size, 8 bytes in
14045              big-endian order.  */
14046           uncompressed_size = start[4]; uncompressed_size <<= 8;
14047           uncompressed_size += start[5]; uncompressed_size <<= 8;
14048           uncompressed_size += start[6]; uncompressed_size <<= 8;
14049           uncompressed_size += start[7]; uncompressed_size <<= 8;
14050           uncompressed_size += start[8]; uncompressed_size <<= 8;
14051           uncompressed_size += start[9]; uncompressed_size <<= 8;
14052           uncompressed_size += start[10]; uncompressed_size <<= 8;
14053           uncompressed_size += start[11];
14054           start += 12;
14055           size -= 12;
14056         }
14057
14058       if (uncompressed_size)
14059         {
14060           if (uncompress_section_contents (&start, uncompressed_size,
14061                                            &size))
14062             {
14063               /* Free the compressed buffer, update the section buffer
14064                  and the section size if uncompress is successful.  */
14065               free (section->start);
14066               section->start = start;
14067             }
14068           else
14069             {
14070               error (_("Unable to decompress section %s\n"),
14071                      printable_section_name (filedata, sec));
14072               return FALSE;
14073             }
14074         }
14075
14076       section->size = size;
14077     }
14078
14079   if (section->start == NULL)
14080     return FALSE;
14081
14082   if (debug_displays [debug].relocate)
14083     {
14084       if (! apply_relocations (filedata, sec, section->start, section->size,
14085                                & section->reloc_info, & section->num_relocs))
14086         return FALSE;
14087     }
14088   else
14089     {
14090       section->reloc_info = NULL;
14091       section->num_relocs = 0;
14092     }
14093
14094   return TRUE;
14095 }
14096
14097 /* If this is not NULL, load_debug_section will only look for sections
14098    within the list of sections given here.  */
14099 static unsigned int * section_subset = NULL;
14100
14101 bfd_boolean
14102 load_debug_section (enum dwarf_section_display_enum debug, void * data)
14103 {
14104   struct dwarf_section * section = &debug_displays [debug].section;
14105   Elf_Internal_Shdr * sec;
14106   Filedata * filedata = (Filedata *) data;
14107
14108   /* Without section headers we cannot find any sections.  */
14109   if (filedata->section_headers == NULL)
14110     return FALSE;
14111
14112   if (filedata->string_table == NULL
14113       && filedata->file_header.e_shstrndx != SHN_UNDEF
14114       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
14115     {
14116       Elf_Internal_Shdr * strs;
14117
14118       /* Read in the string table, so that we have section names to scan.  */
14119       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
14120
14121       if (strs != NULL && strs->sh_size != 0)
14122         {
14123           filedata->string_table
14124             = (char *) get_data (NULL, filedata, strs->sh_offset,
14125                                  1, strs->sh_size, _("string table"));
14126
14127           filedata->string_table_length
14128             = filedata->string_table != NULL ? strs->sh_size : 0;
14129         }
14130     }
14131
14132   /* Locate the debug section.  */
14133   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
14134   if (sec != NULL)
14135     section->name = section->uncompressed_name;
14136   else
14137     {
14138       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
14139       if (sec != NULL)
14140         section->name = section->compressed_name;
14141     }
14142   if (sec == NULL)
14143     return FALSE;
14144
14145   /* If we're loading from a subset of sections, and we've loaded
14146      a section matching this name before, it's likely that it's a
14147      different one.  */
14148   if (section_subset != NULL)
14149     free_debug_section (debug);
14150
14151   return load_specific_debug_section (debug, sec, data);
14152 }
14153
14154 void
14155 free_debug_section (enum dwarf_section_display_enum debug)
14156 {
14157   struct dwarf_section * section = &debug_displays [debug].section;
14158
14159   if (section->start == NULL)
14160     return;
14161
14162   free ((char *) section->start);
14163   section->start = NULL;
14164   section->address = 0;
14165   section->size = 0;
14166 }
14167
14168 static bfd_boolean
14169 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
14170 {
14171   char * name = SECTION_NAME (section);
14172   const char * print_name = printable_section_name (filedata, section);
14173   bfd_size_type length;
14174   bfd_boolean result = TRUE;
14175   int i;
14176
14177   length = section->sh_size;
14178   if (length == 0)
14179     {
14180       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
14181       return TRUE;
14182     }
14183   if (section->sh_type == SHT_NOBITS)
14184     {
14185       /* There is no point in dumping the contents of a debugging section
14186          which has the NOBITS type - the bits in the file will be random.
14187          This can happen when a file containing a .eh_frame section is
14188          stripped with the --only-keep-debug command line option.  */
14189       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14190               print_name);
14191       return FALSE;
14192     }
14193
14194   if (const_strneq (name, ".gnu.linkonce.wi."))
14195     name = ".debug_info";
14196
14197   /* See if we know how to display the contents of this section.  */
14198   for (i = 0; i < max; i++)
14199     {
14200       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
14201       struct dwarf_section_display *   display = debug_displays + i;
14202       struct dwarf_section *           sec = & display->section;
14203
14204       if (streq (sec->uncompressed_name, name)
14205           || (id == line && const_strneq (name, ".debug_line."))
14206           || streq (sec->compressed_name, name))
14207         {
14208           bfd_boolean secondary = (section != find_section (filedata, name));
14209
14210           if (secondary)
14211             free_debug_section (id);
14212
14213           if (i == line && const_strneq (name, ".debug_line."))
14214             sec->name = name;
14215           else if (streq (sec->uncompressed_name, name))
14216             sec->name = sec->uncompressed_name;
14217           else
14218             sec->name = sec->compressed_name;
14219
14220           if (load_specific_debug_section (id, section, filedata))
14221             {
14222               /* If this debug section is part of a CU/TU set in a .dwp file,
14223                  restrict load_debug_section to the sections in that set.  */
14224               section_subset = find_cu_tu_set (filedata, shndx);
14225
14226               result &= display->display (sec, filedata);
14227
14228               section_subset = NULL;
14229
14230               if (secondary || (id != info && id != abbrev))
14231                 free_debug_section (id);
14232             }
14233           break;
14234         }
14235     }
14236
14237   if (i == max)
14238     {
14239       printf (_("Unrecognized debug section: %s\n"), print_name);
14240       result = FALSE;
14241     }
14242
14243   return result;
14244 }
14245
14246 /* Set DUMP_SECTS for all sections where dumps were requested
14247    based on section name.  */
14248
14249 static void
14250 initialise_dumps_byname (Filedata * filedata)
14251 {
14252   struct dump_list_entry * cur;
14253
14254   for (cur = dump_sects_byname; cur; cur = cur->next)
14255     {
14256       unsigned int i;
14257       bfd_boolean any = FALSE;
14258
14259       for (i = 0; i < filedata->file_header.e_shnum; i++)
14260         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
14261           {
14262             request_dump_bynumber (filedata, i, cur->type);
14263             any = TRUE;
14264           }
14265
14266       if (!any)
14267         warn (_("Section '%s' was not dumped because it does not exist!\n"),
14268               cur->name);
14269     }
14270 }
14271
14272 static bfd_boolean
14273 process_section_contents (Filedata * filedata)
14274 {
14275   Elf_Internal_Shdr * section;
14276   unsigned int i;
14277   bfd_boolean res = TRUE;
14278
14279   if (! do_dump)
14280     return TRUE;
14281
14282   initialise_dumps_byname (filedata);
14283
14284   for (i = 0, section = filedata->section_headers;
14285        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
14286        i++, section++)
14287     {
14288       dump_type dump = filedata->dump_sects[i];
14289
14290 #ifdef SUPPORT_DISASSEMBLY
14291       if (dump & DISASS_DUMP)
14292         {
14293           if (! disassemble_section (section, filedata))
14294             res = FALSE;
14295         }
14296 #endif
14297       if (dump & HEX_DUMP)
14298         {
14299           if (! dump_section_as_bytes (section, filedata, FALSE))
14300             res = FALSE;
14301         }
14302
14303       if (dump & RELOC_DUMP)
14304         {
14305           if (! dump_section_as_bytes (section, filedata, TRUE))
14306             res = FALSE;
14307         }
14308
14309       if (dump & STRING_DUMP)
14310         {
14311           if (! dump_section_as_strings (section, filedata))
14312             res = FALSE;
14313         }
14314
14315       if (dump & DEBUG_DUMP)
14316         {
14317           if (! display_debug_section (i, section, filedata))
14318             res = FALSE;
14319         }
14320
14321 #ifdef HAVE_LIBCTF
14322       if (dump & CTF_DUMP)
14323         {
14324           if (! dump_section_as_ctf (section, filedata))
14325             res = FALSE;
14326         }
14327 #endif
14328     }
14329
14330   /* Check to see if the user requested a
14331      dump of a section that does not exist.  */
14332   while (i < filedata->num_dump_sects)
14333     {
14334       if (filedata->dump_sects[i])
14335         {
14336           warn (_("Section %d was not dumped because it does not exist!\n"), i);
14337           res = FALSE;
14338         }
14339       i++;
14340     }
14341
14342   return res;
14343 }
14344
14345 static void
14346 process_mips_fpe_exception (int mask)
14347 {
14348   if (mask)
14349     {
14350       bfd_boolean first = TRUE;
14351
14352       if (mask & OEX_FPU_INEX)
14353         fputs ("INEX", stdout), first = FALSE;
14354       if (mask & OEX_FPU_UFLO)
14355         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14356       if (mask & OEX_FPU_OFLO)
14357         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14358       if (mask & OEX_FPU_DIV0)
14359         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14360       if (mask & OEX_FPU_INVAL)
14361         printf ("%sINVAL", first ? "" : "|");
14362     }
14363   else
14364     fputs ("0", stdout);
14365 }
14366
14367 /* Display's the value of TAG at location P.  If TAG is
14368    greater than 0 it is assumed to be an unknown tag, and
14369    a message is printed to this effect.  Otherwise it is
14370    assumed that a message has already been printed.
14371
14372    If the bottom bit of TAG is set it assumed to have a
14373    string value, otherwise it is assumed to have an integer
14374    value.
14375
14376    Returns an updated P pointing to the first unread byte
14377    beyond the end of TAG's value.
14378
14379    Reads at or beyond END will not be made.  */
14380
14381 static unsigned char *
14382 display_tag_value (signed int tag,
14383                    unsigned char * p,
14384                    const unsigned char * const end)
14385 {
14386   unsigned long val;
14387
14388   if (tag > 0)
14389     printf ("  Tag_unknown_%d: ", tag);
14390
14391   if (p >= end)
14392     {
14393       warn (_("<corrupt tag>\n"));
14394     }
14395   else if (tag & 1)
14396     {
14397       /* PR 17531 file: 027-19978-0.004.  */
14398       size_t maxlen = (end - p) - 1;
14399
14400       putchar ('"');
14401       if (maxlen > 0)
14402         {
14403           print_symbol ((int) maxlen, (const char *) p);
14404           p += strnlen ((char *) p, maxlen) + 1;
14405         }
14406       else
14407         {
14408           printf (_("<corrupt string tag>"));
14409           p = (unsigned char *) end;
14410         }
14411       printf ("\"\n");
14412     }
14413   else
14414     {
14415       unsigned int len;
14416
14417       val = read_uleb128 (p, &len, end);
14418       p += len;
14419       printf ("%ld (0x%lx)\n", val, val);
14420     }
14421
14422   assert (p <= end);
14423   return p;
14424 }
14425
14426 /* ARC ABI attributes section.  */
14427
14428 static unsigned char *
14429 display_arc_attribute (unsigned char * p,
14430                        const unsigned char * const end)
14431 {
14432   unsigned int tag;
14433   unsigned int len;
14434   unsigned int val;
14435
14436   tag = read_uleb128 (p, &len, end);
14437   p += len;
14438
14439   switch (tag)
14440     {
14441     case Tag_ARC_PCS_config:
14442       val = read_uleb128 (p, &len, end);
14443       p += len;
14444       printf ("  Tag_ARC_PCS_config: ");
14445       switch (val)
14446         {
14447         case 0:
14448           printf (_("Absent/Non standard\n"));
14449           break;
14450         case 1:
14451           printf (_("Bare metal/mwdt\n"));
14452           break;
14453         case 2:
14454           printf (_("Bare metal/newlib\n"));
14455           break;
14456         case 3:
14457           printf (_("Linux/uclibc\n"));
14458           break;
14459         case 4:
14460           printf (_("Linux/glibc\n"));
14461           break;
14462         default:
14463           printf (_("Unknown\n"));
14464           break;
14465         }
14466       break;
14467
14468     case Tag_ARC_CPU_base:
14469       val = read_uleb128 (p, &len, end);
14470       p += len;
14471       printf ("  Tag_ARC_CPU_base: ");
14472       switch (val)
14473         {
14474         default:
14475         case TAG_CPU_NONE:
14476           printf (_("Absent\n"));
14477           break;
14478         case TAG_CPU_ARC6xx:
14479           printf ("ARC6xx\n");
14480           break;
14481         case TAG_CPU_ARC7xx:
14482           printf ("ARC7xx\n");
14483           break;
14484         case TAG_CPU_ARCEM:
14485           printf ("ARCEM\n");
14486           break;
14487         case TAG_CPU_ARCHS:
14488           printf ("ARCHS\n");
14489           break;
14490         }
14491       break;
14492
14493     case Tag_ARC_CPU_variation:
14494       val = read_uleb128 (p, &len, end);
14495       p += len;
14496       printf ("  Tag_ARC_CPU_variation: ");
14497       switch (val)
14498         {
14499         default:
14500           if (val > 0 && val < 16)
14501               printf ("Core%d\n", val);
14502           else
14503               printf ("Unknown\n");
14504           break;
14505
14506         case 0:
14507           printf (_("Absent\n"));
14508           break;
14509         }
14510       break;
14511
14512     case Tag_ARC_CPU_name:
14513       printf ("  Tag_ARC_CPU_name: ");
14514       p = display_tag_value (-1, p, end);
14515       break;
14516
14517     case Tag_ARC_ABI_rf16:
14518       val = read_uleb128 (p, &len, end);
14519       p += len;
14520       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14521       break;
14522
14523     case Tag_ARC_ABI_osver:
14524       val = read_uleb128 (p, &len, end);
14525       p += len;
14526       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14527       break;
14528
14529     case Tag_ARC_ABI_pic:
14530     case Tag_ARC_ABI_sda:
14531       val = read_uleb128 (p, &len, end);
14532       p += len;
14533       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14534               : "  Tag_ARC_ABI_pic: ");
14535       switch (val)
14536         {
14537         case 0:
14538           printf (_("Absent\n"));
14539           break;
14540         case 1:
14541           printf ("MWDT\n");
14542           break;
14543         case 2:
14544           printf ("GNU\n");
14545           break;
14546         default:
14547           printf (_("Unknown\n"));
14548           break;
14549         }
14550       break;
14551
14552     case Tag_ARC_ABI_tls:
14553       val = read_uleb128 (p, &len, end);
14554       p += len;
14555       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14556       break;
14557
14558     case Tag_ARC_ABI_enumsize:
14559       val = read_uleb128 (p, &len, end);
14560       p += len;
14561       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14562               _("smallest"));
14563       break;
14564
14565     case Tag_ARC_ABI_exceptions:
14566       val = read_uleb128 (p, &len, end);
14567       p += len;
14568       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14569               : _("default"));
14570       break;
14571
14572     case Tag_ARC_ABI_double_size:
14573       val = read_uleb128 (p, &len, end);
14574       p += len;
14575       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14576       break;
14577
14578     case Tag_ARC_ISA_config:
14579       printf ("  Tag_ARC_ISA_config: ");
14580       p = display_tag_value (-1, p, end);
14581       break;
14582
14583     case Tag_ARC_ISA_apex:
14584       printf ("  Tag_ARC_ISA_apex: ");
14585       p = display_tag_value (-1, p, end);
14586       break;
14587
14588     case Tag_ARC_ISA_mpy_option:
14589       val = read_uleb128 (p, &len, end);
14590       p += len;
14591       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14592       break;
14593
14594     case Tag_ARC_ATR_version:
14595       val = read_uleb128 (p, &len, end);
14596       p += len;
14597       printf ("  Tag_ARC_ATR_version: %d\n", val);
14598       break;
14599
14600     default:
14601       return display_tag_value (tag & 1, p, end);
14602     }
14603
14604   return p;
14605 }
14606
14607 /* ARM EABI attributes section.  */
14608 typedef struct
14609 {
14610   unsigned int tag;
14611   const char * name;
14612   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14613   unsigned int type;
14614   const char ** table;
14615 } arm_attr_public_tag;
14616
14617 static const char * arm_attr_tag_CPU_arch[] =
14618   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14619    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14620    "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14621 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14622 static const char * arm_attr_tag_THUMB_ISA_use[] =
14623   {"No", "Thumb-1", "Thumb-2", "Yes"};
14624 static const char * arm_attr_tag_FP_arch[] =
14625   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14626    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14627 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14628 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14629   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14630    "NEON for ARMv8.1"};
14631 static const char * arm_attr_tag_PCS_config[] =
14632   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14633    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14634 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14635   {"V6", "SB", "TLS", "Unused"};
14636 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14637   {"Absolute", "PC-relative", "SB-relative", "None"};
14638 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14639   {"Absolute", "PC-relative", "None"};
14640 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14641   {"None", "direct", "GOT-indirect"};
14642 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14643   {"None", "??? 1", "2", "??? 3", "4"};
14644 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14645 static const char * arm_attr_tag_ABI_FP_denormal[] =
14646   {"Unused", "Needed", "Sign only"};
14647 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14648 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14649 static const char * arm_attr_tag_ABI_FP_number_model[] =
14650   {"Unused", "Finite", "RTABI", "IEEE 754"};
14651 static const char * arm_attr_tag_ABI_enum_size[] =
14652   {"Unused", "small", "int", "forced to int"};
14653 static const char * arm_attr_tag_ABI_HardFP_use[] =
14654   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14655 static const char * arm_attr_tag_ABI_VFP_args[] =
14656   {"AAPCS", "VFP registers", "custom", "compatible"};
14657 static const char * arm_attr_tag_ABI_WMMX_args[] =
14658   {"AAPCS", "WMMX registers", "custom"};
14659 static const char * arm_attr_tag_ABI_optimization_goals[] =
14660   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14661     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14662 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14663   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14664     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14665 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14666 static const char * arm_attr_tag_FP_HP_extension[] =
14667   {"Not Allowed", "Allowed"};
14668 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14669   {"None", "IEEE 754", "Alternative Format"};
14670 static const char * arm_attr_tag_DSP_extension[] =
14671   {"Follow architecture", "Allowed"};
14672 static const char * arm_attr_tag_MPextension_use[] =
14673   {"Not Allowed", "Allowed"};
14674 static const char * arm_attr_tag_DIV_use[] =
14675   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14676     "Allowed in v7-A with integer division extension"};
14677 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14678 static const char * arm_attr_tag_Virtualization_use[] =
14679   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14680     "TrustZone and Virtualization Extensions"};
14681 static const char * arm_attr_tag_MPextension_use_legacy[] =
14682   {"Not Allowed", "Allowed"};
14683
14684 static const char * arm_attr_tag_MVE_arch[] =
14685   {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14686
14687 #define LOOKUP(id, name) \
14688   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14689 static arm_attr_public_tag arm_attr_public_tags[] =
14690 {
14691   {4, "CPU_raw_name", 1, NULL},
14692   {5, "CPU_name", 1, NULL},
14693   LOOKUP(6, CPU_arch),
14694   {7, "CPU_arch_profile", 0, NULL},
14695   LOOKUP(8, ARM_ISA_use),
14696   LOOKUP(9, THUMB_ISA_use),
14697   LOOKUP(10, FP_arch),
14698   LOOKUP(11, WMMX_arch),
14699   LOOKUP(12, Advanced_SIMD_arch),
14700   LOOKUP(13, PCS_config),
14701   LOOKUP(14, ABI_PCS_R9_use),
14702   LOOKUP(15, ABI_PCS_RW_data),
14703   LOOKUP(16, ABI_PCS_RO_data),
14704   LOOKUP(17, ABI_PCS_GOT_use),
14705   LOOKUP(18, ABI_PCS_wchar_t),
14706   LOOKUP(19, ABI_FP_rounding),
14707   LOOKUP(20, ABI_FP_denormal),
14708   LOOKUP(21, ABI_FP_exceptions),
14709   LOOKUP(22, ABI_FP_user_exceptions),
14710   LOOKUP(23, ABI_FP_number_model),
14711   {24, "ABI_align_needed", 0, NULL},
14712   {25, "ABI_align_preserved", 0, NULL},
14713   LOOKUP(26, ABI_enum_size),
14714   LOOKUP(27, ABI_HardFP_use),
14715   LOOKUP(28, ABI_VFP_args),
14716   LOOKUP(29, ABI_WMMX_args),
14717   LOOKUP(30, ABI_optimization_goals),
14718   LOOKUP(31, ABI_FP_optimization_goals),
14719   {32, "compatibility", 0, NULL},
14720   LOOKUP(34, CPU_unaligned_access),
14721   LOOKUP(36, FP_HP_extension),
14722   LOOKUP(38, ABI_FP_16bit_format),
14723   LOOKUP(42, MPextension_use),
14724   LOOKUP(44, DIV_use),
14725   LOOKUP(46, DSP_extension),
14726   LOOKUP(48, MVE_arch),
14727   {64, "nodefaults", 0, NULL},
14728   {65, "also_compatible_with", 0, NULL},
14729   LOOKUP(66, T2EE_use),
14730   {67, "conformance", 1, NULL},
14731   LOOKUP(68, Virtualization_use),
14732   LOOKUP(70, MPextension_use_legacy)
14733 };
14734 #undef LOOKUP
14735
14736 static unsigned char *
14737 display_arm_attribute (unsigned char * p,
14738                        const unsigned char * const end)
14739 {
14740   unsigned int tag;
14741   unsigned int len;
14742   unsigned int val;
14743   arm_attr_public_tag * attr;
14744   unsigned i;
14745   unsigned int type;
14746
14747   tag = read_uleb128 (p, &len, end);
14748   p += len;
14749   attr = NULL;
14750   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14751     {
14752       if (arm_attr_public_tags[i].tag == tag)
14753         {
14754           attr = &arm_attr_public_tags[i];
14755           break;
14756         }
14757     }
14758
14759   if (attr)
14760     {
14761       printf ("  Tag_%s: ", attr->name);
14762       switch (attr->type)
14763         {
14764         case 0:
14765           switch (tag)
14766             {
14767             case 7: /* Tag_CPU_arch_profile.  */
14768               val = read_uleb128 (p, &len, end);
14769               p += len;
14770               switch (val)
14771                 {
14772                 case 0: printf (_("None\n")); break;
14773                 case 'A': printf (_("Application\n")); break;
14774                 case 'R': printf (_("Realtime\n")); break;
14775                 case 'M': printf (_("Microcontroller\n")); break;
14776                 case 'S': printf (_("Application or Realtime\n")); break;
14777                 default: printf ("??? (%d)\n", val); break;
14778                 }
14779               break;
14780
14781             case 24: /* Tag_align_needed.  */
14782               val = read_uleb128 (p, &len, end);
14783               p += len;
14784               switch (val)
14785                 {
14786                 case 0: printf (_("None\n")); break;
14787                 case 1: printf (_("8-byte\n")); break;
14788                 case 2: printf (_("4-byte\n")); break;
14789                 case 3: printf ("??? 3\n"); break;
14790                 default:
14791                   if (val <= 12)
14792                     printf (_("8-byte and up to %d-byte extended\n"),
14793                             1 << val);
14794                   else
14795                     printf ("??? (%d)\n", val);
14796                   break;
14797                 }
14798               break;
14799
14800             case 25: /* Tag_align_preserved.  */
14801               val = read_uleb128 (p, &len, end);
14802               p += len;
14803               switch (val)
14804                 {
14805                 case 0: printf (_("None\n")); break;
14806                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14807                 case 2: printf (_("8-byte\n")); break;
14808                 case 3: printf ("??? 3\n"); break;
14809                 default:
14810                   if (val <= 12)
14811                     printf (_("8-byte and up to %d-byte extended\n"),
14812                             1 << val);
14813                   else
14814                     printf ("??? (%d)\n", val);
14815                   break;
14816                 }
14817               break;
14818
14819             case 32: /* Tag_compatibility.  */
14820               {
14821                 val = read_uleb128 (p, &len, end);
14822                 p += len;
14823                 printf (_("flag = %d, vendor = "), val);
14824                 if (p < end - 1)
14825                   {
14826                     size_t maxlen = (end - p) - 1;
14827
14828                     print_symbol ((int) maxlen, (const char *) p);
14829                     p += strnlen ((char *) p, maxlen) + 1;
14830                   }
14831                 else
14832                   {
14833                     printf (_("<corrupt>"));
14834                     p = (unsigned char *) end;
14835                   }
14836                 putchar ('\n');
14837               }
14838               break;
14839
14840             case 64: /* Tag_nodefaults.  */
14841               /* PR 17531: file: 001-505008-0.01.  */
14842               if (p < end)
14843                 p++;
14844               printf (_("True\n"));
14845               break;
14846
14847             case 65: /* Tag_also_compatible_with.  */
14848               val = read_uleb128 (p, &len, end);
14849               p += len;
14850               if (val == 6 /* Tag_CPU_arch.  */)
14851                 {
14852                   val = read_uleb128 (p, &len, end);
14853                   p += len;
14854                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14855                     printf ("??? (%d)\n", val);
14856                   else
14857                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14858                 }
14859               else
14860                 printf ("???\n");
14861               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14862                 ;
14863               break;
14864
14865             default:
14866               printf (_("<unknown: %d>\n"), tag);
14867               break;
14868             }
14869           return p;
14870
14871         case 1:
14872           return display_tag_value (-1, p, end);
14873         case 2:
14874           return display_tag_value (0, p, end);
14875
14876         default:
14877           assert (attr->type & 0x80);
14878           val = read_uleb128 (p, &len, end);
14879           p += len;
14880           type = attr->type & 0x7f;
14881           if (val >= type)
14882             printf ("??? (%d)\n", val);
14883           else
14884             printf ("%s\n", attr->table[val]);
14885           return p;
14886         }
14887     }
14888
14889   return display_tag_value (tag, p, end);
14890 }
14891
14892 static unsigned char *
14893 display_gnu_attribute (unsigned char * p,
14894                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14895                        const unsigned char * const end)
14896 {
14897   int tag;
14898   unsigned int len;
14899   unsigned int val;
14900
14901   tag = read_uleb128 (p, &len, end);
14902   p += len;
14903
14904   /* Tag_compatibility is the only generic GNU attribute defined at
14905      present.  */
14906   if (tag == 32)
14907     {
14908       val = read_uleb128 (p, &len, end);
14909       p += len;
14910
14911       printf (_("flag = %d, vendor = "), val);
14912       if (p == end)
14913         {
14914           printf (_("<corrupt>\n"));
14915           warn (_("corrupt vendor attribute\n"));
14916         }
14917       else
14918         {
14919           if (p < end - 1)
14920             {
14921               size_t maxlen = (end - p) - 1;
14922
14923               print_symbol ((int) maxlen, (const char *) p);
14924               p += strnlen ((char *) p, maxlen) + 1;
14925             }
14926           else
14927             {
14928               printf (_("<corrupt>"));
14929               p = (unsigned char *) end;
14930             }
14931           putchar ('\n');
14932         }
14933       return p;
14934     }
14935
14936   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14937     return display_proc_gnu_attribute (p, tag, end);
14938
14939   return display_tag_value (tag, p, end);
14940 }
14941
14942 static unsigned char *
14943 display_power_gnu_attribute (unsigned char * p,
14944                              unsigned int tag,
14945                              const unsigned char * const end)
14946 {
14947   unsigned int len;
14948   unsigned int val;
14949
14950   if (tag == Tag_GNU_Power_ABI_FP)
14951     {
14952       val = read_uleb128 (p, &len, end);
14953       p += len;
14954       printf ("  Tag_GNU_Power_ABI_FP: ");
14955       if (len == 0)
14956         {
14957           printf (_("<corrupt>\n"));
14958           return p;
14959         }
14960
14961       if (val > 15)
14962         printf ("(%#x), ", val);
14963
14964       switch (val & 3)
14965         {
14966         case 0:
14967           printf (_("unspecified hard/soft float, "));
14968           break;
14969         case 1:
14970           printf (_("hard float, "));
14971           break;
14972         case 2:
14973           printf (_("soft float, "));
14974           break;
14975         case 3:
14976           printf (_("single-precision hard float, "));
14977           break;
14978         }
14979
14980       switch (val & 0xC)
14981         {
14982         case 0:
14983           printf (_("unspecified long double\n"));
14984           break;
14985         case 4:
14986           printf (_("128-bit IBM long double\n"));
14987           break;
14988         case 8:
14989           printf (_("64-bit long double\n"));
14990           break;
14991         case 12:
14992           printf (_("128-bit IEEE long double\n"));
14993           break;
14994         }
14995       return p;
14996     }
14997
14998   if (tag == Tag_GNU_Power_ABI_Vector)
14999     {
15000       val = read_uleb128 (p, &len, end);
15001       p += len;
15002       printf ("  Tag_GNU_Power_ABI_Vector: ");
15003       if (len == 0)
15004         {
15005           printf (_("<corrupt>\n"));
15006           return p;
15007         }
15008
15009       if (val > 3)
15010         printf ("(%#x), ", val);
15011
15012       switch (val & 3)
15013         {
15014         case 0:
15015           printf (_("unspecified\n"));
15016           break;
15017         case 1:
15018           printf (_("generic\n"));
15019           break;
15020         case 2:
15021           printf ("AltiVec\n");
15022           break;
15023         case 3:
15024           printf ("SPE\n");
15025           break;
15026         }
15027       return p;
15028     }
15029
15030   if (tag == Tag_GNU_Power_ABI_Struct_Return)
15031     {
15032       val = read_uleb128 (p, &len, end);
15033       p += len;
15034       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
15035       if (len == 0)
15036         {
15037           printf (_("<corrupt>\n"));
15038           return p;
15039         }
15040
15041       if (val > 2)
15042         printf ("(%#x), ", val);
15043
15044       switch (val & 3)
15045         {
15046         case 0:
15047           printf (_("unspecified\n"));
15048           break;
15049         case 1:
15050           printf ("r3/r4\n");
15051           break;
15052         case 2:
15053           printf (_("memory\n"));
15054           break;
15055         case 3:
15056           printf ("???\n");
15057           break;
15058         }
15059       return p;
15060     }
15061
15062   return display_tag_value (tag & 1, p, end);
15063 }
15064
15065 static unsigned char *
15066 display_s390_gnu_attribute (unsigned char * p,
15067                             unsigned int tag,
15068                             const unsigned char * const end)
15069 {
15070   unsigned int len;
15071   int val;
15072
15073   if (tag == Tag_GNU_S390_ABI_Vector)
15074     {
15075       val = read_uleb128 (p, &len, end);
15076       p += len;
15077       printf ("  Tag_GNU_S390_ABI_Vector: ");
15078
15079       switch (val)
15080         {
15081         case 0:
15082           printf (_("any\n"));
15083           break;
15084         case 1:
15085           printf (_("software\n"));
15086           break;
15087         case 2:
15088           printf (_("hardware\n"));
15089           break;
15090         default:
15091           printf ("??? (%d)\n", val);
15092           break;
15093         }
15094       return p;
15095    }
15096
15097   return display_tag_value (tag & 1, p, end);
15098 }
15099
15100 static void
15101 display_sparc_hwcaps (unsigned int mask)
15102 {
15103   if (mask)
15104     {
15105       bfd_boolean first = TRUE;
15106
15107       if (mask & ELF_SPARC_HWCAP_MUL32)
15108         fputs ("mul32", stdout), first = FALSE;
15109       if (mask & ELF_SPARC_HWCAP_DIV32)
15110         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
15111       if (mask & ELF_SPARC_HWCAP_FSMULD)
15112         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
15113       if (mask & ELF_SPARC_HWCAP_V8PLUS)
15114         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
15115       if (mask & ELF_SPARC_HWCAP_POPC)
15116         printf ("%spopc", first ? "" : "|"), first = FALSE;
15117       if (mask & ELF_SPARC_HWCAP_VIS)
15118         printf ("%svis", first ? "" : "|"), first = FALSE;
15119       if (mask & ELF_SPARC_HWCAP_VIS2)
15120         printf ("%svis2", first ? "" : "|"), first = FALSE;
15121       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
15122         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
15123       if (mask & ELF_SPARC_HWCAP_FMAF)
15124         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
15125       if (mask & ELF_SPARC_HWCAP_VIS3)
15126         printf ("%svis3", first ? "" : "|"), first = FALSE;
15127       if (mask & ELF_SPARC_HWCAP_HPC)
15128         printf ("%shpc", first ? "" : "|"), first = FALSE;
15129       if (mask & ELF_SPARC_HWCAP_RANDOM)
15130         printf ("%srandom", first ? "" : "|"), first = FALSE;
15131       if (mask & ELF_SPARC_HWCAP_TRANS)
15132         printf ("%strans", first ? "" : "|"), first = FALSE;
15133       if (mask & ELF_SPARC_HWCAP_FJFMAU)
15134         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
15135       if (mask & ELF_SPARC_HWCAP_IMA)
15136         printf ("%sima", first ? "" : "|"), first = FALSE;
15137       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
15138         printf ("%scspare", first ? "" : "|"), first = FALSE;
15139     }
15140   else
15141     fputc ('0', stdout);
15142   fputc ('\n', stdout);
15143 }
15144
15145 static void
15146 display_sparc_hwcaps2 (unsigned int mask)
15147 {
15148   if (mask)
15149     {
15150       bfd_boolean first = TRUE;
15151
15152       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
15153         fputs ("fjathplus", stdout), first = FALSE;
15154       if (mask & ELF_SPARC_HWCAP2_VIS3B)
15155         printf ("%svis3b", first ? "" : "|"), first = FALSE;
15156       if (mask & ELF_SPARC_HWCAP2_ADP)
15157         printf ("%sadp", first ? "" : "|"), first = FALSE;
15158       if (mask & ELF_SPARC_HWCAP2_SPARC5)
15159         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
15160       if (mask & ELF_SPARC_HWCAP2_MWAIT)
15161         printf ("%smwait", first ? "" : "|"), first = FALSE;
15162       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
15163         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
15164       if (mask & ELF_SPARC_HWCAP2_XMONT)
15165         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
15166       if (mask & ELF_SPARC_HWCAP2_NSEC)
15167         printf ("%snsec", first ? "" : "|"), first = FALSE;
15168       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
15169         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
15170       if (mask & ELF_SPARC_HWCAP2_FJDES)
15171         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
15172       if (mask & ELF_SPARC_HWCAP2_FJAES)
15173         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
15174     }
15175   else
15176     fputc ('0', stdout);
15177   fputc ('\n', stdout);
15178 }
15179
15180 static unsigned char *
15181 display_sparc_gnu_attribute (unsigned char * p,
15182                              unsigned int tag,
15183                              const unsigned char * const end)
15184 {
15185   unsigned int len;
15186   int val;
15187
15188   if (tag == Tag_GNU_Sparc_HWCAPS)
15189     {
15190       val = read_uleb128 (p, &len, end);
15191       p += len;
15192       printf ("  Tag_GNU_Sparc_HWCAPS: ");
15193       display_sparc_hwcaps (val);
15194       return p;
15195     }
15196   if (tag == Tag_GNU_Sparc_HWCAPS2)
15197     {
15198       val = read_uleb128 (p, &len, end);
15199       p += len;
15200       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
15201       display_sparc_hwcaps2 (val);
15202       return p;
15203     }
15204
15205   return display_tag_value (tag, p, end);
15206 }
15207
15208 static void
15209 print_mips_fp_abi_value (unsigned int val)
15210 {
15211   switch (val)
15212     {
15213     case Val_GNU_MIPS_ABI_FP_ANY:
15214       printf (_("Hard or soft float\n"));
15215       break;
15216     case Val_GNU_MIPS_ABI_FP_DOUBLE:
15217       printf (_("Hard float (double precision)\n"));
15218       break;
15219     case Val_GNU_MIPS_ABI_FP_SINGLE:
15220       printf (_("Hard float (single precision)\n"));
15221       break;
15222     case Val_GNU_MIPS_ABI_FP_SOFT:
15223       printf (_("Soft float\n"));
15224       break;
15225     case Val_GNU_MIPS_ABI_FP_OLD_64:
15226       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15227       break;
15228     case Val_GNU_MIPS_ABI_FP_XX:
15229       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15230       break;
15231     case Val_GNU_MIPS_ABI_FP_64:
15232       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15233       break;
15234     case Val_GNU_MIPS_ABI_FP_64A:
15235       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15236       break;
15237     case Val_GNU_MIPS_ABI_FP_NAN2008:
15238       printf (_("NaN 2008 compatibility\n"));
15239       break;
15240     default:
15241       printf ("??? (%d)\n", val);
15242       break;
15243     }
15244 }
15245
15246 static unsigned char *
15247 display_mips_gnu_attribute (unsigned char * p,
15248                             unsigned int tag,
15249                             const unsigned char * const end)
15250 {
15251   if (tag == Tag_GNU_MIPS_ABI_FP)
15252     {
15253       unsigned int len;
15254       unsigned int val;
15255
15256       val = read_uleb128 (p, &len, end);
15257       p += len;
15258       printf ("  Tag_GNU_MIPS_ABI_FP: ");
15259
15260       print_mips_fp_abi_value (val);
15261
15262       return p;
15263    }
15264
15265   if (tag == Tag_GNU_MIPS_ABI_MSA)
15266     {
15267       unsigned int len;
15268       unsigned int val;
15269
15270       val = read_uleb128 (p, &len, end);
15271       p += len;
15272       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
15273
15274       switch (val)
15275         {
15276         case Val_GNU_MIPS_ABI_MSA_ANY:
15277           printf (_("Any MSA or not\n"));
15278           break;
15279         case Val_GNU_MIPS_ABI_MSA_128:
15280           printf (_("128-bit MSA\n"));
15281           break;
15282         default:
15283           printf ("??? (%d)\n", val);
15284           break;
15285         }
15286       return p;
15287     }
15288
15289   return display_tag_value (tag & 1, p, end);
15290 }
15291
15292 static unsigned char *
15293 display_tic6x_attribute (unsigned char * p,
15294                          const unsigned char * const end)
15295 {
15296   unsigned int tag;
15297   unsigned int len;
15298   int val;
15299
15300   tag = read_uleb128 (p, &len, end);
15301   p += len;
15302
15303   switch (tag)
15304     {
15305     case Tag_ISA:
15306       val = read_uleb128 (p, &len, end);
15307       p += len;
15308       printf ("  Tag_ISA: ");
15309
15310       switch (val)
15311         {
15312         case C6XABI_Tag_ISA_none:
15313           printf (_("None\n"));
15314           break;
15315         case C6XABI_Tag_ISA_C62X:
15316           printf ("C62x\n");
15317           break;
15318         case C6XABI_Tag_ISA_C67X:
15319           printf ("C67x\n");
15320           break;
15321         case C6XABI_Tag_ISA_C67XP:
15322           printf ("C67x+\n");
15323           break;
15324         case C6XABI_Tag_ISA_C64X:
15325           printf ("C64x\n");
15326           break;
15327         case C6XABI_Tag_ISA_C64XP:
15328           printf ("C64x+\n");
15329           break;
15330         case C6XABI_Tag_ISA_C674X:
15331           printf ("C674x\n");
15332           break;
15333         default:
15334           printf ("??? (%d)\n", val);
15335           break;
15336         }
15337       return p;
15338
15339     case Tag_ABI_wchar_t:
15340       val = read_uleb128 (p, &len, end);
15341       p += len;
15342       printf ("  Tag_ABI_wchar_t: ");
15343       switch (val)
15344         {
15345         case 0:
15346           printf (_("Not used\n"));
15347           break;
15348         case 1:
15349           printf (_("2 bytes\n"));
15350           break;
15351         case 2:
15352           printf (_("4 bytes\n"));
15353           break;
15354         default:
15355           printf ("??? (%d)\n", val);
15356           break;
15357         }
15358       return p;
15359
15360     case Tag_ABI_stack_align_needed:
15361       val = read_uleb128 (p, &len, end);
15362       p += len;
15363       printf ("  Tag_ABI_stack_align_needed: ");
15364       switch (val)
15365         {
15366         case 0:
15367           printf (_("8-byte\n"));
15368           break;
15369         case 1:
15370           printf (_("16-byte\n"));
15371           break;
15372         default:
15373           printf ("??? (%d)\n", val);
15374           break;
15375         }
15376       return p;
15377
15378     case Tag_ABI_stack_align_preserved:
15379       val = read_uleb128 (p, &len, end);
15380       p += len;
15381       printf ("  Tag_ABI_stack_align_preserved: ");
15382       switch (val)
15383         {
15384         case 0:
15385           printf (_("8-byte\n"));
15386           break;
15387         case 1:
15388           printf (_("16-byte\n"));
15389           break;
15390         default:
15391           printf ("??? (%d)\n", val);
15392           break;
15393         }
15394       return p;
15395
15396     case Tag_ABI_DSBT:
15397       val = read_uleb128 (p, &len, end);
15398       p += len;
15399       printf ("  Tag_ABI_DSBT: ");
15400       switch (val)
15401         {
15402         case 0:
15403           printf (_("DSBT addressing not used\n"));
15404           break;
15405         case 1:
15406           printf (_("DSBT addressing used\n"));
15407           break;
15408         default:
15409           printf ("??? (%d)\n", val);
15410           break;
15411         }
15412       return p;
15413
15414     case Tag_ABI_PID:
15415       val = read_uleb128 (p, &len, end);
15416       p += len;
15417       printf ("  Tag_ABI_PID: ");
15418       switch (val)
15419         {
15420         case 0:
15421           printf (_("Data addressing position-dependent\n"));
15422           break;
15423         case 1:
15424           printf (_("Data addressing position-independent, GOT near DP\n"));
15425           break;
15426         case 2:
15427           printf (_("Data addressing position-independent, GOT far from DP\n"));
15428           break;
15429         default:
15430           printf ("??? (%d)\n", val);
15431           break;
15432         }
15433       return p;
15434
15435     case Tag_ABI_PIC:
15436       val = read_uleb128 (p, &len, end);
15437       p += len;
15438       printf ("  Tag_ABI_PIC: ");
15439       switch (val)
15440         {
15441         case 0:
15442           printf (_("Code addressing position-dependent\n"));
15443           break;
15444         case 1:
15445           printf (_("Code addressing position-independent\n"));
15446           break;
15447         default:
15448           printf ("??? (%d)\n", val);
15449           break;
15450         }
15451       return p;
15452
15453     case Tag_ABI_array_object_alignment:
15454       val = read_uleb128 (p, &len, end);
15455       p += len;
15456       printf ("  Tag_ABI_array_object_alignment: ");
15457       switch (val)
15458         {
15459         case 0:
15460           printf (_("8-byte\n"));
15461           break;
15462         case 1:
15463           printf (_("4-byte\n"));
15464           break;
15465         case 2:
15466           printf (_("16-byte\n"));
15467           break;
15468         default:
15469           printf ("??? (%d)\n", val);
15470           break;
15471         }
15472       return p;
15473
15474     case Tag_ABI_array_object_align_expected:
15475       val = read_uleb128 (p, &len, end);
15476       p += len;
15477       printf ("  Tag_ABI_array_object_align_expected: ");
15478       switch (val)
15479         {
15480         case 0:
15481           printf (_("8-byte\n"));
15482           break;
15483         case 1:
15484           printf (_("4-byte\n"));
15485           break;
15486         case 2:
15487           printf (_("16-byte\n"));
15488           break;
15489         default:
15490           printf ("??? (%d)\n", val);
15491           break;
15492         }
15493       return p;
15494
15495     case Tag_ABI_compatibility:
15496       {
15497         val = read_uleb128 (p, &len, end);
15498         p += len;
15499         printf ("  Tag_ABI_compatibility: ");
15500         printf (_("flag = %d, vendor = "), val);
15501         if (p < end - 1)
15502           {
15503             size_t maxlen = (end - p) - 1;
15504
15505             print_symbol ((int) maxlen, (const char *) p);
15506             p += strnlen ((char *) p, maxlen) + 1;
15507           }
15508         else
15509           {
15510             printf (_("<corrupt>"));
15511             p = (unsigned char *) end;
15512           }
15513         putchar ('\n');
15514         return p;
15515       }
15516
15517     case Tag_ABI_conformance:
15518       {
15519         printf ("  Tag_ABI_conformance: \"");
15520         if (p < end - 1)
15521           {
15522             size_t maxlen = (end - p) - 1;
15523
15524             print_symbol ((int) maxlen, (const char *) p);
15525             p += strnlen ((char *) p, maxlen) + 1;
15526           }
15527         else
15528           {
15529             printf (_("<corrupt>"));
15530             p = (unsigned char *) end;
15531           }
15532         printf ("\"\n");
15533         return p;
15534       }
15535     }
15536
15537   return display_tag_value (tag, p, end);
15538 }
15539
15540 static void
15541 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15542 {
15543   unsigned long addr = 0;
15544   size_t bytes = end - p;
15545
15546   assert (end >= p);
15547   while (bytes)
15548     {
15549       int j;
15550       int k;
15551       int lbytes = (bytes > 16 ? 16 : bytes);
15552
15553       printf ("  0x%8.8lx ", addr);
15554
15555       for (j = 0; j < 16; j++)
15556         {
15557           if (j < lbytes)
15558             printf ("%2.2x", p[j]);
15559           else
15560             printf ("  ");
15561
15562           if ((j & 3) == 3)
15563             printf (" ");
15564         }
15565
15566       for (j = 0; j < lbytes; j++)
15567         {
15568           k = p[j];
15569           if (k >= ' ' && k < 0x7f)
15570             printf ("%c", k);
15571           else
15572             printf (".");
15573         }
15574
15575       putchar ('\n');
15576
15577       p  += lbytes;
15578       bytes -= lbytes;
15579       addr += lbytes;
15580     }
15581
15582   putchar ('\n');
15583 }
15584
15585 static unsigned char *
15586 display_msp430x_attribute (unsigned char * p,
15587                            const unsigned char * const end)
15588 {
15589   unsigned int len;
15590   unsigned int val;
15591   unsigned int tag;
15592
15593   tag = read_uleb128 (p, & len, end);
15594   p += len;
15595
15596   switch (tag)
15597     {
15598     case OFBA_MSPABI_Tag_ISA:
15599       val = read_uleb128 (p, &len, end);
15600       p += len;
15601       printf ("  Tag_ISA: ");
15602       switch (val)
15603         {
15604         case 0: printf (_("None\n")); break;
15605         case 1: printf (_("MSP430\n")); break;
15606         case 2: printf (_("MSP430X\n")); break;
15607         default: printf ("??? (%d)\n", val); break;
15608         }
15609       break;
15610
15611     case OFBA_MSPABI_Tag_Code_Model:
15612       val = read_uleb128 (p, &len, end);
15613       p += len;
15614       printf ("  Tag_Code_Model: ");
15615       switch (val)
15616         {
15617         case 0: printf (_("None\n")); break;
15618         case 1: printf (_("Small\n")); break;
15619         case 2: printf (_("Large\n")); break;
15620         default: printf ("??? (%d)\n", val); break;
15621         }
15622       break;
15623
15624     case OFBA_MSPABI_Tag_Data_Model:
15625       val = read_uleb128 (p, &len, end);
15626       p += len;
15627       printf ("  Tag_Data_Model: ");
15628       switch (val)
15629         {
15630         case 0: printf (_("None\n")); break;
15631         case 1: printf (_("Small\n")); break;
15632         case 2: printf (_("Large\n")); break;
15633         case 3: printf (_("Restricted Large\n")); break;
15634         default: printf ("??? (%d)\n", val); break;
15635         }
15636       break;
15637
15638     default:
15639       printf (_("  <unknown tag %d>: "), tag);
15640
15641       if (tag & 1)
15642         {
15643           putchar ('"');
15644           if (p < end - 1)
15645             {
15646               size_t maxlen = (end - p) - 1;
15647
15648               print_symbol ((int) maxlen, (const char *) p);
15649               p += strnlen ((char *) p, maxlen) + 1;
15650             }
15651           else
15652             {
15653               printf (_("<corrupt>"));
15654               p = (unsigned char *) end;
15655             }
15656           printf ("\"\n");
15657         }
15658       else
15659         {
15660           val = read_uleb128 (p, &len, end);
15661           p += len;
15662           printf ("%d (0x%x)\n", val, val);
15663         }
15664       break;
15665    }
15666
15667   assert (p <= end);
15668   return p;
15669 }
15670
15671 struct riscv_attr_tag_t {
15672   const char *name;
15673   int tag;
15674 };
15675
15676 static struct riscv_attr_tag_t riscv_attr_tag[] =
15677 {
15678 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15679   T(arch),
15680   T(priv_spec),
15681   T(priv_spec_minor),
15682   T(priv_spec_revision),
15683   T(unaligned_access),
15684   T(stack_align),
15685 #undef T
15686 };
15687
15688 static unsigned char *
15689 display_riscv_attribute (unsigned char *p,
15690                          const unsigned char * const end)
15691 {
15692   unsigned int len;
15693   int val;
15694   int tag;
15695   struct riscv_attr_tag_t *attr = NULL;
15696   unsigned i;
15697
15698   tag = read_uleb128 (p, &len, end);
15699   p += len;
15700
15701   /* Find the name of attribute. */
15702   for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
15703     {
15704       if (riscv_attr_tag[i].tag == tag)
15705         {
15706           attr = &riscv_attr_tag[i];
15707           break;
15708         }
15709     }
15710
15711   if (attr)
15712     printf ("  %s: ", attr->name);
15713   else
15714     return display_tag_value (tag, p, end);
15715
15716   switch (tag)
15717     {
15718     case Tag_RISCV_priv_spec:
15719     case Tag_RISCV_priv_spec_minor:
15720     case Tag_RISCV_priv_spec_revision:
15721       val = read_uleb128 (p, &len, end);
15722       p += len;
15723       printf (_("%d\n"), val);
15724       break;
15725     case Tag_RISCV_unaligned_access:
15726       val = read_uleb128 (p, &len, end);
15727       p += len;
15728       switch (val)
15729         {
15730         case 0:
15731           printf (_("No unaligned access\n"));
15732           break;
15733         case 1:
15734           printf (_("Unaligned access\n"));
15735           break;
15736         }
15737       break;
15738     case Tag_RISCV_stack_align:
15739       val = read_uleb128 (p, &len, end);
15740       p += len;
15741       printf (_("%d-bytes\n"), val);
15742       break;
15743     case Tag_RISCV_arch:
15744       p = display_tag_value (-1, p, end);
15745       break;
15746     default:
15747       return display_tag_value (tag, p, end);
15748     }
15749
15750   return p;
15751 }
15752
15753 static bfd_boolean
15754 process_attributes (Filedata * filedata,
15755                     const char * public_name,
15756                     unsigned int proc_type,
15757                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15758                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15759 {
15760   Elf_Internal_Shdr * sect;
15761   unsigned i;
15762   bfd_boolean res = TRUE;
15763
15764   /* Find the section header so that we get the size.  */
15765   for (i = 0, sect = filedata->section_headers;
15766        i < filedata->file_header.e_shnum;
15767        i++, sect++)
15768     {
15769       unsigned char * contents;
15770       unsigned char * p;
15771
15772       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15773         continue;
15774
15775       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15776                                              sect->sh_size, _("attributes"));
15777       if (contents == NULL)
15778         {
15779           res = FALSE;
15780           continue;
15781         }
15782
15783       p = contents;
15784       /* The first character is the version of the attributes.
15785          Currently only version 1, (aka 'A') is recognised here.  */
15786       if (*p != 'A')
15787         {
15788           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15789           res = FALSE;
15790         }
15791       else
15792         {
15793           bfd_vma section_len;
15794
15795           section_len = sect->sh_size - 1;
15796           p++;
15797
15798           while (section_len > 0)
15799             {
15800               bfd_vma attr_len;
15801               unsigned int namelen;
15802               bfd_boolean public_section;
15803               bfd_boolean gnu_section;
15804
15805               if (section_len <= 4)
15806                 {
15807                   error (_("Tag section ends prematurely\n"));
15808                   res = FALSE;
15809                   break;
15810                 }
15811               attr_len = byte_get (p, 4);
15812               p += 4;
15813
15814               if (attr_len > section_len)
15815                 {
15816                   error (_("Bad attribute length (%u > %u)\n"),
15817                           (unsigned) attr_len, (unsigned) section_len);
15818                   attr_len = section_len;
15819                   res = FALSE;
15820                 }
15821               /* PR 17531: file: 001-101425-0.004  */
15822               else if (attr_len < 5)
15823                 {
15824                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15825                   res = FALSE;
15826                   break;
15827                 }
15828
15829               section_len -= attr_len;
15830               attr_len -= 4;
15831
15832               namelen = strnlen ((char *) p, attr_len) + 1;
15833               if (namelen == 0 || namelen >= attr_len)
15834                 {
15835                   error (_("Corrupt attribute section name\n"));
15836                   res = FALSE;
15837                   break;
15838                 }
15839
15840               printf (_("Attribute Section: "));
15841               print_symbol (INT_MAX, (const char *) p);
15842               putchar ('\n');
15843
15844               if (public_name && streq ((char *) p, public_name))
15845                 public_section = TRUE;
15846               else
15847                 public_section = FALSE;
15848
15849               if (streq ((char *) p, "gnu"))
15850                 gnu_section = TRUE;
15851               else
15852                 gnu_section = FALSE;
15853
15854               p += namelen;
15855               attr_len -= namelen;
15856
15857               while (attr_len > 0 && p < contents + sect->sh_size)
15858                 {
15859                   int tag;
15860                   int val;
15861                   bfd_vma size;
15862                   unsigned char * end;
15863
15864                   /* PR binutils/17531: Safe handling of corrupt files.  */
15865                   if (attr_len < 6)
15866                     {
15867                       error (_("Unused bytes at end of section\n"));
15868                       res = FALSE;
15869                       section_len = 0;
15870                       break;
15871                     }
15872
15873                   tag = *(p++);
15874                   size = byte_get (p, 4);
15875                   if (size > attr_len)
15876                     {
15877                       error (_("Bad subsection length (%u > %u)\n"),
15878                               (unsigned) size, (unsigned) attr_len);
15879                       res = FALSE;
15880                       size = attr_len;
15881                     }
15882                   /* PR binutils/17531: Safe handling of corrupt files.  */
15883                   if (size < 6)
15884                     {
15885                       error (_("Bad subsection length (%u < 6)\n"),
15886                               (unsigned) size);
15887                       res = FALSE;
15888                       section_len = 0;
15889                       break;
15890                     }
15891
15892                   attr_len -= size;
15893                   end = p + size - 1;
15894                   assert (end <= contents + sect->sh_size);
15895                   p += 4;
15896
15897                   switch (tag)
15898                     {
15899                     case 1:
15900                       printf (_("File Attributes\n"));
15901                       break;
15902                     case 2:
15903                       printf (_("Section Attributes:"));
15904                       goto do_numlist;
15905                     case 3:
15906                       printf (_("Symbol Attributes:"));
15907                       /* Fall through.  */
15908                     do_numlist:
15909                       for (;;)
15910                         {
15911                           unsigned int j;
15912
15913                           val = read_uleb128 (p, &j, end);
15914                           p += j;
15915                           if (val == 0)
15916                             break;
15917                           printf (" %d", val);
15918                         }
15919                       printf ("\n");
15920                       break;
15921                     default:
15922                       printf (_("Unknown tag: %d\n"), tag);
15923                       public_section = FALSE;
15924                       break;
15925                     }
15926
15927                   if (public_section && display_pub_attribute != NULL)
15928                     {
15929                       while (p < end)
15930                         p = display_pub_attribute (p, end);
15931                       assert (p == end);
15932                     }
15933                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15934                     {
15935                       while (p < end)
15936                         p = display_gnu_attribute (p,
15937                                                    display_proc_gnu_attribute,
15938                                                    end);
15939                       assert (p == end);
15940                     }
15941                   else if (p < end)
15942                     {
15943                       printf (_("  Unknown attribute:\n"));
15944                       display_raw_attribute (p, end);
15945                       p = end;
15946                     }
15947                   else
15948                     attr_len = 0;
15949                 }
15950             }
15951         }
15952
15953       free (contents);
15954     }
15955
15956   return res;
15957 }
15958
15959 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15960    Print the Address, Access and Initial fields of an entry at VMA ADDR
15961    and return the VMA of the next entry, or -1 if there was a problem.
15962    Does not read from DATA_END or beyond.  */
15963
15964 static bfd_vma
15965 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15966                       unsigned char * data_end)
15967 {
15968   printf ("  ");
15969   print_vma (addr, LONG_HEX);
15970   printf (" ");
15971   if (addr < pltgot + 0xfff0)
15972     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15973   else
15974     printf ("%10s", "");
15975   printf (" ");
15976   if (data == NULL)
15977     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15978   else
15979     {
15980       bfd_vma entry;
15981       unsigned char * from = data + addr - pltgot;
15982
15983       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15984         {
15985           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15986           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15987           return (bfd_vma) -1;
15988         }
15989       else
15990         {
15991           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15992           print_vma (entry, LONG_HEX);
15993         }
15994     }
15995   return addr + (is_32bit_elf ? 4 : 8);
15996 }
15997
15998 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15999    PLTGOT.  Print the Address and Initial fields of an entry at VMA
16000    ADDR and return the VMA of the next entry.  */
16001
16002 static bfd_vma
16003 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
16004 {
16005   printf ("  ");
16006   print_vma (addr, LONG_HEX);
16007   printf (" ");
16008   if (data == NULL)
16009     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16010   else
16011     {
16012       bfd_vma entry;
16013
16014       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16015       print_vma (entry, LONG_HEX);
16016     }
16017   return addr + (is_32bit_elf ? 4 : 8);
16018 }
16019
16020 static void
16021 print_mips_ases (unsigned int mask)
16022 {
16023   if (mask & AFL_ASE_DSP)
16024     fputs ("\n\tDSP ASE", stdout);
16025   if (mask & AFL_ASE_DSPR2)
16026     fputs ("\n\tDSP R2 ASE", stdout);
16027   if (mask & AFL_ASE_DSPR3)
16028     fputs ("\n\tDSP R3 ASE", stdout);
16029   if (mask & AFL_ASE_EVA)
16030     fputs ("\n\tEnhanced VA Scheme", stdout);
16031   if (mask & AFL_ASE_MCU)
16032     fputs ("\n\tMCU (MicroController) ASE", stdout);
16033   if (mask & AFL_ASE_MDMX)
16034     fputs ("\n\tMDMX ASE", stdout);
16035   if (mask & AFL_ASE_MIPS3D)
16036     fputs ("\n\tMIPS-3D ASE", stdout);
16037   if (mask & AFL_ASE_MT)
16038     fputs ("\n\tMT ASE", stdout);
16039   if (mask & AFL_ASE_SMARTMIPS)
16040     fputs ("\n\tSmartMIPS ASE", stdout);
16041   if (mask & AFL_ASE_VIRT)
16042     fputs ("\n\tVZ ASE", stdout);
16043   if (mask & AFL_ASE_MSA)
16044     fputs ("\n\tMSA ASE", stdout);
16045   if (mask & AFL_ASE_MIPS16)
16046     fputs ("\n\tMIPS16 ASE", stdout);
16047   if (mask & AFL_ASE_MICROMIPS)
16048     fputs ("\n\tMICROMIPS ASE", stdout);
16049   if (mask & AFL_ASE_XPA)
16050     fputs ("\n\tXPA ASE", stdout);
16051   if (mask & AFL_ASE_MIPS16E2)
16052     fputs ("\n\tMIPS16e2 ASE", stdout);
16053   if (mask & AFL_ASE_CRC)
16054     fputs ("\n\tCRC ASE", stdout);
16055   if (mask & AFL_ASE_GINV)
16056     fputs ("\n\tGINV ASE", stdout);
16057   if (mask & AFL_ASE_LOONGSON_MMI)
16058     fputs ("\n\tLoongson MMI ASE", stdout);
16059   if (mask & AFL_ASE_LOONGSON_CAM)
16060     fputs ("\n\tLoongson CAM ASE", stdout);
16061   if (mask & AFL_ASE_LOONGSON_EXT)
16062     fputs ("\n\tLoongson EXT ASE", stdout);
16063   if (mask & AFL_ASE_LOONGSON_EXT2)
16064     fputs ("\n\tLoongson EXT2 ASE", stdout);
16065   if (mask == 0)
16066     fprintf (stdout, "\n\t%s", _("None"));
16067   else if ((mask & ~AFL_ASE_MASK) != 0)
16068     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
16069 }
16070
16071 static void
16072 print_mips_isa_ext (unsigned int isa_ext)
16073 {
16074   switch (isa_ext)
16075     {
16076     case 0:
16077       fputs (_("None"), stdout);
16078       break;
16079     case AFL_EXT_XLR:
16080       fputs ("RMI XLR", stdout);
16081       break;
16082     case AFL_EXT_OCTEON3:
16083       fputs ("Cavium Networks Octeon3", stdout);
16084       break;
16085     case AFL_EXT_OCTEON2:
16086       fputs ("Cavium Networks Octeon2", stdout);
16087       break;
16088     case AFL_EXT_OCTEONP:
16089       fputs ("Cavium Networks OcteonP", stdout);
16090       break;
16091     case AFL_EXT_OCTEON:
16092       fputs ("Cavium Networks Octeon", stdout);
16093       break;
16094     case AFL_EXT_5900:
16095       fputs ("Toshiba R5900", stdout);
16096       break;
16097     case AFL_EXT_4650:
16098       fputs ("MIPS R4650", stdout);
16099       break;
16100     case AFL_EXT_4010:
16101       fputs ("LSI R4010", stdout);
16102       break;
16103     case AFL_EXT_4100:
16104       fputs ("NEC VR4100", stdout);
16105       break;
16106     case AFL_EXT_3900:
16107       fputs ("Toshiba R3900", stdout);
16108       break;
16109     case AFL_EXT_10000:
16110       fputs ("MIPS R10000", stdout);
16111       break;
16112     case AFL_EXT_SB1:
16113       fputs ("Broadcom SB-1", stdout);
16114       break;
16115     case AFL_EXT_4111:
16116       fputs ("NEC VR4111/VR4181", stdout);
16117       break;
16118     case AFL_EXT_4120:
16119       fputs ("NEC VR4120", stdout);
16120       break;
16121     case AFL_EXT_5400:
16122       fputs ("NEC VR5400", stdout);
16123       break;
16124     case AFL_EXT_5500:
16125       fputs ("NEC VR5500", stdout);
16126       break;
16127     case AFL_EXT_LOONGSON_2E:
16128       fputs ("ST Microelectronics Loongson 2E", stdout);
16129       break;
16130     case AFL_EXT_LOONGSON_2F:
16131       fputs ("ST Microelectronics Loongson 2F", stdout);
16132       break;
16133     case AFL_EXT_INTERAPTIV_MR2:
16134       fputs ("Imagination interAptiv MR2", stdout);
16135       break;
16136     default:
16137       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
16138     }
16139 }
16140
16141 static signed int
16142 get_mips_reg_size (int reg_size)
16143 {
16144   return (reg_size == AFL_REG_NONE) ? 0
16145          : (reg_size == AFL_REG_32) ? 32
16146          : (reg_size == AFL_REG_64) ? 64
16147          : (reg_size == AFL_REG_128) ? 128
16148          : -1;
16149 }
16150
16151 static bfd_boolean
16152 process_mips_specific (Filedata * filedata)
16153 {
16154   Elf_Internal_Dyn * entry;
16155   Elf_Internal_Shdr *sect = NULL;
16156   size_t liblist_offset = 0;
16157   size_t liblistno = 0;
16158   size_t conflictsno = 0;
16159   size_t options_offset = 0;
16160   size_t conflicts_offset = 0;
16161   size_t pltrelsz = 0;
16162   size_t pltrel = 0;
16163   bfd_vma pltgot = 0;
16164   bfd_vma mips_pltgot = 0;
16165   bfd_vma jmprel = 0;
16166   bfd_vma local_gotno = 0;
16167   bfd_vma gotsym = 0;
16168   bfd_vma symtabno = 0;
16169   bfd_boolean res = TRUE;
16170
16171   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
16172                             display_mips_gnu_attribute))
16173     res = FALSE;
16174
16175   sect = find_section (filedata, ".MIPS.abiflags");
16176
16177   if (sect != NULL)
16178     {
16179       Elf_External_ABIFlags_v0 *abiflags_ext;
16180       Elf_Internal_ABIFlags_v0 abiflags_in;
16181
16182       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
16183         {
16184           error (_("Corrupt MIPS ABI Flags section.\n"));
16185           res = FALSE;
16186         }
16187       else
16188         {
16189           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
16190                                    sect->sh_size, _("MIPS ABI Flags section"));
16191           if (abiflags_ext)
16192             {
16193               abiflags_in.version = BYTE_GET (abiflags_ext->version);
16194               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
16195               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
16196               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
16197               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
16198               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
16199               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
16200               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
16201               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
16202               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
16203               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
16204
16205               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
16206               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
16207               if (abiflags_in.isa_rev > 1)
16208                 printf ("r%d", abiflags_in.isa_rev);
16209               printf ("\nGPR size: %d",
16210                       get_mips_reg_size (abiflags_in.gpr_size));
16211               printf ("\nCPR1 size: %d",
16212                       get_mips_reg_size (abiflags_in.cpr1_size));
16213               printf ("\nCPR2 size: %d",
16214                       get_mips_reg_size (abiflags_in.cpr2_size));
16215               fputs ("\nFP ABI: ", stdout);
16216               print_mips_fp_abi_value (abiflags_in.fp_abi);
16217               fputs ("ISA Extension: ", stdout);
16218               print_mips_isa_ext (abiflags_in.isa_ext);
16219               fputs ("\nASEs:", stdout);
16220               print_mips_ases (abiflags_in.ases);
16221               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
16222               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
16223               fputc ('\n', stdout);
16224               free (abiflags_ext);
16225             }
16226         }
16227     }
16228
16229   /* We have a lot of special sections.  Thanks SGI!  */
16230   if (dynamic_section == NULL)
16231     {
16232       /* No dynamic information available.  See if there is static GOT.  */
16233       sect = find_section (filedata, ".got");
16234       if (sect != NULL)
16235         {
16236           unsigned char *data_end;
16237           unsigned char *data;
16238           bfd_vma ent, end;
16239           int addr_size;
16240
16241           pltgot = sect->sh_addr;
16242
16243           ent = pltgot;
16244           addr_size = (is_32bit_elf ? 4 : 8);
16245           end = pltgot + sect->sh_size;
16246
16247           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
16248                                              end - pltgot, 1,
16249                                              _("Global Offset Table data"));
16250           /* PR 12855: Null data is handled gracefully throughout.  */
16251           data_end = data + (end - pltgot);
16252
16253           printf (_("\nStatic GOT:\n"));
16254           printf (_(" Canonical gp value: "));
16255           print_vma (ent + 0x7ff0, LONG_HEX);
16256           printf ("\n\n");
16257
16258           /* In a dynamic binary GOT[0] is reserved for the dynamic
16259              loader to store the lazy resolver pointer, however in
16260              a static binary it may well have been omitted and GOT
16261              reduced to a table of addresses.
16262              PR 21344: Check for the entry being fully available
16263              before fetching it.  */
16264           if (data
16265               && data + ent - pltgot + addr_size <= data_end
16266               && byte_get (data + ent - pltgot, addr_size) == 0)
16267             {
16268               printf (_(" Reserved entries:\n"));
16269               printf (_("  %*s %10s %*s\n"),
16270                       addr_size * 2, _("Address"), _("Access"),
16271                       addr_size * 2, _("Value"));
16272               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16273               printf ("\n");
16274               if (ent == (bfd_vma) -1)
16275                 goto sgot_print_fail;
16276
16277               /* Check for the MSB of GOT[1] being set, identifying a
16278                  GNU object.  This entry will be used by some runtime
16279                  loaders, to store the module pointer.  Otherwise this
16280                  is an ordinary local entry.
16281                  PR 21344: Check for the entry being fully available
16282                  before fetching it.  */
16283               if (data
16284                   && data + ent - pltgot + addr_size <= data_end
16285                   && (byte_get (data + ent - pltgot, addr_size)
16286                       >> (addr_size * 8 - 1)) != 0)
16287                 {
16288                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
16289                   printf ("\n");
16290                   if (ent == (bfd_vma) -1)
16291                     goto sgot_print_fail;
16292                 }
16293               printf ("\n");
16294             }
16295
16296           if (data != NULL && ent < end)
16297             {
16298               printf (_(" Local entries:\n"));
16299               printf ("  %*s %10s %*s\n",
16300                       addr_size * 2, _("Address"), _("Access"),
16301                       addr_size * 2, _("Value"));
16302               while (ent < end)
16303                 {
16304                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
16305                   printf ("\n");
16306                   if (ent == (bfd_vma) -1)
16307                     goto sgot_print_fail;
16308                 }
16309               printf ("\n");
16310             }
16311
16312         sgot_print_fail:
16313           if (data)
16314             free (data);
16315         }
16316       return res;
16317     }
16318
16319   for (entry = dynamic_section;
16320        /* PR 17531 file: 012-50589-0.004.  */
16321        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
16322        ++entry)
16323     switch (entry->d_tag)
16324       {
16325       case DT_MIPS_LIBLIST:
16326         liblist_offset
16327           = offset_from_vma (filedata, entry->d_un.d_val,
16328                              liblistno * sizeof (Elf32_External_Lib));
16329         break;
16330       case DT_MIPS_LIBLISTNO:
16331         liblistno = entry->d_un.d_val;
16332         break;
16333       case DT_MIPS_OPTIONS:
16334         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
16335         break;
16336       case DT_MIPS_CONFLICT:
16337         conflicts_offset
16338           = offset_from_vma (filedata, entry->d_un.d_val,
16339                              conflictsno * sizeof (Elf32_External_Conflict));
16340         break;
16341       case DT_MIPS_CONFLICTNO:
16342         conflictsno = entry->d_un.d_val;
16343         break;
16344       case DT_PLTGOT:
16345         pltgot = entry->d_un.d_ptr;
16346         break;
16347       case DT_MIPS_LOCAL_GOTNO:
16348         local_gotno = entry->d_un.d_val;
16349         break;
16350       case DT_MIPS_GOTSYM:
16351         gotsym = entry->d_un.d_val;
16352         break;
16353       case DT_MIPS_SYMTABNO:
16354         symtabno = entry->d_un.d_val;
16355         break;
16356       case DT_MIPS_PLTGOT:
16357         mips_pltgot = entry->d_un.d_ptr;
16358         break;
16359       case DT_PLTREL:
16360         pltrel = entry->d_un.d_val;
16361         break;
16362       case DT_PLTRELSZ:
16363         pltrelsz = entry->d_un.d_val;
16364         break;
16365       case DT_JMPREL:
16366         jmprel = entry->d_un.d_ptr;
16367         break;
16368       default:
16369         break;
16370       }
16371
16372   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
16373     {
16374       Elf32_External_Lib * elib;
16375       size_t cnt;
16376
16377       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
16378                                               liblistno,
16379                                               sizeof (Elf32_External_Lib),
16380                                               _("liblist section data"));
16381       if (elib)
16382         {
16383           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16384                             "\nSection '.liblist' contains %lu entries:\n",
16385                             (unsigned long) liblistno),
16386                   (unsigned long) liblistno);
16387           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
16388                  stdout);
16389
16390           for (cnt = 0; cnt < liblistno; ++cnt)
16391             {
16392               Elf32_Lib liblist;
16393               time_t atime;
16394               char timebuf[128];
16395               struct tm * tmp;
16396
16397               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16398               atime = BYTE_GET (elib[cnt].l_time_stamp);
16399               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16400               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16401               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16402
16403               tmp = gmtime (&atime);
16404               snprintf (timebuf, sizeof (timebuf),
16405                         "%04u-%02u-%02uT%02u:%02u:%02u",
16406                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16407                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16408
16409               printf ("%3lu: ", (unsigned long) cnt);
16410               if (VALID_DYNAMIC_NAME (liblist.l_name))
16411                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16412               else
16413                 printf (_("<corrupt: %9ld>"), liblist.l_name);
16414               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16415                       liblist.l_version);
16416
16417               if (liblist.l_flags == 0)
16418                 puts (_(" NONE"));
16419               else
16420                 {
16421                   static const struct
16422                   {
16423                     const char * name;
16424                     int bit;
16425                   }
16426                   l_flags_vals[] =
16427                   {
16428                     { " EXACT_MATCH", LL_EXACT_MATCH },
16429                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16430                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16431                     { " EXPORTS", LL_EXPORTS },
16432                     { " DELAY_LOAD", LL_DELAY_LOAD },
16433                     { " DELTA", LL_DELTA }
16434                   };
16435                   int flags = liblist.l_flags;
16436                   size_t fcnt;
16437
16438                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16439                     if ((flags & l_flags_vals[fcnt].bit) != 0)
16440                       {
16441                         fputs (l_flags_vals[fcnt].name, stdout);
16442                         flags ^= l_flags_vals[fcnt].bit;
16443                       }
16444                   if (flags != 0)
16445                     printf (" %#x", (unsigned int) flags);
16446
16447                   puts ("");
16448                 }
16449             }
16450
16451           free (elib);
16452         }
16453       else
16454         res = FALSE;
16455     }
16456
16457   if (options_offset != 0)
16458     {
16459       Elf_External_Options * eopt;
16460       Elf_Internal_Options * iopt;
16461       Elf_Internal_Options * option;
16462       size_t offset;
16463       int cnt;
16464       sect = filedata->section_headers;
16465
16466       /* Find the section header so that we get the size.  */
16467       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16468       /* PR 17533 file: 012-277276-0.004.  */
16469       if (sect == NULL)
16470         {
16471           error (_("No MIPS_OPTIONS header found\n"));
16472           return FALSE;
16473         }
16474       /* PR 24243  */
16475       if (sect->sh_size < sizeof (* eopt))
16476         {
16477           error (_("The MIPS options section is too small.\n"));
16478           return FALSE;
16479         }
16480
16481       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16482                                                 sect->sh_size, _("options"));
16483       if (eopt)
16484         {
16485           iopt = (Elf_Internal_Options *)
16486               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16487           if (iopt == NULL)
16488             {
16489               error (_("Out of memory allocating space for MIPS options\n"));
16490               return FALSE;
16491             }
16492
16493           offset = cnt = 0;
16494           option = iopt;
16495
16496           while (offset <= sect->sh_size - sizeof (* eopt))
16497             {
16498               Elf_External_Options * eoption;
16499
16500               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16501
16502               option->kind = BYTE_GET (eoption->kind);
16503               option->size = BYTE_GET (eoption->size);
16504               option->section = BYTE_GET (eoption->section);
16505               option->info = BYTE_GET (eoption->info);
16506
16507               /* PR 17531: file: ffa0fa3b.  */
16508               if (option->size < sizeof (* eopt)
16509                   || offset + option->size > sect->sh_size)
16510                 {
16511                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
16512                   return FALSE;
16513                 }
16514               offset += option->size;
16515
16516               ++option;
16517               ++cnt;
16518             }
16519
16520           printf (ngettext ("\nSection '%s' contains %d entry:\n",
16521                             "\nSection '%s' contains %d entries:\n",
16522                             cnt),
16523                   printable_section_name (filedata, sect), cnt);
16524
16525           option = iopt;
16526           offset = 0;
16527
16528           while (cnt-- > 0)
16529             {
16530               size_t len;
16531
16532               switch (option->kind)
16533                 {
16534                 case ODK_NULL:
16535                   /* This shouldn't happen.  */
16536                   printf (" NULL       %d %lx", option->section, option->info);
16537                   break;
16538                 case ODK_REGINFO:
16539                   printf (" REGINFO    ");
16540                   if (filedata->file_header.e_machine == EM_MIPS)
16541                     {
16542                       /* 32bit form.  */
16543                       Elf32_External_RegInfo * ereg;
16544                       Elf32_RegInfo reginfo;
16545
16546                       ereg = (Elf32_External_RegInfo *) (option + 1);
16547                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16548                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16549                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16550                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16551                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16552                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16553
16554                       printf ("GPR %08lx  GP 0x%lx\n",
16555                               reginfo.ri_gprmask,
16556                               (unsigned long) reginfo.ri_gp_value);
16557                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16558                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16559                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16560                     }
16561                   else
16562                     {
16563                       /* 64 bit form.  */
16564                       Elf64_External_RegInfo * ereg;
16565                       Elf64_Internal_RegInfo reginfo;
16566
16567                       ereg = (Elf64_External_RegInfo *) (option + 1);
16568                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
16569                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16570                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16571                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16572                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16573                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16574
16575                       printf ("GPR %08lx  GP 0x",
16576                               reginfo.ri_gprmask);
16577                       printf_vma (reginfo.ri_gp_value);
16578                       printf ("\n");
16579
16580                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16581                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16582                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16583                     }
16584                   ++option;
16585                   continue;
16586                 case ODK_EXCEPTIONS:
16587                   fputs (" EXCEPTIONS fpe_min(", stdout);
16588                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16589                   fputs (") fpe_max(", stdout);
16590                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16591                   fputs (")", stdout);
16592
16593                   if (option->info & OEX_PAGE0)
16594                     fputs (" PAGE0", stdout);
16595                   if (option->info & OEX_SMM)
16596                     fputs (" SMM", stdout);
16597                   if (option->info & OEX_FPDBUG)
16598                     fputs (" FPDBUG", stdout);
16599                   if (option->info & OEX_DISMISS)
16600                     fputs (" DISMISS", stdout);
16601                   break;
16602                 case ODK_PAD:
16603                   fputs (" PAD       ", stdout);
16604                   if (option->info & OPAD_PREFIX)
16605                     fputs (" PREFIX", stdout);
16606                   if (option->info & OPAD_POSTFIX)
16607                     fputs (" POSTFIX", stdout);
16608                   if (option->info & OPAD_SYMBOL)
16609                     fputs (" SYMBOL", stdout);
16610                   break;
16611                 case ODK_HWPATCH:
16612                   fputs (" HWPATCH   ", stdout);
16613                   if (option->info & OHW_R4KEOP)
16614                     fputs (" R4KEOP", stdout);
16615                   if (option->info & OHW_R8KPFETCH)
16616                     fputs (" R8KPFETCH", stdout);
16617                   if (option->info & OHW_R5KEOP)
16618                     fputs (" R5KEOP", stdout);
16619                   if (option->info & OHW_R5KCVTL)
16620                     fputs (" R5KCVTL", stdout);
16621                   break;
16622                 case ODK_FILL:
16623                   fputs (" FILL       ", stdout);
16624                   /* XXX Print content of info word?  */
16625                   break;
16626                 case ODK_TAGS:
16627                   fputs (" TAGS       ", stdout);
16628                   /* XXX Print content of info word?  */
16629                   break;
16630                 case ODK_HWAND:
16631                   fputs (" HWAND     ", stdout);
16632                   if (option->info & OHWA0_R4KEOP_CHECKED)
16633                     fputs (" R4KEOP_CHECKED", stdout);
16634                   if (option->info & OHWA0_R4KEOP_CLEAN)
16635                     fputs (" R4KEOP_CLEAN", stdout);
16636                   break;
16637                 case ODK_HWOR:
16638                   fputs (" HWOR      ", stdout);
16639                   if (option->info & OHWA0_R4KEOP_CHECKED)
16640                     fputs (" R4KEOP_CHECKED", stdout);
16641                   if (option->info & OHWA0_R4KEOP_CLEAN)
16642                     fputs (" R4KEOP_CLEAN", stdout);
16643                   break;
16644                 case ODK_GP_GROUP:
16645                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16646                           option->info & OGP_GROUP,
16647                           (option->info & OGP_SELF) >> 16);
16648                   break;
16649                 case ODK_IDENT:
16650                   printf (" IDENT     %#06lx  self-contained %#06lx",
16651                           option->info & OGP_GROUP,
16652                           (option->info & OGP_SELF) >> 16);
16653                   break;
16654                 default:
16655                   /* This shouldn't happen.  */
16656                   printf (" %3d ???     %d %lx",
16657                           option->kind, option->section, option->info);
16658                   break;
16659                 }
16660
16661               len = sizeof (* eopt);
16662               while (len < option->size)
16663                 {
16664                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16665
16666                   if (ISPRINT (datum))
16667                     printf ("%c", datum);
16668                   else
16669                     printf ("\\%03o", datum);
16670                   len ++;
16671                 }
16672               fputs ("\n", stdout);
16673
16674               offset += option->size;
16675               ++option;
16676             }
16677
16678           free (eopt);
16679         }
16680       else
16681         res = FALSE;
16682     }
16683
16684   if (conflicts_offset != 0 && conflictsno != 0)
16685     {
16686       Elf32_Conflict * iconf;
16687       size_t cnt;
16688
16689       if (dynamic_symbols == NULL)
16690         {
16691           error (_("conflict list found without a dynamic symbol table\n"));
16692           return FALSE;
16693         }
16694
16695       /* PR 21345 - print a slightly more helpful error message
16696          if we are sure that the cmalloc will fail.  */
16697       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16698         {
16699           error (_("Overlarge number of conflicts detected: %lx\n"),
16700                  (long) conflictsno);
16701           return FALSE;
16702         }
16703
16704       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16705       if (iconf == NULL)
16706         {
16707           error (_("Out of memory allocating space for dynamic conflicts\n"));
16708           return FALSE;
16709         }
16710
16711       if (is_32bit_elf)
16712         {
16713           Elf32_External_Conflict * econf32;
16714
16715           econf32 = (Elf32_External_Conflict *)
16716               get_data (NULL, filedata, conflicts_offset, conflictsno,
16717                         sizeof (* econf32), _("conflict"));
16718           if (!econf32)
16719             return FALSE;
16720
16721           for (cnt = 0; cnt < conflictsno; ++cnt)
16722             iconf[cnt] = BYTE_GET (econf32[cnt]);
16723
16724           free (econf32);
16725         }
16726       else
16727         {
16728           Elf64_External_Conflict * econf64;
16729
16730           econf64 = (Elf64_External_Conflict *)
16731               get_data (NULL, filedata, conflicts_offset, conflictsno,
16732                         sizeof (* econf64), _("conflict"));
16733           if (!econf64)
16734             return FALSE;
16735
16736           for (cnt = 0; cnt < conflictsno; ++cnt)
16737             iconf[cnt] = BYTE_GET (econf64[cnt]);
16738
16739           free (econf64);
16740         }
16741
16742       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16743                         "\nSection '.conflict' contains %lu entries:\n",
16744                         (unsigned long) conflictsno),
16745               (unsigned long) conflictsno);
16746       puts (_("  Num:    Index       Value  Name"));
16747
16748       for (cnt = 0; cnt < conflictsno; ++cnt)
16749         {
16750           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16751
16752           if (iconf[cnt] >= num_dynamic_syms)
16753             printf (_("<corrupt symbol index>"));
16754           else
16755             {
16756               Elf_Internal_Sym * psym;
16757
16758               psym = & dynamic_symbols[iconf[cnt]];
16759               print_vma (psym->st_value, FULL_HEX);
16760               putchar (' ');
16761               if (VALID_DYNAMIC_NAME (psym->st_name))
16762                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16763               else
16764                 printf (_("<corrupt: %14ld>"), psym->st_name);
16765             }
16766           putchar ('\n');
16767         }
16768
16769       free (iconf);
16770     }
16771
16772   if (pltgot != 0 && local_gotno != 0)
16773     {
16774       bfd_vma ent, local_end, global_end;
16775       size_t i, offset;
16776       unsigned char * data;
16777       unsigned char * data_end;
16778       int addr_size;
16779
16780       ent = pltgot;
16781       addr_size = (is_32bit_elf ? 4 : 8);
16782       local_end = pltgot + local_gotno * addr_size;
16783
16784       /* PR binutils/17533 file: 012-111227-0.004  */
16785       if (symtabno < gotsym)
16786         {
16787           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16788                  (unsigned long) gotsym, (unsigned long) symtabno);
16789           return FALSE;
16790         }
16791
16792       global_end = local_end + (symtabno - gotsym) * addr_size;
16793       /* PR 17531: file: 54c91a34.  */
16794       if (global_end < local_end)
16795         {
16796           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16797           return FALSE;
16798         }
16799
16800       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16801       data = (unsigned char *) get_data (NULL, filedata, offset,
16802                                          global_end - pltgot, 1,
16803                                          _("Global Offset Table data"));
16804       /* PR 12855: Null data is handled gracefully throughout.  */
16805       data_end = data + (global_end - pltgot);
16806
16807       printf (_("\nPrimary GOT:\n"));
16808       printf (_(" Canonical gp value: "));
16809       print_vma (pltgot + 0x7ff0, LONG_HEX);
16810       printf ("\n\n");
16811
16812       printf (_(" Reserved entries:\n"));
16813       printf (_("  %*s %10s %*s Purpose\n"),
16814               addr_size * 2, _("Address"), _("Access"),
16815               addr_size * 2, _("Initial"));
16816       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16817       printf (_(" Lazy resolver\n"));
16818       if (ent == (bfd_vma) -1)
16819         goto got_print_fail;
16820
16821       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16822          This entry will be used by some runtime loaders, to store the
16823          module pointer.  Otherwise this is an ordinary local entry.
16824          PR 21344: Check for the entry being fully available before
16825          fetching it.  */
16826       if (data
16827           && data + ent - pltgot + addr_size <= data_end
16828           && (byte_get (data + ent - pltgot, addr_size)
16829               >> (addr_size * 8 - 1)) != 0)
16830         {
16831           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16832           printf (_(" Module pointer (GNU extension)\n"));
16833           if (ent == (bfd_vma) -1)
16834             goto got_print_fail;
16835         }
16836       printf ("\n");
16837
16838       if (data != NULL && ent < local_end)
16839         {
16840           printf (_(" Local entries:\n"));
16841           printf ("  %*s %10s %*s\n",
16842                   addr_size * 2, _("Address"), _("Access"),
16843                   addr_size * 2, _("Initial"));
16844           while (ent < local_end)
16845             {
16846               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16847               printf ("\n");
16848               if (ent == (bfd_vma) -1)
16849                 goto got_print_fail;
16850             }
16851           printf ("\n");
16852         }
16853
16854       if (data != NULL && gotsym < symtabno)
16855         {
16856           int sym_width;
16857
16858           printf (_(" Global entries:\n"));
16859           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16860                   addr_size * 2, _("Address"),
16861                   _("Access"),
16862                   addr_size * 2, _("Initial"),
16863                   addr_size * 2, _("Sym.Val."),
16864                   _("Type"),
16865                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16866                   _("Ndx"), _("Name"));
16867
16868           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16869
16870           for (i = gotsym; i < symtabno; i++)
16871             {
16872               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16873               printf (" ");
16874
16875               if (dynamic_symbols == NULL)
16876                 printf (_("<no dynamic symbols>"));
16877               else if (i < num_dynamic_syms)
16878                 {
16879                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16880
16881                   print_vma (psym->st_value, LONG_HEX);
16882                   printf (" %-7s %3s ",
16883                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16884                           get_symbol_index_type (filedata, psym->st_shndx));
16885
16886                   if (VALID_DYNAMIC_NAME (psym->st_name))
16887                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16888                   else
16889                     printf (_("<corrupt: %14ld>"), psym->st_name);
16890                 }
16891               else
16892                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16893                         (unsigned long) i);
16894
16895               printf ("\n");
16896               if (ent == (bfd_vma) -1)
16897                 break;
16898             }
16899           printf ("\n");
16900         }
16901
16902     got_print_fail:
16903       if (data)
16904         free (data);
16905     }
16906
16907   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16908     {
16909       bfd_vma ent, end;
16910       size_t offset, rel_offset;
16911       unsigned long count, i;
16912       unsigned char * data;
16913       int addr_size, sym_width;
16914       Elf_Internal_Rela * rels;
16915
16916       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16917       if (pltrel == DT_RELA)
16918         {
16919           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16920             return FALSE;
16921         }
16922       else
16923         {
16924           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16925             return FALSE;
16926         }
16927
16928       ent = mips_pltgot;
16929       addr_size = (is_32bit_elf ? 4 : 8);
16930       end = mips_pltgot + (2 + count) * addr_size;
16931
16932       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16933       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16934                                          1, _("Procedure Linkage Table data"));
16935       if (data == NULL)
16936         return FALSE;
16937
16938       printf ("\nPLT GOT:\n\n");
16939       printf (_(" Reserved entries:\n"));
16940       printf (_("  %*s %*s Purpose\n"),
16941               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16942       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16943       printf (_(" PLT lazy resolver\n"));
16944       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16945       printf (_(" Module pointer\n"));
16946       printf ("\n");
16947
16948       printf (_(" Entries:\n"));
16949       printf ("  %*s %*s %*s %-7s %3s %s\n",
16950               addr_size * 2, _("Address"),
16951               addr_size * 2, _("Initial"),
16952               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16953       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16954       for (i = 0; i < count; i++)
16955         {
16956           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16957
16958           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16959           printf (" ");
16960
16961           if (idx >= num_dynamic_syms)
16962             printf (_("<corrupt symbol index: %lu>"), idx);
16963           else
16964             {
16965               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16966
16967               print_vma (psym->st_value, LONG_HEX);
16968               printf (" %-7s %3s ",
16969                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16970                       get_symbol_index_type (filedata, psym->st_shndx));
16971               if (VALID_DYNAMIC_NAME (psym->st_name))
16972                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16973               else
16974                 printf (_("<corrupt: %14ld>"), psym->st_name);
16975             }
16976           printf ("\n");
16977         }
16978       printf ("\n");
16979
16980       if (data)
16981         free (data);
16982       free (rels);
16983     }
16984
16985   return res;
16986 }
16987
16988 static bfd_boolean
16989 process_nds32_specific (Filedata * filedata)
16990 {
16991   Elf_Internal_Shdr *sect = NULL;
16992
16993   sect = find_section (filedata, ".nds32_e_flags");
16994   if (sect != NULL)
16995     {
16996       unsigned int *flag;
16997
16998       printf ("\nNDS32 elf flags section:\n");
16999       flag = get_data (NULL, filedata, sect->sh_offset, 1,
17000                        sect->sh_size, _("NDS32 elf flags section"));
17001
17002       if (! flag)
17003         return FALSE;
17004
17005       switch ((*flag) & 0x3)
17006         {
17007         case 0:
17008           printf ("(VEC_SIZE):\tNo entry.\n");
17009           break;
17010         case 1:
17011           printf ("(VEC_SIZE):\t4 bytes\n");
17012           break;
17013         case 2:
17014           printf ("(VEC_SIZE):\t16 bytes\n");
17015           break;
17016         case 3:
17017           printf ("(VEC_SIZE):\treserved\n");
17018           break;
17019         }
17020     }
17021
17022   return TRUE;
17023 }
17024
17025 static bfd_boolean
17026 process_gnu_liblist (Filedata * filedata)
17027 {
17028   Elf_Internal_Shdr * section;
17029   Elf_Internal_Shdr * string_sec;
17030   Elf32_External_Lib * elib;
17031   char * strtab;
17032   size_t strtab_size;
17033   size_t cnt;
17034   unsigned long num_liblist;
17035   unsigned i;
17036   bfd_boolean res = TRUE;
17037
17038   if (! do_arch)
17039     return TRUE;
17040
17041   for (i = 0, section = filedata->section_headers;
17042        i < filedata->file_header.e_shnum;
17043        i++, section++)
17044     {
17045       switch (section->sh_type)
17046         {
17047         case SHT_GNU_LIBLIST:
17048           if (section->sh_link >= filedata->file_header.e_shnum)
17049             break;
17050
17051           elib = (Elf32_External_Lib *)
17052               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
17053                         _("liblist section data"));
17054
17055           if (elib == NULL)
17056             {
17057               res = FALSE;
17058               break;
17059             }
17060
17061           string_sec = filedata->section_headers + section->sh_link;
17062           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
17063                                       string_sec->sh_size,
17064                                       _("liblist string table"));
17065           if (strtab == NULL
17066               || section->sh_entsize != sizeof (Elf32_External_Lib))
17067             {
17068               free (elib);
17069               free (strtab);
17070               res = FALSE;
17071               break;
17072             }
17073           strtab_size = string_sec->sh_size;
17074
17075           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
17076           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17077                             "\nLibrary list section '%s' contains %lu entries:\n",
17078                             num_liblist),
17079                   printable_section_name (filedata, section),
17080                   num_liblist);
17081
17082           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
17083
17084           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
17085                ++cnt)
17086             {
17087               Elf32_Lib liblist;
17088               time_t atime;
17089               char timebuf[128];
17090               struct tm * tmp;
17091
17092               liblist.l_name = BYTE_GET (elib[cnt].l_name);
17093               atime = BYTE_GET (elib[cnt].l_time_stamp);
17094               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
17095               liblist.l_version = BYTE_GET (elib[cnt].l_version);
17096               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
17097
17098               tmp = gmtime (&atime);
17099               snprintf (timebuf, sizeof (timebuf),
17100                         "%04u-%02u-%02uT%02u:%02u:%02u",
17101                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
17102                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
17103
17104               printf ("%3lu: ", (unsigned long) cnt);
17105               if (do_wide)
17106                 printf ("%-20s", liblist.l_name < strtab_size
17107                         ? strtab + liblist.l_name : _("<corrupt>"));
17108               else
17109                 printf ("%-20.20s", liblist.l_name < strtab_size
17110                         ? strtab + liblist.l_name : _("<corrupt>"));
17111               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
17112                       liblist.l_version, liblist.l_flags);
17113             }
17114
17115           free (elib);
17116           free (strtab);
17117         }
17118     }
17119
17120   return res;
17121 }
17122
17123 static const char *
17124 get_note_type (Filedata * filedata, unsigned e_type)
17125 {
17126   static char buff[64];
17127
17128   if (filedata->file_header.e_type == ET_CORE)
17129     switch (e_type)
17130       {
17131       case NT_AUXV:
17132         return _("NT_AUXV (auxiliary vector)");
17133       case NT_PRSTATUS:
17134         return _("NT_PRSTATUS (prstatus structure)");
17135       case NT_FPREGSET:
17136         return _("NT_FPREGSET (floating point registers)");
17137       case NT_PRPSINFO:
17138         return _("NT_PRPSINFO (prpsinfo structure)");
17139       case NT_TASKSTRUCT:
17140         return _("NT_TASKSTRUCT (task structure)");
17141       case NT_PRXFPREG:
17142         return _("NT_PRXFPREG (user_xfpregs structure)");
17143       case NT_PPC_VMX:
17144         return _("NT_PPC_VMX (ppc Altivec registers)");
17145       case NT_PPC_VSX:
17146         return _("NT_PPC_VSX (ppc VSX registers)");
17147       case NT_PPC_TAR:
17148         return _("NT_PPC_TAR (ppc TAR register)");
17149       case NT_PPC_PPR:
17150         return _("NT_PPC_PPR (ppc PPR register)");
17151       case NT_PPC_DSCR:
17152         return _("NT_PPC_DSCR (ppc DSCR register)");
17153       case NT_PPC_EBB:
17154         return _("NT_PPC_EBB (ppc EBB registers)");
17155       case NT_PPC_PMU:
17156         return _("NT_PPC_PMU (ppc PMU registers)");
17157       case NT_PPC_TM_CGPR:
17158         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17159       case NT_PPC_TM_CFPR:
17160         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17161       case NT_PPC_TM_CVMX:
17162         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17163       case NT_PPC_TM_CVSX:
17164         return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17165       case NT_PPC_TM_SPR:
17166         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17167       case NT_PPC_TM_CTAR:
17168         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17169       case NT_PPC_TM_CPPR:
17170         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17171       case NT_PPC_TM_CDSCR:
17172         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17173       case NT_386_TLS:
17174         return _("NT_386_TLS (x86 TLS information)");
17175       case NT_386_IOPERM:
17176         return _("NT_386_IOPERM (x86 I/O permissions)");
17177       case NT_X86_XSTATE:
17178         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17179       case NT_S390_HIGH_GPRS:
17180         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17181       case NT_S390_TIMER:
17182         return _("NT_S390_TIMER (s390 timer register)");
17183       case NT_S390_TODCMP:
17184         return _("NT_S390_TODCMP (s390 TOD comparator register)");
17185       case NT_S390_TODPREG:
17186         return _("NT_S390_TODPREG (s390 TOD programmable register)");
17187       case NT_S390_CTRS:
17188         return _("NT_S390_CTRS (s390 control registers)");
17189       case NT_S390_PREFIX:
17190         return _("NT_S390_PREFIX (s390 prefix register)");
17191       case NT_S390_LAST_BREAK:
17192         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17193       case NT_S390_SYSTEM_CALL:
17194         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17195       case NT_S390_TDB:
17196         return _("NT_S390_TDB (s390 transaction diagnostic block)");
17197       case NT_S390_VXRS_LOW:
17198         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17199       case NT_S390_VXRS_HIGH:
17200         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17201       case NT_S390_GS_CB:
17202         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17203       case NT_S390_GS_BC:
17204         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17205       case NT_ARM_VFP:
17206         return _("NT_ARM_VFP (arm VFP registers)");
17207       case NT_ARM_TLS:
17208         return _("NT_ARM_TLS (AArch TLS registers)");
17209       case NT_ARM_HW_BREAK:
17210         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17211       case NT_ARM_HW_WATCH:
17212         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17213       case NT_PSTATUS:
17214         return _("NT_PSTATUS (pstatus structure)");
17215       case NT_FPREGS:
17216         return _("NT_FPREGS (floating point registers)");
17217       case NT_PSINFO:
17218         return _("NT_PSINFO (psinfo structure)");
17219       case NT_LWPSTATUS:
17220         return _("NT_LWPSTATUS (lwpstatus_t structure)");
17221       case NT_LWPSINFO:
17222         return _("NT_LWPSINFO (lwpsinfo_t structure)");
17223       case NT_WIN32PSTATUS:
17224         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17225       case NT_SIGINFO:
17226         return _("NT_SIGINFO (siginfo_t data)");
17227       case NT_FILE:
17228         return _("NT_FILE (mapped files)");
17229       default:
17230         break;
17231       }
17232   else
17233     switch (e_type)
17234       {
17235       case NT_VERSION:
17236         return _("NT_VERSION (version)");
17237       case NT_ARCH:
17238         return _("NT_ARCH (architecture)");
17239       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17240         return _("OPEN");
17241       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17242         return _("func");
17243       default:
17244         break;
17245       }
17246
17247   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17248   return buff;
17249 }
17250
17251 static bfd_boolean
17252 print_core_note (Elf_Internal_Note *pnote)
17253 {
17254   unsigned int addr_size = is_32bit_elf ? 4 : 8;
17255   bfd_vma count, page_size;
17256   unsigned char *descdata, *filenames, *descend;
17257
17258   if (pnote->type != NT_FILE)
17259     {
17260       if (do_wide)
17261         printf ("\n");
17262       return TRUE;
17263     }
17264
17265 #ifndef BFD64
17266   if (!is_32bit_elf)
17267     {
17268       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
17269       /* Still "successful".  */
17270       return TRUE;
17271     }
17272 #endif
17273
17274   if (pnote->descsz < 2 * addr_size)
17275     {
17276       error (_("    Malformed note - too short for header\n"));
17277       return FALSE;
17278     }
17279
17280   descdata = (unsigned char *) pnote->descdata;
17281   descend = descdata + pnote->descsz;
17282
17283   if (descdata[pnote->descsz - 1] != '\0')
17284     {
17285       error (_("    Malformed note - does not end with \\0\n"));
17286       return FALSE;
17287     }
17288
17289   count = byte_get (descdata, addr_size);
17290   descdata += addr_size;
17291
17292   page_size = byte_get (descdata, addr_size);
17293   descdata += addr_size;
17294
17295   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
17296       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
17297     {
17298       error (_("    Malformed note - too short for supplied file count\n"));
17299       return FALSE;
17300     }
17301
17302   printf (_("    Page size: "));
17303   print_vma (page_size, DEC);
17304   printf ("\n");
17305
17306   printf (_("    %*s%*s%*s\n"),
17307           (int) (2 + 2 * addr_size), _("Start"),
17308           (int) (4 + 2 * addr_size), _("End"),
17309           (int) (4 + 2 * addr_size), _("Page Offset"));
17310   filenames = descdata + count * 3 * addr_size;
17311   while (count-- > 0)
17312     {
17313       bfd_vma start, end, file_ofs;
17314
17315       if (filenames == descend)
17316         {
17317           error (_("    Malformed note - filenames end too early\n"));
17318           return FALSE;
17319         }
17320
17321       start = byte_get (descdata, addr_size);
17322       descdata += addr_size;
17323       end = byte_get (descdata, addr_size);
17324       descdata += addr_size;
17325       file_ofs = byte_get (descdata, addr_size);
17326       descdata += addr_size;
17327
17328       printf ("    ");
17329       print_vma (start, FULL_HEX);
17330       printf ("  ");
17331       print_vma (end, FULL_HEX);
17332       printf ("  ");
17333       print_vma (file_ofs, FULL_HEX);
17334       printf ("\n        %s\n", filenames);
17335
17336       filenames += 1 + strlen ((char *) filenames);
17337     }
17338
17339   return TRUE;
17340 }
17341
17342 static const char *
17343 get_gnu_elf_note_type (unsigned e_type)
17344 {
17345   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
17346   switch (e_type)
17347     {
17348     case NT_GNU_ABI_TAG:
17349       return _("NT_GNU_ABI_TAG (ABI version tag)");
17350     case NT_GNU_HWCAP:
17351       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17352     case NT_GNU_BUILD_ID:
17353       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17354     case NT_GNU_GOLD_VERSION:
17355       return _("NT_GNU_GOLD_VERSION (gold version)");
17356     case NT_GNU_PROPERTY_TYPE_0:
17357       return _("NT_GNU_PROPERTY_TYPE_0");
17358     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17359       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17360     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17361       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17362     default:
17363       {
17364         static char buff[64];
17365
17366         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17367         return buff;
17368       }
17369     }
17370 }
17371
17372 static void
17373 decode_x86_compat_isa (unsigned int bitmask)
17374 {
17375   while (bitmask)
17376     {
17377       unsigned int bit = bitmask & (- bitmask);
17378
17379       bitmask &= ~ bit;
17380       switch (bit)
17381         {
17382         case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
17383           printf ("i486");
17384           break;
17385         case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
17386           printf ("586");
17387           break;
17388         case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
17389           printf ("686");
17390           break;
17391         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
17392           printf ("SSE");
17393           break;
17394         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17395           printf ("SSE2");
17396           break;
17397         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17398           printf ("SSE3");
17399           break;
17400         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17401           printf ("SSSE3");
17402           break;
17403         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17404           printf ("SSE4_1");
17405           break;
17406         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17407           printf ("SSE4_2");
17408           break;
17409         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17410           printf ("AVX");
17411           break;
17412         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17413           printf ("AVX2");
17414           break;
17415         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17416           printf ("AVX512F");
17417           break;
17418         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17419           printf ("AVX512CD");
17420           break;
17421         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17422           printf ("AVX512ER");
17423           break;
17424         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17425           printf ("AVX512PF");
17426           break;
17427         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17428           printf ("AVX512VL");
17429           break;
17430         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17431           printf ("AVX512DQ");
17432           break;
17433         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17434           printf ("AVX512BW");
17435           break;
17436         default:
17437           printf (_("<unknown: %x>"), bit);
17438           break;
17439         }
17440       if (bitmask)
17441         printf (", ");
17442     }
17443 }
17444
17445 static void
17446 decode_x86_isa (unsigned int bitmask)
17447 {
17448   if (!bitmask)
17449     {
17450       printf (_("<None>"));
17451       return;
17452     }
17453
17454   while (bitmask)
17455     {
17456       unsigned int bit = bitmask & (- bitmask);
17457
17458       bitmask &= ~ bit;
17459       switch (bit)
17460         {
17461         case GNU_PROPERTY_X86_ISA_1_CMOV:
17462           printf ("CMOV");
17463           break;
17464         case GNU_PROPERTY_X86_ISA_1_SSE:
17465           printf ("SSE");
17466           break;
17467         case GNU_PROPERTY_X86_ISA_1_SSE2:
17468           printf ("SSE2");
17469           break;
17470         case GNU_PROPERTY_X86_ISA_1_SSE3:
17471           printf ("SSE3");
17472           break;
17473         case GNU_PROPERTY_X86_ISA_1_SSSE3:
17474           printf ("SSSE3");
17475           break;
17476         case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17477           printf ("SSE4_1");
17478           break;
17479         case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17480           printf ("SSE4_2");
17481           break;
17482         case GNU_PROPERTY_X86_ISA_1_AVX:
17483           printf ("AVX");
17484           break;
17485         case GNU_PROPERTY_X86_ISA_1_AVX2:
17486           printf ("AVX2");
17487           break;
17488         case GNU_PROPERTY_X86_ISA_1_FMA:
17489           printf ("FMA");
17490           break;
17491         case GNU_PROPERTY_X86_ISA_1_AVX512F:
17492           printf ("AVX512F");
17493           break;
17494         case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17495           printf ("AVX512CD");
17496           break;
17497         case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17498           printf ("AVX512ER");
17499           break;
17500         case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17501           printf ("AVX512PF");
17502           break;
17503         case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17504           printf ("AVX512VL");
17505           break;
17506         case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17507           printf ("AVX512DQ");
17508           break;
17509         case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17510           printf ("AVX512BW");
17511           break;
17512         case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17513           printf ("AVX512_4FMAPS");
17514           break;
17515         case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17516           printf ("AVX512_4VNNIW");
17517           break;
17518         case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17519           printf ("AVX512_BITALG");
17520           break;
17521         case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17522           printf ("AVX512_IFMA");
17523           break;
17524         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17525           printf ("AVX512_VBMI");
17526           break;
17527         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17528           printf ("AVX512_VBMI2");
17529           break;
17530         case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17531           printf ("AVX512_VNNI");
17532           break;
17533         case GNU_PROPERTY_X86_ISA_1_AVX512_BF16:
17534           printf ("AVX512_BF16");
17535           break;
17536         default:
17537           printf (_("<unknown: %x>"), bit);
17538           break;
17539         }
17540       if (bitmask)
17541         printf (", ");
17542     }
17543 }
17544
17545 static void
17546 decode_x86_feature_1 (unsigned int bitmask)
17547 {
17548   if (!bitmask)
17549     {
17550       printf (_("<None>"));
17551       return;
17552     }
17553
17554   while (bitmask)
17555     {
17556       unsigned int bit = bitmask & (- bitmask);
17557
17558       bitmask &= ~ bit;
17559       switch (bit)
17560         {
17561         case GNU_PROPERTY_X86_FEATURE_1_IBT:
17562           printf ("IBT");
17563           break;
17564         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17565           printf ("SHSTK");
17566           break;
17567         default:
17568           printf (_("<unknown: %x>"), bit);
17569           break;
17570         }
17571       if (bitmask)
17572         printf (", ");
17573     }
17574 }
17575
17576 static void
17577 decode_x86_feature_2 (unsigned int bitmask)
17578 {
17579   if (!bitmask)
17580     {
17581       printf (_("<None>"));
17582       return;
17583     }
17584
17585   while (bitmask)
17586     {
17587       unsigned int bit = bitmask & (- bitmask);
17588
17589       bitmask &= ~ bit;
17590       switch (bit)
17591         {
17592         case GNU_PROPERTY_X86_FEATURE_2_X86:
17593           printf ("x86");
17594           break;
17595         case GNU_PROPERTY_X86_FEATURE_2_X87:
17596           printf ("x87");
17597           break;
17598         case GNU_PROPERTY_X86_FEATURE_2_MMX:
17599           printf ("MMX");
17600           break;
17601         case GNU_PROPERTY_X86_FEATURE_2_XMM:
17602           printf ("XMM");
17603           break;
17604         case GNU_PROPERTY_X86_FEATURE_2_YMM:
17605           printf ("YMM");
17606           break;
17607         case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17608           printf ("ZMM");
17609           break;
17610         case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17611           printf ("FXSR");
17612           break;
17613         case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17614           printf ("XSAVE");
17615           break;
17616         case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17617           printf ("XSAVEOPT");
17618           break;
17619         case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17620           printf ("XSAVEC");
17621           break;
17622         default:
17623           printf (_("<unknown: %x>"), bit);
17624           break;
17625         }
17626       if (bitmask)
17627         printf (", ");
17628     }
17629 }
17630
17631 static void
17632 decode_aarch64_feature_1_and (unsigned int bitmask)
17633 {
17634   while (bitmask)
17635     {
17636       unsigned int bit = bitmask & (- bitmask);
17637
17638       bitmask &= ~ bit;
17639       switch (bit)
17640         {
17641         case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
17642           printf ("BTI");
17643           break;
17644
17645         case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
17646           printf ("PAC");
17647           break;
17648
17649         default:
17650           printf (_("<unknown: %x>"), bit);
17651           break;
17652         }
17653       if (bitmask)
17654         printf (", ");
17655     }
17656 }
17657
17658 static void
17659 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17660 {
17661   unsigned char * ptr = (unsigned char *) pnote->descdata;
17662   unsigned char * ptr_end = ptr + pnote->descsz;
17663   unsigned int    size = is_32bit_elf ? 4 : 8;
17664
17665   printf (_("      Properties: "));
17666
17667   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17668     {
17669       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17670       return;
17671     }
17672
17673   while (ptr < ptr_end)
17674     {
17675       unsigned int j;
17676       unsigned int type;
17677       unsigned int datasz;
17678
17679       if ((size_t) (ptr_end - ptr) < 8)
17680         {
17681           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17682           break;
17683         }
17684
17685       type = byte_get (ptr, 4);
17686       datasz = byte_get (ptr + 4, 4);
17687
17688       ptr += 8;
17689
17690       if (datasz > (size_t) (ptr_end - ptr))
17691         {
17692           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17693                   type, datasz);
17694           break;
17695         }
17696
17697       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17698         {
17699           if (filedata->file_header.e_machine == EM_X86_64
17700               || filedata->file_header.e_machine == EM_IAMCU
17701               || filedata->file_header.e_machine == EM_386)
17702             {
17703               unsigned int bitmask;
17704
17705               if (datasz == 4)
17706                 bitmask = byte_get (ptr, 4);
17707               else
17708                 bitmask = 0;
17709
17710               switch (type)
17711                 {
17712                 case GNU_PROPERTY_X86_ISA_1_USED:
17713                   if (datasz != 4)
17714                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17715                             datasz);
17716                   else
17717                     {
17718                       printf ("x86 ISA used: ");
17719                       decode_x86_isa (bitmask);
17720                     }
17721                   goto next;
17722
17723                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17724                   if (datasz != 4)
17725                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17726                             datasz);
17727                   else
17728                     {
17729                       printf ("x86 ISA needed: ");
17730                       decode_x86_isa (bitmask);
17731                     }
17732                   goto next;
17733
17734                 case GNU_PROPERTY_X86_FEATURE_1_AND:
17735                   if (datasz != 4)
17736                     printf (_("x86 feature: <corrupt length: %#x> "),
17737                             datasz);
17738                   else
17739                     {
17740                       printf ("x86 feature: ");
17741                       decode_x86_feature_1 (bitmask);
17742                     }
17743                   goto next;
17744
17745                 case GNU_PROPERTY_X86_FEATURE_2_USED:
17746                   if (datasz != 4)
17747                     printf (_("x86 feature used: <corrupt length: %#x> "),
17748                             datasz);
17749                   else
17750                     {
17751                       printf ("x86 feature used: ");
17752                       decode_x86_feature_2 (bitmask);
17753                     }
17754                   goto next;
17755
17756                 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17757                   if (datasz != 4)
17758                     printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17759                   else
17760                     {
17761                       printf ("x86 feature needed: ");
17762                       decode_x86_feature_2 (bitmask);
17763                     }
17764                   goto next;
17765
17766                 case GNU_PROPERTY_X86_COMPAT_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_compat_isa (bitmask);
17774                     }
17775                   goto next;
17776
17777                 case GNU_PROPERTY_X86_COMPAT_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_compat_isa (bitmask);
17785                     }
17786                   goto next;
17787
17788                 default:
17789                   break;
17790                 }
17791             }
17792           else if (filedata->file_header.e_machine == EM_AARCH64)
17793             {
17794               if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
17795                 {
17796                   printf ("AArch64 feature: ");
17797                   if (datasz != 4)
17798                     printf (_("<corrupt length: %#x> "), datasz);
17799                   else
17800                     decode_aarch64_feature_1_and (byte_get (ptr, 4));
17801                   goto next;
17802                 }
17803             }
17804         }
17805       else
17806         {
17807           switch (type)
17808             {
17809             case GNU_PROPERTY_STACK_SIZE:
17810               printf (_("stack size: "));
17811               if (datasz != size)
17812                 printf (_("<corrupt length: %#x> "), datasz);
17813               else
17814                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17815               goto next;
17816
17817             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17818               printf ("no copy on protected ");
17819               if (datasz)
17820                 printf (_("<corrupt length: %#x> "), datasz);
17821               goto next;
17822
17823             default:
17824               break;
17825             }
17826         }
17827
17828       if (type < GNU_PROPERTY_LOPROC)
17829         printf (_("<unknown type %#x data: "), type);
17830       else if (type < GNU_PROPERTY_LOUSER)
17831         printf (_("<procesor-specific type %#x data: "), type);
17832       else
17833         printf (_("<application-specific type %#x data: "), type);
17834       for (j = 0; j < datasz; ++j)
17835         printf ("%02x ", ptr[j] & 0xff);
17836       printf (">");
17837
17838 next:
17839       ptr += ((datasz + (size - 1)) & ~ (size - 1));
17840       if (ptr == ptr_end)
17841         break;
17842
17843       if (do_wide)
17844         printf (", ");
17845       else
17846         printf ("\n\t");
17847     }
17848
17849   printf ("\n");
17850 }
17851
17852 static bfd_boolean
17853 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17854 {
17855   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17856   switch (pnote->type)
17857     {
17858     case NT_GNU_BUILD_ID:
17859       {
17860         unsigned long i;
17861
17862         printf (_("    Build ID: "));
17863         for (i = 0; i < pnote->descsz; ++i)
17864           printf ("%02x", pnote->descdata[i] & 0xff);
17865         printf ("\n");
17866       }
17867       break;
17868
17869     case NT_GNU_ABI_TAG:
17870       {
17871         unsigned long os, major, minor, subminor;
17872         const char *osname;
17873
17874         /* PR 17531: file: 030-599401-0.004.  */
17875         if (pnote->descsz < 16)
17876           {
17877             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17878             break;
17879           }
17880
17881         os = byte_get ((unsigned char *) pnote->descdata, 4);
17882         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17883         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17884         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17885
17886         switch (os)
17887           {
17888           case GNU_ABI_TAG_LINUX:
17889             osname = "Linux";
17890             break;
17891           case GNU_ABI_TAG_HURD:
17892             osname = "Hurd";
17893             break;
17894           case GNU_ABI_TAG_SOLARIS:
17895             osname = "Solaris";
17896             break;
17897           case GNU_ABI_TAG_FREEBSD:
17898             osname = "FreeBSD";
17899             break;
17900           case GNU_ABI_TAG_NETBSD:
17901             osname = "NetBSD";
17902             break;
17903           case GNU_ABI_TAG_SYLLABLE:
17904             osname = "Syllable";
17905             break;
17906           case GNU_ABI_TAG_NACL:
17907             osname = "NaCl";
17908             break;
17909           default:
17910             osname = "Unknown";
17911             break;
17912           }
17913
17914         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17915                 major, minor, subminor);
17916       }
17917       break;
17918
17919     case NT_GNU_GOLD_VERSION:
17920       {
17921         unsigned long i;
17922
17923         printf (_("    Version: "));
17924         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17925           printf ("%c", pnote->descdata[i]);
17926         printf ("\n");
17927       }
17928       break;
17929
17930     case NT_GNU_HWCAP:
17931       {
17932         unsigned long num_entries, mask;
17933
17934         /* Hardware capabilities information.  Word 0 is the number of entries.
17935            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17936            is a series of entries, where each entry is a single byte followed
17937            by a nul terminated string.  The byte gives the bit number to test
17938            if enabled in the bitmask.  */
17939         printf (_("      Hardware Capabilities: "));
17940         if (pnote->descsz < 8)
17941           {
17942             error (_("<corrupt GNU_HWCAP>\n"));
17943             return FALSE;
17944           }
17945         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17946         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17947         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17948         /* FIXME: Add code to display the entries... */
17949       }
17950       break;
17951
17952     case NT_GNU_PROPERTY_TYPE_0:
17953       print_gnu_property_note (filedata, pnote);
17954       break;
17955
17956     default:
17957       /* Handle unrecognised types.  An error message should have already been
17958          created by get_gnu_elf_note_type(), so all that we need to do is to
17959          display the data.  */
17960       {
17961         unsigned long i;
17962
17963         printf (_("    Description data: "));
17964         for (i = 0; i < pnote->descsz; ++i)
17965           printf ("%02x ", pnote->descdata[i] & 0xff);
17966         printf ("\n");
17967       }
17968       break;
17969     }
17970
17971   return TRUE;
17972 }
17973
17974 static const char *
17975 get_v850_elf_note_type (enum v850_notes n_type)
17976 {
17977   static char buff[64];
17978
17979   switch (n_type)
17980     {
17981     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17982     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17983     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17984     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17985     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17986     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17987     default:
17988       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17989       return buff;
17990     }
17991 }
17992
17993 static bfd_boolean
17994 print_v850_note (Elf_Internal_Note * pnote)
17995 {
17996   unsigned int val;
17997
17998   if (pnote->descsz != 4)
17999     return FALSE;
18000
18001   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
18002
18003   if (val == 0)
18004     {
18005       printf (_("not set\n"));
18006       return TRUE;
18007     }
18008
18009   switch (pnote->type)
18010     {
18011     case V850_NOTE_ALIGNMENT:
18012       switch (val)
18013         {
18014         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
18015         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
18016         }
18017       break;
18018
18019     case V850_NOTE_DATA_SIZE:
18020       switch (val)
18021         {
18022         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
18023         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
18024         }
18025       break;
18026
18027     case V850_NOTE_FPU_INFO:
18028       switch (val)
18029         {
18030         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
18031         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
18032         }
18033       break;
18034
18035     case V850_NOTE_MMU_INFO:
18036     case V850_NOTE_CACHE_INFO:
18037     case V850_NOTE_SIMD_INFO:
18038       if (val == EF_RH850_SIMD)
18039         {
18040           printf (_("yes\n"));
18041           return TRUE;
18042         }
18043       break;
18044
18045     default:
18046       /* An 'unknown note type' message will already have been displayed.  */
18047       break;
18048     }
18049
18050   printf (_("unknown value: %x\n"), val);
18051   return FALSE;
18052 }
18053
18054 static bfd_boolean
18055 process_netbsd_elf_note (Elf_Internal_Note * pnote)
18056 {
18057   unsigned int version;
18058
18059   switch (pnote->type)
18060     {
18061     case NT_NETBSD_IDENT:
18062       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18063       if ((version / 10000) % 100)
18064         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
18065                 version, version / 100000000, (version / 1000000) % 100,
18066                 (version / 10000) % 100 > 26 ? "Z" : "",
18067                 'A' + (version / 10000) % 26);
18068       else
18069         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
18070                 version, version / 100000000, (version / 1000000) % 100,
18071                 (version / 100) % 100);
18072       return TRUE;
18073
18074     case NT_NETBSD_MARCH:
18075       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
18076               pnote->descdata);
18077       return TRUE;
18078
18079     default:
18080       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
18081               pnote->type);
18082       return FALSE;
18083     }
18084 }
18085
18086 static const char *
18087 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18088 {
18089   switch (e_type)
18090     {
18091     case NT_FREEBSD_THRMISC:
18092       return _("NT_THRMISC (thrmisc structure)");
18093     case NT_FREEBSD_PROCSTAT_PROC:
18094       return _("NT_PROCSTAT_PROC (proc data)");
18095     case NT_FREEBSD_PROCSTAT_FILES:
18096       return _("NT_PROCSTAT_FILES (files data)");
18097     case NT_FREEBSD_PROCSTAT_VMMAP:
18098       return _("NT_PROCSTAT_VMMAP (vmmap data)");
18099     case NT_FREEBSD_PROCSTAT_GROUPS:
18100       return _("NT_PROCSTAT_GROUPS (groups data)");
18101     case NT_FREEBSD_PROCSTAT_UMASK:
18102       return _("NT_PROCSTAT_UMASK (umask data)");
18103     case NT_FREEBSD_PROCSTAT_RLIMIT:
18104       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18105     case NT_FREEBSD_PROCSTAT_OSREL:
18106       return _("NT_PROCSTAT_OSREL (osreldate data)");
18107     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
18108       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18109     case NT_FREEBSD_PROCSTAT_AUXV:
18110       return _("NT_PROCSTAT_AUXV (auxv data)");
18111     case NT_FREEBSD_PTLWPINFO:
18112       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18113     }
18114   return get_note_type (filedata, e_type);
18115 }
18116
18117 static const char *
18118 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18119 {
18120   static char buff[64];
18121
18122   if (e_type == NT_NETBSDCORE_PROCINFO)
18123     return _("NetBSD procinfo structure");
18124
18125   /* As of Jan 2002 there are no other machine-independent notes
18126      defined for NetBSD core files.  If the note type is less
18127      than the start of the machine-dependent note types, we don't
18128      understand it.  */
18129
18130   if (e_type < NT_NETBSDCORE_FIRSTMACH)
18131     {
18132       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18133       return buff;
18134     }
18135
18136   switch (filedata->file_header.e_machine)
18137     {
18138     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18139        and PT_GETFPREGS == mach+2.  */
18140
18141     case EM_OLD_ALPHA:
18142     case EM_ALPHA:
18143     case EM_SPARC:
18144     case EM_SPARC32PLUS:
18145     case EM_SPARCV9:
18146       switch (e_type)
18147         {
18148         case NT_NETBSDCORE_FIRSTMACH + 0:
18149           return _("PT_GETREGS (reg structure)");
18150         case NT_NETBSDCORE_FIRSTMACH + 2:
18151           return _("PT_GETFPREGS (fpreg structure)");
18152         default:
18153           break;
18154         }
18155       break;
18156
18157     /* On all other arch's, PT_GETREGS == mach+1 and
18158        PT_GETFPREGS == mach+3.  */
18159     default:
18160       switch (e_type)
18161         {
18162         case NT_NETBSDCORE_FIRSTMACH + 1:
18163           return _("PT_GETREGS (reg structure)");
18164         case NT_NETBSDCORE_FIRSTMACH + 3:
18165           return _("PT_GETFPREGS (fpreg structure)");
18166         default:
18167           break;
18168         }
18169     }
18170
18171   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
18172             e_type - NT_NETBSDCORE_FIRSTMACH);
18173   return buff;
18174 }
18175
18176 static const char *
18177 get_stapsdt_note_type (unsigned e_type)
18178 {
18179   static char buff[64];
18180
18181   switch (e_type)
18182     {
18183     case NT_STAPSDT:
18184       return _("NT_STAPSDT (SystemTap probe descriptors)");
18185
18186     default:
18187       break;
18188     }
18189
18190   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18191   return buff;
18192 }
18193
18194 static bfd_boolean
18195 print_stapsdt_note (Elf_Internal_Note *pnote)
18196 {
18197   size_t len, maxlen;
18198   unsigned long addr_size = is_32bit_elf ? 4 : 8;
18199   char *data = pnote->descdata;
18200   char *data_end = pnote->descdata + pnote->descsz;
18201   bfd_vma pc, base_addr, semaphore;
18202   char *provider, *probe, *arg_fmt;
18203
18204   if (pnote->descsz < (addr_size * 3))
18205     goto stapdt_note_too_small;
18206
18207   pc = byte_get ((unsigned char *) data, addr_size);
18208   data += addr_size;
18209
18210   base_addr = byte_get ((unsigned char *) data, addr_size);
18211   data += addr_size;
18212
18213   semaphore = byte_get ((unsigned char *) data, addr_size);
18214   data += addr_size;
18215
18216   if (data >= data_end)
18217     goto stapdt_note_too_small;
18218   maxlen = data_end - data;
18219   len = strnlen (data, maxlen);
18220   if (len < maxlen)
18221     {
18222       provider = data;
18223       data += len + 1;
18224     }
18225   else
18226     goto stapdt_note_too_small;
18227
18228   if (data >= data_end)
18229     goto stapdt_note_too_small;
18230   maxlen = data_end - data;
18231   len = strnlen (data, maxlen);
18232   if (len < maxlen)
18233     {
18234       probe = data;
18235       data += len + 1;
18236     }
18237   else
18238     goto stapdt_note_too_small;
18239
18240   if (data >= data_end)
18241     goto stapdt_note_too_small;
18242   maxlen = data_end - data;
18243   len = strnlen (data, maxlen);
18244   if (len < maxlen)
18245     {
18246       arg_fmt = data;
18247       data += len + 1;
18248     }
18249   else
18250     goto stapdt_note_too_small;
18251
18252   printf (_("    Provider: %s\n"), provider);
18253   printf (_("    Name: %s\n"), probe);
18254   printf (_("    Location: "));
18255   print_vma (pc, FULL_HEX);
18256   printf (_(", Base: "));
18257   print_vma (base_addr, FULL_HEX);
18258   printf (_(", Semaphore: "));
18259   print_vma (semaphore, FULL_HEX);
18260   printf ("\n");
18261   printf (_("    Arguments: %s\n"), arg_fmt);
18262
18263   return data == data_end;
18264
18265  stapdt_note_too_small:
18266   printf (_("  <corrupt - note is too small>\n"));
18267   error (_("corrupt stapdt note - the data size is too small\n"));
18268   return FALSE;
18269 }
18270
18271 static const char *
18272 get_ia64_vms_note_type (unsigned e_type)
18273 {
18274   static char buff[64];
18275
18276   switch (e_type)
18277     {
18278     case NT_VMS_MHD:
18279       return _("NT_VMS_MHD (module header)");
18280     case NT_VMS_LNM:
18281       return _("NT_VMS_LNM (language name)");
18282     case NT_VMS_SRC:
18283       return _("NT_VMS_SRC (source files)");
18284     case NT_VMS_TITLE:
18285       return "NT_VMS_TITLE";
18286     case NT_VMS_EIDC:
18287       return _("NT_VMS_EIDC (consistency check)");
18288     case NT_VMS_FPMODE:
18289       return _("NT_VMS_FPMODE (FP mode)");
18290     case NT_VMS_LINKTIME:
18291       return "NT_VMS_LINKTIME";
18292     case NT_VMS_IMGNAM:
18293       return _("NT_VMS_IMGNAM (image name)");
18294     case NT_VMS_IMGID:
18295       return _("NT_VMS_IMGID (image id)");
18296     case NT_VMS_LINKID:
18297       return _("NT_VMS_LINKID (link id)");
18298     case NT_VMS_IMGBID:
18299       return _("NT_VMS_IMGBID (build id)");
18300     case NT_VMS_GSTNAM:
18301       return _("NT_VMS_GSTNAM (sym table name)");
18302     case NT_VMS_ORIG_DYN:
18303       return "NT_VMS_ORIG_DYN";
18304     case NT_VMS_PATCHTIME:
18305       return "NT_VMS_PATCHTIME";
18306     default:
18307       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18308       return buff;
18309     }
18310 }
18311
18312 static bfd_boolean
18313 print_ia64_vms_note (Elf_Internal_Note * pnote)
18314 {
18315   int maxlen = pnote->descsz;
18316
18317   if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
18318     goto desc_size_fail;
18319
18320   switch (pnote->type)
18321     {
18322     case NT_VMS_MHD:
18323       if (maxlen <= 36)
18324         goto desc_size_fail;
18325
18326       int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
18327
18328       printf (_("    Creation date  : %.17s\n"), pnote->descdata);
18329       printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
18330       if (l + 34 < maxlen)
18331         {
18332           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
18333           if (l + 35 < maxlen)
18334             printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
18335           else
18336             printf (_("    Module version : <missing>\n"));
18337         }
18338       else
18339         {
18340           printf (_("    Module name    : <missing>\n"));
18341           printf (_("    Module version : <missing>\n"));
18342         }
18343       break;
18344
18345     case NT_VMS_LNM:
18346       printf (_("   Language: %.*s\n"), maxlen, pnote->descdata);
18347       break;
18348
18349 #ifdef BFD64
18350     case NT_VMS_FPMODE:
18351       printf (_("   Floating Point mode: "));
18352       if (maxlen < 8)
18353         goto desc_size_fail;
18354       /* FIXME: Generate an error if descsz > 8 ?  */
18355
18356       printf ("0x%016" BFD_VMA_FMT "x\n",
18357               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
18358       break;
18359
18360     case NT_VMS_LINKTIME:
18361       printf (_("   Link time: "));
18362       if (maxlen < 8)
18363         goto desc_size_fail;
18364       /* FIXME: Generate an error if descsz > 8 ?  */
18365
18366       print_vms_time
18367         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18368       printf ("\n");
18369       break;
18370
18371     case NT_VMS_PATCHTIME:
18372       printf (_("   Patch time: "));
18373       if (maxlen < 8)
18374         goto desc_size_fail;
18375       /* FIXME: Generate an error if descsz > 8 ?  */
18376
18377       print_vms_time
18378         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18379       printf ("\n");
18380       break;
18381
18382     case NT_VMS_ORIG_DYN:
18383       if (maxlen < 34)
18384         goto desc_size_fail;
18385
18386       printf (_("   Major id: %u,  minor id: %u\n"),
18387               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
18388               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
18389       printf (_("   Last modified  : "));
18390       print_vms_time
18391         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
18392       printf (_("\n   Link flags  : "));
18393       printf ("0x%016" BFD_VMA_FMT "x\n",
18394               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
18395       printf (_("   Header flags: 0x%08x\n"),
18396               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
18397       printf (_("   Image id    : %.*s\n"), maxlen - 32, pnote->descdata + 32);
18398       break;
18399 #endif
18400
18401     case NT_VMS_IMGNAM:
18402       printf (_("    Image name: %.*s\n"), maxlen, pnote->descdata);
18403       break;
18404
18405     case NT_VMS_GSTNAM:
18406       printf (_("    Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
18407       break;
18408
18409     case NT_VMS_IMGID:
18410       printf (_("    Image id: %.*s\n"), maxlen, pnote->descdata);
18411       break;
18412
18413     case NT_VMS_LINKID:
18414       printf (_("    Linker id: %.*s\n"), maxlen, pnote->descdata);
18415       break;
18416
18417     default:
18418       return FALSE;
18419     }
18420
18421   return TRUE;
18422
18423  desc_size_fail:
18424   printf (_("  <corrupt - data size is too small>\n"));
18425   error (_("corrupt IA64 note: data size is too small\n"));
18426   return FALSE;
18427 }
18428
18429 /* Find the symbol associated with a build attribute that is attached
18430    to address OFFSET.  If PNAME is non-NULL then store the name of
18431    the symbol (if found) in the provided pointer,  Returns NULL if a
18432    symbol could not be found.  */
18433
18434 static Elf_Internal_Sym *
18435 get_symbol_for_build_attribute (Filedata *       filedata,
18436                                 unsigned long    offset,
18437                                 bfd_boolean      is_open_attr,
18438                                 const char **    pname)
18439 {
18440   static Filedata *         saved_filedata = NULL;
18441   static char *             strtab;
18442   static unsigned long      strtablen;
18443   static Elf_Internal_Sym * symtab;
18444   static unsigned long      nsyms;
18445   Elf_Internal_Sym *        saved_sym = NULL;
18446   Elf_Internal_Sym *        sym;
18447
18448   if (filedata->section_headers != NULL
18449       && (saved_filedata == NULL || filedata != saved_filedata))
18450     {
18451       Elf_Internal_Shdr * symsec;
18452
18453       /* Load the symbol and string sections.  */
18454       for (symsec = filedata->section_headers;
18455            symsec < filedata->section_headers + filedata->file_header.e_shnum;
18456            symsec ++)
18457         {
18458           if (symsec->sh_type == SHT_SYMTAB)
18459             {
18460               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
18461
18462               if (symsec->sh_link < filedata->file_header.e_shnum)
18463                 {
18464                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
18465
18466                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
18467                                               1, strtab_sec->sh_size,
18468                                               _("string table"));
18469                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
18470                 }
18471             }
18472         }
18473       saved_filedata = filedata;
18474     }
18475
18476   if (symtab == NULL || strtab == NULL)
18477     return NULL;
18478
18479   /* Find a symbol whose value matches offset.  */
18480   for (sym = symtab; sym < symtab + nsyms; sym ++)
18481     if (sym->st_value == offset)
18482       {
18483         if (sym->st_name >= strtablen)
18484           /* Huh ?  This should not happen.  */
18485           continue;
18486
18487         if (strtab[sym->st_name] == 0)
18488           continue;
18489
18490         /* The AArch64 and ARM architectures define mapping symbols
18491            (eg $d, $x, $t) which we want to ignore.  */
18492         if (strtab[sym->st_name] == '$'
18493             && strtab[sym->st_name + 1] != 0
18494             && strtab[sym->st_name + 2] == 0)
18495           continue;
18496
18497         if (is_open_attr)
18498           {
18499             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18500                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
18501                FUNC symbols entirely.  */
18502             switch (ELF_ST_TYPE (sym->st_info))
18503               {
18504               case STT_OBJECT:
18505               case STT_FILE:
18506                 saved_sym = sym;
18507                 if (sym->st_size)
18508                   {
18509                     /* If the symbol has a size associated
18510                        with it then we can stop searching.  */
18511                     sym = symtab + nsyms;
18512                   }
18513                 continue;
18514
18515               case STT_FUNC:
18516                 /* Ignore function symbols.  */
18517                 continue;
18518
18519               default:
18520                 break;
18521               }
18522
18523             switch (ELF_ST_BIND (sym->st_info))
18524               {
18525               case STB_GLOBAL:
18526                 if (saved_sym == NULL
18527                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18528                   saved_sym = sym;
18529                 break;
18530
18531               case STB_LOCAL:
18532                 if (saved_sym == NULL)
18533                   saved_sym = sym;
18534                 break;
18535
18536               default:
18537                 break;
18538               }
18539           }
18540         else
18541           {
18542             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18543               continue;
18544
18545             saved_sym = sym;
18546             break;
18547           }
18548       }
18549
18550   if (saved_sym && pname)
18551     * pname = strtab + saved_sym->st_name;
18552
18553   return saved_sym;
18554 }
18555
18556 /* Returns true iff addr1 and addr2 are in the same section.  */
18557
18558 static bfd_boolean
18559 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18560 {
18561   Elf_Internal_Shdr * a1;
18562   Elf_Internal_Shdr * a2;
18563
18564   a1 = find_section_by_address (filedata, addr1);
18565   a2 = find_section_by_address (filedata, addr2);
18566
18567   return a1 == a2 && a1 != NULL;
18568 }
18569
18570 static bfd_boolean
18571 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
18572                                        Filedata *           filedata)
18573 {
18574   static unsigned long  global_offset = 0;
18575   static unsigned long  global_end = 0;
18576   static unsigned long  func_offset = 0;
18577   static unsigned long  func_end = 0;
18578
18579   Elf_Internal_Sym *    sym;
18580   const char *          name;
18581   unsigned long         start;
18582   unsigned long         end;
18583   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18584
18585   switch (pnote->descsz)
18586     {
18587     case 0:
18588       /* A zero-length description means that the range of
18589          the previous note of the same type should be used.  */
18590       if (is_open_attr)
18591         {
18592           if (global_end > global_offset)
18593             printf (_("    Applies to region from %#lx to %#lx\n"),
18594                     global_offset, global_end);
18595           else
18596             printf (_("    Applies to region from %#lx\n"), global_offset);
18597         }
18598       else
18599         {
18600           if (func_end > func_offset)
18601             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18602           else
18603             printf (_("    Applies to region from %#lx\n"), func_offset);
18604         }
18605       return TRUE;
18606
18607     case 4:
18608       start = byte_get ((unsigned char *) pnote->descdata, 4);
18609       end = 0;
18610       break;
18611
18612     case 8:
18613       if (is_32bit_elf)
18614         {
18615           /* FIXME: We should check that version 3+ notes are being used here...  */
18616           start = byte_get ((unsigned char *) pnote->descdata, 4);
18617           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18618         }
18619       else
18620         {
18621           start = byte_get ((unsigned char *) pnote->descdata, 8);
18622           end = 0;
18623         }
18624       break;
18625
18626     case 16:
18627       start = byte_get ((unsigned char *) pnote->descdata, 8);
18628       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18629       break;
18630
18631     default:
18632       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
18633       printf (_("    <invalid descsz>"));
18634       return FALSE;
18635     }
18636
18637   name = NULL;
18638   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18639   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18640      in order to avoid them being confused with the start address of the
18641      first function in the file...  */
18642   if (sym == NULL && is_open_attr)
18643     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18644                                           & name);
18645
18646   if (end == 0 && sym != NULL && sym->st_size > 0)
18647     end = start + sym->st_size;
18648
18649   if (is_open_attr)
18650     {
18651       /* FIXME: Need to properly allow for section alignment.
18652          16 is just the alignment used on x86_64.  */
18653       if (global_end > 0
18654           && start > BFD_ALIGN (global_end, 16)
18655           /* Build notes are not guaranteed to be organised in order of
18656              increasing address, but we should find the all of the notes
18657              for one section in the same place.  */
18658           && same_section (filedata, start, global_end))
18659         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18660               global_end + 1, start - 1);
18661
18662       printf (_("    Applies to region from %#lx"), start);
18663       global_offset = start;
18664
18665       if (end)
18666         {
18667           printf (_(" to %#lx"), end);
18668           global_end = end;
18669         }
18670     }
18671   else
18672     {
18673       printf (_("    Applies to region from %#lx"), start);
18674       func_offset = start;
18675
18676       if (end)
18677         {
18678           printf (_(" to %#lx"), end);
18679           func_end = end;
18680         }
18681     }
18682
18683   if (sym && name)
18684     printf (_(" (%s)"), name);
18685
18686   printf ("\n");
18687   return TRUE;
18688 }
18689
18690 static bfd_boolean
18691 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18692 {
18693   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18694   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18695   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18696   char         name_type;
18697   char         name_attribute;
18698   const char * expected_types;
18699   const char * name = pnote->namedata;
18700   const char * text;
18701   signed int   left;
18702
18703   if (name == NULL || pnote->namesz < 2)
18704     {
18705       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18706       print_symbol (-20, _("  <corrupt name>"));
18707       return FALSE;
18708     }
18709
18710   if (do_wide)
18711     left = 28;
18712   else
18713     left = 20;
18714
18715   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
18716   if (name[0] == 'G' && name[1] == 'A')
18717     {
18718       if (pnote->namesz < 4)
18719         {
18720           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18721           print_symbol (-20, _("  <corrupt name>"));
18722           return FALSE;
18723         }
18724
18725       printf ("GA");
18726       name += 2;
18727       left -= 2;
18728     }
18729
18730   switch ((name_type = * name))
18731     {
18732     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18733     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18734     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18735     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18736       printf ("%c", * name);
18737       left --;
18738       break;
18739     default:
18740       error (_("unrecognised attribute type in name field: %d\n"), name_type);
18741       print_symbol (-20, _("<unknown name type>"));
18742       return FALSE;
18743     }
18744
18745   ++ name;
18746   text = NULL;
18747
18748   switch ((name_attribute = * name))
18749     {
18750     case GNU_BUILD_ATTRIBUTE_VERSION:
18751       text = _("<version>");
18752       expected_types = string_expected;
18753       ++ name;
18754       break;
18755     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18756       text = _("<stack prot>");
18757       expected_types = "!+*";
18758       ++ name;
18759       break;
18760     case GNU_BUILD_ATTRIBUTE_RELRO:
18761       text = _("<relro>");
18762       expected_types = bool_expected;
18763       ++ name;
18764       break;
18765     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18766       text = _("<stack size>");
18767       expected_types = number_expected;
18768       ++ name;
18769       break;
18770     case GNU_BUILD_ATTRIBUTE_TOOL:
18771       text = _("<tool>");
18772       expected_types = string_expected;
18773       ++ name;
18774       break;
18775     case GNU_BUILD_ATTRIBUTE_ABI:
18776       text = _("<ABI>");
18777       expected_types = "$*";
18778       ++ name;
18779       break;
18780     case GNU_BUILD_ATTRIBUTE_PIC:
18781       text = _("<PIC>");
18782       expected_types = number_expected;
18783       ++ name;
18784       break;
18785     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18786       text = _("<short enum>");
18787       expected_types = bool_expected;
18788       ++ name;
18789       break;
18790     default:
18791       if (ISPRINT (* name))
18792         {
18793           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18794
18795           if (len > left && ! do_wide)
18796             len = left;
18797           printf ("%.*s:", len, name);
18798           left -= len;
18799           name += len;
18800         }
18801       else
18802         {
18803           static char tmpbuf [128];
18804
18805           error (_("unrecognised byte in name field: %d\n"), * name);
18806           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18807           text = tmpbuf;
18808           name ++;
18809         }
18810       expected_types = "*$!+";
18811       break;
18812     }
18813
18814   if (text)
18815     left -= printf ("%s", text);
18816
18817   if (strchr (expected_types, name_type) == NULL)
18818     warn (_("attribute does not have an expected type (%c)\n"), name_type);
18819
18820   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18821     {
18822       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18823              (unsigned long) pnote->namesz,
18824              (long) (name - pnote->namedata));
18825       return FALSE;
18826     }
18827
18828   if (left < 1 && ! do_wide)
18829     return TRUE;
18830
18831   switch (name_type)
18832     {
18833     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18834       {
18835         unsigned int        bytes;
18836         unsigned long long  val = 0;
18837         unsigned int        shift = 0;
18838         char *              decoded = NULL;
18839
18840         bytes = pnote->namesz - (name - pnote->namedata);
18841         if (bytes > 0)
18842           /* The -1 is because the name field is always 0 terminated, and we
18843              want to be able to ensure that the shift in the while loop below
18844              will not overflow.  */
18845           -- bytes;
18846
18847         if (bytes > sizeof (val))
18848           {
18849             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18850                    bytes);
18851             bytes = sizeof (val);
18852           }
18853         /* We do not bother to warn if bytes == 0 as this can
18854            happen with some early versions of the gcc plugin.  */
18855
18856         while (bytes --)
18857           {
18858             unsigned long byte = (* name ++) & 0xff;
18859
18860             val |= byte << shift;
18861             shift += 8;
18862           }
18863
18864         switch (name_attribute)
18865           {
18866           case GNU_BUILD_ATTRIBUTE_PIC:
18867             switch (val)
18868               {
18869               case 0: decoded = "static"; break;
18870               case 1: decoded = "pic"; break;
18871               case 2: decoded = "PIC"; break;
18872               case 3: decoded = "pie"; break;
18873               case 4: decoded = "PIE"; break;
18874               default: break;
18875               }
18876             break;
18877           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18878             switch (val)
18879               {
18880                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
18881               case 0: decoded = "off"; break;
18882               case 1: decoded = "on"; break;
18883               case 2: decoded = "all"; break;
18884               case 3: decoded = "strong"; break;
18885               case 4: decoded = "explicit"; break;
18886               default: break;
18887               }
18888             break;
18889           default:
18890             break;
18891           }
18892
18893         if (decoded != NULL)
18894           {
18895             print_symbol (-left, decoded);
18896             left = 0;
18897           }
18898         else if (val == 0)
18899           {
18900             printf ("0x0");
18901             left -= 3;
18902           }
18903         else
18904           {
18905             if (do_wide)
18906               left -= printf ("0x%llx", val);
18907             else
18908               left -= printf ("0x%-.*llx", left, val);
18909           }
18910       }
18911       break;
18912     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18913       left -= print_symbol (- left, name);
18914       break;
18915     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18916       left -= print_symbol (- left, "true");
18917       break;
18918     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18919       left -= print_symbol (- left, "false");
18920       break;
18921     }
18922
18923   if (do_wide && left > 0)
18924     printf ("%-*s", left, " ");
18925
18926   return TRUE;
18927 }
18928
18929 /* Note that by the ELF standard, the name field is already null byte
18930    terminated, and namesz includes the terminating null byte.
18931    I.E. the value of namesz for the name "FSF" is 4.
18932
18933    If the value of namesz is zero, there is no name present.  */
18934
18935 static bfd_boolean
18936 process_note (Elf_Internal_Note *  pnote,
18937               Filedata *           filedata)
18938 {
18939   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18940   const char * nt;
18941
18942   if (pnote->namesz == 0)
18943     /* If there is no note name, then use the default set of
18944        note type strings.  */
18945     nt = get_note_type (filedata, pnote->type);
18946
18947   else if (const_strneq (pnote->namedata, "GNU"))
18948     /* GNU-specific object file notes.  */
18949     nt = get_gnu_elf_note_type (pnote->type);
18950
18951   else if (const_strneq (pnote->namedata, "FreeBSD"))
18952     /* FreeBSD-specific core file notes.  */
18953     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18954
18955   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18956     /* NetBSD-specific core file notes.  */
18957     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18958
18959   else if (const_strneq (pnote->namedata, "NetBSD"))
18960     /* NetBSD-specific core file notes.  */
18961     return process_netbsd_elf_note (pnote);
18962
18963   else if (strneq (pnote->namedata, "SPU/", 4))
18964     {
18965       /* SPU-specific core file notes.  */
18966       nt = pnote->namedata + 4;
18967       name = "SPU";
18968     }
18969
18970   else if (const_strneq (pnote->namedata, "IPF/VMS"))
18971     /* VMS/ia64-specific file notes.  */
18972     nt = get_ia64_vms_note_type (pnote->type);
18973
18974   else if (const_strneq (pnote->namedata, "stapsdt"))
18975     nt = get_stapsdt_note_type (pnote->type);
18976
18977   else
18978     /* Don't recognize this note name; just use the default set of
18979        note type strings.  */
18980     nt = get_note_type (filedata, pnote->type);
18981
18982   printf ("  ");
18983
18984   if (((const_strneq (pnote->namedata, "GA")
18985         && strchr ("*$!+", pnote->namedata[2]) != NULL)
18986        || strchr ("*$!+", pnote->namedata[0]) != NULL)
18987       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18988           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18989     print_gnu_build_attribute_name (pnote);
18990   else
18991     print_symbol (-20, name);
18992
18993   if (do_wide)
18994     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18995   else
18996     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18997
18998   if (const_strneq (pnote->namedata, "IPF/VMS"))
18999     return print_ia64_vms_note (pnote);
19000   else if (const_strneq (pnote->namedata, "GNU"))
19001     return print_gnu_note (filedata, pnote);
19002   else if (const_strneq (pnote->namedata, "stapsdt"))
19003     return print_stapsdt_note (pnote);
19004   else if (const_strneq (pnote->namedata, "CORE"))
19005     return print_core_note (pnote);
19006   else if (((const_strneq (pnote->namedata, "GA")
19007              && strchr ("*$!+", pnote->namedata[2]) != NULL)
19008             || strchr ("*$!+", pnote->namedata[0]) != NULL)
19009            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19010                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19011     return print_gnu_build_attribute_description (pnote, filedata);
19012
19013   if (pnote->descsz)
19014     {
19015       unsigned long i;
19016
19017       printf (_("   description data: "));
19018       for (i = 0; i < pnote->descsz; i++)
19019         printf ("%02x ", pnote->descdata[i]);
19020       if (!do_wide)
19021         printf ("\n");
19022     }
19023
19024   if (do_wide)
19025     printf ("\n");
19026
19027   return TRUE;
19028 }
19029
19030 static bfd_boolean
19031 process_notes_at (Filedata *           filedata,
19032                   Elf_Internal_Shdr *  section,
19033                   bfd_vma              offset,
19034                   bfd_vma              length,
19035                   bfd_vma              align)
19036 {
19037   Elf_External_Note * pnotes;
19038   Elf_External_Note * external;
19039   char *              end;
19040   bfd_boolean         res = TRUE;
19041
19042   if (length <= 0)
19043     return FALSE;
19044
19045   if (section)
19046     {
19047       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
19048       if (pnotes)
19049         {
19050           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
19051             return FALSE;
19052         }
19053     }
19054   else
19055     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19056                                              _("notes"));
19057
19058   if (pnotes == NULL)
19059     return FALSE;
19060
19061   external = pnotes;
19062
19063   if (section)
19064     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
19065   else
19066     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19067             (unsigned long) offset, (unsigned long) length);
19068
19069   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
19070      specifies that notes should be aligned to 4 bytes in 32-bit
19071      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
19072      we also support 4 byte alignment in 64-bit objects.  If section
19073      alignment is less than 4, we treate alignment as 4 bytes.   */
19074   if (align < 4)
19075     align = 4;
19076   else if (align != 4 && align != 8)
19077     {
19078       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19079             (long) align);
19080       return FALSE;
19081     }
19082
19083   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
19084
19085   end = (char *) pnotes + length;
19086   while ((char *) external < end)
19087     {
19088       Elf_Internal_Note inote;
19089       size_t min_notesz;
19090       char * next;
19091       char * temp = NULL;
19092       size_t data_remaining = end - (char *) external;
19093
19094       if (!is_ia64_vms (filedata))
19095         {
19096           /* PR binutils/15191
19097              Make sure that there is enough data to read.  */
19098           min_notesz = offsetof (Elf_External_Note, name);
19099           if (data_remaining < min_notesz)
19100             {
19101               warn (ngettext ("Corrupt note: only %ld byte remains, "
19102                               "not enough for a full note\n",
19103                               "Corrupt note: only %ld bytes remain, "
19104                               "not enough for a full note\n",
19105                               data_remaining),
19106                     (long) data_remaining);
19107               break;
19108             }
19109           data_remaining -= min_notesz;
19110
19111           inote.type     = BYTE_GET (external->type);
19112           inote.namesz   = BYTE_GET (external->namesz);
19113           inote.namedata = external->name;
19114           inote.descsz   = BYTE_GET (external->descsz);
19115           inote.descdata = ((char *) external
19116                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
19117           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19118           next = ((char *) external
19119                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
19120         }
19121       else
19122         {
19123           Elf64_External_VMS_Note *vms_external;
19124
19125           /* PR binutils/15191
19126              Make sure that there is enough data to read.  */
19127           min_notesz = offsetof (Elf64_External_VMS_Note, name);
19128           if (data_remaining < min_notesz)
19129             {
19130               warn (ngettext ("Corrupt note: only %ld byte remains, "
19131                               "not enough for a full note\n",
19132                               "Corrupt note: only %ld bytes remain, "
19133                               "not enough for a full note\n",
19134                               data_remaining),
19135                     (long) data_remaining);
19136               break;
19137             }
19138           data_remaining -= min_notesz;
19139
19140           vms_external = (Elf64_External_VMS_Note *) external;
19141           inote.type     = BYTE_GET (vms_external->type);
19142           inote.namesz   = BYTE_GET (vms_external->namesz);
19143           inote.namedata = vms_external->name;
19144           inote.descsz   = BYTE_GET (vms_external->descsz);
19145           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
19146           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19147           next = inote.descdata + align_power (inote.descsz, 3);
19148         }
19149
19150       /* PR 17531: file: 3443835e.  */
19151       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
19152       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
19153           || (size_t) (inote.descdata - inote.namedata) > data_remaining
19154           || (size_t) (next - inote.descdata) < inote.descsz
19155           || ((size_t) (next - inote.descdata)
19156               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
19157         {
19158           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19159                 (unsigned long) ((char *) external - (char *) pnotes));
19160           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19161                 inote.type, inote.namesz, inote.descsz, (int) align);
19162           break;
19163         }
19164
19165       external = (Elf_External_Note *) next;
19166
19167       /* Verify that name is null terminated.  It appears that at least
19168          one version of Linux (RedHat 6.0) generates corefiles that don't
19169          comply with the ELF spec by failing to include the null byte in
19170          namesz.  */
19171       if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
19172         {
19173           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
19174             {
19175               temp = (char *) malloc (inote.namesz + 1);
19176               if (temp == NULL)
19177                 {
19178                   error (_("Out of memory allocating space for inote name\n"));
19179                   res = FALSE;
19180                   break;
19181                 }
19182
19183               memcpy (temp, inote.namedata, inote.namesz);
19184               inote.namedata = temp;
19185             }
19186           inote.namedata[inote.namesz] = 0;
19187         }
19188
19189       if (! process_note (& inote, filedata))
19190         res = FALSE;
19191
19192       if (temp != NULL)
19193         {
19194           free (temp);
19195           temp = NULL;
19196         }
19197     }
19198
19199   free (pnotes);
19200
19201   return res;
19202 }
19203
19204 static bfd_boolean
19205 process_corefile_note_segments (Filedata * filedata)
19206 {
19207   Elf_Internal_Phdr * segment;
19208   unsigned int i;
19209   bfd_boolean res = TRUE;
19210
19211   if (! get_program_headers (filedata))
19212     return TRUE;
19213
19214   for (i = 0, segment = filedata->program_headers;
19215        i < filedata->file_header.e_phnum;
19216        i++, segment++)
19217     {
19218       if (segment->p_type == PT_NOTE)
19219         if (! process_notes_at (filedata, NULL,
19220                                 (bfd_vma) segment->p_offset,
19221                                 (bfd_vma) segment->p_filesz,
19222                                 (bfd_vma) segment->p_align))
19223           res = FALSE;
19224     }
19225
19226   return res;
19227 }
19228
19229 static bfd_boolean
19230 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
19231 {
19232   Elf_External_Note * pnotes;
19233   Elf_External_Note * external;
19234   char * end;
19235   bfd_boolean res = TRUE;
19236
19237   if (length <= 0)
19238     return FALSE;
19239
19240   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19241                                            _("v850 notes"));
19242   if (pnotes == NULL)
19243     return FALSE;
19244
19245   external = pnotes;
19246   end = (char*) pnotes + length;
19247
19248   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19249           (unsigned long) offset, (unsigned long) length);
19250
19251   while ((char *) external + sizeof (Elf_External_Note) < end)
19252     {
19253       Elf_External_Note * next;
19254       Elf_Internal_Note inote;
19255
19256       inote.type     = BYTE_GET (external->type);
19257       inote.namesz   = BYTE_GET (external->namesz);
19258       inote.namedata = external->name;
19259       inote.descsz   = BYTE_GET (external->descsz);
19260       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
19261       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19262
19263       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
19264         {
19265           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
19266           inote.descdata = inote.namedata;
19267           inote.namesz   = 0;
19268         }
19269
19270       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
19271
19272       if (   ((char *) next > end)
19273           || ((char *) next <  (char *) pnotes))
19274         {
19275           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19276                 (unsigned long) ((char *) external - (char *) pnotes));
19277           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19278                 inote.type, inote.namesz, inote.descsz);
19279           break;
19280         }
19281
19282       external = next;
19283
19284       /* Prevent out-of-bounds indexing.  */
19285       if (   inote.namedata + inote.namesz > end
19286           || inote.namedata + inote.namesz < inote.namedata)
19287         {
19288           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19289                 (unsigned long) ((char *) external - (char *) pnotes));
19290           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19291                 inote.type, inote.namesz, inote.descsz);
19292           break;
19293         }
19294
19295       printf ("  %s: ", get_v850_elf_note_type (inote.type));
19296
19297       if (! print_v850_note (& inote))
19298         {
19299           res = FALSE;
19300           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19301                   inote.namesz, inote.descsz);
19302         }
19303     }
19304
19305   free (pnotes);
19306
19307   return res;
19308 }
19309
19310 static bfd_boolean
19311 process_note_sections (Filedata * filedata)
19312 {
19313   Elf_Internal_Shdr * section;
19314   unsigned long i;
19315   unsigned int n = 0;
19316   bfd_boolean res = TRUE;
19317
19318   for (i = 0, section = filedata->section_headers;
19319        i < filedata->file_header.e_shnum && section != NULL;
19320        i++, section++)
19321     {
19322       if (section->sh_type == SHT_NOTE)
19323         {
19324           if (! process_notes_at (filedata, section,
19325                                   (bfd_vma) section->sh_offset,
19326                                   (bfd_vma) section->sh_size,
19327                                   (bfd_vma) section->sh_addralign))
19328             res = FALSE;
19329           n++;
19330         }
19331
19332       if ((   filedata->file_header.e_machine == EM_V800
19333            || filedata->file_header.e_machine == EM_V850
19334            || filedata->file_header.e_machine == EM_CYGNUS_V850)
19335           && section->sh_type == SHT_RENESAS_INFO)
19336         {
19337           if (! process_v850_notes (filedata,
19338                                     (bfd_vma) section->sh_offset,
19339                                     (bfd_vma) section->sh_size))
19340             res = FALSE;
19341           n++;
19342         }
19343     }
19344
19345   if (n == 0)
19346     /* Try processing NOTE segments instead.  */
19347     return process_corefile_note_segments (filedata);
19348
19349   return res;
19350 }
19351
19352 static bfd_boolean
19353 process_notes (Filedata * filedata)
19354 {
19355   /* If we have not been asked to display the notes then do nothing.  */
19356   if (! do_notes)
19357     return TRUE;
19358
19359   if (filedata->file_header.e_type != ET_CORE)
19360     return process_note_sections (filedata);
19361
19362   /* No program headers means no NOTE segment.  */
19363   if (filedata->file_header.e_phnum > 0)
19364     return process_corefile_note_segments (filedata);
19365
19366   printf (_("No note segments present in the core file.\n"));
19367   return TRUE;
19368 }
19369
19370 static unsigned char *
19371 display_public_gnu_attributes (unsigned char * start,
19372                                const unsigned char * const end)
19373 {
19374   printf (_("  Unknown GNU attribute: %s\n"), start);
19375
19376   start += strnlen ((char *) start, end - start);
19377   display_raw_attribute (start, end);
19378
19379   return (unsigned char *) end;
19380 }
19381
19382 static unsigned char *
19383 display_generic_attribute (unsigned char * start,
19384                            unsigned int tag,
19385                            const unsigned char * const end)
19386 {
19387   if (tag == 0)
19388     return (unsigned char *) end;
19389
19390   return display_tag_value (tag, start, end);
19391 }
19392
19393 static bfd_boolean
19394 process_arch_specific (Filedata * filedata)
19395 {
19396   if (! do_arch)
19397     return TRUE;
19398
19399   switch (filedata->file_header.e_machine)
19400     {
19401     case EM_ARC:
19402     case EM_ARC_COMPACT:
19403     case EM_ARC_COMPACT2:
19404       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
19405                                  display_arc_attribute,
19406                                  display_generic_attribute);
19407     case EM_ARM:
19408       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
19409                                  display_arm_attribute,
19410                                  display_generic_attribute);
19411
19412     case EM_MIPS:
19413     case EM_MIPS_RS3_LE:
19414       return process_mips_specific (filedata);
19415
19416     case EM_MSP430:
19417      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
19418                                 display_msp430x_attribute,
19419                                 display_generic_attribute);
19420
19421     case EM_RISCV:
19422      return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
19423                                 display_riscv_attribute,
19424                                 display_generic_attribute);
19425
19426     case EM_NDS32:
19427       return process_nds32_specific (filedata);
19428
19429     case EM_PPC:
19430     case EM_PPC64:
19431       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19432                                  display_power_gnu_attribute);
19433
19434     case EM_S390:
19435     case EM_S390_OLD:
19436       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19437                                  display_s390_gnu_attribute);
19438
19439     case EM_SPARC:
19440     case EM_SPARC32PLUS:
19441     case EM_SPARCV9:
19442       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19443                                  display_sparc_gnu_attribute);
19444
19445     case EM_TI_C6000:
19446       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
19447                                  display_tic6x_attribute,
19448                                  display_generic_attribute);
19449
19450     default:
19451       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
19452                                  display_public_gnu_attributes,
19453                                  display_generic_attribute);
19454     }
19455 }
19456
19457 static bfd_boolean
19458 get_file_header (Filedata * filedata)
19459 {
19460   /* Read in the identity array.  */
19461   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
19462     return FALSE;
19463
19464   /* Determine how to read the rest of the header.  */
19465   switch (filedata->file_header.e_ident[EI_DATA])
19466     {
19467     default:
19468     case ELFDATANONE:
19469     case ELFDATA2LSB:
19470       byte_get = byte_get_little_endian;
19471       byte_put = byte_put_little_endian;
19472       break;
19473     case ELFDATA2MSB:
19474       byte_get = byte_get_big_endian;
19475       byte_put = byte_put_big_endian;
19476       break;
19477     }
19478
19479   /* For now we only support 32 bit and 64 bit ELF files.  */
19480   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
19481
19482   /* Read in the rest of the header.  */
19483   if (is_32bit_elf)
19484     {
19485       Elf32_External_Ehdr ehdr32;
19486
19487       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
19488         return FALSE;
19489
19490       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
19491       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
19492       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
19493       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
19494       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
19495       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
19496       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
19497       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
19498       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
19499       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
19500       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
19501       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
19502       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
19503     }
19504   else
19505     {
19506       Elf64_External_Ehdr ehdr64;
19507
19508       /* If we have been compiled with sizeof (bfd_vma) == 4, then
19509          we will not be able to cope with the 64bit data found in
19510          64 ELF files.  Detect this now and abort before we start
19511          overwriting things.  */
19512       if (sizeof (bfd_vma) < 8)
19513         {
19514           error (_("This instance of readelf has been built without support for a\n\
19515 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19516           return FALSE;
19517         }
19518
19519       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
19520         return FALSE;
19521
19522       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
19523       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
19524       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
19525       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
19526       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
19527       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
19528       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
19529       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
19530       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19531       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
19532       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19533       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
19534       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
19535     }
19536
19537   if (filedata->file_header.e_shoff)
19538     {
19539       /* There may be some extensions in the first section header.  Don't
19540          bomb if we can't read it.  */
19541       if (is_32bit_elf)
19542         get_32bit_section_headers (filedata, TRUE);
19543       else
19544         get_64bit_section_headers (filedata, TRUE);
19545     }
19546
19547   return TRUE;
19548 }
19549
19550 static void
19551 close_file (Filedata * filedata)
19552 {
19553   if (filedata)
19554     {
19555       if (filedata->handle)
19556         fclose (filedata->handle);
19557       free (filedata);
19558     }
19559 }
19560
19561 void
19562 close_debug_file (void * data)
19563 {
19564   close_file ((Filedata *) data);
19565 }
19566
19567 static Filedata *
19568 open_file (const char * pathname)
19569 {
19570   struct stat  statbuf;
19571   Filedata *   filedata = NULL;
19572
19573   if (stat (pathname, & statbuf) < 0
19574       || ! S_ISREG (statbuf.st_mode))
19575     goto fail;
19576
19577   filedata = calloc (1, sizeof * filedata);
19578   if (filedata == NULL)
19579     goto fail;
19580
19581   filedata->handle = fopen (pathname, "rb");
19582   if (filedata->handle == NULL)
19583     goto fail;
19584
19585   filedata->file_size = (bfd_size_type) statbuf.st_size;
19586   filedata->file_name = pathname;
19587
19588   if (! get_file_header (filedata))
19589     goto fail;
19590
19591   if (filedata->file_header.e_shoff)
19592     {
19593       bfd_boolean res;
19594
19595       /* Read the section headers again, this time for real.  */
19596       if (is_32bit_elf)
19597         res = get_32bit_section_headers (filedata, FALSE);
19598       else
19599         res = get_64bit_section_headers (filedata, FALSE);
19600
19601       if (!res)
19602         goto fail;
19603     }
19604
19605   return filedata;
19606
19607  fail:
19608   if (filedata)
19609     {
19610       if (filedata->handle)
19611         fclose (filedata->handle);
19612       free (filedata);
19613     }
19614   return NULL;
19615 }
19616
19617 void *
19618 open_debug_file (const char * pathname)
19619 {
19620   return open_file (pathname);
19621 }
19622
19623 /* Process one ELF object file according to the command line options.
19624    This file may actually be stored in an archive.  The file is
19625    positioned at the start of the ELF object.  Returns TRUE if no
19626    problems were encountered, FALSE otherwise.  */
19627
19628 static bfd_boolean
19629 process_object (Filedata * filedata)
19630 {
19631   bfd_boolean  have_separate_files;
19632   unsigned int i;
19633   bfd_boolean res = TRUE;
19634
19635   if (! get_file_header (filedata))
19636     {
19637       error (_("%s: Failed to read file header\n"), filedata->file_name);
19638       return FALSE;
19639     }
19640
19641   /* Initialise per file variables.  */
19642   for (i = ARRAY_SIZE (version_info); i--;)
19643     version_info[i] = 0;
19644
19645   for (i = ARRAY_SIZE (dynamic_info); i--;)
19646     dynamic_info[i] = 0;
19647   dynamic_info_DT_GNU_HASH = 0;
19648
19649   /* Process the file.  */
19650   if (show_name)
19651     printf (_("\nFile: %s\n"), filedata->file_name);
19652
19653   /* Initialise the dump_sects array from the cmdline_dump_sects array.
19654      Note we do this even if cmdline_dump_sects is empty because we
19655      must make sure that the dump_sets array is zeroed out before each
19656      object file is processed.  */
19657   if (filedata->num_dump_sects > cmdline.num_dump_sects)
19658     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19659
19660   if (cmdline.num_dump_sects > 0)
19661     {
19662       if (filedata->num_dump_sects == 0)
19663         /* A sneaky way of allocating the dump_sects array.  */
19664         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19665
19666       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19667       memcpy (filedata->dump_sects, cmdline.dump_sects,
19668               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19669     }
19670
19671   if (! process_file_header (filedata))
19672     return FALSE;
19673
19674   if (! process_section_headers (filedata))
19675     {
19676       /* Without loaded section headers we cannot process lots of things.  */
19677       do_unwind = do_version = do_dump = do_arch = FALSE;
19678
19679       if (! do_using_dynamic)
19680         do_syms = do_dyn_syms = do_reloc = FALSE;
19681     }
19682
19683   if (! process_section_groups (filedata))
19684     /* Without loaded section groups we cannot process unwind.  */
19685     do_unwind = FALSE;
19686
19687   if (process_program_headers (filedata))
19688     process_dynamic_section (filedata);
19689   else
19690     res = FALSE;
19691
19692   if (! process_relocs (filedata))
19693     res = FALSE;
19694
19695   if (! process_unwind (filedata))
19696     res = FALSE;
19697
19698   if (! process_symbol_table (filedata))
19699     res = FALSE;
19700
19701   if (! process_syminfo (filedata))
19702     res = FALSE;
19703
19704   if (! process_version_sections (filedata))
19705     res = FALSE;
19706
19707   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19708     have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
19709   else
19710     have_separate_files = FALSE;
19711
19712   if (! process_section_contents (filedata))
19713     res = FALSE;
19714
19715   if (have_separate_files)
19716     {
19717       separate_info * d;
19718
19719       for (d = first_separate_info; d != NULL; d = d->next)
19720         {
19721           if (! process_section_headers (d->handle))
19722             res = FALSE;
19723           else if (! process_section_contents (d->handle))
19724             res = FALSE;
19725         }
19726
19727       /* The file handles are closed by the call to free_debug_memory() below.  */
19728     }
19729
19730   if (! process_notes (filedata))
19731     res = FALSE;
19732
19733   if (! process_gnu_liblist (filedata))
19734     res = FALSE;
19735
19736   if (! process_arch_specific (filedata))
19737     res = FALSE;
19738
19739   free (filedata->program_headers);
19740   filedata->program_headers = NULL;
19741
19742   free (filedata->section_headers);
19743   filedata->section_headers = NULL;
19744
19745   free (filedata->string_table);
19746   filedata->string_table = NULL;
19747   filedata->string_table_length = 0;
19748
19749   if (dynamic_strings)
19750     {
19751       free (dynamic_strings);
19752       dynamic_strings = NULL;
19753       dynamic_strings_length = 0;
19754     }
19755
19756   if (dynamic_symbols)
19757     {
19758       free (dynamic_symbols);
19759       dynamic_symbols = NULL;
19760       num_dynamic_syms = 0;
19761     }
19762
19763   if (dynamic_syminfo)
19764     {
19765       free (dynamic_syminfo);
19766       dynamic_syminfo = NULL;
19767     }
19768
19769   if (dynamic_section)
19770     {
19771       free (dynamic_section);
19772       dynamic_section = NULL;
19773     }
19774
19775   if (section_headers_groups)
19776     {
19777       free (section_headers_groups);
19778       section_headers_groups = NULL;
19779     }
19780
19781   if (section_groups)
19782     {
19783       struct group_list * g;
19784       struct group_list * next;
19785
19786       for (i = 0; i < group_count; i++)
19787         {
19788           for (g = section_groups [i].root; g != NULL; g = next)
19789             {
19790               next = g->next;
19791               free (g);
19792             }
19793         }
19794
19795       free (section_groups);
19796       section_groups = NULL;
19797     }
19798
19799   free_debug_memory ();
19800
19801   return res;
19802 }
19803
19804 /* Process an ELF archive.
19805    On entry the file is positioned just after the ARMAG string.
19806    Returns TRUE upon success, FALSE otherwise.  */
19807
19808 static bfd_boolean
19809 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19810 {
19811   struct archive_info arch;
19812   struct archive_info nested_arch;
19813   size_t got;
19814   bfd_boolean ret = TRUE;
19815
19816   show_name = TRUE;
19817
19818   /* The ARCH structure is used to hold information about this archive.  */
19819   arch.file_name = NULL;
19820   arch.file = NULL;
19821   arch.index_array = NULL;
19822   arch.sym_table = NULL;
19823   arch.longnames = NULL;
19824
19825   /* The NESTED_ARCH structure is used as a single-item cache of information
19826      about a nested archive (when members of a thin archive reside within
19827      another regular archive file).  */
19828   nested_arch.file_name = NULL;
19829   nested_arch.file = NULL;
19830   nested_arch.index_array = NULL;
19831   nested_arch.sym_table = NULL;
19832   nested_arch.longnames = NULL;
19833
19834   if (setup_archive (&arch, filedata->file_name, filedata->handle,
19835                      is_thin_archive, do_archive_index) != 0)
19836     {
19837       ret = FALSE;
19838       goto out;
19839     }
19840
19841   if (do_archive_index)
19842     {
19843       if (arch.sym_table == NULL)
19844         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19845       else
19846         {
19847           unsigned long i, l;
19848           unsigned long current_pos;
19849
19850           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19851                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19852
19853           current_pos = ftell (filedata->handle);
19854
19855           for (i = l = 0; i < arch.index_num; i++)
19856             {
19857               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19858                 {
19859                   char * member_name;
19860
19861                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19862
19863                   if (member_name != NULL)
19864                     {
19865                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19866
19867                       if (qualified_name != NULL)
19868                         {
19869                           printf (_("Contents of binary %s at offset "), qualified_name);
19870                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
19871                           putchar ('\n');
19872                           free (qualified_name);
19873                         }
19874                     }
19875                 }
19876
19877               if (l >= arch.sym_size)
19878                 {
19879                   error (_("%s: end of the symbol table reached before the end of the index\n"),
19880                          filedata->file_name);
19881                   ret = FALSE;
19882                   break;
19883                 }
19884               /* PR 17531: file: 0b6630b2.  */
19885               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19886               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19887             }
19888
19889           if (arch.uses_64bit_indices)
19890             l = (l + 7) & ~ 7;
19891           else
19892             l += l & 1;
19893
19894           if (l < arch.sym_size)
19895             {
19896               error (ngettext ("%s: %ld byte remains in the symbol table, "
19897                                "but without corresponding entries in "
19898                                "the index table\n",
19899                                "%s: %ld bytes remain in the symbol table, "
19900                                "but without corresponding entries in "
19901                                "the index table\n",
19902                                arch.sym_size - l),
19903                      filedata->file_name, arch.sym_size - l);
19904               ret = FALSE;
19905             }
19906
19907           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19908             {
19909               error (_("%s: failed to seek back to start of object files in the archive\n"),
19910                      filedata->file_name);
19911               ret = FALSE;
19912               goto out;
19913             }
19914         }
19915
19916       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19917           && !do_segments && !do_header && !do_dump && !do_version
19918           && !do_histogram && !do_debugging && !do_arch && !do_notes
19919           && !do_section_groups && !do_dyn_syms)
19920         {
19921           ret = TRUE; /* Archive index only.  */
19922           goto out;
19923         }
19924     }
19925
19926   while (1)
19927     {
19928       char * name;
19929       size_t namelen;
19930       char * qualified_name;
19931
19932       /* Read the next archive header.  */
19933       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19934         {
19935           error (_("%s: failed to seek to next archive header\n"), arch.file_name);
19936           return FALSE;
19937         }
19938       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19939       if (got != sizeof arch.arhdr)
19940         {
19941           if (got == 0)
19942             break;
19943           /* PR 24049 - we cannot use filedata->file_name as this will
19944              have already been freed.  */
19945           error (_("%s: failed to read archive header\n"), arch.file_name);
19946
19947           ret = FALSE;
19948           break;
19949         }
19950       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19951         {
19952           error (_("%s: did not find a valid archive header\n"), arch.file_name);
19953           ret = FALSE;
19954           break;
19955         }
19956
19957       arch.next_arhdr_offset += sizeof arch.arhdr;
19958
19959       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19960       if (archive_file_size & 01)
19961         ++archive_file_size;
19962
19963       name = get_archive_member_name (&arch, &nested_arch);
19964       if (name == NULL)
19965         {
19966           error (_("%s: bad archive file name\n"), arch.file_name);
19967           ret = FALSE;
19968           break;
19969         }
19970       namelen = strlen (name);
19971
19972       qualified_name = make_qualified_name (&arch, &nested_arch, name);
19973       if (qualified_name == NULL)
19974         {
19975           error (_("%s: bad archive file name\n"), arch.file_name);
19976           ret = FALSE;
19977           break;
19978         }
19979
19980       if (is_thin_archive && arch.nested_member_origin == 0)
19981         {
19982           /* This is a proxy for an external member of a thin archive.  */
19983           Filedata * member_filedata;
19984           char * member_file_name = adjust_relative_path
19985             (filedata->file_name, name, namelen);
19986
19987           if (member_file_name == NULL)
19988             {
19989               ret = FALSE;
19990               break;
19991             }
19992
19993           member_filedata = open_file (member_file_name);
19994           if (member_filedata == NULL)
19995             {
19996               error (_("Input file '%s' is not readable.\n"), member_file_name);
19997               free (member_file_name);
19998               ret = FALSE;
19999               break;
20000             }
20001
20002           archive_file_offset = arch.nested_member_origin;
20003           member_filedata->file_name = qualified_name;
20004
20005           if (! process_object (member_filedata))
20006             ret = FALSE;
20007
20008           close_file (member_filedata);
20009           free (member_file_name);
20010         }
20011       else if (is_thin_archive)
20012         {
20013           Filedata thin_filedata;
20014
20015           memset (&thin_filedata, 0, sizeof (thin_filedata));
20016
20017           /* PR 15140: Allow for corrupt thin archives.  */
20018           if (nested_arch.file == NULL)
20019             {
20020               error (_("%s: contains corrupt thin archive: %s\n"),
20021                      qualified_name, name);
20022               ret = FALSE;
20023               break;
20024             }
20025
20026           /* This is a proxy for a member of a nested archive.  */
20027           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
20028
20029           /* The nested archive file will have been opened and setup by
20030              get_archive_member_name.  */
20031           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
20032             {
20033               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
20034               ret = FALSE;
20035               break;
20036             }
20037
20038           thin_filedata.handle = nested_arch.file;
20039           thin_filedata.file_name = qualified_name;
20040
20041           if (! process_object (& thin_filedata))
20042             ret = FALSE;
20043         }
20044       else
20045         {
20046           archive_file_offset = arch.next_arhdr_offset;
20047           arch.next_arhdr_offset += archive_file_size;
20048
20049           filedata->file_name = qualified_name;
20050           if (! process_object (filedata))
20051             ret = FALSE;
20052         }
20053
20054       if (filedata->dump_sects != NULL)
20055         {
20056           free (filedata->dump_sects);
20057           filedata->dump_sects = NULL;
20058           filedata->num_dump_sects = 0;
20059         }
20060
20061       free (qualified_name);
20062     }
20063
20064  out:
20065   if (nested_arch.file != NULL)
20066     fclose (nested_arch.file);
20067   release_archive (&nested_arch);
20068   release_archive (&arch);
20069
20070   return ret;
20071 }
20072
20073 static bfd_boolean
20074 process_file (char * file_name)
20075 {
20076   Filedata * filedata = NULL;
20077   struct stat statbuf;
20078   char armag[SARMAG];
20079   bfd_boolean ret = TRUE;
20080
20081   if (stat (file_name, &statbuf) < 0)
20082     {
20083       if (errno == ENOENT)
20084         error (_("'%s': No such file\n"), file_name);
20085       else
20086         error (_("Could not locate '%s'.  System error message: %s\n"),
20087                file_name, strerror (errno));
20088       return FALSE;
20089     }
20090
20091   if (! S_ISREG (statbuf.st_mode))
20092     {
20093       error (_("'%s' is not an ordinary file\n"), file_name);
20094       return FALSE;
20095     }
20096
20097   filedata = calloc (1, sizeof * filedata);
20098   if (filedata == NULL)
20099     {
20100       error (_("Out of memory allocating file data structure\n"));
20101       return FALSE;
20102     }
20103
20104   filedata->file_name = file_name;
20105   filedata->handle = fopen (file_name, "rb");
20106   if (filedata->handle == NULL)
20107     {
20108       error (_("Input file '%s' is not readable.\n"), file_name);
20109       free (filedata);
20110       return FALSE;
20111     }
20112
20113   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
20114     {
20115       error (_("%s: Failed to read file's magic number\n"), file_name);
20116       fclose (filedata->handle);
20117       free (filedata);
20118       return FALSE;
20119     }
20120
20121   filedata->file_size = (bfd_size_type) statbuf.st_size;
20122
20123   if (memcmp (armag, ARMAG, SARMAG) == 0)
20124     {
20125       if (! process_archive (filedata, FALSE))
20126         ret = FALSE;
20127     }
20128   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
20129     {
20130       if ( ! process_archive (filedata, TRUE))
20131         ret = FALSE;
20132     }
20133   else
20134     {
20135       if (do_archive_index)
20136         error (_("File %s is not an archive so its index cannot be displayed.\n"),
20137                file_name);
20138
20139       rewind (filedata->handle);
20140       archive_file_size = archive_file_offset = 0;
20141
20142       if (! process_object (filedata))
20143         ret = FALSE;
20144     }
20145
20146   fclose (filedata->handle);
20147   free (filedata);
20148
20149   return ret;
20150 }
20151
20152 #ifdef SUPPORT_DISASSEMBLY
20153 /* Needed by the i386 disassembler.  For extra credit, someone could
20154    fix this so that we insert symbolic addresses here, esp for GOT/PLT
20155    symbols.  */
20156
20157 void
20158 print_address (unsigned int addr, FILE * outfile)
20159 {
20160   fprintf (outfile,"0x%8.8x", addr);
20161 }
20162
20163 /* Needed by the i386 disassembler.  */
20164
20165 void
20166 db_task_printsym (unsigned int addr)
20167 {
20168   print_address (addr, stderr);
20169 }
20170 #endif
20171
20172 int
20173 main (int argc, char ** argv)
20174 {
20175   int err;
20176
20177 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20178   setlocale (LC_MESSAGES, "");
20179 #endif
20180 #if defined (HAVE_SETLOCALE)
20181   setlocale (LC_CTYPE, "");
20182 #endif
20183   bindtextdomain (PACKAGE, LOCALEDIR);
20184   textdomain (PACKAGE);
20185
20186   expandargv (&argc, &argv);
20187
20188   cmdline.file_name = "<cmdline>";
20189   parse_args (& cmdline, argc, argv);
20190
20191   if (optind < (argc - 1))
20192     show_name = TRUE;
20193   else if (optind >= argc)
20194     {
20195       warn (_("Nothing to do.\n"));
20196       usage (stderr);
20197     }
20198
20199   err = FALSE;
20200   while (optind < argc)
20201     if (! process_file (argv[optind++]))
20202       err = TRUE;
20203
20204   if (cmdline.dump_sects != NULL)
20205     free (cmdline.dump_sects);
20206
20207 #ifdef HAVE_LIBCTF
20208   free (dump_ctf_symtab_name);
20209   free (dump_ctf_strtab_name);
20210   free (dump_ctf_parent_name);
20211 #endif
20212
20213   return err ? EXIT_FAILURE : EXIT_SUCCESS;
20214 }