binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2020 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <[email protected]>
   5    Modifications by Nick Clifton <[email protected]>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #include <zlib.h>
  47 #ifdef HAVE_WCHAR_H
  48 #include <wchar.h>
  49 #endif
  50
  51 #if __GNUC__ >= 2
  52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  53    as this will allow us to read in and parse 64bit and 32bit ELF files.
  54    Only do this if we believe that the compiler can support a 64 bit
  55    data type.  For now we only rely on GCC being able to do this.  */
  56 #define BFD64
  57 #endif
  58
  59 #include "bfd.h"
  60 #include "bucomm.h"
  61 #include "elfcomm.h"
  62 #include "dwarf.h"
  63 #include "ctf-api.h"
  64
  65 #include "elf/common.h"
  66 #include "elf/external.h"
  67 #include "elf/internal.h"
  68
  69
  70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  71    we can obtain the H8 reloc numbers.  We need these for the
  72    get_reloc_size() function.  We include h8.h again after defining
  73    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  74
  75 #include "elf/h8.h"
  76 #undef _ELF_H8_H
  77
  78 /* Undo the effects of #including reloc-macros.h.  */
  79
  80 #undef START_RELOC_NUMBERS
  81 #undef RELOC_NUMBER
  82 #undef FAKE_RELOC
  83 #undef EMPTY_RELOC
  84 #undef END_RELOC_NUMBERS
  85 #undef _RELOC_MACROS_H
  86
  87 /* The following headers use the elf/reloc-macros.h file to
  88    automatically generate relocation recognition functions
  89    such as elf_mips_reloc_type()  */
  90
  91 #define RELOC_MACROS_GEN_FUNC
  92
  93 #include "elf/aarch64.h"
  94 #include "elf/alpha.h"
  95 #include "elf/arc.h"
  96 #include "elf/arm.h"
  97 #include "elf/avr.h"
  98 #include "elf/bfin.h"
  99 #include "elf/cr16.h"
 100 #include "elf/cris.h"
 101 #include "elf/crx.h"
 102 #include "elf/csky.h"
 103 #include "elf/d10v.h"
 104 #include "elf/d30v.h"
 105 #include "elf/dlx.h"
 106 #include "elf/bpf.h"
 107 #include "elf/epiphany.h"
 108 #include "elf/fr30.h"
 109 #include "elf/frv.h"
 110 #include "elf/ft32.h"
 111 #include "elf/h8.h"
 112 #include "elf/hppa.h"
 113 #include "elf/i386.h"
 114 #include "elf/i370.h"
 115 #include "elf/i860.h"
 116 #include "elf/i960.h"
 117 #include "elf/ia64.h"
 118 #include "elf/ip2k.h"
 119 #include "elf/lm32.h"
 120 #include "elf/iq2000.h"
 121 #include "elf/m32c.h"
 122 #include "elf/m32r.h"
 123 #include "elf/m68k.h"
 124 #include "elf/m68hc11.h"
 125 #include "elf/s12z.h"
 126 #include "elf/mcore.h"
 127 #include "elf/mep.h"
 128 #include "elf/metag.h"
 129 #include "elf/microblaze.h"
 130 #include "elf/mips.h"
 131 #include "elf/mmix.h"
 132 #include "elf/mn10200.h"
 133 #include "elf/mn10300.h"
 134 #include "elf/moxie.h"
 135 #include "elf/mt.h"
 136 #include "elf/msp430.h"
 137 #include "elf/nds32.h"
 138 #include "elf/nfp.h"
 139 #include "elf/nios2.h"
 140 #include "elf/or1k.h"
 141 #include "elf/pj.h"
 142 #include "elf/ppc.h"
 143 #include "elf/ppc64.h"
 144 #include "elf/pru.h"
 145 #include "elf/riscv.h"
 146 #include "elf/rl78.h"
 147 #include "elf/rx.h"
 148 #include "elf/s390.h"
 149 #include "elf/score.h"
 150 #include "elf/sh.h"
 151 #include "elf/sparc.h"
 152 #include "elf/spu.h"
 153 #include "elf/tic6x.h"
 154 #include "elf/tilegx.h"
 155 #include "elf/tilepro.h"
 156 #include "elf/v850.h"
 157 #include "elf/vax.h"
 158 #include "elf/visium.h"
 159 #include "elf/wasm32.h"
 160 #include "elf/x86-64.h"
 161 #include "elf/xc16x.h"
 162 #include "elf/xgate.h"
 163 #include "elf/xstormy16.h"
 164 #include "elf/xtensa.h"
 165 #include "elf/z80.h"
 166
 167 #include "getopt.h"
 168 #include "libiberty.h"
 169 #include "safe-ctype.h"
 170 #include "filenames.h"
 171
 172 #ifndef offsetof
 173 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 174 #endif
 175
 176 typedef struct elf_section_list
 177 {
 178   Elf_Internal_Shdr *        hdr;
 179   struct elf_section_list *  next;
 180 } elf_section_list;
 181
 182 /* Flag bits indicating particular types of dump.  */
 183 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 184 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 185 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 186 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 187 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 188 #define CTF_DUMP        (1 << 5)        /* The --ctf command line switch.  */
 189
 190 typedef unsigned char dump_type;
 191
 192 /* A linked list of the section names for which dumps were requested.  */
 193 struct dump_list_entry
 194 {
 195   char *                    name;
 196   dump_type                 type;
 197   struct dump_list_entry *  next;
 198 };
 199
 200 /* A dynamic array of flags indicating for which sections a dump
 201    has been requested via command line switches.  */
 202 struct dump_data
 203 {
 204   dump_type *          dump_sects;
 205   unsigned int         num_dump_sects;
 206 };
 207
 208 static struct dump_data cmdline;
 209
 210 static struct dump_list_entry * dump_sects_byname;
 211
 212 char * program_name = "readelf";
 213
 214 static bfd_boolean show_name = FALSE;
 215 static bfd_boolean do_dynamic = FALSE;
 216 static bfd_boolean do_syms = FALSE;
 217 static bfd_boolean do_dyn_syms = FALSE;
 218 static bfd_boolean do_reloc = FALSE;
 219 static bfd_boolean do_sections = FALSE;
 220 static bfd_boolean do_section_groups = FALSE;
 221 static bfd_boolean do_section_details = FALSE;
 222 static bfd_boolean do_segments = FALSE;
 223 static bfd_boolean do_unwind = FALSE;
 224 static bfd_boolean do_using_dynamic = FALSE;
 225 static bfd_boolean do_header = FALSE;
 226 static bfd_boolean do_dump = FALSE;
 227 static bfd_boolean do_version = FALSE;
 228 static bfd_boolean do_histogram = FALSE;
 229 static bfd_boolean do_debugging = FALSE;
 230 static bfd_boolean do_ctf = FALSE;
 231 static bfd_boolean do_arch = FALSE;
 232 static bfd_boolean do_notes = FALSE;
 233 static bfd_boolean do_archive_index = FALSE;
 234 static bfd_boolean check_all = FALSE;
 235 static bfd_boolean is_32bit_elf = FALSE;
 236 static bfd_boolean decompress_dumps = FALSE;
 237
 238 static char *dump_ctf_parent_name;
 239 static char *dump_ctf_symtab_name;
 240 static char *dump_ctf_strtab_name;
 241
 242 struct group_list
 243 {
 244   struct group_list *  next;
 245   unsigned int         section_index;
 246 };
 247
 248 struct group
 249 {
 250   struct group_list *  root;
 251   unsigned int         group_index;
 252 };
 253
 254 typedef struct filedata
 255 {
 256   const char *         file_name;
 257   FILE *               handle;
 258   bfd_size_type        file_size;
 259   Elf_Internal_Ehdr    file_header;
 260   Elf_Internal_Shdr *  section_headers;
 261   Elf_Internal_Phdr *  program_headers;
 262   char *               string_table;
 263   unsigned long        string_table_length;
 264   unsigned long        archive_file_offset;
 265   unsigned long        archive_file_size;
 266   unsigned long        dynamic_addr;
 267   bfd_size_type        dynamic_size;
 268   size_t               dynamic_nent;
 269   Elf_Internal_Dyn *   dynamic_section;
 270   Elf_Internal_Shdr *  dynamic_strtab_section;
 271   char *               dynamic_strings;
 272   unsigned long        dynamic_strings_length;
 273   Elf_Internal_Shdr *  dynamic_symtab_section;
 274   unsigned long        num_dynamic_syms;
 275   Elf_Internal_Sym *   dynamic_symbols;
 276   bfd_vma              version_info[16];
 277   unsigned int         dynamic_syminfo_nent;
 278   Elf_Internal_Syminfo * dynamic_syminfo;
 279   unsigned long        dynamic_syminfo_offset;
 280   bfd_size_type        nbuckets;
 281   bfd_size_type        nchains;
 282   bfd_vma *            buckets;
 283   bfd_vma *            chains;
 284   bfd_size_type        ngnubuckets;
 285   bfd_size_type        ngnuchains;
 286   bfd_vma *            gnubuckets;
 287   bfd_vma *            gnuchains;
 288   bfd_vma *            mipsxlat;
 289   bfd_vma              gnusymidx;
 290   char                 program_interpreter[PATH_MAX];
 291   bfd_vma              dynamic_info[DT_ENCODING];
 292   bfd_vma              dynamic_info_DT_GNU_HASH;
 293   bfd_vma              dynamic_info_DT_MIPS_XHASH;
 294   elf_section_list *   symtab_shndx_list;
 295   size_t               group_count;
 296   struct group *       section_groups;
 297   struct group **      section_headers_groups;
 298   /* A dynamic array of flags indicating for which sections a dump of
 299      some kind has been requested.  It is reset on a per-object file
 300      basis and then initialised from the cmdline_dump_sects array,
 301      the results of interpreting the -w switch, and the
 302      dump_sects_byname list.  */
 303   struct dump_data     dump;
 304 } Filedata;
 305
 306 /* How to print a vma value.  */
 307 typedef enum print_mode
 308 {
 309   HEX,
 310   DEC,
 311   DEC_5,
 312   UNSIGNED,
 313   PREFIX_HEX,
 314   FULL_HEX,
 315   LONG_HEX
 316 }
 317 print_mode;
 318
 319 /* Versioned symbol info.  */
 320 enum versioned_symbol_info
 321 {
 322   symbol_undefined,
 323   symbol_hidden,
 324   symbol_public
 325 };
 326
 327 static const char * get_symbol_version_string
 328   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 329    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 330
 331 #define UNKNOWN -1
 332
 333 #define SECTION_NAME(X)                                         \
 334   ((X) == NULL ? _("<none>")                                    \
 335    : filedata->string_table == NULL ? _("<no-strings>")         \
 336    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 337   : filedata->string_table + (X)->sh_name))
 338
 339 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 340
 341 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 342   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 343    : get_64bit_elf_symbols (file, section, sym_count))
 344
 345 #define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
 346    (strtab != NULL && offset < strtab_size)
 347 #define VALID_DYNAMIC_NAME(filedata, offset) \
 348   VALID_SYMBOL_NAME (filedata->dynamic_strings, \
 349                      filedata->dynamic_strings_length, offset)
 350 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 351    already been called and verified that the string exists.  */
 352 #define GET_DYNAMIC_NAME(filedata, offset) \
 353   (filedata->dynamic_strings + offset)
 354
 355 #define REMOVE_ARCH_BITS(ADDR)                  \
 356   do                                            \
 357     {                                           \
 358       if (filedata->file_header.e_machine == EM_ARM)    \
 359         (ADDR) &= ~1;                           \
 360     }                                           \
 361   while (0)
 362
 363 /* Get the correct GNU hash section name.  */
 364 #define GNU_HASH_SECTION_NAME(filedata)         \
 365   filedata->dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
 366 \f
 367 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 368    BFD_FMA_FMT can't be used in translated strings.  */
 369
 370 static const char *
 371 bfd_vmatoa (char *fmtch, bfd_vma value)
 372 {
 373   /* bfd_vmatoa is used more then once in a printf call for output.
 374      Cycle through an array of buffers.  */
 375   static int buf_pos = 0;
 376   static struct bfd_vmatoa_buf
 377   {
 378     char place[64];
 379   } buf[4];
 380   char *ret;
 381   char fmt[32];
 382
 383   ret = buf[buf_pos++].place;
 384   buf_pos %= ARRAY_SIZE (buf);
 385
 386   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 387   snprintf (ret, sizeof (buf[0].place), fmt, value);
 388   return ret;
 389 }
 390
 391 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 392    OFFSET + the offset of the current archive member, if we are examining an
 393    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 394    allocate a buffer using malloc and fill that.  In either case return the
 395    pointer to the start of the retrieved data or NULL if something went wrong.
 396    If something does go wrong and REASON is not NULL then emit an error
 397    message using REASON as part of the context.  */
 398
 399 static void *
 400 get_data (void *         var,
 401           Filedata *     filedata,
 402           unsigned long  offset,
 403           bfd_size_type  size,
 404           bfd_size_type  nmemb,
 405           const char *   reason)
 406 {
 407   void * mvar;
 408   bfd_size_type amt = size * nmemb;
 409
 410   if (size == 0 || nmemb == 0)
 411     return NULL;
 412
 413   /* If the size_t type is smaller than the bfd_size_type, eg because
 414      you are building a 32-bit tool on a 64-bit host, then make sure
 415      that when the sizes are cast to (size_t) no information is lost.  */
 416   if ((size_t) size != size
 417       || (size_t) nmemb != nmemb
 418       || (size_t) amt != amt)
 419     {
 420       if (reason)
 421         error (_("Size truncation prevents reading %s"
 422                  " elements of size %s for %s\n"),
 423                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 424       return NULL;
 425     }
 426
 427   /* Check for size overflow.  */
 428   if (amt / size != nmemb || (size_t) amt + 1 == 0)
 429     {
 430       if (reason)
 431         error (_("Size overflow prevents reading %s"
 432                  " elements of size %s for %s\n"),
 433                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 434       return NULL;
 435     }
 436
 437   /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
 438      attempting to allocate memory when the read is bound to fail.  */
 439   if (filedata->archive_file_offset > filedata->file_size
 440       || offset > filedata->file_size - filedata->archive_file_offset
 441       || amt > filedata->file_size - filedata->archive_file_offset - offset)
 442     {
 443       if (reason)
 444         error (_("Reading %s bytes extends past end of file for %s\n"),
 445                bfd_vmatoa ("u", amt), reason);
 446       return NULL;
 447     }
 448
 449   if (fseek (filedata->handle, filedata->archive_file_offset + offset,
 450              SEEK_SET))
 451     {
 452       if (reason)
 453         error (_("Unable to seek to 0x%lx for %s\n"),
 454                filedata->archive_file_offset + offset, reason);
 455       return NULL;
 456     }
 457
 458   mvar = var;
 459   if (mvar == NULL)
 460     {
 461       /* + 1 so that we can '\0' terminate invalid string table sections.  */
 462       mvar = malloc ((size_t) amt + 1);
 463
 464       if (mvar == NULL)
 465         {
 466           if (reason)
 467             error (_("Out of memory allocating %s bytes for %s\n"),
 468                    bfd_vmatoa ("u", amt), reason);
 469           return NULL;
 470         }
 471
 472       ((char *) mvar)[amt] = '\0';
 473     }
 474
 475   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 476     {
 477       if (reason)
 478         error (_("Unable to read in %s bytes of %s\n"),
 479                bfd_vmatoa ("u", amt), reason);
 480       if (mvar != var)
 481         free (mvar);
 482       return NULL;
 483     }
 484
 485   return mvar;
 486 }
 487
 488 /* Print a VMA value in the MODE specified.
 489    Returns the number of characters displayed.  */
 490
 491 static unsigned int
 492 print_vma (bfd_vma vma, print_mode mode)
 493 {
 494   unsigned int nc = 0;
 495
 496   switch (mode)
 497     {
 498     case FULL_HEX:
 499       nc = printf ("0x");
 500       /* Fall through.  */
 501     case LONG_HEX:
 502 #ifdef BFD64
 503       if (is_32bit_elf)
 504         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 505 #endif
 506       printf_vma (vma);
 507       return nc + 16;
 508
 509     case DEC_5:
 510       if (vma <= 99999)
 511         return printf ("%5" BFD_VMA_FMT "d", vma);
 512       /* Fall through.  */
 513     case PREFIX_HEX:
 514       nc = printf ("0x");
 515       /* Fall through.  */
 516     case HEX:
 517       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 518
 519     case DEC:
 520       return printf ("%" BFD_VMA_FMT "d", vma);
 521
 522     case UNSIGNED:
 523       return printf ("%" BFD_VMA_FMT "u", vma);
 524
 525     default:
 526       /* FIXME: Report unrecognised mode ?  */
 527       return 0;
 528     }
 529 }
 530
 531 /* Display a symbol on stdout.  Handles the display of control characters and
 532    multibye characters (assuming the host environment supports them).
 533
 534    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 535
 536    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 537    padding as necessary.
 538
 539    Returns the number of emitted characters.  */
 540
 541 static unsigned int
 542 print_symbol (signed int width, const char *symbol)
 543 {
 544   bfd_boolean extra_padding = FALSE;
 545   signed int num_printed = 0;
 546 #ifdef HAVE_MBSTATE_T
 547   mbstate_t state;
 548 #endif
 549   unsigned int width_remaining;
 550
 551   if (width < 0)
 552     {
 553       /* Keep the width positive.  This helps the code below.  */
 554       width = - width;
 555       extra_padding = TRUE;
 556     }
 557   else if (width == 0)
 558     return 0;
 559
 560   if (do_wide)
 561     /* Set the remaining width to a very large value.
 562        This simplifies the code below.  */
 563     width_remaining = INT_MAX;
 564   else
 565     width_remaining = width;
 566
 567 #ifdef HAVE_MBSTATE_T
 568   /* Initialise the multibyte conversion state.  */
 569   memset (& state, 0, sizeof (state));
 570 #endif
 571
 572   while (width_remaining)
 573     {
 574       size_t  n;
 575       const char c = *symbol++;
 576
 577       if (c == 0)
 578         break;
 579
 580       /* Do not print control characters directly as they can affect terminal
 581          settings.  Such characters usually appear in the names generated
 582          by the assembler for local labels.  */
 583       if (ISCNTRL (c))
 584         {
 585           if (width_remaining < 2)
 586             break;
 587
 588           printf ("^%c", c + 0x40);
 589           width_remaining -= 2;
 590           num_printed += 2;
 591         }
 592       else if (ISPRINT (c))
 593         {
 594           putchar (c);
 595           width_remaining --;
 596           num_printed ++;
 597         }
 598       else
 599         {
 600 #ifdef HAVE_MBSTATE_T
 601           wchar_t w;
 602 #endif
 603           /* Let printf do the hard work of displaying multibyte characters.  */
 604           printf ("%.1s", symbol - 1);
 605           width_remaining --;
 606           num_printed ++;
 607
 608 #ifdef HAVE_MBSTATE_T
 609           /* Try to find out how many bytes made up the character that was
 610              just printed.  Advance the symbol pointer past the bytes that
 611              were displayed.  */
 612           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 613 #else
 614           n = 1;
 615 #endif
 616           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 617             symbol += (n - 1);
 618         }
 619     }
 620
 621   if (extra_padding && num_printed < width)
 622     {
 623       /* Fill in the remaining spaces.  */
 624       printf ("%-*s", width - num_printed, " ");
 625       num_printed = width;
 626     }
 627
 628   return num_printed;
 629 }
 630
 631 /* Returns a pointer to a static buffer containing a printable version of
 632    the given section's name.  Like print_symbol, except that it does not try
 633    to print multibyte characters, it just interprets them as hex values.  */
 634
 635 static const char *
 636 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 637 {
 638 #define MAX_PRINT_SEC_NAME_LEN 128
 639   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 640   const char * name = SECTION_NAME (sec);
 641   char *       buf = sec_name_buf;
 642   char         c;
 643   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 644
 645   while ((c = * name ++) != 0)
 646     {
 647       if (ISCNTRL (c))
 648         {
 649           if (remaining < 2)
 650             break;
 651
 652           * buf ++ = '^';
 653           * buf ++ = c + 0x40;
 654           remaining -= 2;
 655         }
 656       else if (ISPRINT (c))
 657         {
 658           * buf ++ = c;
 659           remaining -= 1;
 660         }
 661       else
 662         {
 663           static char hex[17] = "0123456789ABCDEF";
 664
 665           if (remaining < 4)
 666             break;
 667           * buf ++ = '<';
 668           * buf ++ = hex[(c & 0xf0) >> 4];
 669           * buf ++ = hex[c & 0x0f];
 670           * buf ++ = '>';
 671           remaining -= 4;
 672         }
 673
 674       if (remaining == 0)
 675         break;
 676     }
 677
 678   * buf = 0;
 679   return sec_name_buf;
 680 }
 681
 682 static const char *
 683 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 684 {
 685   if (ndx >= filedata->file_header.e_shnum)
 686     return _("<corrupt>");
 687
 688   return printable_section_name (filedata, filedata->section_headers + ndx);
 689 }
 690
 691 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 692
 693 static Elf_Internal_Shdr *
 694 find_section (Filedata * filedata, const char * name)
 695 {
 696   unsigned int i;
 697
 698   if (filedata->section_headers == NULL)
 699     return NULL;
 700
 701   for (i = 0; i < filedata->file_header.e_shnum; i++)
 702     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 703       return filedata->section_headers + i;
 704
 705   return NULL;
 706 }
 707
 708 /* Return a pointer to a section containing ADDR, or NULL if no such
 709    section exists.  */
 710
 711 static Elf_Internal_Shdr *
 712 find_section_by_address (Filedata * filedata, bfd_vma addr)
 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 (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 724         return sec;
 725     }
 726
 727   return NULL;
 728 }
 729
 730 static Elf_Internal_Shdr *
 731 find_section_by_type (Filedata * filedata, unsigned int type)
 732 {
 733   unsigned int i;
 734
 735   if (filedata->section_headers == NULL)
 736     return NULL;
 737
 738   for (i = 0; i < filedata->file_header.e_shnum; i++)
 739     {
 740       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 741
 742       if (sec->sh_type == type)
 743         return sec;
 744     }
 745
 746   return NULL;
 747 }
 748
 749 /* Return a pointer to section NAME, or NULL if no such section exists,
 750    restricted to the list of sections given in SET.  */
 751
 752 static Elf_Internal_Shdr *
 753 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 754 {
 755   unsigned int i;
 756
 757   if (filedata->section_headers == NULL)
 758     return NULL;
 759
 760   if (set != NULL)
 761     {
 762       while ((i = *set++) > 0)
 763         {
 764           /* See PR 21156 for a reproducer.  */
 765           if (i >= filedata->file_header.e_shnum)
 766             continue; /* FIXME: Should we issue an error message ?  */
 767
 768           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 769             return filedata->section_headers + i;
 770         }
 771     }
 772
 773   return find_section (filedata, name);
 774 }
 775
 776 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 777    This OS has so many departures from the ELF standard that we test it at
 778    many places.  */
 779
 780 static inline bfd_boolean
 781 is_ia64_vms (Filedata * filedata)
 782 {
 783   return filedata->file_header.e_machine == EM_IA_64
 784     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 785 }
 786
 787 /* Guess the relocation size commonly used by the specific machines.  */
 788
 789 static bfd_boolean
 790 guess_is_rela (unsigned int e_machine)
 791 {
 792   switch (e_machine)
 793     {
 794       /* Targets that use REL relocations.  */
 795     case EM_386:
 796     case EM_IAMCU:
 797     case EM_960:
 798     case EM_ARM:
 799     case EM_D10V:
 800     case EM_CYGNUS_D10V:
 801     case EM_DLX:
 802     case EM_MIPS:
 803     case EM_MIPS_RS3_LE:
 804     case EM_CYGNUS_M32R:
 805     case EM_SCORE:
 806     case EM_XGATE:
 807     case EM_NFP:
 808     case EM_BPF:
 809       return FALSE;
 810
 811       /* Targets that use RELA relocations.  */
 812     case EM_68K:
 813     case EM_860:
 814     case EM_AARCH64:
 815     case EM_ADAPTEVA_EPIPHANY:
 816     case EM_ALPHA:
 817     case EM_ALTERA_NIOS2:
 818     case EM_ARC:
 819     case EM_ARC_COMPACT:
 820     case EM_ARC_COMPACT2:
 821     case EM_AVR:
 822     case EM_AVR_OLD:
 823     case EM_BLACKFIN:
 824     case EM_CR16:
 825     case EM_CRIS:
 826     case EM_CRX:
 827     case EM_CSKY:
 828     case EM_D30V:
 829     case EM_CYGNUS_D30V:
 830     case EM_FR30:
 831     case EM_FT32:
 832     case EM_CYGNUS_FR30:
 833     case EM_CYGNUS_FRV:
 834     case EM_H8S:
 835     case EM_H8_300:
 836     case EM_H8_300H:
 837     case EM_IA_64:
 838     case EM_IP2K:
 839     case EM_IP2K_OLD:
 840     case EM_IQ2000:
 841     case EM_LATTICEMICO32:
 842     case EM_M32C_OLD:
 843     case EM_M32C:
 844     case EM_M32R:
 845     case EM_MCORE:
 846     case EM_CYGNUS_MEP:
 847     case EM_METAG:
 848     case EM_MMIX:
 849     case EM_MN10200:
 850     case EM_CYGNUS_MN10200:
 851     case EM_MN10300:
 852     case EM_CYGNUS_MN10300:
 853     case EM_MOXIE:
 854     case EM_MSP430:
 855     case EM_MSP430_OLD:
 856     case EM_MT:
 857     case EM_NDS32:
 858     case EM_NIOS32:
 859     case EM_OR1K:
 860     case EM_PPC64:
 861     case EM_PPC:
 862     case EM_TI_PRU:
 863     case EM_RISCV:
 864     case EM_RL78:
 865     case EM_RX:
 866     case EM_S390:
 867     case EM_S390_OLD:
 868     case EM_SH:
 869     case EM_SPARC:
 870     case EM_SPARC32PLUS:
 871     case EM_SPARCV9:
 872     case EM_SPU:
 873     case EM_TI_C6000:
 874     case EM_TILEGX:
 875     case EM_TILEPRO:
 876     case EM_V800:
 877     case EM_V850:
 878     case EM_CYGNUS_V850:
 879     case EM_VAX:
 880     case EM_VISIUM:
 881     case EM_X86_64:
 882     case EM_L1OM:
 883     case EM_K1OM:
 884     case EM_XSTORMY16:
 885     case EM_XTENSA:
 886     case EM_XTENSA_OLD:
 887     case EM_MICROBLAZE:
 888     case EM_MICROBLAZE_OLD:
 889     case EM_WEBASSEMBLY:
 890       return TRUE;
 891
 892     case EM_68HC05:
 893     case EM_68HC08:
 894     case EM_68HC11:
 895     case EM_68HC16:
 896     case EM_FX66:
 897     case EM_ME16:
 898     case EM_MMA:
 899     case EM_NCPU:
 900     case EM_NDR1:
 901     case EM_PCP:
 902     case EM_ST100:
 903     case EM_ST19:
 904     case EM_ST7:
 905     case EM_ST9PLUS:
 906     case EM_STARCORE:
 907     case EM_SVX:
 908     case EM_TINYJ:
 909     default:
 910       warn (_("Don't know about relocations on this machine architecture\n"));
 911       return FALSE;
 912     }
 913 }
 914
 915 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 916    Returns TRUE upon success, FALSE otherwise.  If successful then a
 917    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 918    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 919    responsibility to free the allocated buffer.  */
 920
 921 static bfd_boolean
 922 slurp_rela_relocs (Filedata *            filedata,
 923                    unsigned long         rel_offset,
 924                    unsigned long         rel_size,
 925                    Elf_Internal_Rela **  relasp,
 926                    unsigned long *       nrelasp)
 927 {
 928   Elf_Internal_Rela * relas;
 929   size_t nrelas;
 930   unsigned int i;
 931
 932   if (is_32bit_elf)
 933     {
 934       Elf32_External_Rela * erelas;
 935
 936       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 937                                                  rel_size, _("32-bit relocation data"));
 938       if (!erelas)
 939         return FALSE;
 940
 941       nrelas = rel_size / sizeof (Elf32_External_Rela);
 942
 943       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 944                                              sizeof (Elf_Internal_Rela));
 945
 946       if (relas == NULL)
 947         {
 948           free (erelas);
 949           error (_("out of memory parsing relocs\n"));
 950           return FALSE;
 951         }
 952
 953       for (i = 0; i < nrelas; i++)
 954         {
 955           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 956           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 957           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 958         }
 959
 960       free (erelas);
 961     }
 962   else
 963     {
 964       Elf64_External_Rela * erelas;
 965
 966       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 967                                                  rel_size, _("64-bit relocation data"));
 968       if (!erelas)
 969         return FALSE;
 970
 971       nrelas = rel_size / sizeof (Elf64_External_Rela);
 972
 973       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 974                                              sizeof (Elf_Internal_Rela));
 975
 976       if (relas == NULL)
 977         {
 978           free (erelas);
 979           error (_("out of memory parsing relocs\n"));
 980           return FALSE;
 981         }
 982
 983       for (i = 0; i < nrelas; i++)
 984         {
 985           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 986           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 987           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 988
 989           /* The #ifdef BFD64 below is to prevent a compile time
 990              warning.  We know that if we do not have a 64 bit data
 991              type that we will never execute this code anyway.  */
 992 #ifdef BFD64
 993           if (filedata->file_header.e_machine == EM_MIPS
 994               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 995             {
 996               /* In little-endian objects, r_info isn't really a
 997                  64-bit little-endian value: it has a 32-bit
 998                  little-endian symbol index followed by four
 999                  individual byte fields.  Reorder INFO
1000                  accordingly.  */
1001               bfd_vma inf = relas[i].r_info;
1002               inf = (((inf & 0xffffffff) << 32)
1003                       | ((inf >> 56) & 0xff)
1004                       | ((inf >> 40) & 0xff00)
1005                       | ((inf >> 24) & 0xff0000)
1006                       | ((inf >> 8) & 0xff000000));
1007               relas[i].r_info = inf;
1008             }
1009 #endif /* BFD64 */
1010         }
1011
1012       free (erelas);
1013     }
1014
1015   *relasp = relas;
1016   *nrelasp = nrelas;
1017   return TRUE;
1018 }
1019
1020 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1021    Returns TRUE upon success, FALSE otherwise.  If successful then a
1022    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1023    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
1024    responsibility to free the allocated buffer.  */
1025
1026 static bfd_boolean
1027 slurp_rel_relocs (Filedata *            filedata,
1028                   unsigned long         rel_offset,
1029                   unsigned long         rel_size,
1030                   Elf_Internal_Rela **  relsp,
1031                   unsigned long *       nrelsp)
1032 {
1033   Elf_Internal_Rela * rels;
1034   size_t nrels;
1035   unsigned int i;
1036
1037   if (is_32bit_elf)
1038     {
1039       Elf32_External_Rel * erels;
1040
1041       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1042                                                rel_size, _("32-bit relocation data"));
1043       if (!erels)
1044         return FALSE;
1045
1046       nrels = rel_size / sizeof (Elf32_External_Rel);
1047
1048       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1049
1050       if (rels == NULL)
1051         {
1052           free (erels);
1053           error (_("out of memory parsing relocs\n"));
1054           return FALSE;
1055         }
1056
1057       for (i = 0; i < nrels; i++)
1058         {
1059           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1060           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1061           rels[i].r_addend = 0;
1062         }
1063
1064       free (erels);
1065     }
1066   else
1067     {
1068       Elf64_External_Rel * erels;
1069
1070       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1071                                                rel_size, _("64-bit relocation data"));
1072       if (!erels)
1073         return FALSE;
1074
1075       nrels = rel_size / sizeof (Elf64_External_Rel);
1076
1077       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1078
1079       if (rels == NULL)
1080         {
1081           free (erels);
1082           error (_("out of memory parsing relocs\n"));
1083           return FALSE;
1084         }
1085
1086       for (i = 0; i < nrels; i++)
1087         {
1088           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1089           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1090           rels[i].r_addend = 0;
1091
1092           /* The #ifdef BFD64 below is to prevent a compile time
1093              warning.  We know that if we do not have a 64 bit data
1094              type that we will never execute this code anyway.  */
1095 #ifdef BFD64
1096           if (filedata->file_header.e_machine == EM_MIPS
1097               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1098             {
1099               /* In little-endian objects, r_info isn't really a
1100                  64-bit little-endian value: it has a 32-bit
1101                  little-endian symbol index followed by four
1102                  individual byte fields.  Reorder INFO
1103                  accordingly.  */
1104               bfd_vma inf = rels[i].r_info;
1105               inf = (((inf & 0xffffffff) << 32)
1106                      | ((inf >> 56) & 0xff)
1107                      | ((inf >> 40) & 0xff00)
1108                      | ((inf >> 24) & 0xff0000)
1109                      | ((inf >> 8) & 0xff000000));
1110               rels[i].r_info = inf;
1111             }
1112 #endif /* BFD64 */
1113         }
1114
1115       free (erels);
1116     }
1117
1118   *relsp = rels;
1119   *nrelsp = nrels;
1120   return TRUE;
1121 }
1122
1123 /* Returns the reloc type extracted from the reloc info field.  */
1124
1125 static unsigned int
1126 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1127 {
1128   if (is_32bit_elf)
1129     return ELF32_R_TYPE (reloc_info);
1130
1131   switch (filedata->file_header.e_machine)
1132     {
1133     case EM_MIPS:
1134       /* Note: We assume that reloc_info has already been adjusted for us.  */
1135       return ELF64_MIPS_R_TYPE (reloc_info);
1136
1137     case EM_SPARCV9:
1138       return ELF64_R_TYPE_ID (reloc_info);
1139
1140     default:
1141       return ELF64_R_TYPE (reloc_info);
1142     }
1143 }
1144
1145 /* Return the symbol index extracted from the reloc info field.  */
1146
1147 static bfd_vma
1148 get_reloc_symindex (bfd_vma reloc_info)
1149 {
1150   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1151 }
1152
1153 static inline bfd_boolean
1154 uses_msp430x_relocs (Filedata * filedata)
1155 {
1156   return
1157     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1158     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1159     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1160         /* TI compiler uses ELFOSABI_NONE.  */
1161         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1162 }
1163
1164 /* Display the contents of the relocation data found at the specified
1165    offset.  */
1166
1167 static bfd_boolean
1168 dump_relocations (Filedata *          filedata,
1169                   unsigned long       rel_offset,
1170                   unsigned long       rel_size,
1171                   Elf_Internal_Sym *  symtab,
1172                   unsigned long       nsyms,
1173                   char *              strtab,
1174                   unsigned long       strtablen,
1175                   int                 is_rela,
1176                   bfd_boolean         is_dynsym)
1177 {
1178   unsigned long i;
1179   Elf_Internal_Rela * rels;
1180   bfd_boolean res = TRUE;
1181
1182   if (is_rela == UNKNOWN)
1183     is_rela = guess_is_rela (filedata->file_header.e_machine);
1184
1185   if (is_rela)
1186     {
1187       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1188         return FALSE;
1189     }
1190   else
1191     {
1192       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1193         return FALSE;
1194     }
1195
1196   if (is_32bit_elf)
1197     {
1198       if (is_rela)
1199         {
1200           if (do_wide)
1201             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1202           else
1203             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1204         }
1205       else
1206         {
1207           if (do_wide)
1208             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1209           else
1210             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1211         }
1212     }
1213   else
1214     {
1215       if (is_rela)
1216         {
1217           if (do_wide)
1218             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1219           else
1220             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1221         }
1222       else
1223         {
1224           if (do_wide)
1225             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1226           else
1227             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1228         }
1229     }
1230
1231   for (i = 0; i < rel_size; i++)
1232     {
1233       const char * rtype;
1234       bfd_vma offset;
1235       bfd_vma inf;
1236       bfd_vma symtab_index;
1237       bfd_vma type;
1238
1239       offset = rels[i].r_offset;
1240       inf    = rels[i].r_info;
1241
1242       type = get_reloc_type (filedata, inf);
1243       symtab_index = get_reloc_symindex  (inf);
1244
1245       if (is_32bit_elf)
1246         {
1247           printf ("%8.8lx  %8.8lx ",
1248                   (unsigned long) offset & 0xffffffff,
1249                   (unsigned long) inf & 0xffffffff);
1250         }
1251       else
1252         {
1253 #if BFD_HOST_64BIT_LONG
1254           printf (do_wide
1255                   ? "%16.16lx  %16.16lx "
1256                   : "%12.12lx  %12.12lx ",
1257                   offset, inf);
1258 #elif BFD_HOST_64BIT_LONG_LONG
1259 #ifndef __MSVCRT__
1260           printf (do_wide
1261                   ? "%16.16llx  %16.16llx "
1262                   : "%12.12llx  %12.12llx ",
1263                   offset, inf);
1264 #else
1265           printf (do_wide
1266                   ? "%16.16I64x  %16.16I64x "
1267                   : "%12.12I64x  %12.12I64x ",
1268                   offset, inf);
1269 #endif
1270 #else
1271           printf (do_wide
1272                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1273                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1274                   _bfd_int64_high (offset),
1275                   _bfd_int64_low (offset),
1276                   _bfd_int64_high (inf),
1277                   _bfd_int64_low (inf));
1278 #endif
1279         }
1280
1281       switch (filedata->file_header.e_machine)
1282         {
1283         default:
1284           rtype = NULL;
1285           break;
1286
1287         case EM_AARCH64:
1288           rtype = elf_aarch64_reloc_type (type);
1289           break;
1290
1291         case EM_M32R:
1292         case EM_CYGNUS_M32R:
1293           rtype = elf_m32r_reloc_type (type);
1294           break;
1295
1296         case EM_386:
1297         case EM_IAMCU:
1298           rtype = elf_i386_reloc_type (type);
1299           break;
1300
1301         case EM_68HC11:
1302         case EM_68HC12:
1303           rtype = elf_m68hc11_reloc_type (type);
1304           break;
1305
1306         case EM_S12Z:
1307           rtype = elf_s12z_reloc_type (type);
1308           break;
1309
1310         case EM_68K:
1311           rtype = elf_m68k_reloc_type (type);
1312           break;
1313
1314         case EM_960:
1315           rtype = elf_i960_reloc_type (type);
1316           break;
1317
1318         case EM_AVR:
1319         case EM_AVR_OLD:
1320           rtype = elf_avr_reloc_type (type);
1321           break;
1322
1323         case EM_OLD_SPARCV9:
1324         case EM_SPARC32PLUS:
1325         case EM_SPARCV9:
1326         case EM_SPARC:
1327           rtype = elf_sparc_reloc_type (type);
1328           break;
1329
1330         case EM_SPU:
1331           rtype = elf_spu_reloc_type (type);
1332           break;
1333
1334         case EM_V800:
1335           rtype = v800_reloc_type (type);
1336           break;
1337         case EM_V850:
1338         case EM_CYGNUS_V850:
1339           rtype = v850_reloc_type (type);
1340           break;
1341
1342         case EM_D10V:
1343         case EM_CYGNUS_D10V:
1344           rtype = elf_d10v_reloc_type (type);
1345           break;
1346
1347         case EM_D30V:
1348         case EM_CYGNUS_D30V:
1349           rtype = elf_d30v_reloc_type (type);
1350           break;
1351
1352         case EM_DLX:
1353           rtype = elf_dlx_reloc_type (type);
1354           break;
1355
1356         case EM_SH:
1357           rtype = elf_sh_reloc_type (type);
1358           break;
1359
1360         case EM_MN10300:
1361         case EM_CYGNUS_MN10300:
1362           rtype = elf_mn10300_reloc_type (type);
1363           break;
1364
1365         case EM_MN10200:
1366         case EM_CYGNUS_MN10200:
1367           rtype = elf_mn10200_reloc_type (type);
1368           break;
1369
1370         case EM_FR30:
1371         case EM_CYGNUS_FR30:
1372           rtype = elf_fr30_reloc_type (type);
1373           break;
1374
1375         case EM_CYGNUS_FRV:
1376           rtype = elf_frv_reloc_type (type);
1377           break;
1378
1379         case EM_CSKY:
1380           rtype = elf_csky_reloc_type (type);
1381           break;
1382
1383         case EM_FT32:
1384           rtype = elf_ft32_reloc_type (type);
1385           break;
1386
1387         case EM_MCORE:
1388           rtype = elf_mcore_reloc_type (type);
1389           break;
1390
1391         case EM_MMIX:
1392           rtype = elf_mmix_reloc_type (type);
1393           break;
1394
1395         case EM_MOXIE:
1396           rtype = elf_moxie_reloc_type (type);
1397           break;
1398
1399         case EM_MSP430:
1400           if (uses_msp430x_relocs (filedata))
1401             {
1402               rtype = elf_msp430x_reloc_type (type);
1403               break;
1404             }
1405           /* Fall through.  */
1406         case EM_MSP430_OLD:
1407           rtype = elf_msp430_reloc_type (type);
1408           break;
1409
1410         case EM_NDS32:
1411           rtype = elf_nds32_reloc_type (type);
1412           break;
1413
1414         case EM_PPC:
1415           rtype = elf_ppc_reloc_type (type);
1416           break;
1417
1418         case EM_PPC64:
1419           rtype = elf_ppc64_reloc_type (type);
1420           break;
1421
1422         case EM_MIPS:
1423         case EM_MIPS_RS3_LE:
1424           rtype = elf_mips_reloc_type (type);
1425           break;
1426
1427         case EM_RISCV:
1428           rtype = elf_riscv_reloc_type (type);
1429           break;
1430
1431         case EM_ALPHA:
1432           rtype = elf_alpha_reloc_type (type);
1433           break;
1434
1435         case EM_ARM:
1436           rtype = elf_arm_reloc_type (type);
1437           break;
1438
1439         case EM_ARC:
1440         case EM_ARC_COMPACT:
1441         case EM_ARC_COMPACT2:
1442           rtype = elf_arc_reloc_type (type);
1443           break;
1444
1445         case EM_PARISC:
1446           rtype = elf_hppa_reloc_type (type);
1447           break;
1448
1449         case EM_H8_300:
1450         case EM_H8_300H:
1451         case EM_H8S:
1452           rtype = elf_h8_reloc_type (type);
1453           break;
1454
1455         case EM_OR1K:
1456           rtype = elf_or1k_reloc_type (type);
1457           break;
1458
1459         case EM_PJ:
1460         case EM_PJ_OLD:
1461           rtype = elf_pj_reloc_type (type);
1462           break;
1463         case EM_IA_64:
1464           rtype = elf_ia64_reloc_type (type);
1465           break;
1466
1467         case EM_CRIS:
1468           rtype = elf_cris_reloc_type (type);
1469           break;
1470
1471         case EM_860:
1472           rtype = elf_i860_reloc_type (type);
1473           break;
1474
1475         case EM_X86_64:
1476         case EM_L1OM:
1477         case EM_K1OM:
1478           rtype = elf_x86_64_reloc_type (type);
1479           break;
1480
1481         case EM_S370:
1482           rtype = i370_reloc_type (type);
1483           break;
1484
1485         case EM_S390_OLD:
1486         case EM_S390:
1487           rtype = elf_s390_reloc_type (type);
1488           break;
1489
1490         case EM_SCORE:
1491           rtype = elf_score_reloc_type (type);
1492           break;
1493
1494         case EM_XSTORMY16:
1495           rtype = elf_xstormy16_reloc_type (type);
1496           break;
1497
1498         case EM_CRX:
1499           rtype = elf_crx_reloc_type (type);
1500           break;
1501
1502         case EM_VAX:
1503           rtype = elf_vax_reloc_type (type);
1504           break;
1505
1506         case EM_VISIUM:
1507           rtype = elf_visium_reloc_type (type);
1508           break;
1509
1510         case EM_BPF:
1511           rtype = elf_bpf_reloc_type (type);
1512           break;
1513
1514         case EM_ADAPTEVA_EPIPHANY:
1515           rtype = elf_epiphany_reloc_type (type);
1516           break;
1517
1518         case EM_IP2K:
1519         case EM_IP2K_OLD:
1520           rtype = elf_ip2k_reloc_type (type);
1521           break;
1522
1523         case EM_IQ2000:
1524           rtype = elf_iq2000_reloc_type (type);
1525           break;
1526
1527         case EM_XTENSA_OLD:
1528         case EM_XTENSA:
1529           rtype = elf_xtensa_reloc_type (type);
1530           break;
1531
1532         case EM_LATTICEMICO32:
1533           rtype = elf_lm32_reloc_type (type);
1534           break;
1535
1536         case EM_M32C_OLD:
1537         case EM_M32C:
1538           rtype = elf_m32c_reloc_type (type);
1539           break;
1540
1541         case EM_MT:
1542           rtype = elf_mt_reloc_type (type);
1543           break;
1544
1545         case EM_BLACKFIN:
1546           rtype = elf_bfin_reloc_type (type);
1547           break;
1548
1549         case EM_CYGNUS_MEP:
1550           rtype = elf_mep_reloc_type (type);
1551           break;
1552
1553         case EM_CR16:
1554           rtype = elf_cr16_reloc_type (type);
1555           break;
1556
1557         case EM_MICROBLAZE:
1558         case EM_MICROBLAZE_OLD:
1559           rtype = elf_microblaze_reloc_type (type);
1560           break;
1561
1562         case EM_RL78:
1563           rtype = elf_rl78_reloc_type (type);
1564           break;
1565
1566         case EM_RX:
1567           rtype = elf_rx_reloc_type (type);
1568           break;
1569
1570         case EM_METAG:
1571           rtype = elf_metag_reloc_type (type);
1572           break;
1573
1574         case EM_XC16X:
1575         case EM_C166:
1576           rtype = elf_xc16x_reloc_type (type);
1577           break;
1578
1579         case EM_TI_C6000:
1580           rtype = elf_tic6x_reloc_type (type);
1581           break;
1582
1583         case EM_TILEGX:
1584           rtype = elf_tilegx_reloc_type (type);
1585           break;
1586
1587         case EM_TILEPRO:
1588           rtype = elf_tilepro_reloc_type (type);
1589           break;
1590
1591         case EM_WEBASSEMBLY:
1592           rtype = elf_wasm32_reloc_type (type);
1593           break;
1594
1595         case EM_XGATE:
1596           rtype = elf_xgate_reloc_type (type);
1597           break;
1598
1599         case EM_ALTERA_NIOS2:
1600           rtype = elf_nios2_reloc_type (type);
1601           break;
1602
1603         case EM_TI_PRU:
1604           rtype = elf_pru_reloc_type (type);
1605           break;
1606
1607         case EM_NFP:
1608           if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1609             rtype = elf_nfp3200_reloc_type (type);
1610           else
1611             rtype = elf_nfp_reloc_type (type);
1612           break;
1613
1614         case EM_Z80:
1615           rtype = elf_z80_reloc_type (type);
1616           break;
1617         }
1618
1619       if (rtype == NULL)
1620         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1621       else
1622         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1623
1624       if (filedata->file_header.e_machine == EM_ALPHA
1625           && rtype != NULL
1626           && streq (rtype, "R_ALPHA_LITUSE")
1627           && is_rela)
1628         {
1629           switch (rels[i].r_addend)
1630             {
1631             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1632             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1633             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1634             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1635             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1636             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1637             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1638             default: rtype = NULL;
1639             }
1640
1641           if (rtype)
1642             printf (" (%s)", rtype);
1643           else
1644             {
1645               putchar (' ');
1646               printf (_("<unknown addend: %lx>"),
1647                       (unsigned long) rels[i].r_addend);
1648               res = FALSE;
1649             }
1650         }
1651       else if (symtab_index)
1652         {
1653           if (symtab == NULL || symtab_index >= nsyms)
1654             {
1655               error (_(" bad symbol index: %08lx in reloc\n"),
1656                      (unsigned long) symtab_index);
1657               res = FALSE;
1658             }
1659           else
1660             {
1661               Elf_Internal_Sym * psym;
1662               const char * version_string;
1663               enum versioned_symbol_info sym_info;
1664               unsigned short vna_other;
1665
1666               psym = symtab + symtab_index;
1667
1668               version_string
1669                 = get_symbol_version_string (filedata, is_dynsym,
1670                                              strtab, strtablen,
1671                                              symtab_index,
1672                                              psym,
1673                                              &sym_info,
1674                                              &vna_other);
1675
1676               printf (" ");
1677
1678               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1679                 {
1680                   const char * name;
1681                   unsigned int len;
1682                   unsigned int width = is_32bit_elf ? 8 : 14;
1683
1684                   /* Relocations against GNU_IFUNC symbols do not use the value
1685                      of the symbol as the address to relocate against.  Instead
1686                      they invoke the function named by the symbol and use its
1687                      result as the address for relocation.
1688
1689                      To indicate this to the user, do not display the value of
1690                      the symbol in the "Symbols's Value" field.  Instead show
1691                      its name followed by () as a hint that the symbol is
1692                      invoked.  */
1693
1694                   if (strtab == NULL
1695                       || psym->st_name == 0
1696                       || psym->st_name >= strtablen)
1697                     name = "??";
1698                   else
1699                     name = strtab + psym->st_name;
1700
1701                   len = print_symbol (width, name);
1702                   if (version_string)
1703                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1704                             version_string);
1705                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1706                 }
1707               else
1708                 {
1709                   print_vma (psym->st_value, LONG_HEX);
1710
1711                   printf (is_32bit_elf ? "   " : " ");
1712                 }
1713
1714               if (psym->st_name == 0)
1715                 {
1716                   const char * sec_name = "<null>";
1717                   char name_buf[40];
1718
1719                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1720                     {
1721                       if (psym->st_shndx < filedata->file_header.e_shnum)
1722                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1723                       else if (psym->st_shndx == SHN_ABS)
1724                         sec_name = "ABS";
1725                       else if (psym->st_shndx == SHN_COMMON)
1726                         sec_name = "COMMON";
1727                       else if ((filedata->file_header.e_machine == EM_MIPS
1728                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1729                                || (filedata->file_header.e_machine == EM_TI_C6000
1730                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1731                         sec_name = "SCOMMON";
1732                       else if (filedata->file_header.e_machine == EM_MIPS
1733                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1734                         sec_name = "SUNDEF";
1735                       else if ((filedata->file_header.e_machine == EM_X86_64
1736                                 || filedata->file_header.e_machine == EM_L1OM
1737                                 || filedata->file_header.e_machine == EM_K1OM)
1738                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1739                         sec_name = "LARGE_COMMON";
1740                       else if (filedata->file_header.e_machine == EM_IA_64
1741                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1742                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1743                         sec_name = "ANSI_COM";
1744                       else if (is_ia64_vms (filedata)
1745                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1746                         sec_name = "VMS_SYMVEC";
1747                       else
1748                         {
1749                           sprintf (name_buf, "<section 0x%x>",
1750                                    (unsigned int) psym->st_shndx);
1751                           sec_name = name_buf;
1752                         }
1753                     }
1754                   print_symbol (22, sec_name);
1755                 }
1756               else if (strtab == NULL)
1757                 printf (_("<string table index: %3ld>"), psym->st_name);
1758               else if (psym->st_name >= strtablen)
1759                 {
1760                   error (_("<corrupt string table index: %3ld>\n"),
1761                          psym->st_name);
1762                   res = FALSE;
1763                 }
1764               else
1765                 {
1766                   print_symbol (22, strtab + psym->st_name);
1767                   if (version_string)
1768                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1769                             version_string);
1770                 }
1771
1772               if (is_rela)
1773                 {
1774                   bfd_vma off = rels[i].r_addend;
1775
1776                   if ((bfd_signed_vma) off < 0)
1777                     printf (" - %" BFD_VMA_FMT "x", - off);
1778                   else
1779                     printf (" + %" BFD_VMA_FMT "x", off);
1780                 }
1781             }
1782         }
1783       else if (is_rela)
1784         {
1785           bfd_vma off = rels[i].r_addend;
1786
1787           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1788           if ((bfd_signed_vma) off < 0)
1789             printf ("-%" BFD_VMA_FMT "x", - off);
1790           else
1791             printf ("%" BFD_VMA_FMT "x", off);
1792         }
1793
1794       if (filedata->file_header.e_machine == EM_SPARCV9
1795           && rtype != NULL
1796           && streq (rtype, "R_SPARC_OLO10"))
1797         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1798
1799       putchar ('\n');
1800
1801 #ifdef BFD64
1802       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1803         {
1804           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1805           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1806           const char * rtype2 = elf_mips_reloc_type (type2);
1807           const char * rtype3 = elf_mips_reloc_type (type3);
1808
1809           printf ("                    Type2: ");
1810
1811           if (rtype2 == NULL)
1812             printf (_("unrecognized: %-7lx"),
1813                     (unsigned long) type2 & 0xffffffff);
1814           else
1815             printf ("%-17.17s", rtype2);
1816
1817           printf ("\n                    Type3: ");
1818
1819           if (rtype3 == NULL)
1820             printf (_("unrecognized: %-7lx"),
1821                     (unsigned long) type3 & 0xffffffff);
1822           else
1823             printf ("%-17.17s", rtype3);
1824
1825           putchar ('\n');
1826         }
1827 #endif /* BFD64 */
1828     }
1829
1830   free (rels);
1831
1832   return res;
1833 }
1834
1835 static const char *
1836 get_aarch64_dynamic_type (unsigned long type)
1837 {
1838   switch (type)
1839     {
1840     case DT_AARCH64_BTI_PLT:  return "AARCH64_BTI_PLT";
1841     case DT_AARCH64_PAC_PLT:  return "AARCH64_PAC_PLT";
1842     case DT_AARCH64_VARIANT_PCS:  return "AARCH64_VARIANT_PCS";
1843     default:
1844       return NULL;
1845     }
1846 }
1847
1848 static const char *
1849 get_mips_dynamic_type (unsigned long type)
1850 {
1851   switch (type)
1852     {
1853     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1854     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1855     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1856     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1857     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1858     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1859     case DT_MIPS_MSYM: return "MIPS_MSYM";
1860     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1861     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1862     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1863     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1864     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1865     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1866     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1867     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1868     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1869     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1870     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1871     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1872     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1873     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1874     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1875     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1876     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1877     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1878     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1879     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1880     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1881     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1882     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1883     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1884     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1885     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1886     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1887     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1888     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1889     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1890     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1891     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1892     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1893     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1894     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1895     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1896     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1897     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1898     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1899     case DT_MIPS_XHASH: return "MIPS_XHASH";
1900     default:
1901       return NULL;
1902     }
1903 }
1904
1905 static const char *
1906 get_sparc64_dynamic_type (unsigned long type)
1907 {
1908   switch (type)
1909     {
1910     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1911     default:
1912       return NULL;
1913     }
1914 }
1915
1916 static const char *
1917 get_ppc_dynamic_type (unsigned long type)
1918 {
1919   switch (type)
1920     {
1921     case DT_PPC_GOT:    return "PPC_GOT";
1922     case DT_PPC_OPT:    return "PPC_OPT";
1923     default:
1924       return NULL;
1925     }
1926 }
1927
1928 static const char *
1929 get_ppc64_dynamic_type (unsigned long type)
1930 {
1931   switch (type)
1932     {
1933     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1934     case DT_PPC64_OPD:    return "PPC64_OPD";
1935     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1936     case DT_PPC64_OPT:    return "PPC64_OPT";
1937     default:
1938       return NULL;
1939     }
1940 }
1941
1942 static const char *
1943 get_parisc_dynamic_type (unsigned long type)
1944 {
1945   switch (type)
1946     {
1947     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1948     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1949     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1950     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1951     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1952     case DT_HP_PREINIT:         return "HP_PREINIT";
1953     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1954     case DT_HP_NEEDED:          return "HP_NEEDED";
1955     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1956     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1957     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1958     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1959     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1960     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1961     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1962     case DT_HP_FILTERED:        return "HP_FILTERED";
1963     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1964     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1965     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1966     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1967     case DT_PLT:                return "PLT";
1968     case DT_PLT_SIZE:           return "PLT_SIZE";
1969     case DT_DLT:                return "DLT";
1970     case DT_DLT_SIZE:           return "DLT_SIZE";
1971     default:
1972       return NULL;
1973     }
1974 }
1975
1976 static const char *
1977 get_ia64_dynamic_type (unsigned long type)
1978 {
1979   switch (type)
1980     {
1981     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1982     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1983     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1984     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1985     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1986     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1987     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1988     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1989     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1990     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1991     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1992     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1993     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1994     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1995     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1996     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1997     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1998     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1999     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
2000     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
2001     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
2002     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
2003     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
2004     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
2005     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
2006     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
2007     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
2008     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
2009     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
2010     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
2011     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
2012     default:
2013       return NULL;
2014     }
2015 }
2016
2017 static const char *
2018 get_solaris_section_type (unsigned long type)
2019 {
2020   switch (type)
2021     {
2022     case 0x6fffffee: return "SUNW_ancillary";
2023     case 0x6fffffef: return "SUNW_capchain";
2024     case 0x6ffffff0: return "SUNW_capinfo";
2025     case 0x6ffffff1: return "SUNW_symsort";
2026     case 0x6ffffff2: return "SUNW_tlssort";
2027     case 0x6ffffff3: return "SUNW_LDYNSYM";
2028     case 0x6ffffff4: return "SUNW_dof";
2029     case 0x6ffffff5: return "SUNW_cap";
2030     case 0x6ffffff6: return "SUNW_SIGNATURE";
2031     case 0x6ffffff7: return "SUNW_ANNOTATE";
2032     case 0x6ffffff8: return "SUNW_DEBUGSTR";
2033     case 0x6ffffff9: return "SUNW_DEBUG";
2034     case 0x6ffffffa: return "SUNW_move";
2035     case 0x6ffffffb: return "SUNW_COMDAT";
2036     case 0x6ffffffc: return "SUNW_syminfo";
2037     case 0x6ffffffd: return "SUNW_verdef";
2038     case 0x6ffffffe: return "SUNW_verneed";
2039     case 0x6fffffff: return "SUNW_versym";
2040     case 0x70000000: return "SPARC_GOTDATA";
2041     default: return NULL;
2042     }
2043 }
2044
2045 static const char *
2046 get_alpha_dynamic_type (unsigned long type)
2047 {
2048   switch (type)
2049     {
2050     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2051     default: return NULL;
2052     }
2053 }
2054
2055 static const char *
2056 get_score_dynamic_type (unsigned long type)
2057 {
2058   switch (type)
2059     {
2060     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2061     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
2062     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
2063     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
2064     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
2065     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
2066     default:                    return NULL;
2067     }
2068 }
2069
2070 static const char *
2071 get_tic6x_dynamic_type (unsigned long type)
2072 {
2073   switch (type)
2074     {
2075     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2076     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2077     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2078     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2079     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2080     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2081     default:                   return NULL;
2082     }
2083 }
2084
2085 static const char *
2086 get_nios2_dynamic_type (unsigned long type)
2087 {
2088   switch (type)
2089     {
2090     case DT_NIOS2_GP: return "NIOS2_GP";
2091     default:          return NULL;
2092     }
2093 }
2094
2095 static const char *
2096 get_solaris_dynamic_type (unsigned long type)
2097 {
2098   switch (type)
2099     {
2100     case 0x6000000d: return "SUNW_AUXILIARY";
2101     case 0x6000000e: return "SUNW_RTLDINF";
2102     case 0x6000000f: return "SUNW_FILTER";
2103     case 0x60000010: return "SUNW_CAP";
2104     case 0x60000011: return "SUNW_SYMTAB";
2105     case 0x60000012: return "SUNW_SYMSZ";
2106     case 0x60000013: return "SUNW_SORTENT";
2107     case 0x60000014: return "SUNW_SYMSORT";
2108     case 0x60000015: return "SUNW_SYMSORTSZ";
2109     case 0x60000016: return "SUNW_TLSSORT";
2110     case 0x60000017: return "SUNW_TLSSORTSZ";
2111     case 0x60000018: return "SUNW_CAPINFO";
2112     case 0x60000019: return "SUNW_STRPAD";
2113     case 0x6000001a: return "SUNW_CAPCHAIN";
2114     case 0x6000001b: return "SUNW_LDMACH";
2115     case 0x6000001d: return "SUNW_CAPCHAINENT";
2116     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2117     case 0x60000021: return "SUNW_PARENT";
2118     case 0x60000023: return "SUNW_ASLR";
2119     case 0x60000025: return "SUNW_RELAX";
2120     case 0x60000029: return "SUNW_NXHEAP";
2121     case 0x6000002b: return "SUNW_NXSTACK";
2122
2123     case 0x70000001: return "SPARC_REGISTER";
2124     case 0x7ffffffd: return "AUXILIARY";
2125     case 0x7ffffffe: return "USED";
2126     case 0x7fffffff: return "FILTER";
2127
2128     default: return NULL;
2129     }
2130 }
2131
2132 static const char *
2133 get_dynamic_type (Filedata * filedata, unsigned long type)
2134 {
2135   static char buff[64];
2136
2137   switch (type)
2138     {
2139     case DT_NULL:       return "NULL";
2140     case DT_NEEDED:     return "NEEDED";
2141     case DT_PLTRELSZ:   return "PLTRELSZ";
2142     case DT_PLTGOT:     return "PLTGOT";
2143     case DT_HASH:       return "HASH";
2144     case DT_STRTAB:     return "STRTAB";
2145     case DT_SYMTAB:     return "SYMTAB";
2146     case DT_RELA:       return "RELA";
2147     case DT_RELASZ:     return "RELASZ";
2148     case DT_RELAENT:    return "RELAENT";
2149     case DT_STRSZ:      return "STRSZ";
2150     case DT_SYMENT:     return "SYMENT";
2151     case DT_INIT:       return "INIT";
2152     case DT_FINI:       return "FINI";
2153     case DT_SONAME:     return "SONAME";
2154     case DT_RPATH:      return "RPATH";
2155     case DT_SYMBOLIC:   return "SYMBOLIC";
2156     case DT_REL:        return "REL";
2157     case DT_RELSZ:      return "RELSZ";
2158     case DT_RELENT:     return "RELENT";
2159     case DT_PLTREL:     return "PLTREL";
2160     case DT_DEBUG:      return "DEBUG";
2161     case DT_TEXTREL:    return "TEXTREL";
2162     case DT_JMPREL:     return "JMPREL";
2163     case DT_BIND_NOW:   return "BIND_NOW";
2164     case DT_INIT_ARRAY: return "INIT_ARRAY";
2165     case DT_FINI_ARRAY: return "FINI_ARRAY";
2166     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2167     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2168     case DT_RUNPATH:    return "RUNPATH";
2169     case DT_FLAGS:      return "FLAGS";
2170
2171     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2172     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2173     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2174
2175     case DT_CHECKSUM:   return "CHECKSUM";
2176     case DT_PLTPADSZ:   return "PLTPADSZ";
2177     case DT_MOVEENT:    return "MOVEENT";
2178     case DT_MOVESZ:     return "MOVESZ";
2179     case DT_FEATURE:    return "FEATURE";
2180     case DT_POSFLAG_1:  return "POSFLAG_1";
2181     case DT_SYMINSZ:    return "SYMINSZ";
2182     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2183
2184     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2185     case DT_CONFIG:     return "CONFIG";
2186     case DT_DEPAUDIT:   return "DEPAUDIT";
2187     case DT_AUDIT:      return "AUDIT";
2188     case DT_PLTPAD:     return "PLTPAD";
2189     case DT_MOVETAB:    return "MOVETAB";
2190     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2191
2192     case DT_VERSYM:     return "VERSYM";
2193
2194     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2195     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2196     case DT_RELACOUNT:  return "RELACOUNT";
2197     case DT_RELCOUNT:   return "RELCOUNT";
2198     case DT_FLAGS_1:    return "FLAGS_1";
2199     case DT_VERDEF:     return "VERDEF";
2200     case DT_VERDEFNUM:  return "VERDEFNUM";
2201     case DT_VERNEED:    return "VERNEED";
2202     case DT_VERNEEDNUM: return "VERNEEDNUM";
2203
2204     case DT_AUXILIARY:  return "AUXILIARY";
2205     case DT_USED:       return "USED";
2206     case DT_FILTER:     return "FILTER";
2207
2208     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2209     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2210     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2211     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2212     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2213     case DT_GNU_HASH:   return "GNU_HASH";
2214
2215     default:
2216       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2217         {
2218           const char * result;
2219
2220           switch (filedata->file_header.e_machine)
2221             {
2222             case EM_AARCH64:
2223               result = get_aarch64_dynamic_type (type);
2224               break;
2225             case EM_MIPS:
2226             case EM_MIPS_RS3_LE:
2227               result = get_mips_dynamic_type (type);
2228               break;
2229             case EM_SPARCV9:
2230               result = get_sparc64_dynamic_type (type);
2231               break;
2232             case EM_PPC:
2233               result = get_ppc_dynamic_type (type);
2234               break;
2235             case EM_PPC64:
2236               result = get_ppc64_dynamic_type (type);
2237               break;
2238             case EM_IA_64:
2239               result = get_ia64_dynamic_type (type);
2240               break;
2241             case EM_ALPHA:
2242               result = get_alpha_dynamic_type (type);
2243               break;
2244             case EM_SCORE:
2245               result = get_score_dynamic_type (type);
2246               break;
2247             case EM_TI_C6000:
2248               result = get_tic6x_dynamic_type (type);
2249               break;
2250             case EM_ALTERA_NIOS2:
2251               result = get_nios2_dynamic_type (type);
2252               break;
2253             default:
2254               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2255                 result = get_solaris_dynamic_type (type);
2256               else
2257                 result = NULL;
2258               break;
2259             }
2260
2261           if (result != NULL)
2262             return result;
2263
2264           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2265         }
2266       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2267                || (filedata->file_header.e_machine == EM_PARISC
2268                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2269         {
2270           const char * result;
2271
2272           switch (filedata->file_header.e_machine)
2273             {
2274             case EM_PARISC:
2275               result = get_parisc_dynamic_type (type);
2276               break;
2277             case EM_IA_64:
2278               result = get_ia64_dynamic_type (type);
2279               break;
2280             default:
2281               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2282                 result = get_solaris_dynamic_type (type);
2283               else
2284                 result = NULL;
2285               break;
2286             }
2287
2288           if (result != NULL)
2289             return result;
2290
2291           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2292                     type);
2293         }
2294       else
2295         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2296
2297       return buff;
2298     }
2299 }
2300
2301 static char *
2302 get_file_type (unsigned e_type)
2303 {
2304   static char buff[64];
2305
2306   switch (e_type)
2307     {
2308     case ET_NONE: return _("NONE (None)");
2309     case ET_REL:  return _("REL (Relocatable file)");
2310     case ET_EXEC: return _("EXEC (Executable file)");
2311     case ET_DYN:  return _("DYN (Shared object file)");
2312     case ET_CORE: return _("CORE (Core file)");
2313
2314     default:
2315       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2316         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2317       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2318         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2319       else
2320         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2321       return buff;
2322     }
2323 }
2324
2325 static char *
2326 get_machine_name (unsigned e_machine)
2327 {
2328   static char buff[64]; /* XXX */
2329
2330   switch (e_machine)
2331     {
2332       /* Please keep this switch table sorted by increasing EM_ value.  */
2333       /* 0 */
2334     case EM_NONE:               return _("None");
2335     case EM_M32:                return "WE32100";
2336     case EM_SPARC:              return "Sparc";
2337     case EM_386:                return "Intel 80386";
2338     case EM_68K:                return "MC68000";
2339     case EM_88K:                return "MC88000";
2340     case EM_IAMCU:              return "Intel MCU";
2341     case EM_860:                return "Intel 80860";
2342     case EM_MIPS:               return "MIPS R3000";
2343     case EM_S370:               return "IBM System/370";
2344       /* 10 */
2345     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2346     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2347     case EM_PARISC:             return "HPPA";
2348     case EM_VPP550:             return "Fujitsu VPP500";
2349     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2350     case EM_960:                return "Intel 80960";
2351     case EM_PPC:                return "PowerPC";
2352       /* 20 */
2353     case EM_PPC64:              return "PowerPC64";
2354     case EM_S390_OLD:
2355     case EM_S390:               return "IBM S/390";
2356     case EM_SPU:                return "SPU";
2357       /* 30 */
2358     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2359     case EM_FR20:               return "Fujitsu FR20";
2360     case EM_RH32:               return "TRW RH32";
2361     case EM_MCORE:              return "MCORE";
2362       /* 40 */
2363     case EM_ARM:                return "ARM";
2364     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2365     case EM_SH:                 return "Renesas / SuperH SH";
2366     case EM_SPARCV9:            return "Sparc v9";
2367     case EM_TRICORE:            return "Siemens Tricore";
2368     case EM_ARC:                return "ARC";
2369     case EM_H8_300:             return "Renesas H8/300";
2370     case EM_H8_300H:            return "Renesas H8/300H";
2371     case EM_H8S:                return "Renesas H8S";
2372     case EM_H8_500:             return "Renesas H8/500";
2373       /* 50 */
2374     case EM_IA_64:              return "Intel IA-64";
2375     case EM_MIPS_X:             return "Stanford MIPS-X";
2376     case EM_COLDFIRE:           return "Motorola Coldfire";
2377     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2378     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2379     case EM_PCP:                return "Siemens PCP";
2380     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2381     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2382     case EM_STARCORE:           return "Motorola Star*Core processor";
2383     case EM_ME16:               return "Toyota ME16 processor";
2384       /* 60 */
2385     case EM_ST100:              return "STMicroelectronics ST100 processor";
2386     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2387     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2388     case EM_PDSP:               return "Sony DSP processor";
2389     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2390     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2391     case EM_FX66:               return "Siemens FX66 microcontroller";
2392     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2393     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2394     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2395       /* 70 */
2396     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2397     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2398     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2399     case EM_SVX:                return "Silicon Graphics SVx";
2400     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2401     case EM_VAX:                return "Digital VAX";
2402     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2403     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2404     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2405     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2406       /* 80 */
2407     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2408     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2409     case EM_PRISM:              return "Vitesse Prism";
2410     case EM_AVR_OLD:
2411     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2412     case EM_CYGNUS_FR30:
2413     case EM_FR30:               return "Fujitsu FR30";
2414     case EM_CYGNUS_D10V:
2415     case EM_D10V:               return "d10v";
2416     case EM_CYGNUS_D30V:
2417     case EM_D30V:               return "d30v";
2418     case EM_CYGNUS_V850:
2419     case EM_V850:               return "Renesas V850";
2420     case EM_CYGNUS_M32R:
2421     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2422     case EM_CYGNUS_MN10300:
2423     case EM_MN10300:            return "mn10300";
2424       /* 90 */
2425     case EM_CYGNUS_MN10200:
2426     case EM_MN10200:            return "mn10200";
2427     case EM_PJ:                 return "picoJava";
2428     case EM_OR1K:               return "OpenRISC 1000";
2429     case EM_ARC_COMPACT:        return "ARCompact";
2430     case EM_XTENSA_OLD:
2431     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2432     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2433     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2434     case EM_NS32K:              return "National Semiconductor 32000 series";
2435     case EM_TPC:                return "Tenor Network TPC processor";
2436     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2437       /* 100 */
2438     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2439     case EM_IP2K_OLD:
2440     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2441     case EM_MAX:                return "MAX Processor";
2442     case EM_CR:                 return "National Semiconductor CompactRISC";
2443     case EM_F2MC16:             return "Fujitsu F2MC16";
2444     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2445     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2446     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2447     case EM_SEP:                return "Sharp embedded microprocessor";
2448     case EM_ARCA:               return "Arca RISC microprocessor";
2449       /* 110 */
2450     case EM_UNICORE:            return "Unicore";
2451     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2452     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2453     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2454     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2455     case EM_XGATE:              return "Motorola XGATE embedded processor";
2456     case EM_C166:
2457     case EM_XC16X:              return "Infineon Technologies xc16x";
2458     case EM_M16C:               return "Renesas M16C series microprocessors";
2459     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2460     case EM_CE:                 return "Freescale Communication Engine RISC core";
2461       /* 120 */
2462     case EM_M32C:               return "Renesas M32c";
2463       /* 130 */
2464     case EM_TSK3000:            return "Altium TSK3000 core";
2465     case EM_RS08:               return "Freescale RS08 embedded processor";
2466     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2467     case EM_SCORE:              return "SUNPLUS S+Core";
2468     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2469     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2470     case EM_LATTICEMICO32:      return "Lattice Mico32";
2471     case EM_SE_C17:             return "Seiko Epson C17 family";
2472       /* 140 */
2473     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2474     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2475     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2476     case EM_TI_PRU:             return "TI PRU I/O processor";
2477       /* 160 */
2478     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2479     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2480     case EM_R32C:               return "Renesas R32C series microprocessors";
2481     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2482     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2483     case EM_8051:               return "Intel 8051 and variants";
2484     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2485     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2486     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2487     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2488       /* 170 */
2489     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2490     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2491     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2492     case EM_RX:                 return "Renesas RX";
2493     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2494     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2495     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2496     case EM_CR16:
2497     case EM_MICROBLAZE:
2498     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2499     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2500     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2501       /* 180 */
2502     case EM_L1OM:               return "Intel L1OM";
2503     case EM_K1OM:               return "Intel K1OM";
2504     case EM_INTEL182:           return "Intel (reserved)";
2505     case EM_AARCH64:            return "AArch64";
2506     case EM_ARM184:             return "ARM (reserved)";
2507     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2508     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2509     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2510     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2511       /* 190 */
2512     case EM_CUDA:               return "NVIDIA CUDA architecture";
2513     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2514     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2515     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2516     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2517     case EM_ARC_COMPACT2:       return "ARCv2";
2518     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2519     case EM_RL78:               return "Renesas RL78";
2520     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2521     case EM_78K0R:              return "Renesas 78K0R";
2522       /* 200 */
2523     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2524     case EM_BA1:                return "Beyond BA1 CPU architecture";
2525     case EM_BA2:                return "Beyond BA2 CPU architecture";
2526     case EM_XCORE:              return "XMOS xCORE processor family";
2527     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2528       /* 210 */
2529     case EM_KM32:               return "KM211 KM32 32-bit processor";
2530     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2531     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2532     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2533     case EM_KVARC:              return "KM211 KVARC processor";
2534     case EM_CDP:                return "Paneve CDP architecture family";
2535     case EM_COGE:               return "Cognitive Smart Memory Processor";
2536     case EM_COOL:               return "Bluechip Systems CoolEngine";
2537     case EM_NORC:               return "Nanoradio Optimized RISC";
2538     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2539       /* 220 */
2540     case EM_Z80:                return "Zilog Z80";
2541     case EM_VISIUM:             return "CDS VISIUMcore processor";
2542     case EM_FT32:               return "FTDI Chip FT32";
2543     case EM_MOXIE:              return "Moxie";
2544     case EM_AMDGPU:             return "AMD GPU";
2545     case EM_RISCV:              return "RISC-V";
2546     case EM_LANAI:              return "Lanai 32-bit processor";
2547     case EM_BPF:                return "Linux BPF";
2548     case EM_NFP:                return "Netronome Flow Processor";
2549
2550       /* Large numbers...  */
2551     case EM_MT:                 return "Morpho Techologies MT processor";
2552     case EM_ALPHA:              return "Alpha";
2553     case EM_WEBASSEMBLY:        return "Web Assembly";
2554     case EM_DLX:                return "OpenDLX";
2555     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2556     case EM_IQ2000:             return "Vitesse IQ2000";
2557     case EM_M32C_OLD:
2558     case EM_NIOS32:             return "Altera Nios";
2559     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2560     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2561     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2562     case EM_S12Z:               return "Freescale S12Z";
2563     case EM_CSKY:               return "C-SKY";
2564
2565     default:
2566       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2567       return buff;
2568     }
2569 }
2570
2571 static void
2572 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2573 {
2574   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2575      other compilers don't a specific architecture type in the e_flags, and
2576      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2577      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2578      architectures.
2579
2580      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2581      but also sets a specific architecture type in the e_flags field.
2582
2583      However, when decoding the flags we don't worry if we see an
2584      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2585      ARCEM architecture type.  */
2586
2587   switch (e_flags & EF_ARC_MACH_MSK)
2588     {
2589       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2590     case EF_ARC_CPU_ARCV2EM:
2591       strcat (buf, ", ARC EM");
2592       break;
2593     case EF_ARC_CPU_ARCV2HS:
2594       strcat (buf, ", ARC HS");
2595       break;
2596
2597       /* We only expect these to occur for EM_ARC_COMPACT.  */
2598     case E_ARC_MACH_ARC600:
2599       strcat (buf, ", ARC600");
2600       break;
2601     case E_ARC_MACH_ARC601:
2602       strcat (buf, ", ARC601");
2603       break;
2604     case E_ARC_MACH_ARC700:
2605       strcat (buf, ", ARC700");
2606       break;
2607
2608       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2609          new ELF with new architecture being read by an old version of
2610          readelf, or (c) An ELF built with non-GNU compiler that does not
2611          set the architecture in the e_flags.  */
2612     default:
2613       if (e_machine == EM_ARC_COMPACT)
2614         strcat (buf, ", Unknown ARCompact");
2615       else
2616         strcat (buf, ", Unknown ARC");
2617       break;
2618     }
2619
2620   switch (e_flags & EF_ARC_OSABI_MSK)
2621     {
2622     case E_ARC_OSABI_ORIG:
2623       strcat (buf, ", (ABI:legacy)");
2624       break;
2625     case E_ARC_OSABI_V2:
2626       strcat (buf, ", (ABI:v2)");
2627       break;
2628       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2629     case E_ARC_OSABI_V3:
2630       strcat (buf, ", v3 no-legacy-syscalls ABI");
2631       break;
2632     case E_ARC_OSABI_V4:
2633       strcat (buf, ", v4 ABI");
2634       break;
2635     default:
2636       strcat (buf, ", unrecognised ARC OSABI flag");
2637       break;
2638     }
2639 }
2640
2641 static void
2642 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2643 {
2644   unsigned eabi;
2645   bfd_boolean unknown = FALSE;
2646
2647   eabi = EF_ARM_EABI_VERSION (e_flags);
2648   e_flags &= ~ EF_ARM_EABIMASK;
2649
2650   /* Handle "generic" ARM flags.  */
2651   if (e_flags & EF_ARM_RELEXEC)
2652     {
2653       strcat (buf, ", relocatable executable");
2654       e_flags &= ~ EF_ARM_RELEXEC;
2655     }
2656
2657   if (e_flags & EF_ARM_PIC)
2658     {
2659       strcat (buf, ", position independent");
2660       e_flags &= ~ EF_ARM_PIC;
2661     }
2662
2663   /* Now handle EABI specific flags.  */
2664   switch (eabi)
2665     {
2666     default:
2667       strcat (buf, ", <unrecognized EABI>");
2668       if (e_flags)
2669         unknown = TRUE;
2670       break;
2671
2672     case EF_ARM_EABI_VER1:
2673       strcat (buf, ", Version1 EABI");
2674       while (e_flags)
2675         {
2676           unsigned flag;
2677
2678           /* Process flags one bit at a time.  */
2679           flag = e_flags & - e_flags;
2680           e_flags &= ~ flag;
2681
2682           switch (flag)
2683             {
2684             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2685               strcat (buf, ", sorted symbol tables");
2686               break;
2687
2688             default:
2689               unknown = TRUE;
2690               break;
2691             }
2692         }
2693       break;
2694
2695     case EF_ARM_EABI_VER2:
2696       strcat (buf, ", Version2 EABI");
2697       while (e_flags)
2698         {
2699           unsigned flag;
2700
2701           /* Process flags one bit at a time.  */
2702           flag = e_flags & - e_flags;
2703           e_flags &= ~ flag;
2704
2705           switch (flag)
2706             {
2707             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2708               strcat (buf, ", sorted symbol tables");
2709               break;
2710
2711             case EF_ARM_DYNSYMSUSESEGIDX:
2712               strcat (buf, ", dynamic symbols use segment index");
2713               break;
2714
2715             case EF_ARM_MAPSYMSFIRST:
2716               strcat (buf, ", mapping symbols precede others");
2717               break;
2718
2719             default:
2720               unknown = TRUE;
2721               break;
2722             }
2723         }
2724       break;
2725
2726     case EF_ARM_EABI_VER3:
2727       strcat (buf, ", Version3 EABI");
2728       break;
2729
2730     case EF_ARM_EABI_VER4:
2731       strcat (buf, ", Version4 EABI");
2732       while (e_flags)
2733         {
2734           unsigned flag;
2735
2736           /* Process flags one bit at a time.  */
2737           flag = e_flags & - e_flags;
2738           e_flags &= ~ flag;
2739
2740           switch (flag)
2741             {
2742             case EF_ARM_BE8:
2743               strcat (buf, ", BE8");
2744               break;
2745
2746             case EF_ARM_LE8:
2747               strcat (buf, ", LE8");
2748               break;
2749
2750             default:
2751               unknown = TRUE;
2752               break;
2753             }
2754         }
2755       break;
2756
2757     case EF_ARM_EABI_VER5:
2758       strcat (buf, ", Version5 EABI");
2759       while (e_flags)
2760         {
2761           unsigned flag;
2762
2763           /* Process flags one bit at a time.  */
2764           flag = e_flags & - e_flags;
2765           e_flags &= ~ flag;
2766
2767           switch (flag)
2768             {
2769             case EF_ARM_BE8:
2770               strcat (buf, ", BE8");
2771               break;
2772
2773             case EF_ARM_LE8:
2774               strcat (buf, ", LE8");
2775               break;
2776
2777             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2778               strcat (buf, ", soft-float ABI");
2779               break;
2780
2781             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2782               strcat (buf, ", hard-float ABI");
2783               break;
2784
2785             default:
2786               unknown = TRUE;
2787               break;
2788             }
2789         }
2790       break;
2791
2792     case EF_ARM_EABI_UNKNOWN:
2793       strcat (buf, ", GNU EABI");
2794       while (e_flags)
2795         {
2796           unsigned flag;
2797
2798           /* Process flags one bit at a time.  */
2799           flag = e_flags & - e_flags;
2800           e_flags &= ~ flag;
2801
2802           switch (flag)
2803             {
2804             case EF_ARM_INTERWORK:
2805               strcat (buf, ", interworking enabled");
2806               break;
2807
2808             case EF_ARM_APCS_26:
2809               strcat (buf, ", uses APCS/26");
2810               break;
2811
2812             case EF_ARM_APCS_FLOAT:
2813               strcat (buf, ", uses APCS/float");
2814               break;
2815
2816             case EF_ARM_PIC:
2817               strcat (buf, ", position independent");
2818               break;
2819
2820             case EF_ARM_ALIGN8:
2821               strcat (buf, ", 8 bit structure alignment");
2822               break;
2823
2824             case EF_ARM_NEW_ABI:
2825               strcat (buf, ", uses new ABI");
2826               break;
2827
2828             case EF_ARM_OLD_ABI:
2829               strcat (buf, ", uses old ABI");
2830               break;
2831
2832             case EF_ARM_SOFT_FLOAT:
2833               strcat (buf, ", software FP");
2834               break;
2835
2836             case EF_ARM_VFP_FLOAT:
2837               strcat (buf, ", VFP");
2838               break;
2839
2840             case EF_ARM_MAVERICK_FLOAT:
2841               strcat (buf, ", Maverick FP");
2842               break;
2843
2844             default:
2845               unknown = TRUE;
2846               break;
2847             }
2848         }
2849     }
2850
2851   if (unknown)
2852     strcat (buf,_(", <unknown>"));
2853 }
2854
2855 static void
2856 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2857 {
2858   --size; /* Leave space for null terminator.  */
2859
2860   switch (e_flags & EF_AVR_MACH)
2861     {
2862     case E_AVR_MACH_AVR1:
2863       strncat (buf, ", avr:1", size);
2864       break;
2865     case E_AVR_MACH_AVR2:
2866       strncat (buf, ", avr:2", size);
2867       break;
2868     case E_AVR_MACH_AVR25:
2869       strncat (buf, ", avr:25", size);
2870       break;
2871     case E_AVR_MACH_AVR3:
2872       strncat (buf, ", avr:3", size);
2873       break;
2874     case E_AVR_MACH_AVR31:
2875       strncat (buf, ", avr:31", size);
2876       break;
2877     case E_AVR_MACH_AVR35:
2878       strncat (buf, ", avr:35", size);
2879       break;
2880     case E_AVR_MACH_AVR4:
2881       strncat (buf, ", avr:4", size);
2882       break;
2883     case E_AVR_MACH_AVR5:
2884       strncat (buf, ", avr:5", size);
2885       break;
2886     case E_AVR_MACH_AVR51:
2887       strncat (buf, ", avr:51", size);
2888       break;
2889     case E_AVR_MACH_AVR6:
2890       strncat (buf, ", avr:6", size);
2891       break;
2892     case E_AVR_MACH_AVRTINY:
2893       strncat (buf, ", avr:100", size);
2894       break;
2895     case E_AVR_MACH_XMEGA1:
2896       strncat (buf, ", avr:101", size);
2897       break;
2898     case E_AVR_MACH_XMEGA2:
2899       strncat (buf, ", avr:102", size);
2900       break;
2901     case E_AVR_MACH_XMEGA3:
2902       strncat (buf, ", avr:103", size);
2903       break;
2904     case E_AVR_MACH_XMEGA4:
2905       strncat (buf, ", avr:104", size);
2906       break;
2907     case E_AVR_MACH_XMEGA5:
2908       strncat (buf, ", avr:105", size);
2909       break;
2910     case E_AVR_MACH_XMEGA6:
2911       strncat (buf, ", avr:106", size);
2912       break;
2913     case E_AVR_MACH_XMEGA7:
2914       strncat (buf, ", avr:107", size);
2915       break;
2916     default:
2917       strncat (buf, ", avr:<unknown>", size);
2918       break;
2919     }
2920
2921   size -= strlen (buf);
2922   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2923     strncat (buf, ", link-relax", size);
2924 }
2925
2926 static void
2927 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2928 {
2929   unsigned abi;
2930   unsigned arch;
2931   unsigned config;
2932   unsigned version;
2933   bfd_boolean has_fpu = FALSE;
2934   unsigned int r = 0;
2935
2936   static const char *ABI_STRINGS[] =
2937   {
2938     "ABI v0", /* use r5 as return register; only used in N1213HC */
2939     "ABI v1", /* use r0 as return register */
2940     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2941     "ABI v2fp", /* for FPU */
2942     "AABI",
2943     "ABI2 FP+"
2944   };
2945   static const char *VER_STRINGS[] =
2946   {
2947     "Andes ELF V1.3 or older",
2948     "Andes ELF V1.3.1",
2949     "Andes ELF V1.4"
2950   };
2951   static const char *ARCH_STRINGS[] =
2952   {
2953     "",
2954     "Andes Star v1.0",
2955     "Andes Star v2.0",
2956     "Andes Star v3.0",
2957     "Andes Star v3.0m"
2958   };
2959
2960   abi = EF_NDS_ABI & e_flags;
2961   arch = EF_NDS_ARCH & e_flags;
2962   config = EF_NDS_INST & e_flags;
2963   version = EF_NDS32_ELF_VERSION & e_flags;
2964
2965   memset (buf, 0, size);
2966
2967   switch (abi)
2968     {
2969     case E_NDS_ABI_V0:
2970     case E_NDS_ABI_V1:
2971     case E_NDS_ABI_V2:
2972     case E_NDS_ABI_V2FP:
2973     case E_NDS_ABI_AABI:
2974     case E_NDS_ABI_V2FP_PLUS:
2975       /* In case there are holes in the array.  */
2976       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2977       break;
2978
2979     default:
2980       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2981       break;
2982     }
2983
2984   switch (version)
2985     {
2986     case E_NDS32_ELF_VER_1_2:
2987     case E_NDS32_ELF_VER_1_3:
2988     case E_NDS32_ELF_VER_1_4:
2989       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2990       break;
2991
2992     default:
2993       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2994       break;
2995     }
2996
2997   if (E_NDS_ABI_V0 == abi)
2998     {
2999       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
3000       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3001       if (arch == E_NDS_ARCH_STAR_V1_0)
3002         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
3003       return;
3004     }
3005
3006   switch (arch)
3007     {
3008     case E_NDS_ARCH_STAR_V1_0:
3009     case E_NDS_ARCH_STAR_V2_0:
3010     case E_NDS_ARCH_STAR_V3_0:
3011     case E_NDS_ARCH_STAR_V3_M:
3012       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
3013       break;
3014
3015     default:
3016       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
3017       /* ARCH version determines how the e_flags are interpreted.
3018          If it is unknown, we cannot proceed.  */
3019       return;
3020     }
3021
3022   /* Newer ABI; Now handle architecture specific flags.  */
3023   if (arch == E_NDS_ARCH_STAR_V1_0)
3024     {
3025       if (config & E_NDS32_HAS_MFUSR_PC_INST)
3026         r += snprintf (buf + r, size -r, ", MFUSR_PC");
3027
3028       if (!(config & E_NDS32_HAS_NO_MAC_INST))
3029         r += snprintf (buf + r, size -r, ", MAC");
3030
3031       if (config & E_NDS32_HAS_DIV_INST)
3032         r += snprintf (buf + r, size -r, ", DIV");
3033
3034       if (config & E_NDS32_HAS_16BIT_INST)
3035         r += snprintf (buf + r, size -r, ", 16b");
3036     }
3037   else
3038     {
3039       if (config & E_NDS32_HAS_MFUSR_PC_INST)
3040         {
3041           if (version <= E_NDS32_ELF_VER_1_3)
3042             r += snprintf (buf + r, size -r, ", [B8]");
3043           else
3044             r += snprintf (buf + r, size -r, ", EX9");
3045         }
3046
3047       if (config & E_NDS32_HAS_MAC_DX_INST)
3048         r += snprintf (buf + r, size -r, ", MAC_DX");
3049
3050       if (config & E_NDS32_HAS_DIV_DX_INST)
3051         r += snprintf (buf + r, size -r, ", DIV_DX");
3052
3053       if (config & E_NDS32_HAS_16BIT_INST)
3054         {
3055           if (version <= E_NDS32_ELF_VER_1_3)
3056             r += snprintf (buf + r, size -r, ", 16b");
3057           else
3058             r += snprintf (buf + r, size -r, ", IFC");
3059         }
3060     }
3061
3062   if (config & E_NDS32_HAS_EXT_INST)
3063     r += snprintf (buf + r, size -r, ", PERF1");
3064
3065   if (config & E_NDS32_HAS_EXT2_INST)
3066     r += snprintf (buf + r, size -r, ", PERF2");
3067
3068   if (config & E_NDS32_HAS_FPU_INST)
3069     {
3070       has_fpu = TRUE;
3071       r += snprintf (buf + r, size -r, ", FPU_SP");
3072     }
3073
3074   if (config & E_NDS32_HAS_FPU_DP_INST)
3075     {
3076       has_fpu = TRUE;
3077       r += snprintf (buf + r, size -r, ", FPU_DP");
3078     }
3079
3080   if (config & E_NDS32_HAS_FPU_MAC_INST)
3081     {
3082       has_fpu = TRUE;
3083       r += snprintf (buf + r, size -r, ", FPU_MAC");
3084     }
3085
3086   if (has_fpu)
3087     {
3088       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3089         {
3090         case E_NDS32_FPU_REG_8SP_4DP:
3091           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3092           break;
3093         case E_NDS32_FPU_REG_16SP_8DP:
3094           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3095           break;
3096         case E_NDS32_FPU_REG_32SP_16DP:
3097           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3098           break;
3099         case E_NDS32_FPU_REG_32SP_32DP:
3100           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3101           break;
3102         }
3103     }
3104
3105   if (config & E_NDS32_HAS_AUDIO_INST)
3106     r += snprintf (buf + r, size -r, ", AUDIO");
3107
3108   if (config & E_NDS32_HAS_STRING_INST)
3109     r += snprintf (buf + r, size -r, ", STR");
3110
3111   if (config & E_NDS32_HAS_REDUCED_REGS)
3112     r += snprintf (buf + r, size -r, ", 16REG");
3113
3114   if (config & E_NDS32_HAS_VIDEO_INST)
3115     {
3116       if (version <= E_NDS32_ELF_VER_1_3)
3117         r += snprintf (buf + r, size -r, ", VIDEO");
3118       else
3119         r += snprintf (buf + r, size -r, ", SATURATION");
3120     }
3121
3122   if (config & E_NDS32_HAS_ENCRIPT_INST)
3123     r += snprintf (buf + r, size -r, ", ENCRP");
3124
3125   if (config & E_NDS32_HAS_L2C_INST)
3126     r += snprintf (buf + r, size -r, ", L2C");
3127 }
3128
3129 static char *
3130 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3131 {
3132   static char buf[1024];
3133
3134   buf[0] = '\0';
3135
3136   if (e_flags)
3137     {
3138       switch (e_machine)
3139         {
3140         default:
3141           break;
3142
3143         case EM_ARC_COMPACT2:
3144         case EM_ARC_COMPACT:
3145           decode_ARC_machine_flags (e_flags, e_machine, buf);
3146           break;
3147
3148         case EM_ARM:
3149           decode_ARM_machine_flags (e_flags, buf);
3150           break;
3151
3152         case EM_AVR:
3153           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3154           break;
3155
3156         case EM_BLACKFIN:
3157           if (e_flags & EF_BFIN_PIC)
3158             strcat (buf, ", PIC");
3159
3160           if (e_flags & EF_BFIN_FDPIC)
3161             strcat (buf, ", FDPIC");
3162
3163           if (e_flags & EF_BFIN_CODE_IN_L1)
3164             strcat (buf, ", code in L1");
3165
3166           if (e_flags & EF_BFIN_DATA_IN_L1)
3167             strcat (buf, ", data in L1");
3168
3169           break;
3170
3171         case EM_CYGNUS_FRV:
3172           switch (e_flags & EF_FRV_CPU_MASK)
3173             {
3174             case EF_FRV_CPU_GENERIC:
3175               break;
3176
3177             default:
3178               strcat (buf, ", fr???");
3179               break;
3180
3181             case EF_FRV_CPU_FR300:
3182               strcat (buf, ", fr300");
3183               break;
3184
3185             case EF_FRV_CPU_FR400:
3186               strcat (buf, ", fr400");
3187               break;
3188             case EF_FRV_CPU_FR405:
3189               strcat (buf, ", fr405");
3190               break;
3191
3192             case EF_FRV_CPU_FR450:
3193               strcat (buf, ", fr450");
3194               break;
3195
3196             case EF_FRV_CPU_FR500:
3197               strcat (buf, ", fr500");
3198               break;
3199             case EF_FRV_CPU_FR550:
3200               strcat (buf, ", fr550");
3201               break;
3202
3203             case EF_FRV_CPU_SIMPLE:
3204               strcat (buf, ", simple");
3205               break;
3206             case EF_FRV_CPU_TOMCAT:
3207               strcat (buf, ", tomcat");
3208               break;
3209             }
3210           break;
3211
3212         case EM_68K:
3213           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3214             strcat (buf, ", m68000");
3215           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3216             strcat (buf, ", cpu32");
3217           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3218             strcat (buf, ", fido_a");
3219           else
3220             {
3221               char const * isa = _("unknown");
3222               char const * mac = _("unknown mac");
3223               char const * additional = NULL;
3224
3225               switch (e_flags & EF_M68K_CF_ISA_MASK)
3226                 {
3227                 case EF_M68K_CF_ISA_A_NODIV:
3228                   isa = "A";
3229                   additional = ", nodiv";
3230                   break;
3231                 case EF_M68K_CF_ISA_A:
3232                   isa = "A";
3233                   break;
3234                 case EF_M68K_CF_ISA_A_PLUS:
3235                   isa = "A+";
3236                   break;
3237                 case EF_M68K_CF_ISA_B_NOUSP:
3238                   isa = "B";
3239                   additional = ", nousp";
3240                   break;
3241                 case EF_M68K_CF_ISA_B:
3242                   isa = "B";
3243                   break;
3244                 case EF_M68K_CF_ISA_C:
3245                   isa = "C";
3246                   break;
3247                 case EF_M68K_CF_ISA_C_NODIV:
3248                   isa = "C";
3249                   additional = ", nodiv";
3250                   break;
3251                 }
3252               strcat (buf, ", cf, isa ");
3253               strcat (buf, isa);
3254               if (additional)
3255                 strcat (buf, additional);
3256               if (e_flags & EF_M68K_CF_FLOAT)
3257                 strcat (buf, ", float");
3258               switch (e_flags & EF_M68K_CF_MAC_MASK)
3259                 {
3260                 case 0:
3261                   mac = NULL;
3262                   break;
3263                 case EF_M68K_CF_MAC:
3264                   mac = "mac";
3265                   break;
3266                 case EF_M68K_CF_EMAC:
3267                   mac = "emac";
3268                   break;
3269                 case EF_M68K_CF_EMAC_B:
3270                   mac = "emac_b";
3271                   break;
3272                 }
3273               if (mac)
3274                 {
3275                   strcat (buf, ", ");
3276                   strcat (buf, mac);
3277                 }
3278             }
3279           break;
3280
3281         case EM_CYGNUS_MEP:
3282           switch (e_flags & EF_MEP_CPU_MASK)
3283             {
3284             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3285             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3286             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3287             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3288             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3289             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3290             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3291             }
3292
3293           switch (e_flags & EF_MEP_COP_MASK)
3294             {
3295             case EF_MEP_COP_NONE: break;
3296             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3297             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3298             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3299             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3300             default: strcat (buf, _("<unknown MeP copro type>")); break;
3301             }
3302
3303           if (e_flags & EF_MEP_LIBRARY)
3304             strcat (buf, ", Built for Library");
3305
3306           if (e_flags & EF_MEP_INDEX_MASK)
3307             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3308                      e_flags & EF_MEP_INDEX_MASK);
3309
3310           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3311             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3312                      e_flags & ~ EF_MEP_ALL_FLAGS);
3313           break;
3314
3315         case EM_PPC:
3316           if (e_flags & EF_PPC_EMB)
3317             strcat (buf, ", emb");
3318
3319           if (e_flags & EF_PPC_RELOCATABLE)
3320             strcat (buf, _(", relocatable"));
3321
3322           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3323             strcat (buf, _(", relocatable-lib"));
3324           break;
3325
3326         case EM_PPC64:
3327           if (e_flags & EF_PPC64_ABI)
3328             {
3329               char abi[] = ", abiv0";
3330
3331               abi[6] += e_flags & EF_PPC64_ABI;
3332               strcat (buf, abi);
3333             }
3334           break;
3335
3336         case EM_V800:
3337           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3338             strcat (buf, ", RH850 ABI");
3339
3340           if (e_flags & EF_V800_850E3)
3341             strcat (buf, ", V3 architecture");
3342
3343           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3344             strcat (buf, ", FPU not used");
3345
3346           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3347             strcat (buf, ", regmode: COMMON");
3348
3349           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3350             strcat (buf, ", r4 not used");
3351
3352           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3353             strcat (buf, ", r30 not used");
3354
3355           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3356             strcat (buf, ", r5 not used");
3357
3358           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3359             strcat (buf, ", r2 not used");
3360
3361           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3362             {
3363               switch (e_flags & - e_flags)
3364                 {
3365                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3366                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3367                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3368                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3369                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3370                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3371                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3372                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3373                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3374                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3375                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3376                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3377                 default: break;
3378                 }
3379             }
3380           break;
3381
3382         case EM_V850:
3383         case EM_CYGNUS_V850:
3384           switch (e_flags & EF_V850_ARCH)
3385             {
3386             case E_V850E3V5_ARCH:
3387               strcat (buf, ", v850e3v5");
3388               break;
3389             case E_V850E2V3_ARCH:
3390               strcat (buf, ", v850e2v3");
3391               break;
3392             case E_V850E2_ARCH:
3393               strcat (buf, ", v850e2");
3394               break;
3395             case E_V850E1_ARCH:
3396               strcat (buf, ", v850e1");
3397               break;
3398             case E_V850E_ARCH:
3399               strcat (buf, ", v850e");
3400               break;
3401             case E_V850_ARCH:
3402               strcat (buf, ", v850");
3403               break;
3404             default:
3405               strcat (buf, _(", unknown v850 architecture variant"));
3406               break;
3407             }
3408           break;
3409
3410         case EM_M32R:
3411         case EM_CYGNUS_M32R:
3412           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3413             strcat (buf, ", m32r");
3414           break;
3415
3416         case EM_MIPS:
3417         case EM_MIPS_RS3_LE:
3418           if (e_flags & EF_MIPS_NOREORDER)
3419             strcat (buf, ", noreorder");
3420
3421           if (e_flags & EF_MIPS_PIC)
3422             strcat (buf, ", pic");
3423
3424           if (e_flags & EF_MIPS_CPIC)
3425             strcat (buf, ", cpic");
3426
3427           if (e_flags & EF_MIPS_UCODE)
3428             strcat (buf, ", ugen_reserved");
3429
3430           if (e_flags & EF_MIPS_ABI2)
3431             strcat (buf, ", abi2");
3432
3433           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3434             strcat (buf, ", odk first");
3435
3436           if (e_flags & EF_MIPS_32BITMODE)
3437             strcat (buf, ", 32bitmode");
3438
3439           if (e_flags & EF_MIPS_NAN2008)
3440             strcat (buf, ", nan2008");
3441
3442           if (e_flags & EF_MIPS_FP64)
3443             strcat (buf, ", fp64");
3444
3445           switch ((e_flags & EF_MIPS_MACH))
3446             {
3447             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3448             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3449             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3450             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3451             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3452             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3453             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3454             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3455             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3456             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3457             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3458             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3459             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3460             case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3461             case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3462             case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3463             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3464             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3465             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3466             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3467             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3468             case 0:
3469             /* We simply ignore the field in this case to avoid confusion:
3470                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3471                extension.  */
3472               break;
3473             default: strcat (buf, _(", unknown CPU")); break;
3474             }
3475
3476           switch ((e_flags & EF_MIPS_ABI))
3477             {
3478             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3479             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3480             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3481             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3482             case 0:
3483             /* We simply ignore the field in this case to avoid confusion:
3484                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3485                This means it is likely to be an o32 file, but not for
3486                sure.  */
3487               break;
3488             default: strcat (buf, _(", unknown ABI")); break;
3489             }
3490
3491           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3492             strcat (buf, ", mdmx");
3493
3494           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3495             strcat (buf, ", mips16");
3496
3497           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3498             strcat (buf, ", micromips");
3499
3500           switch ((e_flags & EF_MIPS_ARCH))
3501             {
3502             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3503             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3504             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3505             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3506             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3507             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3508             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3509             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3510             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3511             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3512             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3513             default: strcat (buf, _(", unknown ISA")); break;
3514             }
3515           break;
3516
3517         case EM_NDS32:
3518           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3519           break;
3520
3521         case EM_NFP:
3522           switch (EF_NFP_MACH (e_flags))
3523             {
3524             case E_NFP_MACH_3200:
3525               strcat (buf, ", NFP-32xx");
3526               break;
3527             case E_NFP_MACH_6000:
3528               strcat (buf, ", NFP-6xxx");
3529               break;
3530             }
3531           break;
3532
3533         case EM_RISCV:
3534           if (e_flags & EF_RISCV_RVC)
3535             strcat (buf, ", RVC");
3536
3537           if (e_flags & EF_RISCV_RVE)
3538             strcat (buf, ", RVE");
3539
3540           switch (e_flags & EF_RISCV_FLOAT_ABI)
3541             {
3542             case EF_RISCV_FLOAT_ABI_SOFT:
3543               strcat (buf, ", soft-float ABI");
3544               break;
3545
3546             case EF_RISCV_FLOAT_ABI_SINGLE:
3547               strcat (buf, ", single-float ABI");
3548               break;
3549
3550             case EF_RISCV_FLOAT_ABI_DOUBLE:
3551               strcat (buf, ", double-float ABI");
3552               break;
3553
3554             case EF_RISCV_FLOAT_ABI_QUAD:
3555               strcat (buf, ", quad-float ABI");
3556               break;
3557             }
3558           break;
3559
3560         case EM_SH:
3561           switch ((e_flags & EF_SH_MACH_MASK))
3562             {
3563             case EF_SH1: strcat (buf, ", sh1"); break;
3564             case EF_SH2: strcat (buf, ", sh2"); break;
3565             case EF_SH3: strcat (buf, ", sh3"); break;
3566             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3567             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3568             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3569             case EF_SH3E: strcat (buf, ", sh3e"); break;
3570             case EF_SH4: strcat (buf, ", sh4"); break;
3571             case EF_SH5: strcat (buf, ", sh5"); break;
3572             case EF_SH2E: strcat (buf, ", sh2e"); break;
3573             case EF_SH4A: strcat (buf, ", sh4a"); break;
3574             case EF_SH2A: strcat (buf, ", sh2a"); break;
3575             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3576             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3577             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3578             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3579             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3580             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3581             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3582             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3583             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3584             default: strcat (buf, _(", unknown ISA")); break;
3585             }
3586
3587           if (e_flags & EF_SH_PIC)
3588             strcat (buf, ", pic");
3589
3590           if (e_flags & EF_SH_FDPIC)
3591             strcat (buf, ", fdpic");
3592           break;
3593
3594         case EM_OR1K:
3595           if (e_flags & EF_OR1K_NODELAY)
3596             strcat (buf, ", no delay");
3597           break;
3598
3599         case EM_SPARCV9:
3600           if (e_flags & EF_SPARC_32PLUS)
3601             strcat (buf, ", v8+");
3602
3603           if (e_flags & EF_SPARC_SUN_US1)
3604             strcat (buf, ", ultrasparcI");
3605
3606           if (e_flags & EF_SPARC_SUN_US3)
3607             strcat (buf, ", ultrasparcIII");
3608
3609           if (e_flags & EF_SPARC_HAL_R1)
3610             strcat (buf, ", halr1");
3611
3612           if (e_flags & EF_SPARC_LEDATA)
3613             strcat (buf, ", ledata");
3614
3615           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3616             strcat (buf, ", tso");
3617
3618           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3619             strcat (buf, ", pso");
3620
3621           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3622             strcat (buf, ", rmo");
3623           break;
3624
3625         case EM_PARISC:
3626           switch (e_flags & EF_PARISC_ARCH)
3627             {
3628             case EFA_PARISC_1_0:
3629               strcpy (buf, ", PA-RISC 1.0");
3630               break;
3631             case EFA_PARISC_1_1:
3632               strcpy (buf, ", PA-RISC 1.1");
3633               break;
3634             case EFA_PARISC_2_0:
3635               strcpy (buf, ", PA-RISC 2.0");
3636               break;
3637             default:
3638               break;
3639             }
3640           if (e_flags & EF_PARISC_TRAPNIL)
3641             strcat (buf, ", trapnil");
3642           if (e_flags & EF_PARISC_EXT)
3643             strcat (buf, ", ext");
3644           if (e_flags & EF_PARISC_LSB)
3645             strcat (buf, ", lsb");
3646           if (e_flags & EF_PARISC_WIDE)
3647             strcat (buf, ", wide");
3648           if (e_flags & EF_PARISC_NO_KABP)
3649             strcat (buf, ", no kabp");
3650           if (e_flags & EF_PARISC_LAZYSWAP)
3651             strcat (buf, ", lazyswap");
3652           break;
3653
3654         case EM_PJ:
3655         case EM_PJ_OLD:
3656           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3657             strcat (buf, ", new calling convention");
3658
3659           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3660             strcat (buf, ", gnu calling convention");
3661           break;
3662
3663         case EM_IA_64:
3664           if ((e_flags & EF_IA_64_ABI64))
3665             strcat (buf, ", 64-bit");
3666           else
3667             strcat (buf, ", 32-bit");
3668           if ((e_flags & EF_IA_64_REDUCEDFP))
3669             strcat (buf, ", reduced fp model");
3670           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3671             strcat (buf, ", no function descriptors, constant gp");
3672           else if ((e_flags & EF_IA_64_CONS_GP))
3673             strcat (buf, ", constant gp");
3674           if ((e_flags & EF_IA_64_ABSOLUTE))
3675             strcat (buf, ", absolute");
3676           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3677             {
3678               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3679                 strcat (buf, ", vms_linkages");
3680               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3681                 {
3682                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3683                   break;
3684                 case EF_IA_64_VMS_COMCOD_WARNING:
3685                   strcat (buf, ", warning");
3686                   break;
3687                 case EF_IA_64_VMS_COMCOD_ERROR:
3688                   strcat (buf, ", error");
3689                   break;
3690                 case EF_IA_64_VMS_COMCOD_ABORT:
3691                   strcat (buf, ", abort");
3692                   break;
3693                 default:
3694                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3695                         e_flags & EF_IA_64_VMS_COMCOD);
3696                   strcat (buf, ", <unknown>");
3697                 }
3698             }
3699           break;
3700
3701         case EM_VAX:
3702           if ((e_flags & EF_VAX_NONPIC))
3703             strcat (buf, ", non-PIC");
3704           if ((e_flags & EF_VAX_DFLOAT))
3705             strcat (buf, ", D-Float");
3706           if ((e_flags & EF_VAX_GFLOAT))
3707             strcat (buf, ", G-Float");
3708           break;
3709
3710         case EM_VISIUM:
3711           if (e_flags & EF_VISIUM_ARCH_MCM)
3712             strcat (buf, ", mcm");
3713           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3714             strcat (buf, ", mcm24");
3715           if (e_flags & EF_VISIUM_ARCH_GR6)
3716             strcat (buf, ", gr6");
3717           break;
3718
3719         case EM_RL78:
3720           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3721             {
3722             case E_FLAG_RL78_ANY_CPU: break;
3723             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3724             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3725             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3726             }
3727           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3728             strcat (buf, ", 64-bit doubles");
3729           break;
3730
3731         case EM_RX:
3732           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3733             strcat (buf, ", 64-bit doubles");
3734           if (e_flags & E_FLAG_RX_DSP)
3735             strcat (buf, ", dsp");
3736           if (e_flags & E_FLAG_RX_PID)
3737             strcat (buf, ", pid");
3738           if (e_flags & E_FLAG_RX_ABI)
3739             strcat (buf, ", RX ABI");
3740           if (e_flags & E_FLAG_RX_SINSNS_SET)
3741             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3742                     ? ", uses String instructions" : ", bans String instructions");
3743           if (e_flags & E_FLAG_RX_V2)
3744             strcat (buf, ", V2");
3745           if (e_flags & E_FLAG_RX_V3)
3746             strcat (buf, ", V3");
3747           break;
3748
3749         case EM_S390:
3750           if (e_flags & EF_S390_HIGH_GPRS)
3751             strcat (buf, ", highgprs");
3752           break;
3753
3754         case EM_TI_C6000:
3755           if ((e_flags & EF_C6000_REL))
3756             strcat (buf, ", relocatable module");
3757           break;
3758
3759         case EM_MSP430:
3760           strcat (buf, _(": architecture variant: "));
3761           switch (e_flags & EF_MSP430_MACH)
3762             {
3763             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3764             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3765             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3766             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3767             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3768             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3769             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3770             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3771             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3772             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3773             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3774             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3775             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3776             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3777             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3778             default:
3779               strcat (buf, _(": unknown")); break;
3780             }
3781
3782           if (e_flags & ~ EF_MSP430_MACH)
3783             strcat (buf, _(": unknown extra flag bits also present"));
3784           break;
3785
3786         case EM_Z80:
3787           switch (e_flags & EF_Z80_MACH_MSK)
3788             {
3789             case EF_Z80_MACH_Z80: strcat (buf, ", Z80"); break;
3790             case EF_Z80_MACH_Z180: strcat (buf, ", Z180"); break;
3791             case EF_Z80_MACH_R800: strcat (buf, ", R800"); break;
3792             case EF_Z80_MACH_EZ80_Z80: strcat (buf, ", EZ80"); break;
3793             case EF_Z80_MACH_EZ80_ADL: strcat (buf, ", EZ80, ADL"); break;
3794             case EF_Z80_MACH_GBZ80: strcat (buf, ", GBZ80"); break;
3795             case EF_Z80_MACH_Z80N: strcat (buf, ", Z80N"); break;
3796             default:
3797               strcat (buf, _(", unknown")); break;
3798             }
3799           break;
3800         }
3801     }
3802
3803   return buf;
3804 }
3805
3806 static const char *
3807 get_osabi_name (Filedata * filedata, unsigned int osabi)
3808 {
3809   static char buff[32];
3810
3811   switch (osabi)
3812     {
3813     case ELFOSABI_NONE:         return "UNIX - System V";
3814     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3815     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3816     case ELFOSABI_GNU:          return "UNIX - GNU";
3817     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3818     case ELFOSABI_AIX:          return "UNIX - AIX";
3819     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3820     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3821     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3822     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3823     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3824     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3825     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3826     case ELFOSABI_AROS:         return "AROS";
3827     case ELFOSABI_FENIXOS:      return "FenixOS";
3828     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3829     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3830     default:
3831       if (osabi >= 64)
3832         switch (filedata->file_header.e_machine)
3833           {
3834           case EM_ARM:
3835             switch (osabi)
3836               {
3837               case ELFOSABI_ARM:        return "ARM";
3838               case ELFOSABI_ARM_FDPIC:  return "ARM FDPIC";
3839               default:
3840                 break;
3841               }
3842             break;
3843
3844           case EM_MSP430:
3845           case EM_MSP430_OLD:
3846           case EM_VISIUM:
3847             switch (osabi)
3848               {
3849               case ELFOSABI_STANDALONE: return _("Standalone App");
3850               default:
3851                 break;
3852               }
3853             break;
3854
3855           case EM_TI_C6000:
3856             switch (osabi)
3857               {
3858               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3859               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3860               default:
3861                 break;
3862               }
3863             break;
3864
3865           default:
3866             break;
3867           }
3868       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3869       return buff;
3870     }
3871 }
3872
3873 static const char *
3874 get_aarch64_segment_type (unsigned long type)
3875 {
3876   switch (type)
3877     {
3878     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3879     default:                  return NULL;
3880     }
3881 }
3882
3883 static const char *
3884 get_arm_segment_type (unsigned long type)
3885 {
3886   switch (type)
3887     {
3888     case PT_ARM_EXIDX: return "EXIDX";
3889     default:           return NULL;
3890     }
3891 }
3892
3893 static const char *
3894 get_s390_segment_type (unsigned long type)
3895 {
3896   switch (type)
3897     {
3898     case PT_S390_PGSTE: return "S390_PGSTE";
3899     default:            return NULL;
3900     }
3901 }
3902
3903 static const char *
3904 get_mips_segment_type (unsigned long type)
3905 {
3906   switch (type)
3907     {
3908     case PT_MIPS_REGINFO:   return "REGINFO";
3909     case PT_MIPS_RTPROC:    return "RTPROC";
3910     case PT_MIPS_OPTIONS:   return "OPTIONS";
3911     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3912     default:                return NULL;
3913     }
3914 }
3915
3916 static const char *
3917 get_parisc_segment_type (unsigned long type)
3918 {
3919   switch (type)
3920     {
3921     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3922     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3923     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3924     default:                    return NULL;
3925     }
3926 }
3927
3928 static const char *
3929 get_ia64_segment_type (unsigned long type)
3930 {
3931   switch (type)
3932     {
3933     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3934     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3935     default:                    return NULL;
3936     }
3937 }
3938
3939 static const char *
3940 get_tic6x_segment_type (unsigned long type)
3941 {
3942   switch (type)
3943     {
3944     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3945     default:               return NULL;
3946     }
3947 }
3948
3949 static const char *
3950 get_hpux_segment_type (unsigned long type, unsigned e_machine)
3951 {
3952   if (e_machine == EM_PARISC)
3953     switch (type)
3954       {
3955       case PT_HP_TLS:           return "HP_TLS";
3956       case PT_HP_CORE_NONE:     return "HP_CORE_NONE";
3957       case PT_HP_CORE_VERSION:  return "HP_CORE_VERSION";
3958       case PT_HP_CORE_KERNEL:   return "HP_CORE_KERNEL";
3959       case PT_HP_CORE_COMM:     return "HP_CORE_COMM";
3960       case PT_HP_CORE_PROC:     return "HP_CORE_PROC";
3961       case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3962       case PT_HP_CORE_STACK:    return "HP_CORE_STACK";
3963       case PT_HP_CORE_SHM:      return "HP_CORE_SHM";
3964       case PT_HP_CORE_MMF:      return "HP_CORE_MMF";
3965       case PT_HP_PARALLEL:      return "HP_PARALLEL";
3966       case PT_HP_FASTBIND:      return "HP_FASTBIND";
3967       case PT_HP_OPT_ANNOT:     return "HP_OPT_ANNOT";
3968       case PT_HP_HSL_ANNOT:     return "HP_HSL_ANNOT";
3969       case PT_HP_STACK:         return "HP_STACK";
3970       case PT_HP_CORE_UTSNAME:  return "HP_CORE_UTSNAME";
3971       default:                  return NULL;
3972       }
3973
3974   if (e_machine == EM_IA_64)
3975     switch (type)
3976       {
3977       case PT_HP_TLS:            return "HP_TLS";
3978       case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3979       case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3980       case PT_IA_64_HP_STACK:    return "HP_STACK";
3981       default:                   return NULL;
3982       }
3983
3984   return NULL;
3985 }
3986
3987 static const char *
3988 get_solaris_segment_type (unsigned long type)
3989 {
3990   switch (type)
3991     {
3992     case 0x6464e550: return "PT_SUNW_UNWIND";
3993     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3994     case 0x6ffffff7: return "PT_LOSUNW";
3995     case 0x6ffffffa: return "PT_SUNWBSS";
3996     case 0x6ffffffb: return "PT_SUNWSTACK";
3997     case 0x6ffffffc: return "PT_SUNWDTRACE";
3998     case 0x6ffffffd: return "PT_SUNWCAP";
3999     case 0x6fffffff: return "PT_HISUNW";
4000     default:         return NULL;
4001     }
4002 }
4003
4004 static const char *
4005 get_segment_type (Filedata * filedata, unsigned long p_type)
4006 {
4007   static char buff[32];
4008
4009   switch (p_type)
4010     {
4011     case PT_NULL:       return "NULL";
4012     case PT_LOAD:       return "LOAD";
4013     case PT_DYNAMIC:    return "DYNAMIC";
4014     case PT_INTERP:     return "INTERP";
4015     case PT_NOTE:       return "NOTE";
4016     case PT_SHLIB:      return "SHLIB";
4017     case PT_PHDR:       return "PHDR";
4018     case PT_TLS:        return "TLS";
4019     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
4020     case PT_GNU_STACK:  return "GNU_STACK";
4021     case PT_GNU_RELRO:  return "GNU_RELRO";
4022     case PT_GNU_PROPERTY: return "GNU_PROPERTY";
4023
4024     default:
4025       if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
4026         {
4027           const char * result;
4028
4029           switch (filedata->file_header.e_machine)
4030             {
4031             case EM_AARCH64:
4032               result = get_aarch64_segment_type (p_type);
4033               break;
4034             case EM_ARM:
4035               result = get_arm_segment_type (p_type);
4036               break;
4037             case EM_MIPS:
4038             case EM_MIPS_RS3_LE:
4039               result = get_mips_segment_type (p_type);
4040               break;
4041             case EM_PARISC:
4042               result = get_parisc_segment_type (p_type);
4043               break;
4044             case EM_IA_64:
4045               result = get_ia64_segment_type (p_type);
4046               break;
4047             case EM_TI_C6000:
4048               result = get_tic6x_segment_type (p_type);
4049               break;
4050             case EM_S390:
4051             case EM_S390_OLD:
4052               result = get_s390_segment_type (p_type);
4053               break;
4054             default:
4055               result = NULL;
4056               break;
4057             }
4058
4059           if (result != NULL)
4060             return result;
4061
4062           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
4063         }
4064       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
4065         {
4066           const char * result = NULL;
4067
4068           switch (filedata->file_header.e_ident[EI_OSABI])
4069             {
4070             case ELFOSABI_GNU:
4071             case ELFOSABI_FREEBSD:
4072               if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
4073                 {
4074                   sprintf (buff, "GNU_MBIND+%#lx", p_type - PT_GNU_MBIND_LO);
4075                   result = buff;
4076                 }
4077               break;
4078             case ELFOSABI_HPUX:
4079               result = get_hpux_segment_type (p_type,
4080                                               filedata->file_header.e_machine);
4081               break;
4082             case ELFOSABI_SOLARIS:
4083               result = get_solaris_segment_type (p_type);
4084               break;
4085             default:
4086               break;
4087             }
4088           if (result != NULL)
4089             return result;
4090
4091           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4092         }
4093       else
4094         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4095
4096       return buff;
4097     }
4098 }
4099
4100 static const char *
4101 get_arc_section_type_name (unsigned int sh_type)
4102 {
4103   switch (sh_type)
4104     {
4105     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
4106     default:
4107       break;
4108     }
4109   return NULL;
4110 }
4111
4112 static const char *
4113 get_mips_section_type_name (unsigned int sh_type)
4114 {
4115   switch (sh_type)
4116     {
4117     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
4118     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
4119     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
4120     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
4121     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
4122     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
4123     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
4124     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
4125     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
4126     case SHT_MIPS_RELD:          return "MIPS_RELD";
4127     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
4128     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
4129     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
4130     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
4131     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
4132     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
4133     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
4134     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
4135     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
4136     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4137     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4138     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4139     case SHT_MIPS_LINE:          return "MIPS_LINE";
4140     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4141     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4142     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4143     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4144     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4145     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4146     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4147     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4148     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4149     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4150     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4151     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4152     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4153     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4154     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4155     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4156     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4157     case SHT_MIPS_XHASH:         return "MIPS_XHASH";
4158     default:
4159       break;
4160     }
4161   return NULL;
4162 }
4163
4164 static const char *
4165 get_parisc_section_type_name (unsigned int sh_type)
4166 {
4167   switch (sh_type)
4168     {
4169     case SHT_PARISC_EXT:        return "PARISC_EXT";
4170     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4171     case SHT_PARISC_DOC:        return "PARISC_DOC";
4172     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4173     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4174     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4175     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4176     default:                    return NULL;
4177     }
4178 }
4179
4180 static const char *
4181 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4182 {
4183   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4184   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4185     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4186
4187   switch (sh_type)
4188     {
4189     case SHT_IA_64_EXT:                return "IA_64_EXT";
4190     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4191     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4192     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4193     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4194     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4195     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4196     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4197     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4198     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4199     default:
4200       break;
4201     }
4202   return NULL;
4203 }
4204
4205 static const char *
4206 get_x86_64_section_type_name (unsigned int sh_type)
4207 {
4208   switch (sh_type)
4209     {
4210     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4211     default:                    return NULL;
4212     }
4213 }
4214
4215 static const char *
4216 get_aarch64_section_type_name (unsigned int sh_type)
4217 {
4218   switch (sh_type)
4219     {
4220     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4221     default:                     return NULL;
4222     }
4223 }
4224
4225 static const char *
4226 get_arm_section_type_name (unsigned int sh_type)
4227 {
4228   switch (sh_type)
4229     {
4230     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4231     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4232     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4233     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4234     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4235     default:                      return NULL;
4236     }
4237 }
4238
4239 static const char *
4240 get_tic6x_section_type_name (unsigned int sh_type)
4241 {
4242   switch (sh_type)
4243     {
4244     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4245     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4246     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4247     case SHT_TI_ICODE:          return "TI_ICODE";
4248     case SHT_TI_XREF:           return "TI_XREF";
4249     case SHT_TI_HANDLER:        return "TI_HANDLER";
4250     case SHT_TI_INITINFO:       return "TI_INITINFO";
4251     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4252     default:                    return NULL;
4253     }
4254 }
4255
4256 static const char *
4257 get_msp430x_section_type_name (unsigned int sh_type)
4258 {
4259   switch (sh_type)
4260     {
4261     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4262     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4263     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4264     default:                      return NULL;
4265     }
4266 }
4267
4268 static const char *
4269 get_nfp_section_type_name (unsigned int sh_type)
4270 {
4271   switch (sh_type)
4272     {
4273     case SHT_NFP_MECONFIG:      return "NFP_MECONFIG";
4274     case SHT_NFP_INITREG:       return "NFP_INITREG";
4275     case SHT_NFP_UDEBUG:        return "NFP_UDEBUG";
4276     default:                    return NULL;
4277     }
4278 }
4279
4280 static const char *
4281 get_v850_section_type_name (unsigned int sh_type)
4282 {
4283   switch (sh_type)
4284     {
4285     case SHT_V850_SCOMMON:  return "V850 Small Common";
4286     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4287     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4288     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4289     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4290     default:                return NULL;
4291     }
4292 }
4293
4294 static const char *
4295 get_riscv_section_type_name (unsigned int sh_type)
4296 {
4297   switch (sh_type)
4298     {
4299     case SHT_RISCV_ATTRIBUTES:  return "RISCV_ATTRIBUTES";
4300     default: return NULL;
4301     }
4302 }
4303
4304 static const char *
4305 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4306 {
4307   static char buff[32];
4308   const char * result;
4309
4310   switch (sh_type)
4311     {
4312     case SHT_NULL:              return "NULL";
4313     case SHT_PROGBITS:          return "PROGBITS";
4314     case SHT_SYMTAB:            return "SYMTAB";
4315     case SHT_STRTAB:            return "STRTAB";
4316     case SHT_RELA:              return "RELA";
4317     case SHT_HASH:              return "HASH";
4318     case SHT_DYNAMIC:           return "DYNAMIC";
4319     case SHT_NOTE:              return "NOTE";
4320     case SHT_NOBITS:            return "NOBITS";
4321     case SHT_REL:               return "REL";
4322     case SHT_SHLIB:             return "SHLIB";
4323     case SHT_DYNSYM:            return "DYNSYM";
4324     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4325     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4326     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4327     case SHT_GNU_HASH:          return "GNU_HASH";
4328     case SHT_GROUP:             return "GROUP";
4329     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICES";
4330     case SHT_GNU_verdef:        return "VERDEF";
4331     case SHT_GNU_verneed:       return "VERNEED";
4332     case SHT_GNU_versym:        return "VERSYM";
4333     case 0x6ffffff0:            return "VERSYM";
4334     case 0x6ffffffc:            return "VERDEF";
4335     case 0x7ffffffd:            return "AUXILIARY";
4336     case 0x7fffffff:            return "FILTER";
4337     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4338
4339     default:
4340       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4341         {
4342           switch (filedata->file_header.e_machine)
4343             {
4344             case EM_ARC:
4345             case EM_ARC_COMPACT:
4346             case EM_ARC_COMPACT2:
4347               result = get_arc_section_type_name (sh_type);
4348               break;
4349             case EM_MIPS:
4350             case EM_MIPS_RS3_LE:
4351               result = get_mips_section_type_name (sh_type);
4352               break;
4353             case EM_PARISC:
4354               result = get_parisc_section_type_name (sh_type);
4355               break;
4356             case EM_IA_64:
4357               result = get_ia64_section_type_name (filedata, sh_type);
4358               break;
4359             case EM_X86_64:
4360             case EM_L1OM:
4361             case EM_K1OM:
4362               result = get_x86_64_section_type_name (sh_type);
4363               break;
4364             case EM_AARCH64:
4365               result = get_aarch64_section_type_name (sh_type);
4366               break;
4367             case EM_ARM:
4368               result = get_arm_section_type_name (sh_type);
4369               break;
4370             case EM_TI_C6000:
4371               result = get_tic6x_section_type_name (sh_type);
4372               break;
4373             case EM_MSP430:
4374               result = get_msp430x_section_type_name (sh_type);
4375               break;
4376             case EM_NFP:
4377               result = get_nfp_section_type_name (sh_type);
4378               break;
4379             case EM_V800:
4380             case EM_V850:
4381             case EM_CYGNUS_V850:
4382               result = get_v850_section_type_name (sh_type);
4383               break;
4384             case EM_RISCV:
4385               result = get_riscv_section_type_name (sh_type);
4386               break;
4387             default:
4388               result = NULL;
4389               break;
4390             }
4391
4392           if (result != NULL)
4393             return result;
4394
4395           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4396         }
4397       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4398         {
4399           switch (filedata->file_header.e_machine)
4400             {
4401             case EM_IA_64:
4402               result = get_ia64_section_type_name (filedata, sh_type);
4403               break;
4404             default:
4405               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4406                 result = get_solaris_section_type (sh_type);
4407               else
4408                 {
4409                   switch (sh_type)
4410                     {
4411                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4412                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4413                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4414                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4415                     default:
4416                       result = NULL;
4417                       break;
4418                     }
4419                 }
4420               break;
4421             }
4422
4423           if (result != NULL)
4424             return result;
4425
4426           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4427         }
4428       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4429         {
4430           switch (filedata->file_header.e_machine)
4431             {
4432             case EM_V800:
4433             case EM_V850:
4434             case EM_CYGNUS_V850:
4435               result = get_v850_section_type_name (sh_type);
4436               break;
4437             default:
4438               result = NULL;
4439               break;
4440             }
4441
4442           if (result != NULL)
4443             return result;
4444
4445           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4446         }
4447       else
4448         /* This message is probably going to be displayed in a 15
4449            character wide field, so put the hex value first.  */
4450         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4451
4452       return buff;
4453     }
4454 }
4455
4456 #define OPTION_DEBUG_DUMP       512
4457 #define OPTION_DYN_SYMS         513
4458 #define OPTION_DWARF_DEPTH      514
4459 #define OPTION_DWARF_START      515
4460 #define OPTION_DWARF_CHECK      516
4461 #define OPTION_CTF_DUMP         517
4462 #define OPTION_CTF_PARENT       518
4463 #define OPTION_CTF_SYMBOLS      519
4464 #define OPTION_CTF_STRINGS      520
4465
4466 static struct option options[] =
4467 {
4468   {"all",              no_argument, 0, 'a'},
4469   {"file-header",      no_argument, 0, 'h'},
4470   {"program-headers",  no_argument, 0, 'l'},
4471   {"headers",          no_argument, 0, 'e'},
4472   {"histogram",        no_argument, 0, 'I'},
4473   {"segments",         no_argument, 0, 'l'},
4474   {"sections",         no_argument, 0, 'S'},
4475   {"section-headers",  no_argument, 0, 'S'},
4476   {"section-groups",   no_argument, 0, 'g'},
4477   {"section-details",  no_argument, 0, 't'},
4478   {"full-section-name",no_argument, 0, 'N'},
4479   {"symbols",          no_argument, 0, 's'},
4480   {"syms",             no_argument, 0, 's'},
4481   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4482   {"relocs",           no_argument, 0, 'r'},
4483   {"notes",            no_argument, 0, 'n'},
4484   {"dynamic",          no_argument, 0, 'd'},
4485   {"lint",             no_argument, 0, 'L'},
4486   {"enable-checks",    no_argument, 0, 'L'},
4487   {"arch-specific",    no_argument, 0, 'A'},
4488   {"version-info",     no_argument, 0, 'V'},
4489   {"use-dynamic",      no_argument, 0, 'D'},
4490   {"unwind",           no_argument, 0, 'u'},
4491   {"archive-index",    no_argument, 0, 'c'},
4492   {"hex-dump",         required_argument, 0, 'x'},
4493   {"relocated-dump",   required_argument, 0, 'R'},
4494   {"string-dump",      required_argument, 0, 'p'},
4495   {"decompress",       no_argument, 0, 'z'},
4496 #ifdef SUPPORT_DISASSEMBLY
4497   {"instruction-dump", required_argument, 0, 'i'},
4498 #endif
4499   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4500
4501   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4502   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4503   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4504
4505 #ifdef ENABLE_LIBCTF
4506   {"ctf",              required_argument, 0, OPTION_CTF_DUMP},
4507
4508   {"ctf-symbols",      required_argument, 0, OPTION_CTF_SYMBOLS},
4509   {"ctf-strings",      required_argument, 0, OPTION_CTF_STRINGS},
4510   {"ctf-parent",       required_argument, 0, OPTION_CTF_PARENT},
4511 #endif
4512
4513   {"version",          no_argument, 0, 'v'},
4514   {"wide",             no_argument, 0, 'W'},
4515   {"help",             no_argument, 0, 'H'},
4516   {0,                  no_argument, 0, 0}
4517 };
4518
4519 static void
4520 usage (FILE * stream)
4521 {
4522   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4523   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4524   fprintf (stream, _(" Options are:\n\
4525   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4526   -h --file-header       Display the ELF file header\n\
4527   -l --program-headers   Display the program headers\n\
4528      --segments          An alias for --program-headers\n\
4529   -S --section-headers   Display the sections' header\n\
4530      --sections          An alias for --section-headers\n\
4531   -g --section-groups    Display the section groups\n\
4532   -t --section-details   Display the section details\n\
4533   -e --headers           Equivalent to: -h -l -S\n\
4534   -s --syms              Display the symbol table\n\
4535      --symbols           An alias for --syms\n\
4536      --dyn-syms          Display the dynamic symbol table\n\
4537   -n --notes             Display the core notes (if present)\n\
4538   -r --relocs            Display the relocations (if present)\n\
4539   -u --unwind            Display the unwind info (if present)\n\
4540   -d --dynamic           Display the dynamic section (if present)\n\
4541   -V --version-info      Display the version sections (if present)\n\
4542   -A --arch-specific     Display architecture specific information (if any)\n\
4543   -c --archive-index     Display the symbol/file index in an archive\n\
4544   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4545   -L --lint|--enable-checks  Display warning messages for possible problems\n\
4546   -x --hex-dump=<number|name>\n\
4547                          Dump the contents of section <number|name> as bytes\n\
4548   -p --string-dump=<number|name>\n\
4549                          Dump the contents of section <number|name> as strings\n\
4550   -R --relocated-dump=<number|name>\n\
4551                          Dump the contents of section <number|name> as relocated bytes\n\
4552   -z --decompress        Decompress section before dumping it\n\
4553   -w[lLiaprmfFsoORtUuTgAckK] or\n\
4554   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4555                =frames-interp,=str,=str-offsets,=loc,=Ranges,=pubtypes,\n\
4556                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4557                =addr,=cu_index,=links,=follow-links]\n\
4558                          Display the contents of DWARF debug sections\n"));
4559   fprintf (stream, _("\
4560   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4561   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4562                          or deeper\n"));
4563 #ifdef ENABLE_LIBCTF
4564   fprintf (stream, _("\
4565   --ctf=<number|name>    Display CTF info from section <number|name>\n\
4566   --ctf-parent=<number|name>\n\
4567                          Use section <number|name> as the CTF parent\n\n\
4568   --ctf-symbols=<number|name>\n\
4569                          Use section <number|name> as the CTF external symtab\n\n\
4570   --ctf-strings=<number|name>\n\
4571                          Use section <number|name> as the CTF external strtab\n\n"));
4572 #endif
4573
4574 #ifdef SUPPORT_DISASSEMBLY
4575   fprintf (stream, _("\
4576   -i --instruction-dump=<number|name>\n\
4577                          Disassemble the contents of section <number|name>\n"));
4578 #endif
4579   fprintf (stream, _("\
4580   -I --histogram         Display histogram of bucket list lengths\n\
4581   -W --wide              Allow output width to exceed 80 characters\n\
4582   @<file>                Read options from <file>\n\
4583   -H --help              Display this information\n\
4584   -v --version           Display the version number of readelf\n"));
4585
4586   if (REPORT_BUGS_TO[0] && stream == stdout)
4587     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4588
4589   exit (stream == stdout ? 0 : 1);
4590 }
4591
4592 /* Record the fact that the user wants the contents of section number
4593    SECTION to be displayed using the method(s) encoded as flags bits
4594    in TYPE.  Note, TYPE can be zero if we are creating the array for
4595    the first time.  */
4596
4597 static void
4598 request_dump_bynumber (struct dump_data *dumpdata,
4599                        unsigned int section, dump_type type)
4600 {
4601   if (section >= dumpdata->num_dump_sects)
4602     {
4603       dump_type * new_dump_sects;
4604
4605       new_dump_sects = (dump_type *) calloc (section + 1,
4606                                              sizeof (* new_dump_sects));
4607
4608       if (new_dump_sects == NULL)
4609         error (_("Out of memory allocating dump request table.\n"));
4610       else
4611         {
4612           if (dumpdata->dump_sects)
4613             {
4614               /* Copy current flag settings.  */
4615               memcpy (new_dump_sects, dumpdata->dump_sects,
4616                       dumpdata->num_dump_sects * sizeof (* new_dump_sects));
4617
4618               free (dumpdata->dump_sects);
4619             }
4620
4621           dumpdata->dump_sects = new_dump_sects;
4622           dumpdata->num_dump_sects = section + 1;
4623         }
4624     }
4625
4626   if (dumpdata->dump_sects)
4627     dumpdata->dump_sects[section] |= type;
4628 }
4629
4630 /* Request a dump by section name.  */
4631
4632 static void
4633 request_dump_byname (const char * section, dump_type type)
4634 {
4635   struct dump_list_entry * new_request;
4636
4637   new_request = (struct dump_list_entry *)
4638       malloc (sizeof (struct dump_list_entry));
4639   if (!new_request)
4640     error (_("Out of memory allocating dump request table.\n"));
4641
4642   new_request->name = strdup (section);
4643   if (!new_request->name)
4644     error (_("Out of memory allocating dump request table.\n"));
4645
4646   new_request->type = type;
4647
4648   new_request->next = dump_sects_byname;
4649   dump_sects_byname = new_request;
4650 }
4651
4652 static inline void
4653 request_dump (struct dump_data *dumpdata, dump_type type)
4654 {
4655   int section;
4656   char * cp;
4657
4658   do_dump++;
4659   section = strtoul (optarg, & cp, 0);
4660
4661   if (! *cp && section >= 0)
4662     request_dump_bynumber (dumpdata, section, type);
4663   else
4664     request_dump_byname (optarg, type);
4665 }
4666
4667 static void
4668 parse_args (struct dump_data *dumpdata, int argc, char ** argv)
4669 {
4670   int c;
4671
4672   if (argc < 2)
4673     usage (stderr);
4674
4675   while ((c = getopt_long
4676           (argc, argv, "ADHILNR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4677     {
4678       switch (c)
4679         {
4680         case 0:
4681           /* Long options.  */
4682           break;
4683         case 'H':
4684           usage (stdout);
4685           break;
4686
4687         case 'a':
4688           do_syms = TRUE;
4689           do_reloc = TRUE;
4690           do_unwind = TRUE;
4691           do_dynamic = TRUE;
4692           do_header = TRUE;
4693           do_sections = TRUE;
4694           do_section_groups = TRUE;
4695           do_segments = TRUE;
4696           do_version = TRUE;
4697           do_histogram = TRUE;
4698           do_arch = TRUE;
4699           do_notes = TRUE;
4700           break;
4701         case 'g':
4702           do_section_groups = TRUE;
4703           break;
4704         case 't':
4705         case 'N':
4706           do_sections = TRUE;
4707           do_section_details = TRUE;
4708           break;
4709         case 'e':
4710           do_header = TRUE;
4711           do_sections = TRUE;
4712           do_segments = TRUE;
4713           break;
4714         case 'A':
4715           do_arch = TRUE;
4716           break;
4717         case 'D':
4718           do_using_dynamic = TRUE;
4719           break;
4720         case 'r':
4721           do_reloc = TRUE;
4722           break;
4723         case 'u':
4724           do_unwind = TRUE;
4725           break;
4726         case 'h':
4727           do_header = TRUE;
4728           break;
4729         case 'l':
4730           do_segments = TRUE;
4731           break;
4732         case 's':
4733           do_syms = TRUE;
4734           break;
4735         case 'S':
4736           do_sections = TRUE;
4737           break;
4738         case 'd':
4739           do_dynamic = TRUE;
4740           break;
4741         case 'I':
4742           do_histogram = TRUE;
4743           break;
4744         case 'n':
4745           do_notes = TRUE;
4746           break;
4747         case 'c':
4748           do_archive_index = TRUE;
4749           break;
4750         case 'L':
4751           do_checks = TRUE;
4752           break;
4753         case 'x':
4754           request_dump (dumpdata, HEX_DUMP);
4755           break;
4756         case 'p':
4757           request_dump (dumpdata, STRING_DUMP);
4758           break;
4759         case 'R':
4760           request_dump (dumpdata, RELOC_DUMP);
4761           break;
4762         case 'z':
4763           decompress_dumps = TRUE;
4764           break;
4765         case 'w':
4766           do_dump = TRUE;
4767           if (optarg == 0)
4768             {
4769               do_debugging = TRUE;
4770               dwarf_select_sections_all ();
4771             }
4772           else
4773             {
4774               do_debugging = FALSE;
4775               dwarf_select_sections_by_letters (optarg);
4776             }
4777           break;
4778         case OPTION_DEBUG_DUMP:
4779           do_dump = TRUE;
4780           if (optarg == 0)
4781             do_debugging = TRUE;
4782           else
4783             {
4784               do_debugging = FALSE;
4785               dwarf_select_sections_by_names (optarg);
4786             }
4787           break;
4788         case OPTION_DWARF_DEPTH:
4789           {
4790             char *cp;
4791
4792             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4793           }
4794           break;
4795         case OPTION_DWARF_START:
4796           {
4797             char *cp;
4798
4799             dwarf_start_die = strtoul (optarg, & cp, 0);
4800           }
4801           break;
4802         case OPTION_DWARF_CHECK:
4803           dwarf_check = TRUE;
4804           break;
4805         case OPTION_CTF_DUMP:
4806           do_ctf = TRUE;
4807           request_dump (dumpdata, CTF_DUMP);
4808           break;
4809         case OPTION_CTF_SYMBOLS:
4810           dump_ctf_symtab_name = strdup (optarg);
4811           break;
4812         case OPTION_CTF_STRINGS:
4813           dump_ctf_strtab_name = strdup (optarg);
4814           break;
4815         case OPTION_CTF_PARENT:
4816           dump_ctf_parent_name = strdup (optarg);
4817           break;
4818         case OPTION_DYN_SYMS:
4819           do_dyn_syms = TRUE;
4820           break;
4821 #ifdef SUPPORT_DISASSEMBLY
4822         case 'i':
4823           request_dump (dumpdata, DISASS_DUMP);
4824           break;
4825 #endif
4826         case 'v':
4827           print_version (program_name);
4828           break;
4829         case 'V':
4830           do_version = TRUE;
4831           break;
4832         case 'W':
4833           do_wide = TRUE;
4834           break;
4835         default:
4836           /* xgettext:c-format */
4837           error (_("Invalid option '-%c'\n"), c);
4838           /* Fall through.  */
4839         case '?':
4840           usage (stderr);
4841         }
4842     }
4843
4844   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4845       && !do_segments && !do_header && !do_dump && !do_version
4846       && !do_histogram && !do_debugging && !do_arch && !do_notes
4847       && !do_section_groups && !do_archive_index
4848       && !do_dyn_syms)
4849     {
4850       if (do_checks)
4851         {
4852           check_all = TRUE;
4853           do_dynamic = do_syms = do_reloc = do_unwind = do_sections = TRUE;
4854           do_segments = do_header = do_dump = do_version = TRUE;
4855           do_histogram = do_debugging = do_arch = do_notes = TRUE;
4856           do_section_groups = do_archive_index = do_dyn_syms = TRUE;
4857         }
4858       else
4859         usage (stderr);
4860     }
4861 }
4862
4863 static const char *
4864 get_elf_class (unsigned int elf_class)
4865 {
4866   static char buff[32];
4867
4868   switch (elf_class)
4869     {
4870     case ELFCLASSNONE: return _("none");
4871     case ELFCLASS32:   return "ELF32";
4872     case ELFCLASS64:   return "ELF64";
4873     default:
4874       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4875       return buff;
4876     }
4877 }
4878
4879 static const char *
4880 get_data_encoding (unsigned int encoding)
4881 {
4882   static char buff[32];
4883
4884   switch (encoding)
4885     {
4886     case ELFDATANONE: return _("none");
4887     case ELFDATA2LSB: return _("2's complement, little endian");
4888     case ELFDATA2MSB: return _("2's complement, big endian");
4889     default:
4890       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4891       return buff;
4892     }
4893 }
4894
4895 /* Decode the data held in 'filedata->file_header'.  */
4896
4897 static bfd_boolean
4898 process_file_header (Filedata * filedata)
4899 {
4900   Elf_Internal_Ehdr * header = & filedata->file_header;
4901
4902   if (   header->e_ident[EI_MAG0] != ELFMAG0
4903       || header->e_ident[EI_MAG1] != ELFMAG1
4904       || header->e_ident[EI_MAG2] != ELFMAG2
4905       || header->e_ident[EI_MAG3] != ELFMAG3)
4906     {
4907       error
4908         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4909       return FALSE;
4910     }
4911
4912   init_dwarf_regnames_by_elf_machine_code (header->e_machine);
4913
4914   if (do_header)
4915     {
4916       unsigned i;
4917
4918       printf (_("ELF Header:\n"));
4919       printf (_("  Magic:   "));
4920       for (i = 0; i < EI_NIDENT; i++)
4921         printf ("%2.2x ", header->e_ident[i]);
4922       printf ("\n");
4923       printf (_("  Class:                             %s\n"),
4924               get_elf_class (header->e_ident[EI_CLASS]));
4925       printf (_("  Data:                              %s\n"),
4926               get_data_encoding (header->e_ident[EI_DATA]));
4927       printf (_("  Version:                           %d%s\n"),
4928               header->e_ident[EI_VERSION],
4929               (header->e_ident[EI_VERSION] == EV_CURRENT
4930                ? _(" (current)")
4931                : (header->e_ident[EI_VERSION] != EV_NONE
4932                   ? _(" <unknown>")
4933                   : "")));
4934       printf (_("  OS/ABI:                            %s\n"),
4935               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4936       printf (_("  ABI Version:                       %d\n"),
4937               header->e_ident[EI_ABIVERSION]);
4938       printf (_("  Type:                              %s\n"),
4939               get_file_type (header->e_type));
4940       printf (_("  Machine:                           %s\n"),
4941               get_machine_name (header->e_machine));
4942       printf (_("  Version:                           0x%lx\n"),
4943               header->e_version);
4944
4945       printf (_("  Entry point address:               "));
4946       print_vma (header->e_entry, PREFIX_HEX);
4947       printf (_("\n  Start of program headers:          "));
4948       print_vma (header->e_phoff, DEC);
4949       printf (_(" (bytes into file)\n  Start of section headers:          "));
4950       print_vma (header->e_shoff, DEC);
4951       printf (_(" (bytes into file)\n"));
4952
4953       printf (_("  Flags:                             0x%lx%s\n"),
4954               header->e_flags,
4955               get_machine_flags (filedata, header->e_flags, header->e_machine));
4956       printf (_("  Size of this header:               %u (bytes)\n"),
4957               header->e_ehsize);
4958       printf (_("  Size of program headers:           %u (bytes)\n"),
4959               header->e_phentsize);
4960       printf (_("  Number of program headers:         %u"),
4961               header->e_phnum);
4962       if (filedata->section_headers != NULL
4963           && header->e_phnum == PN_XNUM
4964           && filedata->section_headers[0].sh_info != 0)
4965         {
4966           header->e_phnum = filedata->section_headers[0].sh_info;
4967           printf (" (%u)", header->e_phnum);
4968         }
4969       putc ('\n', stdout);
4970       printf (_("  Size of section headers:           %u (bytes)\n"),
4971               header->e_shentsize);
4972       printf (_("  Number of section headers:         %u"),
4973               header->e_shnum);
4974       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4975         {
4976           header->e_shnum = filedata->section_headers[0].sh_size;
4977           printf (" (%u)", header->e_shnum);
4978         }
4979       putc ('\n', stdout);
4980       printf (_("  Section header string table index: %u"),
4981               header->e_shstrndx);
4982       if (filedata->section_headers != NULL
4983           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4984         {
4985           header->e_shstrndx = filedata->section_headers[0].sh_link;
4986           printf (" (%u)", header->e_shstrndx);
4987         }
4988       if (header->e_shstrndx != SHN_UNDEF
4989           && header->e_shstrndx >= header->e_shnum)
4990         {
4991           header->e_shstrndx = SHN_UNDEF;
4992           printf (_(" <corrupt: out of range>"));
4993         }
4994       putc ('\n', stdout);
4995     }
4996
4997   if (filedata->section_headers != NULL)
4998     {
4999       if (header->e_phnum == PN_XNUM
5000           && filedata->section_headers[0].sh_info != 0)
5001         header->e_phnum = filedata->section_headers[0].sh_info;
5002       if (header->e_shnum == SHN_UNDEF)
5003         header->e_shnum = filedata->section_headers[0].sh_size;
5004       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
5005         header->e_shstrndx = filedata->section_headers[0].sh_link;
5006       if (header->e_shstrndx >= header->e_shnum)
5007         header->e_shstrndx = SHN_UNDEF;
5008       free (filedata->section_headers);
5009       filedata->section_headers = NULL;
5010     }
5011
5012   return TRUE;
5013 }
5014
5015 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5016    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
5017
5018 static bfd_boolean
5019 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
5020 {
5021   Elf32_External_Phdr * phdrs;
5022   Elf32_External_Phdr * external;
5023   Elf_Internal_Phdr *   internal;
5024   unsigned int i;
5025   unsigned int size = filedata->file_header.e_phentsize;
5026   unsigned int num  = filedata->file_header.e_phnum;
5027
5028   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5029   if (size == 0 || num == 0)
5030     return FALSE;
5031   if (size < sizeof * phdrs)
5032     {
5033       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5034       return FALSE;
5035     }
5036   if (size > sizeof * phdrs)
5037     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5038
5039   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5040                                             size, num, _("program headers"));
5041   if (phdrs == NULL)
5042     return FALSE;
5043
5044   for (i = 0, internal = pheaders, external = phdrs;
5045        i < filedata->file_header.e_phnum;
5046        i++, internal++, external++)
5047     {
5048       internal->p_type   = BYTE_GET (external->p_type);
5049       internal->p_offset = BYTE_GET (external->p_offset);
5050       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
5051       internal->p_paddr  = BYTE_GET (external->p_paddr);
5052       internal->p_filesz = BYTE_GET (external->p_filesz);
5053       internal->p_memsz  = BYTE_GET (external->p_memsz);
5054       internal->p_flags  = BYTE_GET (external->p_flags);
5055       internal->p_align  = BYTE_GET (external->p_align);
5056     }
5057
5058   free (phdrs);
5059   return TRUE;
5060 }
5061
5062 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5063    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
5064
5065 static bfd_boolean
5066 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
5067 {
5068   Elf64_External_Phdr * phdrs;
5069   Elf64_External_Phdr * external;
5070   Elf_Internal_Phdr *   internal;
5071   unsigned int i;
5072   unsigned int size = filedata->file_header.e_phentsize;
5073   unsigned int num  = filedata->file_header.e_phnum;
5074
5075   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5076   if (size == 0 || num == 0)
5077     return FALSE;
5078   if (size < sizeof * phdrs)
5079     {
5080       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5081       return FALSE;
5082     }
5083   if (size > sizeof * phdrs)
5084     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5085
5086   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5087                                             size, num, _("program headers"));
5088   if (!phdrs)
5089     return FALSE;
5090
5091   for (i = 0, internal = pheaders, external = phdrs;
5092        i < filedata->file_header.e_phnum;
5093        i++, internal++, external++)
5094     {
5095       internal->p_type   = BYTE_GET (external->p_type);
5096       internal->p_flags  = BYTE_GET (external->p_flags);
5097       internal->p_offset = BYTE_GET (external->p_offset);
5098       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
5099       internal->p_paddr  = BYTE_GET (external->p_paddr);
5100       internal->p_filesz = BYTE_GET (external->p_filesz);
5101       internal->p_memsz  = BYTE_GET (external->p_memsz);
5102       internal->p_align  = BYTE_GET (external->p_align);
5103     }
5104
5105   free (phdrs);
5106   return TRUE;
5107 }
5108
5109 /* Returns TRUE if the program headers were read into `program_headers'.  */
5110
5111 static bfd_boolean
5112 get_program_headers (Filedata * filedata)
5113 {
5114   Elf_Internal_Phdr * phdrs;
5115
5116   /* Check cache of prior read.  */
5117   if (filedata->program_headers != NULL)
5118     return TRUE;
5119
5120   /* Be kind to memory checkers by looking for
5121      e_phnum values which we know must be invalid.  */
5122   if (filedata->file_header.e_phnum
5123       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
5124       >= filedata->file_size)
5125     {
5126       error (_("Too many program headers - %#x - the file is not that big\n"),
5127              filedata->file_header.e_phnum);
5128       return FALSE;
5129     }
5130
5131   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
5132                                          sizeof (Elf_Internal_Phdr));
5133   if (phdrs == NULL)
5134     {
5135       error (_("Out of memory reading %u program headers\n"),
5136              filedata->file_header.e_phnum);
5137       return FALSE;
5138     }
5139
5140   if (is_32bit_elf
5141       ? get_32bit_program_headers (filedata, phdrs)
5142       : get_64bit_program_headers (filedata, phdrs))
5143     {
5144       filedata->program_headers = phdrs;
5145       return TRUE;
5146     }
5147
5148   free (phdrs);
5149   return FALSE;
5150 }
5151
5152 /* Returns TRUE if the program headers were loaded.  */
5153
5154 static bfd_boolean
5155 process_program_headers (Filedata * filedata)
5156 {
5157   Elf_Internal_Phdr * segment;
5158   unsigned int i;
5159   Elf_Internal_Phdr * previous_load = NULL;
5160
5161   filedata->dynamic_addr = 0;
5162   filedata->dynamic_size = 0;
5163
5164   if (filedata->file_header.e_phnum == 0)
5165     {
5166       /* PR binutils/12467.  */
5167       if (filedata->file_header.e_phoff != 0)
5168         {
5169           warn (_("possibly corrupt ELF header - it has a non-zero program"
5170                   " header offset, but no program headers\n"));
5171           return FALSE;
5172         }
5173       else if (do_segments)
5174         printf (_("\nThere are no program headers in this file.\n"));
5175       return TRUE;
5176     }
5177
5178   if (do_segments && !do_header)
5179     {
5180       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5181       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5182       printf (ngettext ("There is %d program header, starting at offset %s\n",
5183                         "There are %d program headers, starting at offset %s\n",
5184                         filedata->file_header.e_phnum),
5185               filedata->file_header.e_phnum,
5186               bfd_vmatoa ("u", filedata->file_header.e_phoff));
5187     }
5188
5189   if (! get_program_headers (filedata))
5190     return TRUE;
5191
5192   if (do_segments)
5193     {
5194       if (filedata->file_header.e_phnum > 1)
5195         printf (_("\nProgram Headers:\n"));
5196       else
5197         printf (_("\nProgram Headers:\n"));
5198
5199       if (is_32bit_elf)
5200         printf
5201           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
5202       else if (do_wide)
5203         printf
5204           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
5205       else
5206         {
5207           printf
5208             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
5209           printf
5210             (_("                 FileSiz            MemSiz              Flags  Align\n"));
5211         }
5212     }
5213
5214   for (i = 0, segment = filedata->program_headers;
5215        i < filedata->file_header.e_phnum;
5216        i++, segment++)
5217     {
5218       if (do_segments)
5219         {
5220           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
5221
5222           if (is_32bit_elf)
5223             {
5224               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5225               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5226               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5227               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5228               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5229               printf ("%c%c%c ",
5230                       (segment->p_flags & PF_R ? 'R' : ' '),
5231                       (segment->p_flags & PF_W ? 'W' : ' '),
5232                       (segment->p_flags & PF_X ? 'E' : ' '));
5233               printf ("%#lx", (unsigned long) segment->p_align);
5234             }
5235           else if (do_wide)
5236             {
5237               if ((unsigned long) segment->p_offset == segment->p_offset)
5238                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5239               else
5240                 {
5241                   print_vma (segment->p_offset, FULL_HEX);
5242                   putchar (' ');
5243                 }
5244
5245               print_vma (segment->p_vaddr, FULL_HEX);
5246               putchar (' ');
5247               print_vma (segment->p_paddr, FULL_HEX);
5248               putchar (' ');
5249
5250               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5251                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5252               else
5253                 {
5254                   print_vma (segment->p_filesz, FULL_HEX);
5255                   putchar (' ');
5256                 }
5257
5258               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5259                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5260               else
5261                 {
5262                   print_vma (segment->p_memsz, FULL_HEX);
5263                 }
5264
5265               printf (" %c%c%c ",
5266                       (segment->p_flags & PF_R ? 'R' : ' '),
5267                       (segment->p_flags & PF_W ? 'W' : ' '),
5268                       (segment->p_flags & PF_X ? 'E' : ' '));
5269
5270               if ((unsigned long) segment->p_align == segment->p_align)
5271                 printf ("%#lx", (unsigned long) segment->p_align);
5272               else
5273                 {
5274                   print_vma (segment->p_align, PREFIX_HEX);
5275                 }
5276             }
5277           else
5278             {
5279               print_vma (segment->p_offset, FULL_HEX);
5280               putchar (' ');
5281               print_vma (segment->p_vaddr, FULL_HEX);
5282               putchar (' ');
5283               print_vma (segment->p_paddr, FULL_HEX);
5284               printf ("\n                 ");
5285               print_vma (segment->p_filesz, FULL_HEX);
5286               putchar (' ');
5287               print_vma (segment->p_memsz, FULL_HEX);
5288               printf ("  %c%c%c    ",
5289                       (segment->p_flags & PF_R ? 'R' : ' '),
5290                       (segment->p_flags & PF_W ? 'W' : ' '),
5291                       (segment->p_flags & PF_X ? 'E' : ' '));
5292               print_vma (segment->p_align, PREFIX_HEX);
5293             }
5294
5295           putc ('\n', stdout);
5296         }
5297
5298       switch (segment->p_type)
5299         {
5300         case PT_LOAD:
5301 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5302          required by the ELF standard, several programs, including the Linux
5303          kernel, make use of non-ordered segments.  */
5304           if (previous_load
5305               && previous_load->p_vaddr > segment->p_vaddr)
5306             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5307 #endif
5308           if (segment->p_memsz < segment->p_filesz)
5309             error (_("the segment's file size is larger than its memory size\n"));
5310           previous_load = segment;
5311           break;
5312
5313         case PT_PHDR:
5314           /* PR 20815 - Verify that the program header is loaded into memory.  */
5315           if (i > 0 && previous_load != NULL)
5316             error (_("the PHDR segment must occur before any LOAD segment\n"));
5317           if (filedata->file_header.e_machine != EM_PARISC)
5318             {
5319               unsigned int j;
5320
5321               for (j = 1; j < filedata->file_header.e_phnum; j++)
5322                 {
5323                   Elf_Internal_Phdr *load = filedata->program_headers + j;
5324                   if (load->p_type == PT_LOAD
5325                       && load->p_offset <= segment->p_offset
5326                       && (load->p_offset + load->p_filesz
5327                           >= segment->p_offset + segment->p_filesz)
5328                       && load->p_vaddr <= segment->p_vaddr
5329                       && (load->p_vaddr + load->p_filesz
5330                           >= segment->p_vaddr + segment->p_filesz))
5331                     break;
5332                 }
5333               if (j == filedata->file_header.e_phnum)
5334                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5335             }
5336           break;
5337
5338         case PT_DYNAMIC:
5339           if (filedata->dynamic_addr)
5340             error (_("more than one dynamic segment\n"));
5341
5342           /* By default, assume that the .dynamic section is the first
5343              section in the DYNAMIC segment.  */
5344           filedata->dynamic_addr = segment->p_offset;
5345           filedata->dynamic_size = segment->p_filesz;
5346
5347           /* Try to locate the .dynamic section. If there is
5348              a section header table, we can easily locate it.  */
5349           if (filedata->section_headers != NULL)
5350             {
5351               Elf_Internal_Shdr * sec;
5352
5353               sec = find_section (filedata, ".dynamic");
5354               if (sec == NULL || sec->sh_size == 0)
5355                 {
5356                   /* A corresponding .dynamic section is expected, but on
5357                      IA-64/OpenVMS it is OK for it to be missing.  */
5358                   if (!is_ia64_vms (filedata))
5359                     error (_("no .dynamic section in the dynamic segment\n"));
5360                   break;
5361                 }
5362
5363               if (sec->sh_type == SHT_NOBITS)
5364                 {
5365                   filedata->dynamic_size = 0;
5366                   break;
5367                 }
5368
5369               filedata->dynamic_addr = sec->sh_offset;
5370               filedata->dynamic_size = sec->sh_size;
5371
5372               /* The PT_DYNAMIC segment, which is used by the run-time
5373                  loader,  should exactly match the .dynamic section.  */
5374               if (do_checks
5375                   && (filedata->dynamic_addr != segment->p_offset
5376                       || filedata->dynamic_size != segment->p_filesz))
5377                 warn (_("\
5378 the .dynamic section is not the same as the dynamic segment\n"));
5379             }
5380
5381           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5382              segment.  Check this after matching against the section headers
5383              so we don't warn on debuginfo file (which have NOBITS .dynamic
5384              sections).  */
5385           if (filedata->dynamic_addr > filedata->file_size
5386               || (filedata->dynamic_size
5387                   > filedata->file_size - filedata->dynamic_addr))
5388             {
5389               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5390               filedata->dynamic_addr = filedata->dynamic_size = 0;
5391             }
5392           break;
5393
5394         case PT_INTERP:
5395           if (fseek (filedata->handle,
5396                      filedata->archive_file_offset + (long) segment->p_offset,
5397                      SEEK_SET))
5398             error (_("Unable to find program interpreter name\n"));
5399           else
5400             {
5401               char fmt [32];
5402               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5403
5404               if (ret >= (int) sizeof (fmt) || ret < 0)
5405                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5406
5407               filedata->program_interpreter[0] = 0;
5408               if (fscanf (filedata->handle, fmt,
5409                           filedata->program_interpreter) <= 0)
5410                 error (_("Unable to read program interpreter name\n"));
5411
5412               if (do_segments)
5413                 printf (_("      [Requesting program interpreter: %s]\n"),
5414                     filedata->program_interpreter);
5415             }
5416           break;
5417         }
5418     }
5419
5420   if (do_segments
5421       && filedata->section_headers != NULL
5422       && filedata->string_table != NULL)
5423     {
5424       printf (_("\n Section to Segment mapping:\n"));
5425       printf (_("  Segment Sections...\n"));
5426
5427       for (i = 0; i < filedata->file_header.e_phnum; i++)
5428         {
5429           unsigned int j;
5430           Elf_Internal_Shdr * section;
5431
5432           segment = filedata->program_headers + i;
5433           section = filedata->section_headers + 1;
5434
5435           printf ("   %2.2d     ", i);
5436
5437           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5438             {
5439               if (!ELF_TBSS_SPECIAL (section, segment)
5440                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5441                 printf ("%s ", printable_section_name (filedata, section));
5442             }
5443
5444           putc ('\n',stdout);
5445         }
5446     }
5447
5448   return TRUE;
5449 }
5450
5451
5452 /* Find the file offset corresponding to VMA by using the program headers.  */
5453
5454 static long
5455 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5456 {
5457   Elf_Internal_Phdr * seg;
5458
5459   if (! get_program_headers (filedata))
5460     {
5461       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5462       return (long) vma;
5463     }
5464
5465   for (seg = filedata->program_headers;
5466        seg < filedata->program_headers + filedata->file_header.e_phnum;
5467        ++seg)
5468     {
5469       if (seg->p_type != PT_LOAD)
5470         continue;
5471
5472       if (vma >= (seg->p_vaddr & -seg->p_align)
5473           && vma + size <= seg->p_vaddr + seg->p_filesz)
5474         return vma - seg->p_vaddr + seg->p_offset;
5475     }
5476
5477   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5478         (unsigned long) vma);
5479   return (long) vma;
5480 }
5481
5482
5483 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5484    If PROBE is true, this is just a probe and we do not generate any error
5485    messages if the load fails.  */
5486
5487 static bfd_boolean
5488 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5489 {
5490   Elf32_External_Shdr * shdrs;
5491   Elf_Internal_Shdr *   internal;
5492   unsigned int          i;
5493   unsigned int          size = filedata->file_header.e_shentsize;
5494   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5495
5496   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5497   if (size == 0 || num == 0)
5498     return FALSE;
5499   if (size < sizeof * shdrs)
5500     {
5501       if (! probe)
5502         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5503       return FALSE;
5504     }
5505   if (!probe && size > sizeof * shdrs)
5506     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5507
5508   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5509                                             size, num,
5510                                             probe ? NULL : _("section headers"));
5511   if (shdrs == NULL)
5512     return FALSE;
5513
5514   free (filedata->section_headers);
5515   filedata->section_headers = (Elf_Internal_Shdr *)
5516     cmalloc (num, sizeof (Elf_Internal_Shdr));
5517   if (filedata->section_headers == NULL)
5518     {
5519       if (!probe)
5520         error (_("Out of memory reading %u section headers\n"), num);
5521       free (shdrs);
5522       return FALSE;
5523     }
5524
5525   for (i = 0, internal = filedata->section_headers;
5526        i < num;
5527        i++, internal++)
5528     {
5529       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5530       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5531       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5532       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5533       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5534       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5535       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5536       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5537       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5538       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5539       if (!probe && internal->sh_link > num)
5540         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5541       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5542         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5543     }
5544
5545   free (shdrs);
5546   return TRUE;
5547 }
5548
5549 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5550
5551 static bfd_boolean
5552 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5553 {
5554   Elf64_External_Shdr *  shdrs;
5555   Elf_Internal_Shdr *    internal;
5556   unsigned int           i;
5557   unsigned int           size = filedata->file_header.e_shentsize;
5558   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5559
5560   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5561   if (size == 0 || num == 0)
5562     return FALSE;
5563
5564   if (size < sizeof * shdrs)
5565     {
5566       if (! probe)
5567         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5568       return FALSE;
5569     }
5570
5571   if (! probe && size > sizeof * shdrs)
5572     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5573
5574   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5575                                             filedata->file_header.e_shoff,
5576                                             size, num,
5577                                             probe ? NULL : _("section headers"));
5578   if (shdrs == NULL)
5579     return FALSE;
5580
5581   free (filedata->section_headers);
5582   filedata->section_headers = (Elf_Internal_Shdr *)
5583     cmalloc (num, sizeof (Elf_Internal_Shdr));
5584   if (filedata->section_headers == NULL)
5585     {
5586       if (! probe)
5587         error (_("Out of memory reading %u section headers\n"), num);
5588       free (shdrs);
5589       return FALSE;
5590     }
5591
5592   for (i = 0, internal = filedata->section_headers;
5593        i < num;
5594        i++, internal++)
5595     {
5596       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5597       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5598       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5599       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5600       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5601       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5602       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5603       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5604       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5605       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5606       if (!probe && internal->sh_link > num)
5607         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5608       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5609         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5610     }
5611
5612   free (shdrs);
5613   return TRUE;
5614 }
5615
5616 static Elf_Internal_Sym *
5617 get_32bit_elf_symbols (Filedata *           filedata,
5618                        Elf_Internal_Shdr *  section,
5619                        unsigned long *      num_syms_return)
5620 {
5621   unsigned long number = 0;
5622   Elf32_External_Sym * esyms = NULL;
5623   Elf_External_Sym_Shndx * shndx = NULL;
5624   Elf_Internal_Sym * isyms = NULL;
5625   Elf_Internal_Sym * psym;
5626   unsigned int j;
5627   elf_section_list * entry;
5628
5629   if (section->sh_size == 0)
5630     {
5631       if (num_syms_return != NULL)
5632         * num_syms_return = 0;
5633       return NULL;
5634     }
5635
5636   /* Run some sanity checks first.  */
5637   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5638     {
5639       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5640              printable_section_name (filedata, section),
5641              (unsigned long) section->sh_entsize);
5642       goto exit_point;
5643     }
5644
5645   if (section->sh_size > filedata->file_size)
5646     {
5647       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5648              printable_section_name (filedata, section),
5649              (unsigned long) section->sh_size);
5650       goto exit_point;
5651     }
5652
5653   number = section->sh_size / section->sh_entsize;
5654
5655   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5656     {
5657       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5658              (unsigned long) section->sh_size,
5659              printable_section_name (filedata, section),
5660              (unsigned long) section->sh_entsize);
5661       goto exit_point;
5662     }
5663
5664   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5665                                            section->sh_size, _("symbols"));
5666   if (esyms == NULL)
5667     goto exit_point;
5668
5669   shndx = NULL;
5670   for (entry = filedata->symtab_shndx_list; entry != NULL; entry = entry->next)
5671     {
5672       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5673         continue;
5674
5675       if (shndx != NULL)
5676         {
5677           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5678           free (shndx);
5679         }
5680
5681       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5682                                                    entry->hdr->sh_offset,
5683                                                    1, entry->hdr->sh_size,
5684                                                    _("symbol table section indices"));
5685       if (shndx == NULL)
5686         goto exit_point;
5687
5688       /* PR17531: file: heap-buffer-overflow */
5689       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5690         {
5691           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5692                  printable_section_name (filedata, entry->hdr),
5693                  (unsigned long) entry->hdr->sh_size,
5694                  (unsigned long) section->sh_size);
5695           goto exit_point;
5696         }
5697     }
5698
5699   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5700
5701   if (isyms == NULL)
5702     {
5703       error (_("Out of memory reading %lu symbols\n"),
5704              (unsigned long) number);
5705       goto exit_point;
5706     }
5707
5708   for (j = 0, psym = isyms; j < number; j++, psym++)
5709     {
5710       psym->st_name  = BYTE_GET (esyms[j].st_name);
5711       psym->st_value = BYTE_GET (esyms[j].st_value);
5712       psym->st_size  = BYTE_GET (esyms[j].st_size);
5713       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5714       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5715         psym->st_shndx
5716           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5717       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5718         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5719       psym->st_info  = BYTE_GET (esyms[j].st_info);
5720       psym->st_other = BYTE_GET (esyms[j].st_other);
5721     }
5722
5723  exit_point:
5724   free (shndx);
5725   free (esyms);
5726
5727   if (num_syms_return != NULL)
5728     * num_syms_return = isyms == NULL ? 0 : number;
5729
5730   return isyms;
5731 }
5732
5733 static Elf_Internal_Sym *
5734 get_64bit_elf_symbols (Filedata *           filedata,
5735                        Elf_Internal_Shdr *  section,
5736                        unsigned long *      num_syms_return)
5737 {
5738   unsigned long number = 0;
5739   Elf64_External_Sym * esyms = NULL;
5740   Elf_External_Sym_Shndx * shndx = NULL;
5741   Elf_Internal_Sym * isyms = NULL;
5742   Elf_Internal_Sym * psym;
5743   unsigned int j;
5744   elf_section_list * entry;
5745
5746   if (section->sh_size == 0)
5747     {
5748       if (num_syms_return != NULL)
5749         * num_syms_return = 0;
5750       return NULL;
5751     }
5752
5753   /* Run some sanity checks first.  */
5754   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5755     {
5756       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5757              printable_section_name (filedata, section),
5758              (unsigned long) section->sh_entsize);
5759       goto exit_point;
5760     }
5761
5762   if (section->sh_size > filedata->file_size)
5763     {
5764       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5765              printable_section_name (filedata, section),
5766              (unsigned long) section->sh_size);
5767       goto exit_point;
5768     }
5769
5770   number = section->sh_size / section->sh_entsize;
5771
5772   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5773     {
5774       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5775              (unsigned long) section->sh_size,
5776              printable_section_name (filedata, section),
5777              (unsigned long) section->sh_entsize);
5778       goto exit_point;
5779     }
5780
5781   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5782                                            section->sh_size, _("symbols"));
5783   if (!esyms)
5784     goto exit_point;
5785
5786   shndx = NULL;
5787   for (entry = filedata->symtab_shndx_list; entry != NULL; entry = entry->next)
5788     {
5789       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5790         continue;
5791
5792       if (shndx != NULL)
5793         {
5794           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5795           free (shndx);
5796         }
5797
5798       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5799                                                    entry->hdr->sh_offset,
5800                                                    1, entry->hdr->sh_size,
5801                                                    _("symbol table section indices"));
5802       if (shndx == NULL)
5803         goto exit_point;
5804
5805       /* PR17531: file: heap-buffer-overflow */
5806       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5807         {
5808           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5809                  printable_section_name (filedata, entry->hdr),
5810                  (unsigned long) entry->hdr->sh_size,
5811                  (unsigned long) section->sh_size);
5812           goto exit_point;
5813         }
5814     }
5815
5816   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5817
5818   if (isyms == NULL)
5819     {
5820       error (_("Out of memory reading %lu symbols\n"),
5821              (unsigned long) number);
5822       goto exit_point;
5823     }
5824
5825   for (j = 0, psym = isyms; j < number; j++, psym++)
5826     {
5827       psym->st_name  = BYTE_GET (esyms[j].st_name);
5828       psym->st_info  = BYTE_GET (esyms[j].st_info);
5829       psym->st_other = BYTE_GET (esyms[j].st_other);
5830       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5831
5832       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5833         psym->st_shndx
5834           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5835       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5836         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5837
5838       psym->st_value = BYTE_GET (esyms[j].st_value);
5839       psym->st_size  = BYTE_GET (esyms[j].st_size);
5840     }
5841
5842  exit_point:
5843   free (shndx);
5844   free (esyms);
5845
5846   if (num_syms_return != NULL)
5847     * num_syms_return = isyms == NULL ? 0 : number;
5848
5849   return isyms;
5850 }
5851
5852 static const char *
5853 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5854 {
5855   static char buff[1024];
5856   char * p = buff;
5857   unsigned int field_size = is_32bit_elf ? 8 : 16;
5858   signed int sindex;
5859   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5860   bfd_vma os_flags = 0;
5861   bfd_vma proc_flags = 0;
5862   bfd_vma unknown_flags = 0;
5863   static const struct
5864     {
5865       const char * str;
5866       unsigned int len;
5867     }
5868   flags [] =
5869     {
5870       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5871       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5872       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5873       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5874       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5875       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5876       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5877       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5878       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5879       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5880       /* IA-64 specific.  */
5881       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5882       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5883       /* IA-64 OpenVMS specific.  */
5884       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5885       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5886       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5887       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5888       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5889       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5890       /* Generic.  */
5891       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5892       /* SPARC specific.  */
5893       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5894       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5895       /* ARM specific.  */
5896       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5897       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5898       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5899       /* GNU specific.  */
5900       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5901       /* VLE specific.  */
5902       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5903     };
5904
5905   if (do_section_details)
5906     {
5907       sprintf (buff, "[%*.*lx]: ",
5908                field_size, field_size, (unsigned long) sh_flags);
5909       p += field_size + 4;
5910     }
5911
5912   while (sh_flags)
5913     {
5914       bfd_vma flag;
5915
5916       flag = sh_flags & - sh_flags;
5917       sh_flags &= ~ flag;
5918
5919       if (do_section_details)
5920         {
5921           switch (flag)
5922             {
5923             case SHF_WRITE:             sindex = 0; break;
5924             case SHF_ALLOC:             sindex = 1; break;
5925             case SHF_EXECINSTR:         sindex = 2; break;
5926             case SHF_MERGE:             sindex = 3; break;
5927             case SHF_STRINGS:           sindex = 4; break;
5928             case SHF_INFO_LINK:         sindex = 5; break;
5929             case SHF_LINK_ORDER:        sindex = 6; break;
5930             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5931             case SHF_GROUP:             sindex = 8; break;
5932             case SHF_TLS:               sindex = 9; break;
5933             case SHF_EXCLUDE:           sindex = 18; break;
5934             case SHF_COMPRESSED:        sindex = 20; break;
5935             case SHF_GNU_MBIND:         sindex = 24; break;
5936
5937             default:
5938               sindex = -1;
5939               switch (filedata->file_header.e_machine)
5940                 {
5941                 case EM_IA_64:
5942                   if (flag == SHF_IA_64_SHORT)
5943                     sindex = 10;
5944                   else if (flag == SHF_IA_64_NORECOV)
5945                     sindex = 11;
5946 #ifdef BFD64
5947                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5948                     switch (flag)
5949                       {
5950                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5951                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5952                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5953                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5954                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5955                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5956                       default:                        break;
5957                       }
5958 #endif
5959                   break;
5960
5961                 case EM_386:
5962                 case EM_IAMCU:
5963                 case EM_X86_64:
5964                 case EM_L1OM:
5965                 case EM_K1OM:
5966                 case EM_OLD_SPARCV9:
5967                 case EM_SPARC32PLUS:
5968                 case EM_SPARCV9:
5969                 case EM_SPARC:
5970                   if (flag == SHF_ORDERED)
5971                     sindex = 19;
5972                   break;
5973
5974                 case EM_ARM:
5975                   switch (flag)
5976                     {
5977                     case SHF_ENTRYSECT: sindex = 21; break;
5978                     case SHF_ARM_PURECODE: sindex = 22; break;
5979                     case SHF_COMDEF: sindex = 23; break;
5980                     default: break;
5981                     }
5982                   break;
5983                 case EM_PPC:
5984                   if (flag == SHF_PPC_VLE)
5985                     sindex = 25;
5986                   break;
5987
5988                 default:
5989                   break;
5990                 }
5991             }
5992
5993           if (sindex != -1)
5994             {
5995               if (p != buff + field_size + 4)
5996                 {
5997                   if (size < (10 + 2))
5998                     {
5999                       warn (_("Internal error: not enough buffer room for section flag info"));
6000                       return _("<unknown>");
6001                     }
6002                   size -= 2;
6003                   *p++ = ',';
6004                   *p++ = ' ';
6005                 }
6006
6007               size -= flags [sindex].len;
6008               p = stpcpy (p, flags [sindex].str);
6009             }
6010           else if (flag & SHF_MASKOS)
6011             os_flags |= flag;
6012           else if (flag & SHF_MASKPROC)
6013             proc_flags |= flag;
6014           else
6015             unknown_flags |= flag;
6016         }
6017       else
6018         {
6019           switch (flag)
6020             {
6021             case SHF_WRITE:             *p = 'W'; break;
6022             case SHF_ALLOC:             *p = 'A'; break;
6023             case SHF_EXECINSTR:         *p = 'X'; break;
6024             case SHF_MERGE:             *p = 'M'; break;
6025             case SHF_STRINGS:           *p = 'S'; break;
6026             case SHF_INFO_LINK:         *p = 'I'; break;
6027             case SHF_LINK_ORDER:        *p = 'L'; break;
6028             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
6029             case SHF_GROUP:             *p = 'G'; break;
6030             case SHF_TLS:               *p = 'T'; break;
6031             case SHF_EXCLUDE:           *p = 'E'; break;
6032             case SHF_COMPRESSED:        *p = 'C'; break;
6033             case SHF_GNU_MBIND:         *p = 'D'; break;
6034
6035             default:
6036               if ((filedata->file_header.e_machine == EM_X86_64
6037                    || filedata->file_header.e_machine == EM_L1OM
6038                    || filedata->file_header.e_machine == EM_K1OM)
6039                   && flag == SHF_X86_64_LARGE)
6040                 *p = 'l';
6041               else if (filedata->file_header.e_machine == EM_ARM
6042                        && flag == SHF_ARM_PURECODE)
6043                   *p = 'y';
6044               else if (filedata->file_header.e_machine == EM_PPC
6045                        && flag == SHF_PPC_VLE)
6046                   *p = 'v';
6047               else if (flag & SHF_MASKOS)
6048                 {
6049                   *p = 'o';
6050                   sh_flags &= ~ SHF_MASKOS;
6051                 }
6052               else if (flag & SHF_MASKPROC)
6053                 {
6054                   *p = 'p';
6055                   sh_flags &= ~ SHF_MASKPROC;
6056                 }
6057               else
6058                 *p = 'x';
6059               break;
6060             }
6061           p++;
6062         }
6063     }
6064
6065   if (do_section_details)
6066     {
6067       if (os_flags)
6068         {
6069           size -= 5 + field_size;
6070           if (p != buff + field_size + 4)
6071             {
6072               if (size < (2 + 1))
6073                 {
6074                   warn (_("Internal error: not enough buffer room for section flag info"));
6075                   return _("<unknown>");
6076                 }
6077               size -= 2;
6078               *p++ = ',';
6079               *p++ = ' ';
6080             }
6081           sprintf (p, "OS (%*.*lx)", field_size, field_size,
6082                    (unsigned long) os_flags);
6083           p += 5 + field_size;
6084         }
6085       if (proc_flags)
6086         {
6087           size -= 7 + field_size;
6088           if (p != buff + field_size + 4)
6089             {
6090               if (size < (2 + 1))
6091                 {
6092                   warn (_("Internal error: not enough buffer room for section flag info"));
6093                   return _("<unknown>");
6094                 }
6095               size -= 2;
6096               *p++ = ',';
6097               *p++ = ' ';
6098             }
6099           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
6100                    (unsigned long) proc_flags);
6101           p += 7 + field_size;
6102         }
6103       if (unknown_flags)
6104         {
6105           size -= 10 + field_size;
6106           if (p != buff + field_size + 4)
6107             {
6108               if (size < (2 + 1))
6109                 {
6110                   warn (_("Internal error: not enough buffer room for section flag info"));
6111                   return _("<unknown>");
6112                 }
6113               size -= 2;
6114               *p++ = ',';
6115               *p++ = ' ';
6116             }
6117           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
6118                    (unsigned long) unknown_flags);
6119           p += 10 + field_size;
6120         }
6121     }
6122
6123   *p = '\0';
6124   return buff;
6125 }
6126
6127 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6128 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
6129 {
6130   if (is_32bit_elf)
6131     {
6132       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
6133
6134       if (size < sizeof (* echdr))
6135         {
6136           error (_("Compressed section is too small even for a compression header\n"));
6137           return 0;
6138         }
6139
6140       chdr->ch_type = BYTE_GET (echdr->ch_type);
6141       chdr->ch_size = BYTE_GET (echdr->ch_size);
6142       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6143       return sizeof (*echdr);
6144     }
6145   else
6146     {
6147       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
6148
6149       if (size < sizeof (* echdr))
6150         {
6151           error (_("Compressed section is too small even for a compression header\n"));
6152           return 0;
6153         }
6154
6155       chdr->ch_type = BYTE_GET (echdr->ch_type);
6156       chdr->ch_size = BYTE_GET (echdr->ch_size);
6157       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6158       return sizeof (*echdr);
6159     }
6160 }
6161
6162 static bfd_boolean
6163 process_section_headers (Filedata * filedata)
6164 {
6165   Elf_Internal_Shdr * section;
6166   unsigned int i;
6167
6168   free (filedata->section_headers);
6169   filedata->section_headers = NULL;
6170   free (filedata->dynamic_symbols);
6171   filedata->dynamic_symbols = NULL;
6172   filedata->num_dynamic_syms = 0;
6173   free (filedata->dynamic_strings);
6174   filedata->dynamic_strings = NULL;
6175   filedata->dynamic_strings_length = 0;
6176   free (filedata->dynamic_syminfo);
6177   filedata->dynamic_syminfo = NULL;
6178   while (filedata->symtab_shndx_list != NULL)
6179     {
6180       elf_section_list *next = filedata->symtab_shndx_list->next;
6181       free (filedata->symtab_shndx_list);
6182       filedata->symtab_shndx_list = next;
6183     }
6184
6185   if (filedata->file_header.e_shnum == 0)
6186     {
6187       /* PR binutils/12467.  */
6188       if (filedata->file_header.e_shoff != 0)
6189         {
6190           warn (_("possibly corrupt ELF file header - it has a non-zero"
6191                   " section header offset, but no section headers\n"));
6192           return FALSE;
6193         }
6194       else if (do_sections)
6195         printf (_("\nThere are no sections in this file.\n"));
6196
6197       return TRUE;
6198     }
6199
6200   if (do_sections && !do_header)
6201     printf (ngettext ("There is %d section header, "
6202                       "starting at offset 0x%lx:\n",
6203                       "There are %d section headers, "
6204                       "starting at offset 0x%lx:\n",
6205                       filedata->file_header.e_shnum),
6206             filedata->file_header.e_shnum,
6207             (unsigned long) filedata->file_header.e_shoff);
6208
6209   if (is_32bit_elf)
6210     {
6211       if (! get_32bit_section_headers (filedata, FALSE))
6212         return FALSE;
6213     }
6214   else
6215     {
6216       if (! get_64bit_section_headers (filedata, FALSE))
6217         return FALSE;
6218     }
6219
6220   /* Read in the string table, so that we have names to display.  */
6221   if (filedata->file_header.e_shstrndx != SHN_UNDEF
6222        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6223     {
6224       section = filedata->section_headers + filedata->file_header.e_shstrndx;
6225
6226       if (section->sh_size != 0)
6227         {
6228           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6229                                                       1, section->sh_size,
6230                                                       _("string table"));
6231
6232           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6233         }
6234     }
6235
6236   /* Scan the sections for the dynamic symbol table
6237      and dynamic string table and debug sections.  */
6238   eh_addr_size = is_32bit_elf ? 4 : 8;
6239   switch (filedata->file_header.e_machine)
6240     {
6241     case EM_MIPS:
6242     case EM_MIPS_RS3_LE:
6243       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6244          FDE addresses.  However, the ABI also has a semi-official ILP32
6245          variant for which the normal FDE address size rules apply.
6246
6247          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6248          section, where XX is the size of longs in bits.  Unfortunately,
6249          earlier compilers provided no way of distinguishing ILP32 objects
6250          from LP64 objects, so if there's any doubt, we should assume that
6251          the official LP64 form is being used.  */
6252       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6253           && find_section (filedata, ".gcc_compiled_long32") == NULL)
6254         eh_addr_size = 8;
6255       break;
6256
6257     case EM_H8_300:
6258     case EM_H8_300H:
6259       switch (filedata->file_header.e_flags & EF_H8_MACH)
6260         {
6261         case E_H8_MACH_H8300:
6262         case E_H8_MACH_H8300HN:
6263         case E_H8_MACH_H8300SN:
6264         case E_H8_MACH_H8300SXN:
6265           eh_addr_size = 2;
6266           break;
6267         case E_H8_MACH_H8300H:
6268         case E_H8_MACH_H8300S:
6269         case E_H8_MACH_H8300SX:
6270           eh_addr_size = 4;
6271           break;
6272         }
6273       break;
6274
6275     case EM_M32C_OLD:
6276     case EM_M32C:
6277       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6278         {
6279         case EF_M32C_CPU_M16C:
6280           eh_addr_size = 2;
6281           break;
6282         }
6283       break;
6284     }
6285
6286 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6287   do                                                                    \
6288     {                                                                   \
6289       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6290       if (section->sh_entsize != expected_entsize)                      \
6291         {                                                               \
6292           char buf[40];                                                 \
6293           sprintf_vma (buf, section->sh_entsize);                       \
6294           /* Note: coded this way so that there is a single string for  \
6295              translation.  */ \
6296           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6297           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6298                    (unsigned) expected_entsize);                        \
6299           section->sh_entsize = expected_entsize;                       \
6300         }                                                               \
6301     }                                                                   \
6302   while (0)
6303
6304 #define CHECK_ENTSIZE(section, i, type)                                 \
6305   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),     \
6306                         sizeof (Elf64_External_##type))
6307
6308   for (i = 0, section = filedata->section_headers;
6309        i < filedata->file_header.e_shnum;
6310        i++, section++)
6311     {
6312       char * name = SECTION_NAME (section);
6313
6314       /* Run some sanity checks on the headers and
6315          possibly fill in some file data as well.  */
6316       switch (section->sh_type)
6317         {
6318         case SHT_DYNSYM:
6319           if (filedata->dynamic_symbols != NULL)
6320             {
6321               error (_("File contains multiple dynamic symbol tables\n"));
6322               continue;
6323             }
6324
6325           CHECK_ENTSIZE (section, i, Sym);
6326           filedata->dynamic_symbols
6327             = GET_ELF_SYMBOLS (filedata, section, &filedata->num_dynamic_syms);
6328           filedata->dynamic_symtab_section = section;
6329           break;
6330
6331         case SHT_STRTAB:
6332           if (streq (name, ".dynstr"))
6333             {
6334               if (filedata->dynamic_strings != NULL)
6335                 {
6336                   error (_("File contains multiple dynamic string tables\n"));
6337                   continue;
6338                 }
6339
6340               filedata->dynamic_strings
6341                 = (char *) get_data (NULL, filedata, section->sh_offset,
6342                                      1, section->sh_size, _("dynamic strings"));
6343               filedata->dynamic_strings_length
6344                 = filedata->dynamic_strings == NULL ? 0 : section->sh_size;
6345               filedata->dynamic_strtab_section = section;
6346             }
6347           break;
6348
6349         case SHT_SYMTAB_SHNDX:
6350           {
6351             elf_section_list * entry = xmalloc (sizeof * entry);
6352
6353             entry->hdr = section;
6354             entry->next = filedata->symtab_shndx_list;
6355             filedata->symtab_shndx_list = entry;
6356           }
6357           break;
6358
6359         case SHT_SYMTAB:
6360           CHECK_ENTSIZE (section, i, Sym);
6361           break;
6362
6363         case SHT_GROUP:
6364           CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6365           break;
6366
6367         case SHT_REL:
6368           CHECK_ENTSIZE (section, i, Rel);
6369           if (do_checks && section->sh_size == 0)
6370             warn (_("Section '%s': zero-sized relocation section\n"), name);
6371           break;
6372
6373         case SHT_RELA:
6374           CHECK_ENTSIZE (section, i, Rela);
6375           if (do_checks && section->sh_size == 0)
6376             warn (_("Section '%s': zero-sized relocation section\n"), name);
6377           break;
6378
6379         case SHT_NOTE:
6380         case SHT_PROGBITS:
6381           /* Having a zero sized section is not illegal according to the
6382              ELF standard, but it might be an indication that something
6383              is wrong.  So issue a warning if we are running in lint mode.  */
6384           if (do_checks && section->sh_size == 0)
6385             warn (_("Section '%s': has a size of zero - is this intended ?\n"), name);
6386           break;
6387
6388         default:
6389           break;
6390         }
6391
6392       if ((do_debugging || do_debug_info || do_debug_abbrevs
6393            || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6394            || do_debug_aranges || do_debug_frames || do_debug_macinfo
6395            || do_debug_str || do_debug_str_offsets || do_debug_loc || do_debug_ranges
6396            || do_debug_addr || do_debug_cu_index || do_debug_links)
6397           && (const_strneq (name, ".debug_")
6398               || const_strneq (name, ".zdebug_")))
6399         {
6400           if (name[1] == 'z')
6401             name += sizeof (".zdebug_") - 1;
6402           else
6403             name += sizeof (".debug_") - 1;
6404
6405           if (do_debugging
6406               || (do_debug_info     && const_strneq (name, "info"))
6407               || (do_debug_info     && const_strneq (name, "types"))
6408               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6409               || (do_debug_lines    && strcmp (name, "line") == 0)
6410               || (do_debug_lines    && const_strneq (name, "line."))
6411               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6412               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6413               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6414               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6415               || (do_debug_aranges  && const_strneq (name, "aranges"))
6416               || (do_debug_ranges   && const_strneq (name, "ranges"))
6417               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6418               || (do_debug_frames   && const_strneq (name, "frame"))
6419               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6420               || (do_debug_macinfo  && const_strneq (name, "macro"))
6421               || (do_debug_str      && const_strneq (name, "str"))
6422               || (do_debug_str_offsets && const_strneq (name, "str_offsets"))
6423               || (do_debug_loc      && const_strneq (name, "loc"))
6424               || (do_debug_loc      && const_strneq (name, "loclists"))
6425               || (do_debug_addr     && const_strneq (name, "addr"))
6426               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6427               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6428               )
6429             request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6430         }
6431       /* Linkonce section to be combined with .debug_info at link time.  */
6432       else if ((do_debugging || do_debug_info)
6433                && const_strneq (name, ".gnu.linkonce.wi."))
6434         request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6435       else if (do_debug_frames && streq (name, ".eh_frame"))
6436         request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6437       else if (do_gdb_index && (streq (name, ".gdb_index")
6438                                 || streq (name, ".debug_names")))
6439         request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6440       /* Trace sections for Itanium VMS.  */
6441       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6442                 || do_trace_aranges)
6443                && const_strneq (name, ".trace_"))
6444         {
6445           name += sizeof (".trace_") - 1;
6446
6447           if (do_debugging
6448               || (do_trace_info     && streq (name, "info"))
6449               || (do_trace_abbrevs  && streq (name, "abbrev"))
6450               || (do_trace_aranges  && streq (name, "aranges"))
6451               )
6452             request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6453         }
6454       else if ((do_debugging || do_debug_links)
6455                && (const_strneq (name, ".gnu_debuglink")
6456                    || const_strneq (name, ".gnu_debugaltlink")))
6457         request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
6458     }
6459
6460   if (! do_sections)
6461     return TRUE;
6462
6463   if (filedata->file_header.e_shnum > 1)
6464     printf (_("\nSection Headers:\n"));
6465   else
6466     printf (_("\nSection Header:\n"));
6467
6468   if (is_32bit_elf)
6469     {
6470       if (do_section_details)
6471         {
6472           printf (_("  [Nr] Name\n"));
6473           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6474         }
6475       else
6476         printf
6477           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6478     }
6479   else if (do_wide)
6480     {
6481       if (do_section_details)
6482         {
6483           printf (_("  [Nr] Name\n"));
6484           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6485         }
6486       else
6487         printf
6488           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6489     }
6490   else
6491     {
6492       if (do_section_details)
6493         {
6494           printf (_("  [Nr] Name\n"));
6495           printf (_("       Type              Address          Offset            Link\n"));
6496           printf (_("       Size              EntSize          Info              Align\n"));
6497         }
6498       else
6499         {
6500           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6501           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6502         }
6503     }
6504
6505   if (do_section_details)
6506     printf (_("       Flags\n"));
6507
6508   for (i = 0, section = filedata->section_headers;
6509        i < filedata->file_header.e_shnum;
6510        i++, section++)
6511     {
6512       /* Run some sanity checks on the section header.  */
6513
6514       /* Check the sh_link field.  */
6515       switch (section->sh_type)
6516         {
6517         case SHT_REL:
6518         case SHT_RELA:
6519           if (section->sh_link == 0
6520               && (filedata->file_header.e_type == ET_EXEC
6521                   || filedata->file_header.e_type == ET_DYN))
6522             /* A dynamic relocation section where all entries use a
6523                zero symbol index need not specify a symtab section.  */
6524             break;
6525           /* Fall through.  */
6526         case SHT_SYMTAB_SHNDX:
6527         case SHT_GROUP:
6528         case SHT_HASH:
6529         case SHT_GNU_HASH:
6530         case SHT_GNU_versym:
6531           if (section->sh_link == 0
6532               || section->sh_link >= filedata->file_header.e_shnum
6533               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6534                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6535             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6536                   i, section->sh_link);
6537           break;
6538
6539         case SHT_DYNAMIC:
6540         case SHT_SYMTAB:
6541         case SHT_DYNSYM:
6542         case SHT_GNU_verneed:
6543         case SHT_GNU_verdef:
6544         case SHT_GNU_LIBLIST:
6545           if (section->sh_link == 0
6546               || section->sh_link >= filedata->file_header.e_shnum
6547               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6548             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6549                   i, section->sh_link);
6550           break;
6551
6552         case SHT_INIT_ARRAY:
6553         case SHT_FINI_ARRAY:
6554         case SHT_PREINIT_ARRAY:
6555           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6556             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6557                   i, section->sh_link);
6558           break;
6559
6560         default:
6561           /* FIXME: Add support for target specific section types.  */
6562 #if 0     /* Currently we do not check other section types as there are too
6563              many special cases.  Stab sections for example have a type
6564              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6565              section.  */
6566           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6567             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6568                   i, section->sh_link);
6569 #endif
6570           break;
6571         }
6572
6573       /* Check the sh_info field.  */
6574       switch (section->sh_type)
6575         {
6576         case SHT_REL:
6577         case SHT_RELA:
6578           if (section->sh_info == 0
6579               && (filedata->file_header.e_type == ET_EXEC
6580                   || filedata->file_header.e_type == ET_DYN))
6581             /* Dynamic relocations apply to segments, so they do not
6582                need to specify the section they relocate.  */
6583             break;
6584           if (section->sh_info == 0
6585               || section->sh_info >= filedata->file_header.e_shnum
6586               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6587                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6588                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6589                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6590                   && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6591                   && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6592                   /* FIXME: Are other section types valid ?  */
6593                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6594             warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6595                   i, section->sh_info);
6596           break;
6597
6598         case SHT_DYNAMIC:
6599         case SHT_HASH:
6600         case SHT_SYMTAB_SHNDX:
6601         case SHT_INIT_ARRAY:
6602         case SHT_FINI_ARRAY:
6603         case SHT_PREINIT_ARRAY:
6604           if (section->sh_info != 0)
6605             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6606                   i, section->sh_info);
6607           break;
6608
6609         case SHT_GROUP:
6610         case SHT_SYMTAB:
6611         case SHT_DYNSYM:
6612           /* A symbol index - we assume that it is valid.  */
6613           break;
6614
6615         default:
6616           /* FIXME: Add support for target specific section types.  */
6617           if (section->sh_type == SHT_NOBITS)
6618             /* NOBITS section headers with non-zero sh_info fields can be
6619                created when a binary is stripped of everything but its debug
6620                information.  The stripped sections have their headers
6621                preserved but their types set to SHT_NOBITS.  So do not check
6622                this type of section.  */
6623             ;
6624           else if (section->sh_flags & SHF_INFO_LINK)
6625             {
6626               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6627                 warn (_("[%2u]: Expected link to another section in info field"), i);
6628             }
6629           else if (section->sh_type < SHT_LOOS
6630                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6631                    && section->sh_info != 0)
6632             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6633                   i, section->sh_info);
6634           break;
6635         }
6636
6637       /* Check the sh_size field.  */
6638       if (section->sh_size > filedata->file_size
6639           && section->sh_type != SHT_NOBITS
6640           && section->sh_type != SHT_NULL
6641           && section->sh_type < SHT_LOOS)
6642         warn (_("Size of section %u is larger than the entire file!\n"), i);
6643
6644       printf ("  [%2u] ", i);
6645       if (do_section_details)
6646         printf ("%s\n      ", printable_section_name (filedata, section));
6647       else
6648         print_symbol (-17, SECTION_NAME (section));
6649
6650       printf (do_wide ? " %-15s " : " %-15.15s ",
6651               get_section_type_name (filedata, section->sh_type));
6652
6653       if (is_32bit_elf)
6654         {
6655           const char * link_too_big = NULL;
6656
6657           print_vma (section->sh_addr, LONG_HEX);
6658
6659           printf ( " %6.6lx %6.6lx %2.2lx",
6660                    (unsigned long) section->sh_offset,
6661                    (unsigned long) section->sh_size,
6662                    (unsigned long) section->sh_entsize);
6663
6664           if (do_section_details)
6665             fputs ("  ", stdout);
6666           else
6667             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6668
6669           if (section->sh_link >= filedata->file_header.e_shnum)
6670             {
6671               link_too_big = "";
6672               /* The sh_link value is out of range.  Normally this indicates
6673                  an error but it can have special values in Solaris binaries.  */
6674               switch (filedata->file_header.e_machine)
6675                 {
6676                 case EM_386:
6677                 case EM_IAMCU:
6678                 case EM_X86_64:
6679                 case EM_L1OM:
6680                 case EM_K1OM:
6681                 case EM_OLD_SPARCV9:
6682                 case EM_SPARC32PLUS:
6683                 case EM_SPARCV9:
6684                 case EM_SPARC:
6685                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6686                     link_too_big = "BEFORE";
6687                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6688                     link_too_big = "AFTER";
6689                   break;
6690                 default:
6691                   break;
6692                 }
6693             }
6694
6695           if (do_section_details)
6696             {
6697               if (link_too_big != NULL && * link_too_big)
6698                 printf ("<%s> ", link_too_big);
6699               else
6700                 printf ("%2u ", section->sh_link);
6701               printf ("%3u %2lu\n", section->sh_info,
6702                       (unsigned long) section->sh_addralign);
6703             }
6704           else
6705             printf ("%2u %3u %2lu\n",
6706                     section->sh_link,
6707                     section->sh_info,
6708                     (unsigned long) section->sh_addralign);
6709
6710           if (link_too_big && ! * link_too_big)
6711             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6712                   i, section->sh_link);
6713         }
6714       else if (do_wide)
6715         {
6716           print_vma (section->sh_addr, LONG_HEX);
6717
6718           if ((long) section->sh_offset == section->sh_offset)
6719             printf (" %6.6lx", (unsigned long) section->sh_offset);
6720           else
6721             {
6722               putchar (' ');
6723               print_vma (section->sh_offset, LONG_HEX);
6724             }
6725
6726           if ((unsigned long) section->sh_size == section->sh_size)
6727             printf (" %6.6lx", (unsigned long) section->sh_size);
6728           else
6729             {
6730               putchar (' ');
6731               print_vma (section->sh_size, LONG_HEX);
6732             }
6733
6734           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6735             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6736           else
6737             {
6738               putchar (' ');
6739               print_vma (section->sh_entsize, LONG_HEX);
6740             }
6741
6742           if (do_section_details)
6743             fputs ("  ", stdout);
6744           else
6745             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6746
6747           printf ("%2u %3u ", section->sh_link, section->sh_info);
6748
6749           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6750             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6751           else
6752             {
6753               print_vma (section->sh_addralign, DEC);
6754               putchar ('\n');
6755             }
6756         }
6757       else if (do_section_details)
6758         {
6759           putchar (' ');
6760           print_vma (section->sh_addr, LONG_HEX);
6761           if ((long) section->sh_offset == section->sh_offset)
6762             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6763           else
6764             {
6765               printf ("  ");
6766               print_vma (section->sh_offset, LONG_HEX);
6767             }
6768           printf ("  %u\n       ", section->sh_link);
6769           print_vma (section->sh_size, LONG_HEX);
6770           putchar (' ');
6771           print_vma (section->sh_entsize, LONG_HEX);
6772
6773           printf ("  %-16u  %lu\n",
6774                   section->sh_info,
6775                   (unsigned long) section->sh_addralign);
6776         }
6777       else
6778         {
6779           putchar (' ');
6780           print_vma (section->sh_addr, LONG_HEX);
6781           if ((long) section->sh_offset == section->sh_offset)
6782             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6783           else
6784             {
6785               printf ("  ");
6786               print_vma (section->sh_offset, LONG_HEX);
6787             }
6788           printf ("\n       ");
6789           print_vma (section->sh_size, LONG_HEX);
6790           printf ("  ");
6791           print_vma (section->sh_entsize, LONG_HEX);
6792
6793           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6794
6795           printf ("     %2u   %3u     %lu\n",
6796                   section->sh_link,
6797                   section->sh_info,
6798                   (unsigned long) section->sh_addralign);
6799         }
6800
6801       if (do_section_details)
6802         {
6803           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6804           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6805             {
6806               /* Minimum section size is 12 bytes for 32-bit compression
6807                  header + 12 bytes for compressed data header.  */
6808               unsigned char buf[24];
6809
6810               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6811               if (get_data (&buf, filedata, section->sh_offset, 1,
6812                             sizeof (buf), _("compression header")))
6813                 {
6814                   Elf_Internal_Chdr chdr;
6815
6816                   if (get_compression_header (&chdr, buf, sizeof (buf)) == 0)
6817                     printf (_("       [<corrupt>]\n"));
6818                   else
6819                     {
6820                       if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6821                         printf ("       ZLIB, ");
6822                       else
6823                         printf (_("       [<unknown>: 0x%x], "),
6824                                 chdr.ch_type);
6825                       print_vma (chdr.ch_size, LONG_HEX);
6826                       printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6827                     }
6828                 }
6829             }
6830         }
6831     }
6832
6833   if (!do_section_details)
6834     {
6835       /* The ordering of the letters shown here matches the ordering of the
6836          corresponding SHF_xxx values, and hence the order in which these
6837          letters will be displayed to the user.  */
6838       printf (_("Key to Flags:\n\
6839   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6840   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6841   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6842       if (filedata->file_header.e_machine == EM_X86_64
6843           || filedata->file_header.e_machine == EM_L1OM
6844           || filedata->file_header.e_machine == EM_K1OM)
6845         printf (_("l (large), "));
6846       else if (filedata->file_header.e_machine == EM_ARM)
6847         printf (_("y (purecode), "));
6848       else if (filedata->file_header.e_machine == EM_PPC)
6849         printf (_("v (VLE), "));
6850       printf ("p (processor specific)\n");
6851     }
6852
6853   return TRUE;
6854 }
6855
6856 static bfd_boolean
6857 get_symtab (Filedata *filedata, Elf_Internal_Shdr *symsec,
6858             Elf_Internal_Sym **symtab, unsigned long *nsyms,
6859             char **strtab, unsigned long *strtablen)
6860 {
6861   *strtab = NULL;
6862   *strtablen = 0;
6863   *symtab = GET_ELF_SYMBOLS (filedata, symsec, nsyms);
6864
6865   if (*symtab == NULL)
6866     return FALSE;
6867
6868   if (symsec->sh_link != 0)
6869     {
6870       Elf_Internal_Shdr *strsec;
6871
6872       if (symsec->sh_link >= filedata->file_header.e_shnum)
6873         {
6874           error (_("Bad sh_link in symbol table section\n"));
6875           free (*symtab);
6876           *symtab = NULL;
6877           *nsyms = 0;
6878           return FALSE;
6879         }
6880
6881       strsec = filedata->section_headers + symsec->sh_link;
6882
6883       *strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
6884                                    1, strsec->sh_size, _("string table"));
6885       if (*strtab == NULL)
6886         {
6887           free (*symtab);
6888           *symtab = NULL;
6889           *nsyms = 0;
6890           return FALSE;
6891         }
6892       *strtablen = strsec->sh_size;
6893     }
6894   return TRUE;
6895 }
6896
6897 static const char *
6898 get_group_flags (unsigned int flags)
6899 {
6900   static char buff[128];
6901
6902   if (flags == 0)
6903     return "";
6904   else if (flags == GRP_COMDAT)
6905     return "COMDAT ";
6906
6907   snprintf (buff, sizeof buff, "[0x%x: %s%s%s]",
6908             flags,
6909             flags & GRP_MASKOS ? _("<OS specific>") : "",
6910             flags & GRP_MASKPROC ? _("<PROC specific>") : "",
6911             (flags & ~(GRP_COMDAT | GRP_MASKOS | GRP_MASKPROC)
6912              ? _("<unknown>") : ""));
6913
6914   return buff;
6915 }
6916
6917 static bfd_boolean
6918 process_section_groups (Filedata * filedata)
6919 {
6920   Elf_Internal_Shdr * section;
6921   unsigned int i;
6922   struct group * group;
6923   Elf_Internal_Shdr * symtab_sec;
6924   Elf_Internal_Shdr * strtab_sec;
6925   Elf_Internal_Sym * symtab;
6926   unsigned long num_syms;
6927   char * strtab;
6928   size_t strtab_size;
6929
6930   /* Don't process section groups unless needed.  */
6931   if (!do_unwind && !do_section_groups)
6932     return TRUE;
6933
6934   if (filedata->file_header.e_shnum == 0)
6935     {
6936       if (do_section_groups)
6937         printf (_("\nThere are no sections to group in this file.\n"));
6938
6939       return TRUE;
6940     }
6941
6942   if (filedata->section_headers == NULL)
6943     {
6944       error (_("Section headers are not available!\n"));
6945       /* PR 13622: This can happen with a corrupt ELF header.  */
6946       return FALSE;
6947     }
6948
6949   filedata->section_headers_groups
6950     = (struct group **) calloc (filedata->file_header.e_shnum,
6951                                 sizeof (struct group *));
6952
6953   if (filedata->section_headers_groups == NULL)
6954     {
6955       error (_("Out of memory reading %u section group headers\n"),
6956              filedata->file_header.e_shnum);
6957       return FALSE;
6958     }
6959
6960   /* Scan the sections for the group section.  */
6961   filedata->group_count = 0;
6962   for (i = 0, section = filedata->section_headers;
6963        i < filedata->file_header.e_shnum;
6964        i++, section++)
6965     if (section->sh_type == SHT_GROUP)
6966       filedata->group_count++;
6967
6968   if (filedata->group_count == 0)
6969     {
6970       if (do_section_groups)
6971         printf (_("\nThere are no section groups in this file.\n"));
6972
6973       return TRUE;
6974     }
6975
6976   filedata->section_groups = (struct group *) calloc (filedata->group_count,
6977                                                       sizeof (struct group));
6978
6979   if (filedata->section_groups == NULL)
6980     {
6981       error (_("Out of memory reading %lu groups\n"),
6982              (unsigned long) filedata->group_count);
6983       return FALSE;
6984     }
6985
6986   symtab_sec = NULL;
6987   strtab_sec = NULL;
6988   symtab = NULL;
6989   num_syms = 0;
6990   strtab = NULL;
6991   strtab_size = 0;
6992   for (i = 0, section = filedata->section_headers, group = filedata->section_groups;
6993        i < filedata->file_header.e_shnum;
6994        i++, section++)
6995     {
6996       if (section->sh_type == SHT_GROUP)
6997         {
6998           const char * name = printable_section_name (filedata, section);
6999           const char * group_name;
7000           unsigned char * start;
7001           unsigned char * indices;
7002           unsigned int entry, j, size;
7003           Elf_Internal_Shdr * sec;
7004           Elf_Internal_Sym * sym;
7005
7006           /* Get the symbol table.  */
7007           if (section->sh_link >= filedata->file_header.e_shnum
7008               || ((sec = filedata->section_headers + section->sh_link)->sh_type
7009                   != SHT_SYMTAB))
7010             {
7011               error (_("Bad sh_link in group section `%s'\n"), name);
7012               continue;
7013             }
7014
7015           if (symtab_sec != sec)
7016             {
7017               symtab_sec = sec;
7018               free (symtab);
7019               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
7020             }
7021
7022           if (symtab == NULL)
7023             {
7024               error (_("Corrupt header in group section `%s'\n"), name);
7025               continue;
7026             }
7027
7028           if (section->sh_info >= num_syms)
7029             {
7030               error (_("Bad sh_info in group section `%s'\n"), name);
7031               continue;
7032             }
7033
7034           sym = symtab + section->sh_info;
7035
7036           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
7037             {
7038               if (sym->st_shndx == 0
7039                   || sym->st_shndx >= filedata->file_header.e_shnum)
7040                 {
7041                   error (_("Bad sh_info in group section `%s'\n"), name);
7042                   continue;
7043                 }
7044
7045               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
7046               strtab_sec = NULL;
7047               free (strtab);
7048               strtab = NULL;
7049               strtab_size = 0;
7050             }
7051           else
7052             {
7053               /* Get the string table.  */
7054               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
7055                 {
7056                   strtab_sec = NULL;
7057                   free (strtab);
7058                   strtab = NULL;
7059                   strtab_size = 0;
7060                 }
7061               else if (strtab_sec
7062                        != (sec = filedata->section_headers + symtab_sec->sh_link))
7063                 {
7064                   strtab_sec = sec;
7065                   free (strtab);
7066
7067                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
7068                                               1, strtab_sec->sh_size,
7069                                               _("string table"));
7070                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
7071                 }
7072               group_name = sym->st_name < strtab_size
7073                 ? strtab + sym->st_name : _("<corrupt>");
7074             }
7075
7076           /* PR 17531: file: loop.  */
7077           if (section->sh_entsize > section->sh_size)
7078             {
7079               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7080                      printable_section_name (filedata, section),
7081                      (unsigned long) section->sh_entsize,
7082                      (unsigned long) section->sh_size);
7083               continue;
7084             }
7085
7086           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
7087                                               1, section->sh_size,
7088                                               _("section data"));
7089           if (start == NULL)
7090             continue;
7091
7092           indices = start;
7093           size = (section->sh_size / section->sh_entsize) - 1;
7094           entry = byte_get (indices, 4);
7095           indices += 4;
7096
7097           if (do_section_groups)
7098             {
7099               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7100                       get_group_flags (entry), i, name, group_name, size);
7101
7102               printf (_("   [Index]    Name\n"));
7103             }
7104
7105           group->group_index = i;
7106
7107           for (j = 0; j < size; j++)
7108             {
7109               struct group_list * g;
7110
7111               entry = byte_get (indices, 4);
7112               indices += 4;
7113
7114               if (entry >= filedata->file_header.e_shnum)
7115                 {
7116                   static unsigned num_group_errors = 0;
7117
7118                   if (num_group_errors ++ < 10)
7119                     {
7120                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7121                              entry, i, filedata->file_header.e_shnum - 1);
7122                       if (num_group_errors == 10)
7123                         warn (_("Further error messages about overlarge group section indices suppressed\n"));
7124                     }
7125                   continue;
7126                 }
7127
7128               if (filedata->section_headers_groups [entry] != NULL)
7129                 {
7130                   if (entry)
7131                     {
7132                       static unsigned num_errs = 0;
7133
7134                       if (num_errs ++ < 10)
7135                         {
7136                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7137                                  entry, i,
7138                                  filedata->section_headers_groups [entry]->group_index);
7139                           if (num_errs == 10)
7140                             warn (_("Further error messages about already contained group sections suppressed\n"));
7141                         }
7142                       continue;
7143                     }
7144                   else
7145                     {
7146                       /* Intel C/C++ compiler may put section 0 in a
7147                          section group.  We just warn it the first time
7148                          and ignore it afterwards.  */
7149                       static bfd_boolean warned = FALSE;
7150                       if (!warned)
7151                         {
7152                           error (_("section 0 in group section [%5u]\n"),
7153                                  filedata->section_headers_groups [entry]->group_index);
7154                           warned = TRUE;
7155                         }
7156                     }
7157                 }
7158
7159               filedata->section_headers_groups [entry] = group;
7160
7161               if (do_section_groups)
7162                 {
7163                   sec = filedata->section_headers + entry;
7164                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
7165                 }
7166
7167               g = (struct group_list *) xmalloc (sizeof (struct group_list));
7168               g->section_index = entry;
7169               g->next = group->root;
7170               group->root = g;
7171             }
7172
7173           free (start);
7174
7175           group++;
7176         }
7177     }
7178
7179   free (symtab);
7180   free (strtab);
7181   return TRUE;
7182 }
7183
7184 /* Data used to display dynamic fixups.  */
7185
7186 struct ia64_vms_dynfixup
7187 {
7188   bfd_vma needed_ident;         /* Library ident number.  */
7189   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
7190   bfd_vma fixup_needed;         /* Index of the library.  */
7191   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
7192   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
7193 };
7194
7195 /* Data used to display dynamic relocations.  */
7196
7197 struct ia64_vms_dynimgrela
7198 {
7199   bfd_vma img_rela_cnt;         /* Number of relocations.  */
7200   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
7201 };
7202
7203 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7204    library).  */
7205
7206 static bfd_boolean
7207 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
7208                               struct ia64_vms_dynfixup *  fixup,
7209                               const char *                strtab,
7210                               unsigned int                strtab_sz)
7211 {
7212   Elf64_External_VMS_IMAGE_FIXUP * imfs;
7213   long i;
7214   const char * lib_name;
7215
7216   imfs = get_data (NULL, filedata,
7217                    filedata->dynamic_addr + fixup->fixup_rela_off,
7218                    sizeof (*imfs), fixup->fixup_rela_cnt,
7219                    _("dynamic section image fixups"));
7220   if (!imfs)
7221     return FALSE;
7222
7223   if (fixup->needed < strtab_sz)
7224     lib_name = strtab + fixup->needed;
7225   else
7226     {
7227       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7228             (unsigned long) fixup->needed);
7229       lib_name = "???";
7230     }
7231
7232   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7233           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
7234   printf
7235     (_("Seg Offset           Type                             SymVec DataType\n"));
7236
7237   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
7238     {
7239       unsigned int type;
7240       const char *rtype;
7241
7242       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
7243       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7244       type = BYTE_GET (imfs [i].type);
7245       rtype = elf_ia64_reloc_type (type);
7246       if (rtype == NULL)
7247         printf (" 0x%08x                       ", type);
7248       else
7249         printf (" %-32s ", rtype);
7250       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7251       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7252     }
7253
7254   free (imfs);
7255   return TRUE;
7256 }
7257
7258 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
7259
7260 static bfd_boolean
7261 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7262 {
7263   Elf64_External_VMS_IMAGE_RELA *imrs;
7264   long i;
7265
7266   imrs = get_data (NULL, filedata,
7267                    filedata->dynamic_addr + imgrela->img_rela_off,
7268                    sizeof (*imrs), imgrela->img_rela_cnt,
7269                    _("dynamic section image relocations"));
7270   if (!imrs)
7271     return FALSE;
7272
7273   printf (_("\nImage relocs\n"));
7274   printf
7275     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
7276
7277   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7278     {
7279       unsigned int type;
7280       const char *rtype;
7281
7282       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7283       printf ("%08" BFD_VMA_FMT "x ",
7284               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7285       type = BYTE_GET (imrs [i].type);
7286       rtype = elf_ia64_reloc_type (type);
7287       if (rtype == NULL)
7288         printf ("0x%08x                      ", type);
7289       else
7290         printf ("%-31s ", rtype);
7291       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7292       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7293       printf ("%08" BFD_VMA_FMT "x\n",
7294               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7295     }
7296
7297   free (imrs);
7298   return TRUE;
7299 }
7300
7301 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
7302
7303 static bfd_boolean
7304 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7305 {
7306   struct ia64_vms_dynfixup fixup;
7307   struct ia64_vms_dynimgrela imgrela;
7308   Elf_Internal_Dyn *entry;
7309   bfd_vma strtab_off = 0;
7310   bfd_vma strtab_sz = 0;
7311   char *strtab = NULL;
7312   bfd_boolean res = TRUE;
7313
7314   memset (&fixup, 0, sizeof (fixup));
7315   memset (&imgrela, 0, sizeof (imgrela));
7316
7317   /* Note: the order of the entries is specified by the OpenVMS specs.  */
7318   for (entry = filedata->dynamic_section;
7319        entry < filedata->dynamic_section + filedata->dynamic_nent;
7320        entry++)
7321     {
7322       switch (entry->d_tag)
7323         {
7324         case DT_IA_64_VMS_STRTAB_OFFSET:
7325           strtab_off = entry->d_un.d_val;
7326           break;
7327         case DT_STRSZ:
7328           strtab_sz = entry->d_un.d_val;
7329           if (strtab == NULL)
7330             strtab = get_data (NULL, filedata,
7331                                filedata->dynamic_addr + strtab_off,
7332                                1, strtab_sz, _("dynamic string section"));
7333           if (strtab == NULL)
7334             strtab_sz = 0;
7335           break;
7336
7337         case DT_IA_64_VMS_NEEDED_IDENT:
7338           fixup.needed_ident = entry->d_un.d_val;
7339           break;
7340         case DT_NEEDED:
7341           fixup.needed = entry->d_un.d_val;
7342           break;
7343         case DT_IA_64_VMS_FIXUP_NEEDED:
7344           fixup.fixup_needed = entry->d_un.d_val;
7345           break;
7346         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7347           fixup.fixup_rela_cnt = entry->d_un.d_val;
7348           break;
7349         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7350           fixup.fixup_rela_off = entry->d_un.d_val;
7351           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7352             res = FALSE;
7353           break;
7354         case DT_IA_64_VMS_IMG_RELA_CNT:
7355           imgrela.img_rela_cnt = entry->d_un.d_val;
7356           break;
7357         case DT_IA_64_VMS_IMG_RELA_OFF:
7358           imgrela.img_rela_off = entry->d_un.d_val;
7359           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7360             res = FALSE;
7361           break;
7362
7363         default:
7364           break;
7365         }
7366     }
7367
7368   free (strtab);
7369
7370   return res;
7371 }
7372
7373 static struct
7374 {
7375   const char * name;
7376   int reloc;
7377   int size;
7378   int rela;
7379 }
7380   dynamic_relocations [] =
7381 {
7382   { "REL", DT_REL, DT_RELSZ, FALSE },
7383   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7384   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7385 };
7386
7387 /* Process the reloc section.  */
7388
7389 static bfd_boolean
7390 process_relocs (Filedata * filedata)
7391 {
7392   unsigned long rel_size;
7393   unsigned long rel_offset;
7394
7395   if (!do_reloc)
7396     return TRUE;
7397
7398   if (do_using_dynamic)
7399     {
7400       int          is_rela;
7401       const char * name;
7402       bfd_boolean  has_dynamic_reloc;
7403       unsigned int i;
7404
7405       has_dynamic_reloc = FALSE;
7406
7407       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7408         {
7409           is_rela = dynamic_relocations [i].rela;
7410           name = dynamic_relocations [i].name;
7411           rel_size = filedata->dynamic_info[dynamic_relocations [i].size];
7412           rel_offset = filedata->dynamic_info[dynamic_relocations [i].reloc];
7413
7414           if (rel_size)
7415             has_dynamic_reloc = TRUE;
7416
7417           if (is_rela == UNKNOWN)
7418             {
7419               if (dynamic_relocations [i].reloc == DT_JMPREL)
7420                 switch (filedata->dynamic_info[DT_PLTREL])
7421                   {
7422                   case DT_REL:
7423                     is_rela = FALSE;
7424                     break;
7425                   case DT_RELA:
7426                     is_rela = TRUE;
7427                     break;
7428                   }
7429             }
7430
7431           if (rel_size)
7432             {
7433               printf
7434                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7435                  name, rel_offset, rel_size);
7436
7437               dump_relocations (filedata,
7438                                 offset_from_vma (filedata, rel_offset, rel_size),
7439                                 rel_size,
7440                                 filedata->dynamic_symbols,
7441                                 filedata->num_dynamic_syms,
7442                                 filedata->dynamic_strings,
7443                                 filedata->dynamic_strings_length,
7444                                 is_rela, TRUE /* is_dynamic */);
7445             }
7446         }
7447
7448       if (is_ia64_vms (filedata))
7449         if (process_ia64_vms_dynamic_relocs (filedata))
7450           has_dynamic_reloc = TRUE;
7451
7452       if (! has_dynamic_reloc)
7453         printf (_("\nThere are no dynamic relocations in this file.\n"));
7454     }
7455   else
7456     {
7457       Elf_Internal_Shdr * section;
7458       unsigned long i;
7459       bfd_boolean found = FALSE;
7460
7461       for (i = 0, section = filedata->section_headers;
7462            i < filedata->file_header.e_shnum;
7463            i++, section++)
7464         {
7465           if (   section->sh_type != SHT_RELA
7466               && section->sh_type != SHT_REL)
7467             continue;
7468
7469           rel_offset = section->sh_offset;
7470           rel_size   = section->sh_size;
7471
7472           if (rel_size)
7473             {
7474               int is_rela;
7475               unsigned long num_rela;
7476
7477               printf (_("\nRelocation section "));
7478
7479               if (filedata->string_table == NULL)
7480                 printf ("%d", section->sh_name);
7481               else
7482                 printf ("'%s'", printable_section_name (filedata, section));
7483
7484               num_rela = rel_size / section->sh_entsize;
7485               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7486                                 " at offset 0x%lx contains %lu entries:\n",
7487                                 num_rela),
7488                       rel_offset, num_rela);
7489
7490               is_rela = section->sh_type == SHT_RELA;
7491
7492               if (section->sh_link != 0
7493                   && section->sh_link < filedata->file_header.e_shnum)
7494                 {
7495                   Elf_Internal_Shdr * symsec;
7496                   Elf_Internal_Sym *  symtab;
7497                   unsigned long nsyms;
7498                   unsigned long strtablen = 0;
7499                   char * strtab = NULL;
7500
7501                   symsec = filedata->section_headers + section->sh_link;
7502                   if (symsec->sh_type != SHT_SYMTAB
7503                       && symsec->sh_type != SHT_DYNSYM)
7504                     continue;
7505
7506                   if (!get_symtab (filedata, symsec,
7507                                    &symtab, &nsyms, &strtab, &strtablen))
7508                     continue;
7509
7510                   dump_relocations (filedata, rel_offset, rel_size,
7511                                     symtab, nsyms, strtab, strtablen,
7512                                     is_rela,
7513                                     symsec->sh_type == SHT_DYNSYM);
7514                   free (strtab);
7515                   free (symtab);
7516                 }
7517               else
7518                 dump_relocations (filedata, rel_offset, rel_size,
7519                                   NULL, 0, NULL, 0, is_rela,
7520                                   FALSE /* is_dynamic */);
7521
7522               found = TRUE;
7523             }
7524         }
7525
7526       if (! found)
7527         {
7528           /* Users sometimes forget the -D option, so try to be helpful.  */
7529           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7530             {
7531               if (filedata->dynamic_info[dynamic_relocations [i].size])
7532                 {
7533                   printf (_("\nThere are no static relocations in this file."));
7534                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7535
7536                   break;
7537                 }
7538             }
7539           if (i == ARRAY_SIZE (dynamic_relocations))
7540             printf (_("\nThere are no relocations in this file.\n"));
7541         }
7542     }
7543
7544   return TRUE;
7545 }
7546
7547 /* An absolute address consists of a section and an offset.  If the
7548    section is NULL, the offset itself is the address, otherwise, the
7549    address equals to LOAD_ADDRESS(section) + offset.  */
7550
7551 struct absaddr
7552 {
7553   unsigned short section;
7554   bfd_vma offset;
7555 };
7556
7557 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7558    name, if found, and the offset from the symbol to ADDR.  */
7559
7560 static void
7561 find_symbol_for_address (Filedata *          filedata,
7562                          Elf_Internal_Sym *  symtab,
7563                          unsigned long       nsyms,
7564                          const char *        strtab,
7565                          unsigned long       strtab_size,
7566                          struct absaddr      addr,
7567                          const char **       symname,
7568                          bfd_vma *           offset)
7569 {
7570   bfd_vma dist = 0x100000;
7571   Elf_Internal_Sym * sym;
7572   Elf_Internal_Sym * beg;
7573   Elf_Internal_Sym * end;
7574   Elf_Internal_Sym * best = NULL;
7575
7576   REMOVE_ARCH_BITS (addr.offset);
7577   beg = symtab;
7578   end = symtab + nsyms;
7579
7580   while (beg < end)
7581     {
7582       bfd_vma value;
7583
7584       sym = beg + (end - beg) / 2;
7585
7586       value = sym->st_value;
7587       REMOVE_ARCH_BITS (value);
7588
7589       if (sym->st_name != 0
7590           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7591           && addr.offset >= value
7592           && addr.offset - value < dist)
7593         {
7594           best = sym;
7595           dist = addr.offset - value;
7596           if (!dist)
7597             break;
7598         }
7599
7600       if (addr.offset < value)
7601         end = sym;
7602       else
7603         beg = sym + 1;
7604     }
7605
7606   if (best)
7607     {
7608       *symname = (best->st_name >= strtab_size
7609                   ? _("<corrupt>") : strtab + best->st_name);
7610       *offset = dist;
7611       return;
7612     }
7613
7614   *symname = NULL;
7615   *offset = addr.offset;
7616 }
7617
7618 static /* signed */ int
7619 symcmp (const void *p, const void *q)
7620 {
7621   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7622   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7623
7624   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7625 }
7626
7627 /* Process the unwind section.  */
7628
7629 #include "unwind-ia64.h"
7630
7631 struct ia64_unw_table_entry
7632 {
7633   struct absaddr start;
7634   struct absaddr end;
7635   struct absaddr info;
7636 };
7637
7638 struct ia64_unw_aux_info
7639 {
7640   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7641   unsigned long                 table_len;      /* Length of unwind table.  */
7642   unsigned char *               info;           /* Unwind info.  */
7643   unsigned long                 info_size;      /* Size of unwind info.  */
7644   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7645   bfd_vma                       seg_base;       /* Starting address of segment.  */
7646   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7647   unsigned long                 nsyms;          /* Number of symbols.  */
7648   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7649   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7650   char *                        strtab;         /* The string table.  */
7651   unsigned long                 strtab_size;    /* Size of string table.  */
7652 };
7653
7654 static bfd_boolean
7655 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7656 {
7657   struct ia64_unw_table_entry * tp;
7658   unsigned long j, nfuns;
7659   int in_body;
7660   bfd_boolean res = TRUE;
7661
7662   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7663   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7664     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7665       aux->funtab[nfuns++] = aux->symtab[j];
7666   aux->nfuns = nfuns;
7667   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7668
7669   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7670     {
7671       bfd_vma stamp;
7672       bfd_vma offset;
7673       const unsigned char * dp;
7674       const unsigned char * head;
7675       const unsigned char * end;
7676       const char * procname;
7677
7678       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7679                                aux->strtab_size, tp->start, &procname, &offset);
7680
7681       fputs ("\n<", stdout);
7682
7683       if (procname)
7684         {
7685           fputs (procname, stdout);
7686
7687           if (offset)
7688             printf ("+%lx", (unsigned long) offset);
7689         }
7690
7691       fputs (">: [", stdout);
7692       print_vma (tp->start.offset, PREFIX_HEX);
7693       fputc ('-', stdout);
7694       print_vma (tp->end.offset, PREFIX_HEX);
7695       printf ("], info at +0x%lx\n",
7696               (unsigned long) (tp->info.offset - aux->seg_base));
7697
7698       /* PR 17531: file: 86232b32.  */
7699       if (aux->info == NULL)
7700         continue;
7701
7702       offset = tp->info.offset;
7703       if (tp->info.section)
7704         {
7705           if (tp->info.section >= filedata->file_header.e_shnum)
7706             {
7707               warn (_("Invalid section %u in table entry %ld\n"),
7708                     tp->info.section, (long) (tp - aux->table));
7709               res = FALSE;
7710               continue;
7711             }
7712           offset += filedata->section_headers[tp->info.section].sh_addr;
7713         }
7714       offset -= aux->info_addr;
7715       /* PR 17531: file: 0997b4d1.  */
7716       if (offset >= aux->info_size
7717           || aux->info_size - offset < 8)
7718         {
7719           warn (_("Invalid offset %lx in table entry %ld\n"),
7720                 (long) tp->info.offset, (long) (tp - aux->table));
7721           res = FALSE;
7722           continue;
7723         }
7724
7725       head = aux->info + offset;
7726       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7727
7728       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7729               (unsigned) UNW_VER (stamp),
7730               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7731               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7732               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7733               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7734
7735       if (UNW_VER (stamp) != 1)
7736         {
7737           printf (_("\tUnknown version.\n"));
7738           continue;
7739         }
7740
7741       in_body = 0;
7742       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7743       /* PR 17531: file: 16ceda89.  */
7744       if (end > aux->info + aux->info_size)
7745         end = aux->info + aux->info_size;
7746       for (dp = head + 8; dp < end;)
7747         dp = unw_decode (dp, in_body, & in_body, end);
7748     }
7749
7750   free (aux->funtab);
7751
7752   return res;
7753 }
7754
7755 static bfd_boolean
7756 slurp_ia64_unwind_table (Filedata *                  filedata,
7757                          struct ia64_unw_aux_info *  aux,
7758                          Elf_Internal_Shdr *         sec)
7759 {
7760   unsigned long size, nrelas, i;
7761   Elf_Internal_Phdr * seg;
7762   struct ia64_unw_table_entry * tep;
7763   Elf_Internal_Shdr * relsec;
7764   Elf_Internal_Rela * rela;
7765   Elf_Internal_Rela * rp;
7766   unsigned char * table;
7767   unsigned char * tp;
7768   Elf_Internal_Sym * sym;
7769   const char * relname;
7770
7771   aux->table_len = 0;
7772
7773   /* First, find the starting address of the segment that includes
7774      this section: */
7775
7776   if (filedata->file_header.e_phnum)
7777     {
7778       if (! get_program_headers (filedata))
7779           return FALSE;
7780
7781       for (seg = filedata->program_headers;
7782            seg < filedata->program_headers + filedata->file_header.e_phnum;
7783            ++seg)
7784         {
7785           if (seg->p_type != PT_LOAD)
7786             continue;
7787
7788           if (sec->sh_addr >= seg->p_vaddr
7789               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7790             {
7791               aux->seg_base = seg->p_vaddr;
7792               break;
7793             }
7794         }
7795     }
7796
7797   /* Second, build the unwind table from the contents of the unwind section:  */
7798   size = sec->sh_size;
7799   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7800                                       _("unwind table"));
7801   if (!table)
7802     return FALSE;
7803
7804   aux->table_len = size / (3 * eh_addr_size);
7805   aux->table = (struct ia64_unw_table_entry *)
7806     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7807   tep = aux->table;
7808
7809   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7810     {
7811       tep->start.section = SHN_UNDEF;
7812       tep->end.section   = SHN_UNDEF;
7813       tep->info.section  = SHN_UNDEF;
7814       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7815       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7816       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7817       tep->start.offset += aux->seg_base;
7818       tep->end.offset   += aux->seg_base;
7819       tep->info.offset  += aux->seg_base;
7820     }
7821   free (table);
7822
7823   /* Third, apply any relocations to the unwind table:  */
7824   for (relsec = filedata->section_headers;
7825        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7826        ++relsec)
7827     {
7828       if (relsec->sh_type != SHT_RELA
7829           || relsec->sh_info >= filedata->file_header.e_shnum
7830           || filedata->section_headers + relsec->sh_info != sec)
7831         continue;
7832
7833       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7834                               & rela, & nrelas))
7835         {
7836           free (aux->table);
7837           aux->table = NULL;
7838           aux->table_len = 0;
7839           return FALSE;
7840         }
7841
7842       for (rp = rela; rp < rela + nrelas; ++rp)
7843         {
7844           unsigned int sym_ndx;
7845           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7846           relname = elf_ia64_reloc_type (r_type);
7847
7848           /* PR 17531: file: 9fa67536.  */
7849           if (relname == NULL)
7850             {
7851               warn (_("Skipping unknown relocation type: %u\n"), r_type);
7852               continue;
7853             }
7854
7855           if (! const_strneq (relname, "R_IA64_SEGREL"))
7856             {
7857               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7858               continue;
7859             }
7860
7861           i = rp->r_offset / (3 * eh_addr_size);
7862
7863           /* PR 17531: file: 5bc8d9bf.  */
7864           if (i >= aux->table_len)
7865             {
7866               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7867               continue;
7868             }
7869
7870           sym_ndx = get_reloc_symindex (rp->r_info);
7871           if (sym_ndx >= aux->nsyms)
7872             {
7873               warn (_("Skipping reloc with invalid symbol index: %u\n"),
7874                     sym_ndx);
7875               continue;
7876             }
7877           sym = aux->symtab + sym_ndx;
7878
7879           switch (rp->r_offset / eh_addr_size % 3)
7880             {
7881             case 0:
7882               aux->table[i].start.section = sym->st_shndx;
7883               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7884               break;
7885             case 1:
7886               aux->table[i].end.section   = sym->st_shndx;
7887               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7888               break;
7889             case 2:
7890               aux->table[i].info.section  = sym->st_shndx;
7891               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7892               break;
7893             default:
7894               break;
7895             }
7896         }
7897
7898       free (rela);
7899     }
7900
7901   return TRUE;
7902 }
7903
7904 static bfd_boolean
7905 ia64_process_unwind (Filedata * filedata)
7906 {
7907   Elf_Internal_Shdr * sec;
7908   Elf_Internal_Shdr * unwsec = NULL;
7909   unsigned long i, unwcount = 0, unwstart = 0;
7910   struct ia64_unw_aux_info aux;
7911   bfd_boolean res = TRUE;
7912
7913   memset (& aux, 0, sizeof (aux));
7914
7915   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7916     {
7917       if (sec->sh_type == SHT_SYMTAB)
7918         {
7919           if (aux.symtab)
7920             {
7921               error (_("Multiple symbol tables encountered\n"));
7922               free (aux.symtab);
7923               aux.symtab = NULL;
7924               free (aux.strtab);
7925               aux.strtab = NULL;
7926             }
7927           if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
7928                            &aux.strtab, &aux.strtab_size))
7929             return FALSE;
7930         }
7931       else if (sec->sh_type == SHT_IA_64_UNWIND)
7932         unwcount++;
7933     }
7934
7935   if (!unwcount)
7936     printf (_("\nThere are no unwind sections in this file.\n"));
7937
7938   while (unwcount-- > 0)
7939     {
7940       char * suffix;
7941       size_t len, len2;
7942
7943       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7944            i < filedata->file_header.e_shnum; ++i, ++sec)
7945         if (sec->sh_type == SHT_IA_64_UNWIND)
7946           {
7947             unwsec = sec;
7948             break;
7949           }
7950       /* We have already counted the number of SHT_IA64_UNWIND
7951          sections so the loop above should never fail.  */
7952       assert (unwsec != NULL);
7953
7954       unwstart = i + 1;
7955       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7956
7957       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7958         {
7959           /* We need to find which section group it is in.  */
7960           struct group_list * g;
7961
7962           if (filedata->section_headers_groups == NULL
7963               || filedata->section_headers_groups[i] == NULL)
7964             i = filedata->file_header.e_shnum;
7965           else
7966             {
7967               g = filedata->section_headers_groups[i]->root;
7968
7969               for (; g != NULL; g = g->next)
7970                 {
7971                   sec = filedata->section_headers + g->section_index;
7972
7973                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7974                     break;
7975                 }
7976
7977               if (g == NULL)
7978                 i = filedata->file_header.e_shnum;
7979             }
7980         }
7981       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7982         {
7983           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7984           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7985           suffix = SECTION_NAME (unwsec) + len;
7986           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7987                ++i, ++sec)
7988             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7989                 && streq (SECTION_NAME (sec) + len2, suffix))
7990               break;
7991         }
7992       else
7993         {
7994           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7995              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7996           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7997           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7998           suffix = "";
7999           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
8000             suffix = SECTION_NAME (unwsec) + len;
8001           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
8002                ++i, ++sec)
8003             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
8004                 && streq (SECTION_NAME (sec) + len2, suffix))
8005               break;
8006         }
8007
8008       if (i == filedata->file_header.e_shnum)
8009         {
8010           printf (_("\nCould not find unwind info section for "));
8011
8012           if (filedata->string_table == NULL)
8013             printf ("%d", unwsec->sh_name);
8014           else
8015             printf ("'%s'", printable_section_name (filedata, unwsec));
8016         }
8017       else
8018         {
8019           aux.info_addr = sec->sh_addr;
8020           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
8021                                                  sec->sh_size,
8022                                                  _("unwind info"));
8023           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
8024
8025           printf (_("\nUnwind section "));
8026
8027           if (filedata->string_table == NULL)
8028             printf ("%d", unwsec->sh_name);
8029           else
8030             printf ("'%s'", printable_section_name (filedata, unwsec));
8031
8032           printf (_(" at offset 0x%lx contains %lu entries:\n"),
8033                   (unsigned long) unwsec->sh_offset,
8034                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
8035
8036           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
8037               && aux.table_len > 0)
8038             dump_ia64_unwind (filedata, & aux);
8039
8040           free ((char *) aux.table);
8041           free ((char *) aux.info);
8042           aux.table = NULL;
8043           aux.info = NULL;
8044         }
8045     }
8046
8047   free (aux.symtab);
8048   free ((char *) aux.strtab);
8049
8050   return res;
8051 }
8052
8053 struct hppa_unw_table_entry
8054 {
8055   struct absaddr start;
8056   struct absaddr end;
8057   unsigned int Cannot_unwind:1;                 /* 0 */
8058   unsigned int Millicode:1;                     /* 1 */
8059   unsigned int Millicode_save_sr0:1;            /* 2 */
8060   unsigned int Region_description:2;            /* 3..4 */
8061   unsigned int reserved1:1;                     /* 5 */
8062   unsigned int Entry_SR:1;                      /* 6 */
8063   unsigned int Entry_FR:4;     /* Number saved     7..10 */
8064   unsigned int Entry_GR:5;     /* Number saved     11..15 */
8065   unsigned int Args_stored:1;                   /* 16 */
8066   unsigned int Variable_Frame:1;                /* 17 */
8067   unsigned int Separate_Package_Body:1;         /* 18 */
8068   unsigned int Frame_Extension_Millicode:1;     /* 19 */
8069   unsigned int Stack_Overflow_Check:1;          /* 20 */
8070   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
8071   unsigned int Ada_Region:1;                    /* 22 */
8072   unsigned int cxx_info:1;                      /* 23 */
8073   unsigned int cxx_try_catch:1;                 /* 24 */
8074   unsigned int sched_entry_seq:1;               /* 25 */
8075   unsigned int reserved2:1;                     /* 26 */
8076   unsigned int Save_SP:1;                       /* 27 */
8077   unsigned int Save_RP:1;                       /* 28 */
8078   unsigned int Save_MRP_in_frame:1;             /* 29 */
8079   unsigned int extn_ptr_defined:1;              /* 30 */
8080   unsigned int Cleanup_defined:1;               /* 31 */
8081
8082   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
8083   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
8084   unsigned int Large_frame:1;                   /* 2 */
8085   unsigned int Pseudo_SP_Set:1;                 /* 3 */
8086   unsigned int reserved4:1;                     /* 4 */
8087   unsigned int Total_frame_size:27;             /* 5..31 */
8088 };
8089
8090 struct hppa_unw_aux_info
8091 {
8092   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
8093   unsigned long                  table_len;     /* Length of unwind table.  */
8094   bfd_vma                        seg_base;      /* Starting address of segment.  */
8095   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
8096   unsigned long                  nsyms;         /* Number of symbols.  */
8097   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
8098   unsigned long                  nfuns;         /* Number of entries in funtab.  */
8099   char *                         strtab;        /* The string table.  */
8100   unsigned long                  strtab_size;   /* Size of string table.  */
8101 };
8102
8103 static bfd_boolean
8104 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
8105 {
8106   struct hppa_unw_table_entry * tp;
8107   unsigned long j, nfuns;
8108   bfd_boolean res = TRUE;
8109
8110   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8111   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8112     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8113       aux->funtab[nfuns++] = aux->symtab[j];
8114   aux->nfuns = nfuns;
8115   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8116
8117   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
8118     {
8119       bfd_vma offset;
8120       const char * procname;
8121
8122       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8123                                aux->strtab_size, tp->start, &procname,
8124                                &offset);
8125
8126       fputs ("\n<", stdout);
8127
8128       if (procname)
8129         {
8130           fputs (procname, stdout);
8131
8132           if (offset)
8133             printf ("+%lx", (unsigned long) offset);
8134         }
8135
8136       fputs (">: [", stdout);
8137       print_vma (tp->start.offset, PREFIX_HEX);
8138       fputc ('-', stdout);
8139       print_vma (tp->end.offset, PREFIX_HEX);
8140       printf ("]\n\t");
8141
8142 #define PF(_m) if (tp->_m) printf (#_m " ");
8143 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8144       PF(Cannot_unwind);
8145       PF(Millicode);
8146       PF(Millicode_save_sr0);
8147       /* PV(Region_description);  */
8148       PF(Entry_SR);
8149       PV(Entry_FR);
8150       PV(Entry_GR);
8151       PF(Args_stored);
8152       PF(Variable_Frame);
8153       PF(Separate_Package_Body);
8154       PF(Frame_Extension_Millicode);
8155       PF(Stack_Overflow_Check);
8156       PF(Two_Instruction_SP_Increment);
8157       PF(Ada_Region);
8158       PF(cxx_info);
8159       PF(cxx_try_catch);
8160       PF(sched_entry_seq);
8161       PF(Save_SP);
8162       PF(Save_RP);
8163       PF(Save_MRP_in_frame);
8164       PF(extn_ptr_defined);
8165       PF(Cleanup_defined);
8166       PF(MPE_XL_interrupt_marker);
8167       PF(HP_UX_interrupt_marker);
8168       PF(Large_frame);
8169       PF(Pseudo_SP_Set);
8170       PV(Total_frame_size);
8171 #undef PF
8172 #undef PV
8173     }
8174
8175   printf ("\n");
8176
8177   free (aux->funtab);
8178
8179   return res;
8180 }
8181
8182 static bfd_boolean
8183 slurp_hppa_unwind_table (Filedata *                  filedata,
8184                          struct hppa_unw_aux_info *  aux,
8185                          Elf_Internal_Shdr *         sec)
8186 {
8187   unsigned long size, unw_ent_size, nentries, nrelas, i;
8188   Elf_Internal_Phdr * seg;
8189   struct hppa_unw_table_entry * tep;
8190   Elf_Internal_Shdr * relsec;
8191   Elf_Internal_Rela * rela;
8192   Elf_Internal_Rela * rp;
8193   unsigned char * table;
8194   unsigned char * tp;
8195   Elf_Internal_Sym * sym;
8196   const char * relname;
8197
8198   /* First, find the starting address of the segment that includes
8199      this section.  */
8200   if (filedata->file_header.e_phnum)
8201     {
8202       if (! get_program_headers (filedata))
8203         return FALSE;
8204
8205       for (seg = filedata->program_headers;
8206            seg < filedata->program_headers + filedata->file_header.e_phnum;
8207            ++seg)
8208         {
8209           if (seg->p_type != PT_LOAD)
8210             continue;
8211
8212           if (sec->sh_addr >= seg->p_vaddr
8213               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
8214             {
8215               aux->seg_base = seg->p_vaddr;
8216               break;
8217             }
8218         }
8219     }
8220
8221   /* Second, build the unwind table from the contents of the unwind
8222      section.  */
8223   size = sec->sh_size;
8224   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
8225                                       _("unwind table"));
8226   if (!table)
8227     return FALSE;
8228
8229   unw_ent_size = 16;
8230   nentries = size / unw_ent_size;
8231   size = unw_ent_size * nentries;
8232
8233   tep = aux->table = (struct hppa_unw_table_entry *)
8234       xcmalloc (nentries, sizeof (aux->table[0]));
8235
8236   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8237     {
8238       unsigned int tmp1, tmp2;
8239
8240       tep->start.section = SHN_UNDEF;
8241       tep->end.section   = SHN_UNDEF;
8242
8243       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8244       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8245       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8246       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8247
8248       tep->start.offset += aux->seg_base;
8249       tep->end.offset   += aux->seg_base;
8250
8251       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8252       tep->Millicode = (tmp1 >> 30) & 0x1;
8253       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8254       tep->Region_description = (tmp1 >> 27) & 0x3;
8255       tep->reserved1 = (tmp1 >> 26) & 0x1;
8256       tep->Entry_SR = (tmp1 >> 25) & 0x1;
8257       tep->Entry_FR = (tmp1 >> 21) & 0xf;
8258       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8259       tep->Args_stored = (tmp1 >> 15) & 0x1;
8260       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8261       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8262       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8263       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8264       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8265       tep->Ada_Region = (tmp1 >> 9) & 0x1;
8266       tep->cxx_info = (tmp1 >> 8) & 0x1;
8267       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8268       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8269       tep->reserved2 = (tmp1 >> 5) & 0x1;
8270       tep->Save_SP = (tmp1 >> 4) & 0x1;
8271       tep->Save_RP = (tmp1 >> 3) & 0x1;
8272       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8273       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8274       tep->Cleanup_defined = tmp1 & 0x1;
8275
8276       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8277       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8278       tep->Large_frame = (tmp2 >> 29) & 0x1;
8279       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8280       tep->reserved4 = (tmp2 >> 27) & 0x1;
8281       tep->Total_frame_size = tmp2 & 0x7ffffff;
8282     }
8283   free (table);
8284
8285   /* Third, apply any relocations to the unwind table.  */
8286   for (relsec = filedata->section_headers;
8287        relsec < filedata->section_headers + filedata->file_header.e_shnum;
8288        ++relsec)
8289     {
8290       if (relsec->sh_type != SHT_RELA
8291           || relsec->sh_info >= filedata->file_header.e_shnum
8292           || filedata->section_headers + relsec->sh_info != sec)
8293         continue;
8294
8295       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8296                               & rela, & nrelas))
8297         return FALSE;
8298
8299       for (rp = rela; rp < rela + nrelas; ++rp)
8300         {
8301           unsigned int sym_ndx;
8302           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8303           relname = elf_hppa_reloc_type (r_type);
8304
8305           if (relname == NULL)
8306             {
8307               warn (_("Skipping unknown relocation type: %u\n"), r_type);
8308               continue;
8309             }
8310
8311           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
8312           if (! const_strneq (relname, "R_PARISC_SEGREL"))
8313             {
8314               warn (_("Skipping unexpected relocation type: %s\n"), relname);
8315               continue;
8316             }
8317
8318           i = rp->r_offset / unw_ent_size;
8319           if (i >= aux->table_len)
8320             {
8321               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8322               continue;
8323             }
8324
8325           sym_ndx = get_reloc_symindex (rp->r_info);
8326           if (sym_ndx >= aux->nsyms)
8327             {
8328               warn (_("Skipping reloc with invalid symbol index: %u\n"),
8329                     sym_ndx);
8330               continue;
8331             }
8332           sym = aux->symtab + sym_ndx;
8333
8334           switch ((rp->r_offset % unw_ent_size) / 4)
8335             {
8336             case 0:
8337               aux->table[i].start.section = sym->st_shndx;
8338               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
8339               break;
8340             case 1:
8341               aux->table[i].end.section   = sym->st_shndx;
8342               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
8343               break;
8344             default:
8345               break;
8346             }
8347         }
8348
8349       free (rela);
8350     }
8351
8352   aux->table_len = nentries;
8353
8354   return TRUE;
8355 }
8356
8357 static bfd_boolean
8358 hppa_process_unwind (Filedata * filedata)
8359 {
8360   struct hppa_unw_aux_info aux;
8361   Elf_Internal_Shdr * unwsec = NULL;
8362   Elf_Internal_Shdr * sec;
8363   unsigned long i;
8364   bfd_boolean res = TRUE;
8365
8366   if (filedata->string_table == NULL)
8367     return FALSE;
8368
8369   memset (& aux, 0, sizeof (aux));
8370
8371   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8372     {
8373       if (sec->sh_type == SHT_SYMTAB)
8374         {
8375           if (aux.symtab)
8376             {
8377               error (_("Multiple symbol tables encountered\n"));
8378               free (aux.symtab);
8379               aux.symtab = NULL;
8380               free (aux.strtab);
8381               aux.strtab = NULL;
8382             }
8383           if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
8384                            &aux.strtab, &aux.strtab_size))
8385             return FALSE;
8386         }
8387       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8388         unwsec = sec;
8389     }
8390
8391   if (!unwsec)
8392     printf (_("\nThere are no unwind sections in this file.\n"));
8393
8394   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8395     {
8396       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8397         {
8398           unsigned long num_unwind = sec->sh_size / 16;
8399
8400           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8401                             "contains %lu entry:\n",
8402                             "\nUnwind section '%s' at offset 0x%lx "
8403                             "contains %lu entries:\n",
8404                             num_unwind),
8405                   printable_section_name (filedata, sec),
8406                   (unsigned long) sec->sh_offset,
8407                   num_unwind);
8408
8409           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8410             res = FALSE;
8411
8412           if (res && aux.table_len > 0)
8413             {
8414               if (! dump_hppa_unwind (filedata, &aux))
8415                 res = FALSE;
8416             }
8417
8418           free ((char *) aux.table);
8419           aux.table = NULL;
8420         }
8421     }
8422
8423   free (aux.symtab);
8424   free ((char *) aux.strtab);
8425
8426   return res;
8427 }
8428
8429 struct arm_section
8430 {
8431   unsigned char *      data;            /* The unwind data.  */
8432   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8433   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8434   unsigned long        nrelas;          /* The number of relocations.  */
8435   unsigned int         rel_type;        /* REL or RELA ?  */
8436   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8437 };
8438
8439 struct arm_unw_aux_info
8440 {
8441   Filedata *          filedata;         /* The file containing the unwind sections.  */
8442   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8443   unsigned long       nsyms;            /* Number of symbols.  */
8444   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8445   unsigned long       nfuns;            /* Number of these symbols.  */
8446   char *              strtab;           /* The file's string table.  */
8447   unsigned long       strtab_size;      /* Size of string table.  */
8448 };
8449
8450 static const char *
8451 arm_print_vma_and_name (Filedata *                 filedata,
8452                         struct arm_unw_aux_info *  aux,
8453                         bfd_vma                    fn,
8454                         struct absaddr             addr)
8455 {
8456   const char *procname;
8457   bfd_vma sym_offset;
8458
8459   if (addr.section == SHN_UNDEF)
8460     addr.offset = fn;
8461
8462   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8463                            aux->strtab_size, addr, &procname,
8464                            &sym_offset);
8465
8466   print_vma (fn, PREFIX_HEX);
8467
8468   if (procname)
8469     {
8470       fputs (" <", stdout);
8471       fputs (procname, stdout);
8472
8473       if (sym_offset)
8474         printf ("+0x%lx", (unsigned long) sym_offset);
8475       fputc ('>', stdout);
8476     }
8477
8478   return procname;
8479 }
8480
8481 static void
8482 arm_free_section (struct arm_section *arm_sec)
8483 {
8484   free (arm_sec->data);
8485   free (arm_sec->rela);
8486 }
8487
8488 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8489       cached section and install SEC instead.
8490    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8491       and return its valued in * WORDP, relocating if necessary.
8492    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8493       relocation's offset in ADDR.
8494    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8495       into the string table of the symbol associated with the reloc.  If no
8496       reloc was applied store -1 there.
8497    5) Return TRUE upon success, FALSE otherwise.  */
8498
8499 static bfd_boolean
8500 get_unwind_section_word (Filedata *                 filedata,
8501                          struct arm_unw_aux_info *  aux,
8502                          struct arm_section *       arm_sec,
8503                          Elf_Internal_Shdr *        sec,
8504                          bfd_vma                    word_offset,
8505                          unsigned int *             wordp,
8506                          struct absaddr *           addr,
8507                          bfd_vma *                  sym_name)
8508 {
8509   Elf_Internal_Rela *rp;
8510   Elf_Internal_Sym *sym;
8511   const char * relname;
8512   unsigned int word;
8513   bfd_boolean wrapped;
8514
8515   if (sec == NULL || arm_sec == NULL)
8516     return FALSE;
8517
8518   addr->section = SHN_UNDEF;
8519   addr->offset = 0;
8520
8521   if (sym_name != NULL)
8522     *sym_name = (bfd_vma) -1;
8523
8524   /* If necessary, update the section cache.  */
8525   if (sec != arm_sec->sec)
8526     {
8527       Elf_Internal_Shdr *relsec;
8528
8529       arm_free_section (arm_sec);
8530
8531       arm_sec->sec = sec;
8532       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8533                                 sec->sh_size, _("unwind data"));
8534       arm_sec->rela = NULL;
8535       arm_sec->nrelas = 0;
8536
8537       for (relsec = filedata->section_headers;
8538            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8539            ++relsec)
8540         {
8541           if (relsec->sh_info >= filedata->file_header.e_shnum
8542               || filedata->section_headers + relsec->sh_info != sec
8543               /* PR 15745: Check the section type as well.  */
8544               || (relsec->sh_type != SHT_REL
8545                   && relsec->sh_type != SHT_RELA))
8546             continue;
8547
8548           arm_sec->rel_type = relsec->sh_type;
8549           if (relsec->sh_type == SHT_REL)
8550             {
8551               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8552                                      relsec->sh_size,
8553                                      & arm_sec->rela, & arm_sec->nrelas))
8554                 return FALSE;
8555             }
8556           else /* relsec->sh_type == SHT_RELA */
8557             {
8558               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8559                                       relsec->sh_size,
8560                                       & arm_sec->rela, & arm_sec->nrelas))
8561                 return FALSE;
8562             }
8563           break;
8564         }
8565
8566       arm_sec->next_rela = arm_sec->rela;
8567     }
8568
8569   /* If there is no unwind data we can do nothing.  */
8570   if (arm_sec->data == NULL)
8571     return FALSE;
8572
8573   /* If the offset is invalid then fail.  */
8574   if (/* PR 21343 *//* PR 18879 */
8575       sec->sh_size < 4
8576       || word_offset > (sec->sh_size - 4)
8577       || ((bfd_signed_vma) word_offset) < 0)
8578     return FALSE;
8579
8580   /* Get the word at the required offset.  */
8581   word = byte_get (arm_sec->data + word_offset, 4);
8582
8583   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8584   if (arm_sec->rela == NULL)
8585     {
8586       * wordp = word;
8587       return TRUE;
8588     }
8589
8590   /* Look through the relocs to find the one that applies to the provided offset.  */
8591   wrapped = FALSE;
8592   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8593     {
8594       bfd_vma prelval, offset;
8595
8596       if (rp->r_offset > word_offset && !wrapped)
8597         {
8598           rp = arm_sec->rela;
8599           wrapped = TRUE;
8600         }
8601       if (rp->r_offset > word_offset)
8602         break;
8603
8604       if (rp->r_offset & 3)
8605         {
8606           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8607                 (unsigned long) rp->r_offset);
8608           continue;
8609         }
8610
8611       if (rp->r_offset < word_offset)
8612         continue;
8613
8614       /* PR 17531: file: 027-161405-0.004  */
8615       if (aux->symtab == NULL)
8616         continue;
8617
8618       if (arm_sec->rel_type == SHT_REL)
8619         {
8620           offset = word & 0x7fffffff;
8621           if (offset & 0x40000000)
8622             offset |= ~ (bfd_vma) 0x7fffffff;
8623         }
8624       else if (arm_sec->rel_type == SHT_RELA)
8625         offset = rp->r_addend;
8626       else
8627         {
8628           error (_("Unknown section relocation type %d encountered\n"),
8629                  arm_sec->rel_type);
8630           break;
8631         }
8632
8633       /* PR 17531 file: 027-1241568-0.004.  */
8634       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8635         {
8636           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8637                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8638           break;
8639         }
8640
8641       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8642       offset += sym->st_value;
8643       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8644
8645       /* Check that we are processing the expected reloc type.  */
8646       if (filedata->file_header.e_machine == EM_ARM)
8647         {
8648           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8649           if (relname == NULL)
8650             {
8651               warn (_("Skipping unknown ARM relocation type: %d\n"),
8652                     (int) ELF32_R_TYPE (rp->r_info));
8653               continue;
8654             }
8655
8656           if (streq (relname, "R_ARM_NONE"))
8657               continue;
8658
8659           if (! streq (relname, "R_ARM_PREL31"))
8660             {
8661               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8662               continue;
8663             }
8664         }
8665       else if (filedata->file_header.e_machine == EM_TI_C6000)
8666         {
8667           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8668           if (relname == NULL)
8669             {
8670               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8671                     (int) ELF32_R_TYPE (rp->r_info));
8672               continue;
8673             }
8674
8675           if (streq (relname, "R_C6000_NONE"))
8676             continue;
8677
8678           if (! streq (relname, "R_C6000_PREL31"))
8679             {
8680               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8681               continue;
8682             }
8683
8684           prelval >>= 1;
8685         }
8686       else
8687         {
8688           /* This function currently only supports ARM and TI unwinders.  */
8689           warn (_("Only TI and ARM unwinders are currently supported\n"));
8690           break;
8691         }
8692
8693       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8694       addr->section = sym->st_shndx;
8695       addr->offset = offset;
8696
8697       if (sym_name)
8698         * sym_name = sym->st_name;
8699       break;
8700     }
8701
8702   *wordp = word;
8703   arm_sec->next_rela = rp;
8704
8705   return TRUE;
8706 }
8707
8708 static const char *tic6x_unwind_regnames[16] =
8709 {
8710   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8711   "A14", "A13", "A12", "A11", "A10",
8712   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8713 };
8714
8715 static void
8716 decode_tic6x_unwind_regmask (unsigned int mask)
8717 {
8718   int i;
8719
8720   for (i = 12; mask; mask >>= 1, i--)
8721     {
8722       if (mask & 1)
8723         {
8724           fputs (tic6x_unwind_regnames[i], stdout);
8725           if (mask > 1)
8726             fputs (", ", stdout);
8727         }
8728     }
8729 }
8730
8731 #define ADVANCE                                                 \
8732   if (remaining == 0 && more_words)                             \
8733     {                                                           \
8734       data_offset += 4;                                         \
8735       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8736                                      data_offset, & word, & addr, NULL))        \
8737         return FALSE;                                           \
8738       remaining = 4;                                            \
8739       more_words--;                                             \
8740     }                                                           \
8741
8742 #define GET_OP(OP)                      \
8743   ADVANCE;                              \
8744   if (remaining)                        \
8745     {                                   \
8746       remaining--;                      \
8747       (OP) = word >> 24;                \
8748       word <<= 8;                       \
8749     }                                   \
8750   else                                  \
8751     {                                   \
8752       printf (_("[Truncated opcode]\n"));       \
8753       return FALSE;                     \
8754     }                                   \
8755   printf ("0x%02x ", OP)
8756
8757 static bfd_boolean
8758 decode_arm_unwind_bytecode (Filedata *                 filedata,
8759                             struct arm_unw_aux_info *  aux,
8760                             unsigned int               word,
8761                             unsigned int               remaining,
8762                             unsigned int               more_words,
8763                             bfd_vma                    data_offset,
8764                             Elf_Internal_Shdr *        data_sec,
8765                             struct arm_section *       data_arm_sec)
8766 {
8767   struct absaddr addr;
8768   bfd_boolean res = TRUE;
8769
8770   /* Decode the unwinding instructions.  */
8771   while (1)
8772     {
8773       unsigned int op, op2;
8774
8775       ADVANCE;
8776       if (remaining == 0)
8777         break;
8778       remaining--;
8779       op = word >> 24;
8780       word <<= 8;
8781
8782       printf ("  0x%02x ", op);
8783
8784       if ((op & 0xc0) == 0x00)
8785         {
8786           int offset = ((op & 0x3f) << 2) + 4;
8787
8788           printf ("     vsp = vsp + %d", offset);
8789         }
8790       else if ((op & 0xc0) == 0x40)
8791         {
8792           int offset = ((op & 0x3f) << 2) + 4;
8793
8794           printf ("     vsp = vsp - %d", offset);
8795         }
8796       else if ((op & 0xf0) == 0x80)
8797         {
8798           GET_OP (op2);
8799           if (op == 0x80 && op2 == 0)
8800             printf (_("Refuse to unwind"));
8801           else
8802             {
8803               unsigned int mask = ((op & 0x0f) << 8) | op2;
8804               bfd_boolean first = TRUE;
8805               int i;
8806
8807               printf ("pop {");
8808               for (i = 0; i < 12; i++)
8809                 if (mask & (1 << i))
8810                   {
8811                     if (first)
8812                       first = FALSE;
8813                     else
8814                       printf (", ");
8815                     printf ("r%d", 4 + i);
8816                   }
8817               printf ("}");
8818             }
8819         }
8820       else if ((op & 0xf0) == 0x90)
8821         {
8822           if (op == 0x9d || op == 0x9f)
8823             printf (_("     [Reserved]"));
8824           else
8825             printf ("     vsp = r%d", op & 0x0f);
8826         }
8827       else if ((op & 0xf0) == 0xa0)
8828         {
8829           int end = 4 + (op & 0x07);
8830           bfd_boolean first = TRUE;
8831           int i;
8832
8833           printf ("     pop {");
8834           for (i = 4; i <= end; i++)
8835             {
8836               if (first)
8837                 first = FALSE;
8838               else
8839                 printf (", ");
8840               printf ("r%d", i);
8841             }
8842           if (op & 0x08)
8843             {
8844               if (!first)
8845                 printf (", ");
8846               printf ("r14");
8847             }
8848           printf ("}");
8849         }
8850       else if (op == 0xb0)
8851         printf (_("     finish"));
8852       else if (op == 0xb1)
8853         {
8854           GET_OP (op2);
8855           if (op2 == 0 || (op2 & 0xf0) != 0)
8856             printf (_("[Spare]"));
8857           else
8858             {
8859               unsigned int mask = op2 & 0x0f;
8860               bfd_boolean first = TRUE;
8861               int i;
8862
8863               printf ("pop {");
8864               for (i = 0; i < 12; i++)
8865                 if (mask & (1 << i))
8866                   {
8867                     if (first)
8868                       first = FALSE;
8869                     else
8870                       printf (", ");
8871                     printf ("r%d", i);
8872                   }
8873               printf ("}");
8874             }
8875         }
8876       else if (op == 0xb2)
8877         {
8878           unsigned char buf[9];
8879           unsigned int i, len;
8880           unsigned long offset;
8881
8882           for (i = 0; i < sizeof (buf); i++)
8883             {
8884               GET_OP (buf[i]);
8885               if ((buf[i] & 0x80) == 0)
8886                 break;
8887             }
8888           if (i == sizeof (buf))
8889             {
8890               error (_("corrupt change to vsp\n"));
8891               res = FALSE;
8892             }
8893           else
8894             {
8895               offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
8896               assert (len == i + 1);
8897               offset = offset * 4 + 0x204;
8898               printf ("vsp = vsp + %ld", offset);
8899             }
8900         }
8901       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8902         {
8903           unsigned int first, last;
8904
8905           GET_OP (op2);
8906           first = op2 >> 4;
8907           last = op2 & 0x0f;
8908           if (op == 0xc8)
8909             first = first + 16;
8910           printf ("pop {D%d", first);
8911           if (last)
8912             printf ("-D%d", first + last);
8913           printf ("}");
8914         }
8915       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8916         {
8917           unsigned int count = op & 0x07;
8918
8919           printf ("pop {D8");
8920           if (count)
8921             printf ("-D%d", 8 + count);
8922           printf ("}");
8923         }
8924       else if (op >= 0xc0 && op <= 0xc5)
8925         {
8926           unsigned int count = op & 0x07;
8927
8928           printf ("     pop {wR10");
8929           if (count)
8930             printf ("-wR%d", 10 + count);
8931           printf ("}");
8932         }
8933       else if (op == 0xc6)
8934         {
8935           unsigned int first, last;
8936
8937           GET_OP (op2);
8938           first = op2 >> 4;
8939           last = op2 & 0x0f;
8940           printf ("pop {wR%d", first);
8941           if (last)
8942             printf ("-wR%d", first + last);
8943           printf ("}");
8944         }
8945       else if (op == 0xc7)
8946         {
8947           GET_OP (op2);
8948           if (op2 == 0 || (op2 & 0xf0) != 0)
8949             printf (_("[Spare]"));
8950           else
8951             {
8952               unsigned int mask = op2 & 0x0f;
8953               bfd_boolean first = TRUE;
8954               int i;
8955
8956               printf ("pop {");
8957               for (i = 0; i < 4; i++)
8958                 if (mask & (1 << i))
8959                   {
8960                     if (first)
8961                       first = FALSE;
8962                     else
8963                       printf (", ");
8964                     printf ("wCGR%d", i);
8965                   }
8966               printf ("}");
8967             }
8968         }
8969       else
8970         {
8971           printf (_("     [unsupported opcode]"));
8972           res = FALSE;
8973         }
8974
8975       printf ("\n");
8976     }
8977
8978   return res;
8979 }
8980
8981 static bfd_boolean
8982 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8983                               struct arm_unw_aux_info *  aux,
8984                               unsigned int               word,
8985                               unsigned int               remaining,
8986                               unsigned int               more_words,
8987                               bfd_vma                    data_offset,
8988                               Elf_Internal_Shdr *        data_sec,
8989                               struct arm_section *       data_arm_sec)
8990 {
8991   struct absaddr addr;
8992
8993   /* Decode the unwinding instructions.  */
8994   while (1)
8995     {
8996       unsigned int op, op2;
8997
8998       ADVANCE;
8999       if (remaining == 0)
9000         break;
9001       remaining--;
9002       op = word >> 24;
9003       word <<= 8;
9004
9005       printf ("  0x%02x ", op);
9006
9007       if ((op & 0xc0) == 0x00)
9008         {
9009           int offset = ((op & 0x3f) << 3) + 8;
9010           printf ("     sp = sp + %d", offset);
9011         }
9012       else if ((op & 0xc0) == 0x80)
9013         {
9014           GET_OP (op2);
9015           if (op == 0x80 && op2 == 0)
9016             printf (_("Refuse to unwind"));
9017           else
9018             {
9019               unsigned int mask = ((op & 0x1f) << 8) | op2;
9020               if (op & 0x20)
9021                 printf ("pop compact {");
9022               else
9023                 printf ("pop {");
9024
9025               decode_tic6x_unwind_regmask (mask);
9026               printf("}");
9027             }
9028         }
9029       else if ((op & 0xf0) == 0xc0)
9030         {
9031           unsigned int reg;
9032           unsigned int nregs;
9033           unsigned int i;
9034           const char *name;
9035           struct
9036           {
9037             unsigned int offset;
9038             unsigned int reg;
9039           } regpos[16];
9040
9041           /* Scan entire instruction first so that GET_OP output is not
9042              interleaved with disassembly.  */
9043           nregs = 0;
9044           for (i = 0; nregs < (op & 0xf); i++)
9045             {
9046               GET_OP (op2);
9047               reg = op2 >> 4;
9048               if (reg != 0xf)
9049                 {
9050                   regpos[nregs].offset = i * 2;
9051                   regpos[nregs].reg = reg;
9052                   nregs++;
9053                 }
9054
9055               reg = op2 & 0xf;
9056               if (reg != 0xf)
9057                 {
9058                   regpos[nregs].offset = i * 2 + 1;
9059                   regpos[nregs].reg = reg;
9060                   nregs++;
9061                 }
9062             }
9063
9064           printf (_("pop frame {"));
9065           if (nregs == 0)
9066             {
9067               printf (_("*corrupt* - no registers specified"));
9068             }
9069           else
9070             {
9071               reg = nregs - 1;
9072               for (i = i * 2; i > 0; i--)
9073                 {
9074                   if (regpos[reg].offset == i - 1)
9075                     {
9076                       name = tic6x_unwind_regnames[regpos[reg].reg];
9077                       if (reg > 0)
9078                         reg--;
9079                     }
9080                   else
9081                     name = _("[pad]");
9082
9083                   fputs (name, stdout);
9084                   if (i > 1)
9085                     printf (", ");
9086                 }
9087             }
9088
9089           printf ("}");
9090         }
9091       else if (op == 0xd0)
9092         printf ("     MOV FP, SP");
9093       else if (op == 0xd1)
9094         printf ("     __c6xabi_pop_rts");
9095       else if (op == 0xd2)
9096         {
9097           unsigned char buf[9];
9098           unsigned int i, len;
9099           unsigned long offset;
9100
9101           for (i = 0; i < sizeof (buf); i++)
9102             {
9103               GET_OP (buf[i]);
9104               if ((buf[i] & 0x80) == 0)
9105                 break;
9106             }
9107           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
9108           if (i == sizeof (buf))
9109             {
9110               warn (_("Corrupt stack pointer adjustment detected\n"));
9111               return FALSE;
9112             }
9113
9114           offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
9115           assert (len == i + 1);
9116           offset = offset * 8 + 0x408;
9117           printf (_("sp = sp + %ld"), offset);
9118         }
9119       else if ((op & 0xf0) == 0xe0)
9120         {
9121           if ((op & 0x0f) == 7)
9122             printf ("     RETURN");
9123           else
9124             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
9125         }
9126       else
9127         {
9128           printf (_("     [unsupported opcode]"));
9129         }
9130       putchar ('\n');
9131     }
9132
9133   return TRUE;
9134 }
9135
9136 static bfd_vma
9137 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
9138 {
9139   bfd_vma offset;
9140
9141   offset = word & 0x7fffffff;
9142   if (offset & 0x40000000)
9143     offset |= ~ (bfd_vma) 0x7fffffff;
9144
9145   if (filedata->file_header.e_machine == EM_TI_C6000)
9146     offset <<= 1;
9147
9148   return offset + where;
9149 }
9150
9151 static bfd_boolean
9152 decode_arm_unwind (Filedata *                 filedata,
9153                    struct arm_unw_aux_info *  aux,
9154                    unsigned int               word,
9155                    unsigned int               remaining,
9156                    bfd_vma                    data_offset,
9157                    Elf_Internal_Shdr *        data_sec,
9158                    struct arm_section *       data_arm_sec)
9159 {
9160   int per_index;
9161   unsigned int more_words = 0;
9162   struct absaddr addr;
9163   bfd_vma sym_name = (bfd_vma) -1;
9164   bfd_boolean res = TRUE;
9165
9166   if (remaining == 0)
9167     {
9168       /* Fetch the first word.
9169          Note - when decoding an object file the address extracted
9170          here will always be 0.  So we also pass in the sym_name
9171          parameter so that we can find the symbol associated with
9172          the personality routine.  */
9173       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
9174                                      & word, & addr, & sym_name))
9175         return FALSE;
9176
9177       remaining = 4;
9178     }
9179   else
9180     {
9181       addr.section = SHN_UNDEF;
9182       addr.offset = 0;
9183     }
9184
9185   if ((word & 0x80000000) == 0)
9186     {
9187       /* Expand prel31 for personality routine.  */
9188       bfd_vma fn;
9189       const char *procname;
9190
9191       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
9192       printf (_("  Personality routine: "));
9193       if (fn == 0
9194           && addr.section == SHN_UNDEF && addr.offset == 0
9195           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
9196         {
9197           procname = aux->strtab + sym_name;
9198           print_vma (fn, PREFIX_HEX);
9199           if (procname)
9200             {
9201               fputs (" <", stdout);
9202               fputs (procname, stdout);
9203               fputc ('>', stdout);
9204             }
9205         }
9206       else
9207         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
9208       fputc ('\n', stdout);
9209
9210       /* The GCC personality routines use the standard compact
9211          encoding, starting with one byte giving the number of
9212          words.  */
9213       if (procname != NULL
9214           && (const_strneq (procname, "__gcc_personality_v0")
9215               || const_strneq (procname, "__gxx_personality_v0")
9216               || const_strneq (procname, "__gcj_personality_v0")
9217               || const_strneq (procname, "__gnu_objc_personality_v0")))
9218         {
9219           remaining = 0;
9220           more_words = 1;
9221           ADVANCE;
9222           if (!remaining)
9223             {
9224               printf (_("  [Truncated data]\n"));
9225               return FALSE;
9226             }
9227           more_words = word >> 24;
9228           word <<= 8;
9229           remaining--;
9230           per_index = -1;
9231         }
9232       else
9233         return TRUE;
9234     }
9235   else
9236     {
9237       /* ARM EHABI Section 6.3:
9238
9239          An exception-handling table entry for the compact model looks like:
9240
9241            31 30-28 27-24 23-0
9242            -- ----- ----- ----
9243             1   0   index Data for personalityRoutine[index]    */
9244
9245       if (filedata->file_header.e_machine == EM_ARM
9246           && (word & 0x70000000))
9247         {
9248           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9249           res = FALSE;
9250         }
9251
9252       per_index = (word >> 24) & 0x7f;
9253       printf (_("  Compact model index: %d\n"), per_index);
9254       if (per_index == 0)
9255         {
9256           more_words = 0;
9257           word <<= 8;
9258           remaining--;
9259         }
9260       else if (per_index < 3)
9261         {
9262           more_words = (word >> 16) & 0xff;
9263           word <<= 16;
9264           remaining -= 2;
9265         }
9266     }
9267
9268   switch (filedata->file_header.e_machine)
9269     {
9270     case EM_ARM:
9271       if (per_index < 3)
9272         {
9273           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9274                                             data_offset, data_sec, data_arm_sec))
9275             res = FALSE;
9276         }
9277       else
9278         {
9279           warn (_("Unknown ARM compact model index encountered\n"));
9280           printf (_("  [reserved]\n"));
9281           res = FALSE;
9282         }
9283       break;
9284
9285     case EM_TI_C6000:
9286       if (per_index < 3)
9287         {
9288           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9289                                               data_offset, data_sec, data_arm_sec))
9290             res = FALSE;
9291         }
9292       else if (per_index < 5)
9293         {
9294           if (((word >> 17) & 0x7f) == 0x7f)
9295             printf (_("  Restore stack from frame pointer\n"));
9296           else
9297             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
9298           printf (_("  Registers restored: "));
9299           if (per_index == 4)
9300             printf (" (compact) ");
9301           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9302           putchar ('\n');
9303           printf (_("  Return register: %s\n"),
9304                   tic6x_unwind_regnames[word & 0xf]);
9305         }
9306       else
9307         printf (_("  [reserved (%d)]\n"), per_index);
9308       break;
9309
9310     default:
9311       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9312              filedata->file_header.e_machine);
9313       res = FALSE;
9314     }
9315
9316   /* Decode the descriptors.  Not implemented.  */
9317
9318   return res;
9319 }
9320
9321 static bfd_boolean
9322 dump_arm_unwind (Filedata *                 filedata,
9323                  struct arm_unw_aux_info *  aux,
9324                  Elf_Internal_Shdr *        exidx_sec)
9325 {
9326   struct arm_section exidx_arm_sec, extab_arm_sec;
9327   unsigned int i, exidx_len;
9328   unsigned long j, nfuns;
9329   bfd_boolean res = TRUE;
9330
9331   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9332   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9333   exidx_len = exidx_sec->sh_size / 8;
9334
9335   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9336   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9337     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9338       aux->funtab[nfuns++] = aux->symtab[j];
9339   aux->nfuns = nfuns;
9340   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9341
9342   for (i = 0; i < exidx_len; i++)
9343     {
9344       unsigned int exidx_fn, exidx_entry;
9345       struct absaddr fn_addr, entry_addr;
9346       bfd_vma fn;
9347
9348       fputc ('\n', stdout);
9349
9350       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9351                                      8 * i, & exidx_fn, & fn_addr, NULL)
9352           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9353                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9354         {
9355           free (aux->funtab);
9356           arm_free_section (& exidx_arm_sec);
9357           arm_free_section (& extab_arm_sec);
9358           return FALSE;
9359         }
9360
9361       /* ARM EHABI, Section 5:
9362          An index table entry consists of 2 words.
9363          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9364       if (exidx_fn & 0x80000000)
9365         {
9366           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9367           res = FALSE;
9368         }
9369
9370       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9371
9372       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9373       fputs (": ", stdout);
9374
9375       if (exidx_entry == 1)
9376         {
9377           print_vma (exidx_entry, PREFIX_HEX);
9378           fputs (" [cantunwind]\n", stdout);
9379         }
9380       else if (exidx_entry & 0x80000000)
9381         {
9382           print_vma (exidx_entry, PREFIX_HEX);
9383           fputc ('\n', stdout);
9384           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9385         }
9386       else
9387         {
9388           bfd_vma table, table_offset = 0;
9389           Elf_Internal_Shdr *table_sec;
9390
9391           fputs ("@", stdout);
9392           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9393           print_vma (table, PREFIX_HEX);
9394           printf ("\n");
9395
9396           /* Locate the matching .ARM.extab.  */
9397           if (entry_addr.section != SHN_UNDEF
9398               && entry_addr.section < filedata->file_header.e_shnum)
9399             {
9400               table_sec = filedata->section_headers + entry_addr.section;
9401               table_offset = entry_addr.offset;
9402               /* PR 18879 */
9403               if (table_offset > table_sec->sh_size
9404                   || ((bfd_signed_vma) table_offset) < 0)
9405                 {
9406                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9407                         (unsigned long) table_offset,
9408                         printable_section_name (filedata, table_sec));
9409                   res = FALSE;
9410                   continue;
9411                 }
9412             }
9413           else
9414             {
9415               table_sec = find_section_by_address (filedata, table);
9416               if (table_sec != NULL)
9417                 table_offset = table - table_sec->sh_addr;
9418             }
9419
9420           if (table_sec == NULL)
9421             {
9422               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9423                     (unsigned long) table);
9424               res = FALSE;
9425               continue;
9426             }
9427
9428           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9429                                    &extab_arm_sec))
9430             res = FALSE;
9431         }
9432     }
9433
9434   printf ("\n");
9435
9436   free (aux->funtab);
9437   arm_free_section (&exidx_arm_sec);
9438   arm_free_section (&extab_arm_sec);
9439
9440   return res;
9441 }
9442
9443 /* Used for both ARM and C6X unwinding tables.  */
9444
9445 static bfd_boolean
9446 arm_process_unwind (Filedata * filedata)
9447 {
9448   struct arm_unw_aux_info aux;
9449   Elf_Internal_Shdr *unwsec = NULL;
9450   Elf_Internal_Shdr *sec;
9451   unsigned long i;
9452   unsigned int sec_type;
9453   bfd_boolean res = TRUE;
9454
9455   switch (filedata->file_header.e_machine)
9456     {
9457     case EM_ARM:
9458       sec_type = SHT_ARM_EXIDX;
9459       break;
9460
9461     case EM_TI_C6000:
9462       sec_type = SHT_C6000_UNWIND;
9463       break;
9464
9465     default:
9466       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9467              filedata->file_header.e_machine);
9468       return FALSE;
9469     }
9470
9471   if (filedata->string_table == NULL)
9472     return FALSE;
9473
9474   memset (& aux, 0, sizeof (aux));
9475   aux.filedata = filedata;
9476
9477   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9478     {
9479       if (sec->sh_type == SHT_SYMTAB)
9480         {
9481           if (aux.symtab)
9482             {
9483               error (_("Multiple symbol tables encountered\n"));
9484               free (aux.symtab);
9485               aux.symtab = NULL;
9486               free (aux.strtab);
9487               aux.strtab = NULL;
9488             }
9489           if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
9490                            &aux.strtab, &aux.strtab_size))
9491             return FALSE;
9492         }
9493       else if (sec->sh_type == sec_type)
9494         unwsec = sec;
9495     }
9496
9497   if (unwsec == NULL)
9498     printf (_("\nThere are no unwind sections in this file.\n"));
9499   else
9500     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9501       {
9502         if (sec->sh_type == sec_type)
9503           {
9504             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9505             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9506                               "contains %lu entry:\n",
9507                               "\nUnwind section '%s' at offset 0x%lx "
9508                               "contains %lu entries:\n",
9509                               num_unwind),
9510                     printable_section_name (filedata, sec),
9511                     (unsigned long) sec->sh_offset,
9512                     num_unwind);
9513
9514             if (! dump_arm_unwind (filedata, &aux, sec))
9515               res = FALSE;
9516           }
9517       }
9518
9519   free (aux.symtab);
9520   free ((char *) aux.strtab);
9521
9522   return res;
9523 }
9524
9525 static bfd_boolean
9526 process_unwind (Filedata * filedata)
9527 {
9528   struct unwind_handler
9529   {
9530     unsigned int machtype;
9531     bfd_boolean (* handler)(Filedata *);
9532   } handlers[] =
9533   {
9534     { EM_ARM, arm_process_unwind },
9535     { EM_IA_64, ia64_process_unwind },
9536     { EM_PARISC, hppa_process_unwind },
9537     { EM_TI_C6000, arm_process_unwind },
9538     { 0, NULL }
9539   };
9540   int i;
9541
9542   if (!do_unwind)
9543     return TRUE;
9544
9545   for (i = 0; handlers[i].handler != NULL; i++)
9546     if (filedata->file_header.e_machine == handlers[i].machtype)
9547       return handlers[i].handler (filedata);
9548
9549   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9550           get_machine_name (filedata->file_header.e_machine));
9551   return TRUE;
9552 }
9553
9554 static void
9555 dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
9556 {
9557   switch (entry->d_tag)
9558     {
9559     case DT_AARCH64_BTI_PLT:
9560     case DT_AARCH64_PAC_PLT:
9561       break;
9562     default:
9563       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9564       break;
9565     }
9566   putchar ('\n');
9567 }
9568
9569 static void
9570 dynamic_section_mips_val (Filedata * filedata, Elf_Internal_Dyn * entry)
9571 {
9572   switch (entry->d_tag)
9573     {
9574     case DT_MIPS_FLAGS:
9575       if (entry->d_un.d_val == 0)
9576         printf (_("NONE"));
9577       else
9578         {
9579           static const char * opts[] =
9580           {
9581             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9582             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9583             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9584             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9585             "RLD_ORDER_SAFE"
9586           };
9587           unsigned int cnt;
9588           bfd_boolean first = TRUE;
9589
9590           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9591             if (entry->d_un.d_val & (1 << cnt))
9592               {
9593                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9594                 first = FALSE;
9595               }
9596         }
9597       break;
9598
9599     case DT_MIPS_IVERSION:
9600       if (VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
9601         printf (_("Interface Version: %s"),
9602                 GET_DYNAMIC_NAME (filedata, entry->d_un.d_val));
9603       else
9604         {
9605           char buf[40];
9606           sprintf_vma (buf, entry->d_un.d_ptr);
9607           /* Note: coded this way so that there is a single string for translation.  */
9608           printf (_("<corrupt: %s>"), buf);
9609         }
9610       break;
9611
9612     case DT_MIPS_TIME_STAMP:
9613       {
9614         char timebuf[128];
9615         struct tm * tmp;
9616         time_t atime = entry->d_un.d_val;
9617
9618         tmp = gmtime (&atime);
9619         /* PR 17531: file: 6accc532.  */
9620         if (tmp == NULL)
9621           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9622         else
9623           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9624                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9625                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9626         printf (_("Time Stamp: %s"), timebuf);
9627       }
9628       break;
9629
9630     case DT_MIPS_RLD_VERSION:
9631     case DT_MIPS_LOCAL_GOTNO:
9632     case DT_MIPS_CONFLICTNO:
9633     case DT_MIPS_LIBLISTNO:
9634     case DT_MIPS_SYMTABNO:
9635     case DT_MIPS_UNREFEXTNO:
9636     case DT_MIPS_HIPAGENO:
9637     case DT_MIPS_DELTA_CLASS_NO:
9638     case DT_MIPS_DELTA_INSTANCE_NO:
9639     case DT_MIPS_DELTA_RELOC_NO:
9640     case DT_MIPS_DELTA_SYM_NO:
9641     case DT_MIPS_DELTA_CLASSSYM_NO:
9642     case DT_MIPS_COMPACT_SIZE:
9643       print_vma (entry->d_un.d_val, DEC);
9644       break;
9645
9646     case DT_MIPS_XHASH:
9647       filedata->dynamic_info_DT_MIPS_XHASH = entry->d_un.d_val;
9648       filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9649       /* Falls through.  */
9650
9651     default:
9652       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9653     }
9654     putchar ('\n');
9655 }
9656
9657 static void
9658 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9659 {
9660   switch (entry->d_tag)
9661     {
9662     case DT_HP_DLD_FLAGS:
9663       {
9664         static struct
9665         {
9666           long int bit;
9667           const char * str;
9668         }
9669         flags[] =
9670         {
9671           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9672           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9673           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9674           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9675           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9676           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9677           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9678           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9679           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9680           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9681           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9682           { DT_HP_GST, "HP_GST" },
9683           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9684           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9685           { DT_HP_NODELETE, "HP_NODELETE" },
9686           { DT_HP_GROUP, "HP_GROUP" },
9687           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9688         };
9689         bfd_boolean first = TRUE;
9690         size_t cnt;
9691         bfd_vma val = entry->d_un.d_val;
9692
9693         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9694           if (val & flags[cnt].bit)
9695             {
9696               if (! first)
9697                 putchar (' ');
9698               fputs (flags[cnt].str, stdout);
9699               first = FALSE;
9700               val ^= flags[cnt].bit;
9701             }
9702
9703         if (val != 0 || first)
9704           {
9705             if (! first)
9706               putchar (' ');
9707             print_vma (val, HEX);
9708           }
9709       }
9710       break;
9711
9712     default:
9713       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9714       break;
9715     }
9716   putchar ('\n');
9717 }
9718
9719 #ifdef BFD64
9720
9721 /* VMS vs Unix time offset and factor.  */
9722
9723 #define VMS_EPOCH_OFFSET 35067168000000000LL
9724 #define VMS_GRANULARITY_FACTOR 10000000
9725
9726 /* Display a VMS time in a human readable format.  */
9727
9728 static void
9729 print_vms_time (bfd_int64_t vmstime)
9730 {
9731   struct tm *tm;
9732   time_t unxtime;
9733
9734   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9735   tm = gmtime (&unxtime);
9736   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9737           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9738           tm->tm_hour, tm->tm_min, tm->tm_sec);
9739 }
9740 #endif /* BFD64 */
9741
9742 static void
9743 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9744 {
9745   switch (entry->d_tag)
9746     {
9747     case DT_IA_64_PLT_RESERVE:
9748       /* First 3 slots reserved.  */
9749       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9750       printf (" -- ");
9751       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9752       break;
9753
9754     case DT_IA_64_VMS_LINKTIME:
9755 #ifdef BFD64
9756       print_vms_time (entry->d_un.d_val);
9757 #endif
9758       break;
9759
9760     case DT_IA_64_VMS_LNKFLAGS:
9761       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9762       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9763         printf (" CALL_DEBUG");
9764       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9765         printf (" NOP0BUFS");
9766       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9767         printf (" P0IMAGE");
9768       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9769         printf (" MKTHREADS");
9770       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9771         printf (" UPCALLS");
9772       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9773         printf (" IMGSTA");
9774       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9775         printf (" INITIALIZE");
9776       if (entry->d_un.d_val & VMS_LF_MAIN)
9777         printf (" MAIN");
9778       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9779         printf (" EXE_INIT");
9780       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9781         printf (" TBK_IN_IMG");
9782       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9783         printf (" DBG_IN_IMG");
9784       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9785         printf (" TBK_IN_DSF");
9786       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9787         printf (" DBG_IN_DSF");
9788       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9789         printf (" SIGNATURES");
9790       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9791         printf (" REL_SEG_OFF");
9792       break;
9793
9794     default:
9795       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9796       break;
9797     }
9798   putchar ('\n');
9799 }
9800
9801 static bfd_boolean
9802 get_32bit_dynamic_section (Filedata * filedata)
9803 {
9804   Elf32_External_Dyn * edyn;
9805   Elf32_External_Dyn * ext;
9806   Elf_Internal_Dyn * entry;
9807
9808   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata,
9809                                           filedata->dynamic_addr, 1,
9810                                           filedata->dynamic_size,
9811                                           _("dynamic section"));
9812   if (!edyn)
9813     return FALSE;
9814
9815   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9816      might not have the luxury of section headers.  Look for the DT_NULL
9817      terminator to determine the number of entries.  */
9818   for (ext = edyn, filedata->dynamic_nent = 0;
9819        (char *) (ext + 1) <= (char *) edyn + filedata->dynamic_size;
9820        ext++)
9821     {
9822       filedata->dynamic_nent++;
9823       if (BYTE_GET (ext->d_tag) == DT_NULL)
9824         break;
9825     }
9826
9827   filedata->dynamic_section
9828     = (Elf_Internal_Dyn *) cmalloc (filedata->dynamic_nent, sizeof (* entry));
9829   if (filedata->dynamic_section == NULL)
9830     {
9831       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9832              (unsigned long) filedata->dynamic_nent);
9833       free (edyn);
9834       return FALSE;
9835     }
9836
9837   for (ext = edyn, entry = filedata->dynamic_section;
9838        entry < filedata->dynamic_section + filedata->dynamic_nent;
9839        ext++, entry++)
9840     {
9841       entry->d_tag      = BYTE_GET (ext->d_tag);
9842       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9843     }
9844
9845   free (edyn);
9846
9847   return TRUE;
9848 }
9849
9850 static bfd_boolean
9851 get_64bit_dynamic_section (Filedata * filedata)
9852 {
9853   Elf64_External_Dyn * edyn;
9854   Elf64_External_Dyn * ext;
9855   Elf_Internal_Dyn * entry;
9856
9857   /* Read in the data.  */
9858   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata,
9859                                           filedata->dynamic_addr, 1,
9860                                           filedata->dynamic_size,
9861                                           _("dynamic section"));
9862   if (!edyn)
9863     return FALSE;
9864
9865   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9866      might not have the luxury of section headers.  Look for the DT_NULL
9867      terminator to determine the number of entries.  */
9868   for (ext = edyn, filedata->dynamic_nent = 0;
9869        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9870        (char *) (ext + 1) <= (char *) edyn + filedata->dynamic_size;
9871        ext++)
9872     {
9873       filedata->dynamic_nent++;
9874       if (BYTE_GET (ext->d_tag) == DT_NULL)
9875         break;
9876     }
9877
9878   filedata->dynamic_section
9879     = (Elf_Internal_Dyn *) cmalloc (filedata->dynamic_nent, sizeof (* entry));
9880   if (filedata->dynamic_section == NULL)
9881     {
9882       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9883              (unsigned long) filedata->dynamic_nent);
9884       free (edyn);
9885       return FALSE;
9886     }
9887
9888   /* Convert from external to internal formats.  */
9889   for (ext = edyn, entry = filedata->dynamic_section;
9890        entry < filedata->dynamic_section + filedata->dynamic_nent;
9891        ext++, entry++)
9892     {
9893       entry->d_tag      = BYTE_GET (ext->d_tag);
9894       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9895     }
9896
9897   free (edyn);
9898
9899   return TRUE;
9900 }
9901
9902 static void
9903 print_dynamic_flags (bfd_vma flags)
9904 {
9905   bfd_boolean first = TRUE;
9906
9907   while (flags)
9908     {
9909       bfd_vma flag;
9910
9911       flag = flags & - flags;
9912       flags &= ~ flag;
9913
9914       if (first)
9915         first = FALSE;
9916       else
9917         putc (' ', stdout);
9918
9919       switch (flag)
9920         {
9921         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9922         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9923         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9924         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9925         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9926         default:                fputs (_("unknown"), stdout); break;
9927         }
9928     }
9929   puts ("");
9930 }
9931
9932 static bfd_vma *
9933 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
9934 {
9935   unsigned char * e_data;
9936   bfd_vma * i_data;
9937
9938   /* If the size_t type is smaller than the bfd_size_type, eg because
9939      you are building a 32-bit tool on a 64-bit host, then make sure
9940      that when (number) is cast to (size_t) no information is lost.  */
9941   if (sizeof (size_t) < sizeof (bfd_size_type)
9942       && (bfd_size_type) ((size_t) number) != number)
9943     {
9944       error (_("Size truncation prevents reading %s elements of size %u\n"),
9945              bfd_vmatoa ("u", number), ent_size);
9946       return NULL;
9947     }
9948
9949   /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
9950      attempting to allocate memory when the read is bound to fail.  */
9951   if (ent_size * number > filedata->file_size)
9952     {
9953       error (_("Invalid number of dynamic entries: %s\n"),
9954              bfd_vmatoa ("u", number));
9955       return NULL;
9956     }
9957
9958   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
9959   if (e_data == NULL)
9960     {
9961       error (_("Out of memory reading %s dynamic entries\n"),
9962              bfd_vmatoa ("u", number));
9963       return NULL;
9964     }
9965
9966   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
9967     {
9968       error (_("Unable to read in %s bytes of dynamic data\n"),
9969              bfd_vmatoa ("u", number * ent_size));
9970       free (e_data);
9971       return NULL;
9972     }
9973
9974   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
9975   if (i_data == NULL)
9976     {
9977       error (_("Out of memory allocating space for %s dynamic entries\n"),
9978              bfd_vmatoa ("u", number));
9979       free (e_data);
9980       return NULL;
9981     }
9982
9983   while (number--)
9984     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9985
9986   free (e_data);
9987
9988   return i_data;
9989 }
9990
9991 static unsigned long
9992 get_num_dynamic_syms (Filedata * filedata)
9993 {
9994   unsigned long num_of_syms = 0;
9995
9996   if (!do_histogram && (!do_using_dynamic || do_dyn_syms))
9997     return num_of_syms;
9998
9999   if (filedata->dynamic_info[DT_HASH])
10000     {
10001       unsigned char nb[8];
10002       unsigned char nc[8];
10003       unsigned int hash_ent_size = 4;
10004
10005       if ((filedata->file_header.e_machine == EM_ALPHA
10006            || filedata->file_header.e_machine == EM_S390
10007            || filedata->file_header.e_machine == EM_S390_OLD)
10008           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
10009         hash_ent_size = 8;
10010
10011       if (fseek (filedata->handle,
10012                  (filedata->archive_file_offset
10013                   + offset_from_vma (filedata, filedata->dynamic_info[DT_HASH],
10014                                      sizeof nb + sizeof nc)),
10015                  SEEK_SET))
10016         {
10017           error (_("Unable to seek to start of dynamic information\n"));
10018           goto no_hash;
10019         }
10020
10021       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
10022         {
10023           error (_("Failed to read in number of buckets\n"));
10024           goto no_hash;
10025         }
10026
10027       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
10028         {
10029           error (_("Failed to read in number of chains\n"));
10030           goto no_hash;
10031         }
10032
10033       filedata->nbuckets = byte_get (nb, hash_ent_size);
10034       filedata->nchains = byte_get (nc, hash_ent_size);
10035
10036       if (filedata->nbuckets != 0 && filedata->nchains != 0)
10037         {
10038           filedata->buckets = get_dynamic_data (filedata, filedata->nbuckets,
10039                                                 hash_ent_size);
10040           filedata->chains  = get_dynamic_data (filedata, filedata->nchains,
10041                                                 hash_ent_size);
10042
10043           if (filedata->buckets != NULL && filedata->chains != NULL)
10044             num_of_syms = filedata->nchains;
10045         }
10046     no_hash:
10047       if (num_of_syms == 0)
10048         {
10049           free (filedata->buckets);
10050           filedata->buckets = NULL;
10051           free (filedata->chains);
10052           filedata->chains = NULL;
10053           filedata->nbuckets = 0;
10054         }
10055     }
10056
10057   if (filedata->dynamic_info_DT_GNU_HASH)
10058     {
10059       unsigned char nb[16];
10060       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10061       bfd_vma buckets_vma;
10062       unsigned long hn;
10063
10064       if (fseek (filedata->handle,
10065                  (filedata->archive_file_offset
10066                   + offset_from_vma (filedata,
10067                                      filedata->dynamic_info_DT_GNU_HASH,
10068                                      sizeof nb)),
10069                  SEEK_SET))
10070         {
10071           error (_("Unable to seek to start of dynamic information\n"));
10072           goto no_gnu_hash;
10073         }
10074
10075       if (fread (nb, 16, 1, filedata->handle) != 1)
10076         {
10077           error (_("Failed to read in number of buckets\n"));
10078           goto no_gnu_hash;
10079         }
10080
10081       filedata->ngnubuckets = byte_get (nb, 4);
10082       filedata->gnusymidx = byte_get (nb + 4, 4);
10083       bitmaskwords = byte_get (nb + 8, 4);
10084       buckets_vma = filedata->dynamic_info_DT_GNU_HASH + 16;
10085       if (is_32bit_elf)
10086         buckets_vma += bitmaskwords * 4;
10087       else
10088         buckets_vma += bitmaskwords * 8;
10089
10090       if (fseek (filedata->handle,
10091                  (filedata->archive_file_offset
10092                   + offset_from_vma (filedata, buckets_vma, 4)),
10093                  SEEK_SET))
10094         {
10095           error (_("Unable to seek to start of dynamic information\n"));
10096           goto no_gnu_hash;
10097         }
10098
10099       filedata->gnubuckets
10100         = get_dynamic_data (filedata, filedata->ngnubuckets, 4);
10101
10102       if (filedata->gnubuckets == NULL)
10103         goto no_gnu_hash;
10104
10105       for (i = 0; i < filedata->ngnubuckets; i++)
10106         if (filedata->gnubuckets[i] != 0)
10107           {
10108             if (filedata->gnubuckets[i] < filedata->gnusymidx)
10109               goto no_gnu_hash;
10110
10111             if (maxchain == 0xffffffff || filedata->gnubuckets[i] > maxchain)
10112               maxchain = filedata->gnubuckets[i];
10113           }
10114
10115       if (maxchain == 0xffffffff)
10116         goto no_gnu_hash;
10117
10118       maxchain -= filedata->gnusymidx;
10119
10120       if (fseek (filedata->handle,
10121                  (filedata->archive_file_offset
10122                   + offset_from_vma (filedata,
10123                                      buckets_vma + 4 * (filedata->ngnubuckets
10124                                                         + maxchain),
10125                                       4)),
10126                  SEEK_SET))
10127         {
10128           error (_("Unable to seek to start of dynamic information\n"));
10129           goto no_gnu_hash;
10130         }
10131
10132       do
10133         {
10134           if (fread (nb, 4, 1, filedata->handle) != 1)
10135             {
10136               error (_("Failed to determine last chain length\n"));
10137               goto no_gnu_hash;
10138             }
10139
10140           if (maxchain + 1 == 0)
10141             goto no_gnu_hash;
10142
10143           ++maxchain;
10144         }
10145       while ((byte_get (nb, 4) & 1) == 0);
10146
10147       if (fseek (filedata->handle,
10148                  (filedata->archive_file_offset
10149                   + offset_from_vma (filedata, (buckets_vma
10150                                                 + 4 * filedata->ngnubuckets),
10151                                      4)),
10152                  SEEK_SET))
10153         {
10154           error (_("Unable to seek to start of dynamic information\n"));
10155           goto no_gnu_hash;
10156         }
10157
10158       filedata->gnuchains = get_dynamic_data (filedata, maxchain, 4);
10159       filedata->ngnuchains = maxchain;
10160
10161       if (filedata->gnuchains == NULL)
10162         goto no_gnu_hash;
10163
10164       if (filedata->dynamic_info_DT_MIPS_XHASH)
10165         {
10166           if (fseek (filedata->handle,
10167                      (filedata->archive_file_offset
10168                       + offset_from_vma (filedata, (buckets_vma
10169                                                     + 4 * (filedata->ngnubuckets
10170                                                            + maxchain)), 4)),
10171                      SEEK_SET))
10172             {
10173               error (_("Unable to seek to start of dynamic information\n"));
10174               goto no_gnu_hash;
10175             }
10176
10177           filedata->mipsxlat = get_dynamic_data (filedata, maxchain, 4);
10178           if (filedata->mipsxlat == NULL)
10179             goto no_gnu_hash;
10180         }
10181
10182       for (hn = 0; hn < filedata->ngnubuckets; ++hn)
10183         if (filedata->gnubuckets[hn] != 0)
10184           {
10185             bfd_vma si = filedata->gnubuckets[hn];
10186             bfd_vma off = si - filedata->gnusymidx;
10187
10188             do
10189               {
10190                 if (filedata->dynamic_info_DT_MIPS_XHASH)
10191                   {
10192                     if (off < filedata->ngnuchains
10193                         && filedata->mipsxlat[off] >= num_of_syms)
10194                       num_of_syms = filedata->mipsxlat[off] + 1;
10195                   }
10196                 else
10197                   {
10198                     if (si >= num_of_syms)
10199                       num_of_syms = si + 1;
10200                   }
10201                 si++;
10202               }
10203             while (off < filedata->ngnuchains
10204                    && (filedata->gnuchains[off++] & 1) == 0);
10205           }
10206
10207       if (num_of_syms == 0)
10208         {
10209         no_gnu_hash:
10210           free (filedata->mipsxlat);
10211           filedata->mipsxlat = NULL;
10212           free (filedata->gnuchains);
10213           filedata->gnuchains = NULL;
10214           free (filedata->gnubuckets);
10215           filedata->gnubuckets = NULL;
10216           filedata->ngnubuckets = 0;
10217           filedata->ngnuchains = 0;
10218         }
10219     }
10220
10221   return num_of_syms;
10222 }
10223
10224 /* Parse and display the contents of the dynamic section.  */
10225
10226 static bfd_boolean
10227 process_dynamic_section (Filedata * filedata)
10228 {
10229   Elf_Internal_Dyn * entry;
10230
10231   if (filedata->dynamic_size == 0)
10232     {
10233       if (do_dynamic)
10234         printf (_("\nThere is no dynamic section in this file.\n"));
10235
10236       return TRUE;
10237     }
10238
10239   if (is_32bit_elf)
10240     {
10241       if (! get_32bit_dynamic_section (filedata))
10242         return FALSE;
10243     }
10244   else
10245     {
10246       if (! get_64bit_dynamic_section (filedata))
10247         return FALSE;
10248     }
10249
10250   /* Find the appropriate symbol table.  */
10251   if (filedata->dynamic_symbols == NULL || do_histogram)
10252     {
10253       unsigned long num_of_syms;
10254
10255       for (entry = filedata->dynamic_section;
10256            entry < filedata->dynamic_section + filedata->dynamic_nent;
10257            ++entry)
10258         if (entry->d_tag == DT_SYMTAB)
10259           filedata->dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
10260         else if (entry->d_tag == DT_SYMENT)
10261           filedata->dynamic_info[DT_SYMENT] = entry->d_un.d_val;
10262         else if (entry->d_tag == DT_HASH)
10263           filedata->dynamic_info[DT_HASH] = entry->d_un.d_val;
10264         else if (entry->d_tag == DT_GNU_HASH)
10265           filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10266         else if ((filedata->file_header.e_machine == EM_MIPS
10267                   || filedata->file_header.e_machine == EM_MIPS_RS3_LE)
10268                  && entry->d_tag == DT_MIPS_XHASH)
10269           {
10270             filedata->dynamic_info_DT_MIPS_XHASH = entry->d_un.d_val;
10271             filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10272           }
10273
10274       num_of_syms = get_num_dynamic_syms (filedata);
10275
10276       if (num_of_syms != 0
10277           && filedata->dynamic_symbols == NULL
10278           && filedata->dynamic_info[DT_SYMTAB]
10279           && filedata->dynamic_info[DT_SYMENT])
10280         {
10281           Elf_Internal_Phdr *seg;
10282           bfd_vma vma = filedata->dynamic_info[DT_SYMTAB];
10283
10284           if (! get_program_headers (filedata))
10285             {
10286               error (_("Cannot interpret virtual addresses "
10287                        "without program headers.\n"));
10288               return FALSE;
10289             }
10290
10291           for (seg = filedata->program_headers;
10292                seg < filedata->program_headers + filedata->file_header.e_phnum;
10293                ++seg)
10294             {
10295               if (seg->p_type != PT_LOAD)
10296                 continue;
10297
10298               if (seg->p_offset + seg->p_filesz > filedata->file_size)
10299                 {
10300                   /* See PR 21379 for a reproducer.  */
10301                   error (_("Invalid PT_LOAD entry\n"));
10302                   return FALSE;
10303                 }
10304
10305               if (vma >= (seg->p_vaddr & -seg->p_align)
10306                   && vma < seg->p_vaddr + seg->p_filesz)
10307                 {
10308                   /* Since we do not know how big the symbol table is,
10309                      we default to reading in up to the end of PT_LOAD
10310                      segment and processing that.  This is overkill, I
10311                      know, but it should work.  */
10312                   Elf_Internal_Shdr section;
10313                   section.sh_offset = (vma - seg->p_vaddr
10314                                        + seg->p_offset);
10315                   section.sh_size = (num_of_syms
10316                                      * filedata->dynamic_info[DT_SYMENT]);
10317                   section.sh_entsize = filedata->dynamic_info[DT_SYMENT];
10318
10319                   if (do_checks
10320                       && filedata->dynamic_symtab_section != NULL
10321                       && ((filedata->dynamic_symtab_section->sh_offset
10322                            != section.sh_offset)
10323                           || (filedata->dynamic_symtab_section->sh_size
10324                               != section.sh_size)
10325                           || (filedata->dynamic_symtab_section->sh_entsize
10326                               != section.sh_entsize)))
10327                     warn (_("\
10328 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10329
10330                   section.sh_name = filedata->string_table_length;
10331                   filedata->dynamic_symbols
10332                     = GET_ELF_SYMBOLS (filedata, &section,
10333                                        &filedata->num_dynamic_syms);
10334                   if (filedata->dynamic_symbols == NULL
10335                       || filedata->num_dynamic_syms != num_of_syms)
10336                     {
10337                       error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10338                       return FALSE;
10339                     }
10340                   break;
10341                 }
10342             }
10343         }
10344     }
10345
10346   /* Similarly find a string table.  */
10347   if (filedata->dynamic_strings == NULL)
10348     for (entry = filedata->dynamic_section;
10349          entry < filedata->dynamic_section + filedata->dynamic_nent;
10350          ++entry)
10351       {
10352         if (entry->d_tag == DT_STRTAB)
10353           filedata->dynamic_info[DT_STRTAB] = entry->d_un.d_val;
10354
10355         if (entry->d_tag == DT_STRSZ)
10356           filedata->dynamic_info[DT_STRSZ] = entry->d_un.d_val;
10357
10358         if (filedata->dynamic_info[DT_STRTAB]
10359             && filedata->dynamic_info[DT_STRSZ])
10360           {
10361             unsigned long offset;
10362             bfd_size_type str_tab_len = filedata->dynamic_info[DT_STRSZ];
10363
10364             offset = offset_from_vma (filedata,
10365                                       filedata->dynamic_info[DT_STRTAB],
10366                                       str_tab_len);
10367             if (do_checks
10368                 && filedata->dynamic_strtab_section
10369                 && ((filedata->dynamic_strtab_section->sh_offset
10370                      != (file_ptr) offset)
10371                     || (filedata->dynamic_strtab_section->sh_size
10372                         != str_tab_len)))
10373               warn (_("\
10374 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10375
10376             filedata->dynamic_strings
10377               = (char *) get_data (NULL, filedata, offset, 1, str_tab_len,
10378                                    _("dynamic string table"));
10379             if (filedata->dynamic_strings == NULL)
10380               {
10381                 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10382                 break;
10383               }
10384
10385             filedata->dynamic_strings_length = str_tab_len;
10386             break;
10387           }
10388       }
10389
10390   /* And find the syminfo section if available.  */
10391   if (filedata->dynamic_syminfo == NULL)
10392     {
10393       unsigned long syminsz = 0;
10394
10395       for (entry = filedata->dynamic_section;
10396            entry < filedata->dynamic_section + filedata->dynamic_nent;
10397            ++entry)
10398         {
10399           if (entry->d_tag == DT_SYMINENT)
10400             {
10401               /* Note: these braces are necessary to avoid a syntax
10402                  error from the SunOS4 C compiler.  */
10403               /* PR binutils/17531: A corrupt file can trigger this test.
10404                  So do not use an assert, instead generate an error message.  */
10405               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
10406                 error (_("Bad value (%d) for SYMINENT entry\n"),
10407                        (int) entry->d_un.d_val);
10408             }
10409           else if (entry->d_tag == DT_SYMINSZ)
10410             syminsz = entry->d_un.d_val;
10411           else if (entry->d_tag == DT_SYMINFO)
10412             filedata->dynamic_syminfo_offset
10413               = offset_from_vma (filedata, entry->d_un.d_val, syminsz);
10414         }
10415
10416       if (filedata->dynamic_syminfo_offset != 0 && syminsz != 0)
10417         {
10418           Elf_External_Syminfo * extsyminfo;
10419           Elf_External_Syminfo * extsym;
10420           Elf_Internal_Syminfo * syminfo;
10421
10422           /* There is a syminfo section.  Read the data.  */
10423           extsyminfo = (Elf_External_Syminfo *)
10424             get_data (NULL, filedata, filedata->dynamic_syminfo_offset,
10425                       1, syminsz, _("symbol information"));
10426           if (!extsyminfo)
10427             return FALSE;
10428
10429           if (filedata->dynamic_syminfo != NULL)
10430             {
10431               error (_("Multiple dynamic symbol information sections found\n"));
10432               free (filedata->dynamic_syminfo);
10433             }
10434           filedata->dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
10435           if (filedata->dynamic_syminfo == NULL)
10436             {
10437               error (_("Out of memory allocating %lu bytes "
10438                        "for dynamic symbol info\n"),
10439                      (unsigned long) syminsz);
10440               return FALSE;
10441             }
10442
10443           filedata->dynamic_syminfo_nent
10444             = syminsz / sizeof (Elf_External_Syminfo);
10445           for (syminfo = filedata->dynamic_syminfo, extsym = extsyminfo;
10446                syminfo < (filedata->dynamic_syminfo
10447                           + filedata->dynamic_syminfo_nent);
10448                ++syminfo, ++extsym)
10449             {
10450               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
10451               syminfo->si_flags = BYTE_GET (extsym->si_flags);
10452             }
10453
10454           free (extsyminfo);
10455         }
10456     }
10457
10458   if (do_dynamic && filedata->dynamic_addr)
10459     printf (ngettext ("\nDynamic section at offset 0x%lx "
10460                       "contains %lu entry:\n",
10461                       "\nDynamic section at offset 0x%lx "
10462                       "contains %lu entries:\n",
10463                       filedata->dynamic_nent),
10464             filedata->dynamic_addr, (unsigned long) filedata->dynamic_nent);
10465   if (do_dynamic)
10466     printf (_("  Tag        Type                         Name/Value\n"));
10467
10468   for (entry = filedata->dynamic_section;
10469        entry < filedata->dynamic_section + filedata->dynamic_nent;
10470        entry++)
10471     {
10472       if (do_dynamic)
10473         {
10474           const char * dtype;
10475
10476           putchar (' ');
10477           print_vma (entry->d_tag, FULL_HEX);
10478           dtype = get_dynamic_type (filedata, entry->d_tag);
10479           printf (" (%s)%*s", dtype,
10480                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
10481         }
10482
10483       switch (entry->d_tag)
10484         {
10485         case DT_FLAGS:
10486           if (do_dynamic)
10487             print_dynamic_flags (entry->d_un.d_val);
10488           break;
10489
10490         case DT_AUXILIARY:
10491         case DT_FILTER:
10492         case DT_CONFIG:
10493         case DT_DEPAUDIT:
10494         case DT_AUDIT:
10495           if (do_dynamic)
10496             {
10497               switch (entry->d_tag)
10498                 {
10499                 case DT_AUXILIARY:
10500                   printf (_("Auxiliary library"));
10501                   break;
10502
10503                 case DT_FILTER:
10504                   printf (_("Filter library"));
10505                   break;
10506
10507                 case DT_CONFIG:
10508                   printf (_("Configuration file"));
10509                   break;
10510
10511                 case DT_DEPAUDIT:
10512                   printf (_("Dependency audit library"));
10513                   break;
10514
10515                 case DT_AUDIT:
10516                   printf (_("Audit library"));
10517                   break;
10518                 }
10519
10520               if (VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
10521                 printf (": [%s]\n",
10522                         GET_DYNAMIC_NAME (filedata, entry->d_un.d_val));
10523               else
10524                 {
10525                   printf (": ");
10526                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10527                   putchar ('\n');
10528                 }
10529             }
10530           break;
10531
10532         case DT_FEATURE:
10533           if (do_dynamic)
10534             {
10535               printf (_("Flags:"));
10536
10537               if (entry->d_un.d_val == 0)
10538                 printf (_(" None\n"));
10539               else
10540                 {
10541                   unsigned long int val = entry->d_un.d_val;
10542
10543                   if (val & DTF_1_PARINIT)
10544                     {
10545                       printf (" PARINIT");
10546                       val ^= DTF_1_PARINIT;
10547                     }
10548                   if (val & DTF_1_CONFEXP)
10549                     {
10550                       printf (" CONFEXP");
10551                       val ^= DTF_1_CONFEXP;
10552                     }
10553                   if (val != 0)
10554                     printf (" %lx", val);
10555                   puts ("");
10556                 }
10557             }
10558           break;
10559
10560         case DT_POSFLAG_1:
10561           if (do_dynamic)
10562             {
10563               printf (_("Flags:"));
10564
10565               if (entry->d_un.d_val == 0)
10566                 printf (_(" None\n"));
10567               else
10568                 {
10569                   unsigned long int val = entry->d_un.d_val;
10570
10571                   if (val & DF_P1_LAZYLOAD)
10572                     {
10573                       printf (" LAZYLOAD");
10574                       val ^= DF_P1_LAZYLOAD;
10575                     }
10576                   if (val & DF_P1_GROUPPERM)
10577                     {
10578                       printf (" GROUPPERM");
10579                       val ^= DF_P1_GROUPPERM;
10580                     }
10581                   if (val != 0)
10582                     printf (" %lx", val);
10583                   puts ("");
10584                 }
10585             }
10586           break;
10587
10588         case DT_FLAGS_1:
10589           if (do_dynamic)
10590             {
10591               printf (_("Flags:"));
10592               if (entry->d_un.d_val == 0)
10593                 printf (_(" None\n"));
10594               else
10595                 {
10596                   unsigned long int val = entry->d_un.d_val;
10597
10598                   if (val & DF_1_NOW)
10599                     {
10600                       printf (" NOW");
10601                       val ^= DF_1_NOW;
10602                     }
10603                   if (val & DF_1_GLOBAL)
10604                     {
10605                       printf (" GLOBAL");
10606                       val ^= DF_1_GLOBAL;
10607                     }
10608                   if (val & DF_1_GROUP)
10609                     {
10610                       printf (" GROUP");
10611                       val ^= DF_1_GROUP;
10612                     }
10613                   if (val & DF_1_NODELETE)
10614                     {
10615                       printf (" NODELETE");
10616                       val ^= DF_1_NODELETE;
10617                     }
10618                   if (val & DF_1_LOADFLTR)
10619                     {
10620                       printf (" LOADFLTR");
10621                       val ^= DF_1_LOADFLTR;
10622                     }
10623                   if (val & DF_1_INITFIRST)
10624                     {
10625                       printf (" INITFIRST");
10626                       val ^= DF_1_INITFIRST;
10627                     }
10628                   if (val & DF_1_NOOPEN)
10629                     {
10630                       printf (" NOOPEN");
10631                       val ^= DF_1_NOOPEN;
10632                     }
10633                   if (val & DF_1_ORIGIN)
10634                     {
10635                       printf (" ORIGIN");
10636                       val ^= DF_1_ORIGIN;
10637                     }
10638                   if (val & DF_1_DIRECT)
10639                     {
10640                       printf (" DIRECT");
10641                       val ^= DF_1_DIRECT;
10642                     }
10643                   if (val & DF_1_TRANS)
10644                     {
10645                       printf (" TRANS");
10646                       val ^= DF_1_TRANS;
10647                     }
10648                   if (val & DF_1_INTERPOSE)
10649                     {
10650                       printf (" INTERPOSE");
10651                       val ^= DF_1_INTERPOSE;
10652                     }
10653                   if (val & DF_1_NODEFLIB)
10654                     {
10655                       printf (" NODEFLIB");
10656                       val ^= DF_1_NODEFLIB;
10657                     }
10658                   if (val & DF_1_NODUMP)
10659                     {
10660                       printf (" NODUMP");
10661                       val ^= DF_1_NODUMP;
10662                     }
10663                   if (val & DF_1_CONFALT)
10664                     {
10665                       printf (" CONFALT");
10666                       val ^= DF_1_CONFALT;
10667                     }
10668                   if (val & DF_1_ENDFILTEE)
10669                     {
10670                       printf (" ENDFILTEE");
10671                       val ^= DF_1_ENDFILTEE;
10672                     }
10673                   if (val & DF_1_DISPRELDNE)
10674                     {
10675                       printf (" DISPRELDNE");
10676                       val ^= DF_1_DISPRELDNE;
10677                     }
10678                   if (val & DF_1_DISPRELPND)
10679                     {
10680                       printf (" DISPRELPND");
10681                       val ^= DF_1_DISPRELPND;
10682                     }
10683                   if (val & DF_1_NODIRECT)
10684                     {
10685                       printf (" NODIRECT");
10686                       val ^= DF_1_NODIRECT;
10687                     }
10688                   if (val & DF_1_IGNMULDEF)
10689                     {
10690                       printf (" IGNMULDEF");
10691                       val ^= DF_1_IGNMULDEF;
10692                     }
10693                   if (val & DF_1_NOKSYMS)
10694                     {
10695                       printf (" NOKSYMS");
10696                       val ^= DF_1_NOKSYMS;
10697                     }
10698                   if (val & DF_1_NOHDR)
10699                     {
10700                       printf (" NOHDR");
10701                       val ^= DF_1_NOHDR;
10702                     }
10703                   if (val & DF_1_EDITED)
10704                     {
10705                       printf (" EDITED");
10706                       val ^= DF_1_EDITED;
10707                     }
10708                   if (val & DF_1_NORELOC)
10709                     {
10710                       printf (" NORELOC");
10711                       val ^= DF_1_NORELOC;
10712                     }
10713                   if (val & DF_1_SYMINTPOSE)
10714                     {
10715                       printf (" SYMINTPOSE");
10716                       val ^= DF_1_SYMINTPOSE;
10717                     }
10718                   if (val & DF_1_GLOBAUDIT)
10719                     {
10720                       printf (" GLOBAUDIT");
10721                       val ^= DF_1_GLOBAUDIT;
10722                     }
10723                   if (val & DF_1_SINGLETON)
10724                     {
10725                       printf (" SINGLETON");
10726                       val ^= DF_1_SINGLETON;
10727                     }
10728                   if (val & DF_1_STUB)
10729                     {
10730                       printf (" STUB");
10731                       val ^= DF_1_STUB;
10732                     }
10733                   if (val & DF_1_PIE)
10734                     {
10735                       printf (" PIE");
10736                       val ^= DF_1_PIE;
10737                     }
10738                   if (val & DF_1_KMOD)
10739                     {
10740                       printf (" KMOD");
10741                       val ^= DF_1_KMOD;
10742                     }
10743                   if (val & DF_1_WEAKFILTER)
10744                     {
10745                       printf (" WEAKFILTER");
10746                       val ^= DF_1_WEAKFILTER;
10747                     }
10748                   if (val & DF_1_NOCOMMON)
10749                     {
10750                       printf (" NOCOMMON");
10751                       val ^= DF_1_NOCOMMON;
10752                     }
10753                   if (val != 0)
10754                     printf (" %lx", val);
10755                   puts ("");
10756                 }
10757             }
10758           break;
10759
10760         case DT_PLTREL:
10761           filedata->dynamic_info[entry->d_tag] = entry->d_un.d_val;
10762           if (do_dynamic)
10763             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10764           break;
10765
10766         case DT_NULL    :
10767         case DT_NEEDED  :
10768         case DT_PLTGOT  :
10769         case DT_HASH    :
10770         case DT_STRTAB  :
10771         case DT_SYMTAB  :
10772         case DT_RELA    :
10773         case DT_INIT    :
10774         case DT_FINI    :
10775         case DT_SONAME  :
10776         case DT_RPATH   :
10777         case DT_SYMBOLIC:
10778         case DT_REL     :
10779         case DT_DEBUG   :
10780         case DT_TEXTREL :
10781         case DT_JMPREL  :
10782         case DT_RUNPATH :
10783           filedata->dynamic_info[entry->d_tag] = entry->d_un.d_val;
10784
10785           if (do_dynamic)
10786             {
10787               char * name;
10788
10789               if (VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
10790                 name = GET_DYNAMIC_NAME (filedata, entry->d_un.d_val);
10791               else
10792                 name = NULL;
10793
10794               if (name)
10795                 {
10796                   switch (entry->d_tag)
10797                     {
10798                     case DT_NEEDED:
10799                       printf (_("Shared library: [%s]"), name);
10800
10801                       if (streq (name, filedata->program_interpreter))
10802                         printf (_(" program interpreter"));
10803                       break;
10804
10805                     case DT_SONAME:
10806                       printf (_("Library soname: [%s]"), name);
10807                       break;
10808
10809                     case DT_RPATH:
10810                       printf (_("Library rpath: [%s]"), name);
10811                       break;
10812
10813                     case DT_RUNPATH:
10814                       printf (_("Library runpath: [%s]"), name);
10815                       break;
10816
10817                     default:
10818                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10819                       break;
10820                     }
10821                 }
10822               else
10823                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10824
10825               putchar ('\n');
10826             }
10827           break;
10828
10829         case DT_PLTRELSZ:
10830         case DT_RELASZ  :
10831         case DT_STRSZ   :
10832         case DT_RELSZ   :
10833         case DT_RELAENT :
10834         case DT_SYMENT  :
10835         case DT_RELENT  :
10836           filedata->dynamic_info[entry->d_tag] = entry->d_un.d_val;
10837           /* Fall through.  */
10838         case DT_PLTPADSZ:
10839         case DT_MOVEENT :
10840         case DT_MOVESZ  :
10841         case DT_INIT_ARRAYSZ:
10842         case DT_FINI_ARRAYSZ:
10843         case DT_GNU_CONFLICTSZ:
10844         case DT_GNU_LIBLISTSZ:
10845           if (do_dynamic)
10846             {
10847               print_vma (entry->d_un.d_val, UNSIGNED);
10848               printf (_(" (bytes)\n"));
10849             }
10850           break;
10851
10852         case DT_VERDEFNUM:
10853         case DT_VERNEEDNUM:
10854         case DT_RELACOUNT:
10855         case DT_RELCOUNT:
10856           if (do_dynamic)
10857             {
10858               print_vma (entry->d_un.d_val, UNSIGNED);
10859               putchar ('\n');
10860             }
10861           break;
10862
10863         case DT_SYMINSZ:
10864         case DT_SYMINENT:
10865         case DT_SYMINFO:
10866         case DT_USED:
10867         case DT_INIT_ARRAY:
10868         case DT_FINI_ARRAY:
10869           if (do_dynamic)
10870             {
10871               if (entry->d_tag == DT_USED
10872                   && VALID_DYNAMIC_NAME (filedata, entry->d_un.d_val))
10873                 {
10874                   char * name = GET_DYNAMIC_NAME (filedata, entry->d_un.d_val);
10875
10876                   if (*name)
10877                     {
10878                       printf (_("Not needed object: [%s]\n"), name);
10879                       break;
10880                     }
10881                 }
10882
10883               print_vma (entry->d_un.d_val, PREFIX_HEX);
10884               putchar ('\n');
10885             }
10886           break;
10887
10888         case DT_BIND_NOW:
10889           /* The value of this entry is ignored.  */
10890           if (do_dynamic)
10891             putchar ('\n');
10892           break;
10893
10894         case DT_GNU_PRELINKED:
10895           if (do_dynamic)
10896             {
10897               struct tm * tmp;
10898               time_t atime = entry->d_un.d_val;
10899
10900               tmp = gmtime (&atime);
10901               /* PR 17533 file: 041-1244816-0.004.  */
10902               if (tmp == NULL)
10903                 printf (_("<corrupt time val: %lx"),
10904                         (unsigned long) atime);
10905               else
10906                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10907                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10908                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10909
10910             }
10911           break;
10912
10913         case DT_GNU_HASH:
10914           filedata->dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10915           if (do_dynamic)
10916             {
10917               print_vma (entry->d_un.d_val, PREFIX_HEX);
10918               putchar ('\n');
10919             }
10920           break;
10921
10922         default:
10923           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10924             filedata->version_info[DT_VERSIONTAGIDX (entry->d_tag)]
10925               = entry->d_un.d_val;
10926
10927           if (do_dynamic)
10928             {
10929               switch (filedata->file_header.e_machine)
10930                 {
10931                 case EM_AARCH64:
10932                   dynamic_section_aarch64_val (entry);
10933                   break;
10934                 case EM_MIPS:
10935                 case EM_MIPS_RS3_LE:
10936                   dynamic_section_mips_val (filedata, entry);
10937                   break;
10938                 case EM_PARISC:
10939                   dynamic_section_parisc_val (entry);
10940                   break;
10941                 case EM_IA_64:
10942                   dynamic_section_ia64_val (entry);
10943                   break;
10944                 default:
10945                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10946                   putchar ('\n');
10947                 }
10948             }
10949           break;
10950         }
10951     }
10952
10953   return TRUE;
10954 }
10955
10956 static char *
10957 get_ver_flags (unsigned int flags)
10958 {
10959   static char buff[128];
10960
10961   buff[0] = 0;
10962
10963   if (flags == 0)
10964     return _("none");
10965
10966   if (flags & VER_FLG_BASE)
10967     strcat (buff, "BASE");
10968
10969   if (flags & VER_FLG_WEAK)
10970     {
10971       if (flags & VER_FLG_BASE)
10972         strcat (buff, " | ");
10973
10974       strcat (buff, "WEAK");
10975     }
10976
10977   if (flags & VER_FLG_INFO)
10978     {
10979       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10980         strcat (buff, " | ");
10981
10982       strcat (buff, "INFO");
10983     }
10984
10985   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10986     {
10987       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10988         strcat (buff, " | ");
10989
10990       strcat (buff, _("<unknown>"));
10991     }
10992
10993   return buff;
10994 }
10995
10996 /* Display the contents of the version sections.  */
10997
10998 static bfd_boolean
10999 process_version_sections (Filedata * filedata)
11000 {
11001   Elf_Internal_Shdr * section;
11002   unsigned i;
11003   bfd_boolean found = FALSE;
11004
11005   if (! do_version)
11006     return TRUE;
11007
11008   for (i = 0, section = filedata->section_headers;
11009        i < filedata->file_header.e_shnum;
11010        i++, section++)
11011     {
11012       switch (section->sh_type)
11013         {
11014         case SHT_GNU_verdef:
11015           {
11016             Elf_External_Verdef * edefs;
11017             unsigned long idx;
11018             unsigned long cnt;
11019             char * endbuf;
11020
11021             found = TRUE;
11022
11023             printf (ngettext ("\nVersion definition section '%s' "
11024                               "contains %u entry:\n",
11025                               "\nVersion definition section '%s' "
11026                               "contains %u entries:\n",
11027                               section->sh_info),
11028                     printable_section_name (filedata, section),
11029                     section->sh_info);
11030
11031             printf (_(" Addr: 0x"));
11032             printf_vma (section->sh_addr);
11033             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
11034                     (unsigned long) section->sh_offset, section->sh_link,
11035                     printable_section_name_from_index (filedata, section->sh_link));
11036
11037             edefs = (Elf_External_Verdef *)
11038                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
11039                           _("version definition section"));
11040             if (!edefs)
11041               break;
11042             endbuf = (char *) edefs + section->sh_size;
11043
11044             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
11045               {
11046                 char * vstart;
11047                 Elf_External_Verdef * edef;
11048                 Elf_Internal_Verdef ent;
11049                 Elf_External_Verdaux * eaux;
11050                 Elf_Internal_Verdaux aux;
11051                 unsigned long isum;
11052                 int j;
11053
11054                 vstart = ((char *) edefs) + idx;
11055                 if (vstart + sizeof (*edef) > endbuf)
11056                   break;
11057
11058                 edef = (Elf_External_Verdef *) vstart;
11059
11060                 ent.vd_version = BYTE_GET (edef->vd_version);
11061                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
11062                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
11063                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
11064                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
11065                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
11066                 ent.vd_next    = BYTE_GET (edef->vd_next);
11067
11068                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
11069                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
11070
11071                 printf (_("  Index: %d  Cnt: %d  "),
11072                         ent.vd_ndx, ent.vd_cnt);
11073
11074                 /* Check for overflow.  */
11075                 if (ent.vd_aux > (size_t) (endbuf - vstart))
11076                   break;
11077
11078                 vstart += ent.vd_aux;
11079
11080                 if (vstart + sizeof (*eaux) > endbuf)
11081                   break;
11082                 eaux = (Elf_External_Verdaux *) vstart;
11083
11084                 aux.vda_name = BYTE_GET (eaux->vda_name);
11085                 aux.vda_next = BYTE_GET (eaux->vda_next);
11086
11087                 if (VALID_DYNAMIC_NAME (filedata, aux.vda_name))
11088                   printf (_("Name: %s\n"),
11089                           GET_DYNAMIC_NAME (filedata, aux.vda_name));
11090                 else
11091                   printf (_("Name index: %ld\n"), aux.vda_name);
11092
11093                 isum = idx + ent.vd_aux;
11094
11095                 for (j = 1; j < ent.vd_cnt; j++)
11096                   {
11097                     if (aux.vda_next < sizeof (*eaux)
11098                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
11099                       {
11100                         warn (_("Invalid vda_next field of %lx\n"),
11101                               aux.vda_next);
11102                         j = ent.vd_cnt;
11103                         break;
11104                       }
11105                     /* Check for overflow.  */
11106                     if (aux.vda_next > (size_t) (endbuf - vstart))
11107                       break;
11108
11109                     isum   += aux.vda_next;
11110                     vstart += aux.vda_next;
11111
11112                     if (vstart + sizeof (*eaux) > endbuf)
11113                       break;
11114                     eaux = (Elf_External_Verdaux *) vstart;
11115
11116                     aux.vda_name = BYTE_GET (eaux->vda_name);
11117                     aux.vda_next = BYTE_GET (eaux->vda_next);
11118
11119                     if (VALID_DYNAMIC_NAME (filedata, aux.vda_name))
11120                       printf (_("  %#06lx: Parent %d: %s\n"),
11121                               isum, j,
11122                               GET_DYNAMIC_NAME (filedata, aux.vda_name));
11123                     else
11124                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
11125                               isum, j, aux.vda_name);
11126                   }
11127
11128                 if (j < ent.vd_cnt)
11129                   printf (_("  Version def aux past end of section\n"));
11130
11131                 /* PR 17531:
11132                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
11133                 if (ent.vd_next < sizeof (*edef)
11134                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
11135                   {
11136                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
11137                     cnt = section->sh_info;
11138                     break;
11139                   }
11140                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
11141                   break;
11142
11143                 idx += ent.vd_next;
11144               }
11145
11146             if (cnt < section->sh_info)
11147               printf (_("  Version definition past end of section\n"));
11148
11149             free (edefs);
11150           }
11151           break;
11152
11153         case SHT_GNU_verneed:
11154           {
11155             Elf_External_Verneed * eneed;
11156             unsigned long idx;
11157             unsigned long cnt;
11158             char * endbuf;
11159
11160             found = TRUE;
11161
11162             printf (ngettext ("\nVersion needs section '%s' "
11163                               "contains %u entry:\n",
11164                               "\nVersion needs section '%s' "
11165                               "contains %u entries:\n",
11166                               section->sh_info),
11167                     printable_section_name (filedata, section), section->sh_info);
11168
11169             printf (_(" Addr: 0x"));
11170             printf_vma (section->sh_addr);
11171             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
11172                     (unsigned long) section->sh_offset, section->sh_link,
11173                     printable_section_name_from_index (filedata, section->sh_link));
11174
11175             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
11176                                                        section->sh_offset, 1,
11177                                                        section->sh_size,
11178                                                        _("Version Needs section"));
11179             if (!eneed)
11180               break;
11181             endbuf = (char *) eneed + section->sh_size;
11182
11183             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
11184               {
11185                 Elf_External_Verneed * entry;
11186                 Elf_Internal_Verneed ent;
11187                 unsigned long isum;
11188                 int j;
11189                 char * vstart;
11190
11191                 vstart = ((char *) eneed) + idx;
11192                 if (vstart + sizeof (*entry) > endbuf)
11193                   break;
11194
11195                 entry = (Elf_External_Verneed *) vstart;
11196
11197                 ent.vn_version = BYTE_GET (entry->vn_version);
11198                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
11199                 ent.vn_file    = BYTE_GET (entry->vn_file);
11200                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
11201                 ent.vn_next    = BYTE_GET (entry->vn_next);
11202
11203                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
11204
11205                 if (VALID_DYNAMIC_NAME (filedata, ent.vn_file))
11206                   printf (_("  File: %s"),
11207                           GET_DYNAMIC_NAME (filedata, ent.vn_file));
11208                 else
11209                   printf (_("  File: %lx"), ent.vn_file);
11210
11211                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
11212
11213                 /* Check for overflow.  */
11214                 if (ent.vn_aux > (size_t) (endbuf - vstart))
11215                   break;
11216                 vstart += ent.vn_aux;
11217
11218                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
11219                   {
11220                     Elf_External_Vernaux * eaux;
11221                     Elf_Internal_Vernaux aux;
11222
11223                     if (vstart + sizeof (*eaux) > endbuf)
11224                       break;
11225                     eaux = (Elf_External_Vernaux *) vstart;
11226
11227                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
11228                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
11229                     aux.vna_other = BYTE_GET (eaux->vna_other);
11230                     aux.vna_name  = BYTE_GET (eaux->vna_name);
11231                     aux.vna_next  = BYTE_GET (eaux->vna_next);
11232
11233                     if (VALID_DYNAMIC_NAME (filedata, aux.vna_name))
11234                       printf (_("  %#06lx:   Name: %s"),
11235                               isum, GET_DYNAMIC_NAME (filedata, aux.vna_name));
11236                     else
11237                       printf (_("  %#06lx:   Name index: %lx"),
11238                               isum, aux.vna_name);
11239
11240                     printf (_("  Flags: %s  Version: %d\n"),
11241                             get_ver_flags (aux.vna_flags), aux.vna_other);
11242
11243                     if (aux.vna_next < sizeof (*eaux)
11244                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
11245                       {
11246                         warn (_("Invalid vna_next field of %lx\n"),
11247                               aux.vna_next);
11248                         j = ent.vn_cnt;
11249                         break;
11250                       }
11251                     /* Check for overflow.  */
11252                     if (aux.vna_next > (size_t) (endbuf - vstart))
11253                       break;
11254                     isum   += aux.vna_next;
11255                     vstart += aux.vna_next;
11256                   }
11257
11258                 if (j < ent.vn_cnt)
11259                   warn (_("Missing Version Needs auxillary information\n"));
11260
11261                 if (ent.vn_next < sizeof (*entry)
11262                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
11263                   {
11264                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
11265                     cnt = section->sh_info;
11266                     break;
11267                   }
11268                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
11269                   break;
11270                 idx += ent.vn_next;
11271               }
11272
11273             if (cnt < section->sh_info)
11274               warn (_("Missing Version Needs information\n"));
11275
11276             free (eneed);
11277           }
11278           break;
11279
11280         case SHT_GNU_versym:
11281           {
11282             Elf_Internal_Shdr * link_section;
11283             size_t total;
11284             unsigned int cnt;
11285             unsigned char * edata;
11286             unsigned short * data;
11287             char * strtab;
11288             Elf_Internal_Sym * symbols;
11289             Elf_Internal_Shdr * string_sec;
11290             unsigned long num_syms;
11291             long off;
11292
11293             if (section->sh_link >= filedata->file_header.e_shnum)
11294               break;
11295
11296             link_section = filedata->section_headers + section->sh_link;
11297             total = section->sh_size / sizeof (Elf_External_Versym);
11298
11299             if (link_section->sh_link >= filedata->file_header.e_shnum)
11300               break;
11301
11302             found = TRUE;
11303
11304             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
11305             if (symbols == NULL)
11306               break;
11307
11308             string_sec = filedata->section_headers + link_section->sh_link;
11309
11310             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
11311                                         string_sec->sh_size,
11312                                         _("version string table"));
11313             if (!strtab)
11314               {
11315                 free (symbols);
11316                 break;
11317               }
11318
11319             printf (ngettext ("\nVersion symbols section '%s' "
11320                               "contains %lu entry:\n",
11321                               "\nVersion symbols section '%s' "
11322                               "contains %lu entries:\n",
11323                               total),
11324                     printable_section_name (filedata, section), (unsigned long) total);
11325
11326             printf (_(" Addr: 0x"));
11327             printf_vma (section->sh_addr);
11328             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
11329                     (unsigned long) section->sh_offset, section->sh_link,
11330                     printable_section_name (filedata, link_section));
11331
11332             off = offset_from_vma (filedata,
11333                                    filedata->version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11334                                    total * sizeof (short));
11335             edata = (unsigned char *) get_data (NULL, filedata, off,
11336                                                 sizeof (short), total,
11337                                                 _("version symbol data"));
11338             if (!edata)
11339               {
11340                 free (strtab);
11341                 free (symbols);
11342                 break;
11343               }
11344
11345             data = (short unsigned int *) cmalloc (total, sizeof (short));
11346
11347             for (cnt = total; cnt --;)
11348               data[cnt] = byte_get (edata + cnt * sizeof (short),
11349                                     sizeof (short));
11350
11351             free (edata);
11352
11353             for (cnt = 0; cnt < total; cnt += 4)
11354               {
11355                 int j, nn;
11356                 char *name;
11357                 char *invalid = _("*invalid*");
11358
11359                 printf ("  %03x:", cnt);
11360
11361                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
11362                   switch (data[cnt + j])
11363                     {
11364                     case 0:
11365                       fputs (_("   0 (*local*)    "), stdout);
11366                       break;
11367
11368                     case 1:
11369                       fputs (_("   1 (*global*)   "), stdout);
11370                       break;
11371
11372                     default:
11373                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
11374                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
11375
11376                       /* If this index value is greater than the size of the symbols
11377                          array, break to avoid an out-of-bounds read.  */
11378                       if ((unsigned long)(cnt + j) >= num_syms)
11379                         {
11380                           warn (_("invalid index into symbol array\n"));
11381                           break;
11382                         }
11383
11384                       name = NULL;
11385                       if (filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11386                         {
11387                           Elf_Internal_Verneed ivn;
11388                           unsigned long offset;
11389
11390                           offset = offset_from_vma
11391                             (filedata,
11392                              filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11393                              sizeof (Elf_External_Verneed));
11394
11395                           do
11396                             {
11397                               Elf_Internal_Vernaux ivna;
11398                               Elf_External_Verneed evn;
11399                               Elf_External_Vernaux evna;
11400                               unsigned long a_off;
11401
11402                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11403                                             _("version need")) == NULL)
11404                                 break;
11405
11406                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11407                               ivn.vn_next = BYTE_GET (evn.vn_next);
11408
11409                               a_off = offset + ivn.vn_aux;
11410
11411                               do
11412                                 {
11413                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
11414                                                 1, _("version need aux (2)")) == NULL)
11415                                     {
11416                                       ivna.vna_next  = 0;
11417                                       ivna.vna_other = 0;
11418                                     }
11419                                   else
11420                                     {
11421                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
11422                                       ivna.vna_other = BYTE_GET (evna.vna_other);
11423                                     }
11424
11425                                   a_off += ivna.vna_next;
11426                                 }
11427                               while (ivna.vna_other != data[cnt + j]
11428                                      && ivna.vna_next != 0);
11429
11430                               if (ivna.vna_other == data[cnt + j])
11431                                 {
11432                                   ivna.vna_name = BYTE_GET (evna.vna_name);
11433
11434                                   if (ivna.vna_name >= string_sec->sh_size)
11435                                     name = invalid;
11436                                   else
11437                                     name = strtab + ivna.vna_name;
11438                                   break;
11439                                 }
11440
11441                               offset += ivn.vn_next;
11442                             }
11443                           while (ivn.vn_next);
11444                         }
11445
11446                       if (data[cnt + j] != 0x8001
11447                           && filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11448                         {
11449                           Elf_Internal_Verdef ivd;
11450                           Elf_External_Verdef evd;
11451                           unsigned long offset;
11452
11453                           offset = offset_from_vma
11454                             (filedata,
11455                              filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11456                              sizeof evd);
11457
11458                           do
11459                             {
11460                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
11461                                             _("version def")) == NULL)
11462                                 {
11463                                   ivd.vd_next = 0;
11464                                   /* PR 17531: file: 046-1082287-0.004.  */
11465                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
11466                                   break;
11467                                 }
11468                               else
11469                                 {
11470                                   ivd.vd_next = BYTE_GET (evd.vd_next);
11471                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
11472                                 }
11473
11474                               offset += ivd.vd_next;
11475                             }
11476                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
11477                                  && ivd.vd_next != 0);
11478
11479                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
11480                             {
11481                               Elf_External_Verdaux evda;
11482                               Elf_Internal_Verdaux ivda;
11483
11484                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11485
11486                               if (get_data (&evda, filedata,
11487                                             offset - ivd.vd_next + ivd.vd_aux,
11488                                             sizeof (evda), 1,
11489                                             _("version def aux")) == NULL)
11490                                 break;
11491
11492                               ivda.vda_name = BYTE_GET (evda.vda_name);
11493
11494                               if (ivda.vda_name >= string_sec->sh_size)
11495                                 name = invalid;
11496                               else if (name != NULL && name != invalid)
11497                                 name = _("*both*");
11498                               else
11499                                 name = strtab + ivda.vda_name;
11500                             }
11501                         }
11502                       if (name != NULL)
11503                         nn += printf ("(%s%-*s",
11504                                       name,
11505                                       12 - (int) strlen (name),
11506                                       ")");
11507
11508                       if (nn < 18)
11509                         printf ("%*c", 18 - nn, ' ');
11510                     }
11511
11512                 putchar ('\n');
11513               }
11514
11515             free (data);
11516             free (strtab);
11517             free (symbols);
11518           }
11519           break;
11520
11521         default:
11522           break;
11523         }
11524     }
11525
11526   if (! found)
11527     printf (_("\nNo version information found in this file.\n"));
11528
11529   return TRUE;
11530 }
11531
11532 static const char *
11533 get_symbol_binding (Filedata * filedata, unsigned int binding)
11534 {
11535   static char buff[64];
11536
11537   switch (binding)
11538     {
11539     case STB_LOCAL:     return "LOCAL";
11540     case STB_GLOBAL:    return "GLOBAL";
11541     case STB_WEAK:      return "WEAK";
11542     default:
11543       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
11544         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
11545                   binding);
11546       else if (binding >= STB_LOOS && binding <= STB_HIOS)
11547         {
11548           if (binding == STB_GNU_UNIQUE
11549               && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU)
11550             return "UNIQUE";
11551           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
11552         }
11553       else
11554         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
11555       return buff;
11556     }
11557 }
11558
11559 static const char *
11560 get_symbol_type (Filedata * filedata, unsigned int type)
11561 {
11562   static char buff[64];
11563
11564   switch (type)
11565     {
11566     case STT_NOTYPE:    return "NOTYPE";
11567     case STT_OBJECT:    return "OBJECT";
11568     case STT_FUNC:      return "FUNC";
11569     case STT_SECTION:   return "SECTION";
11570     case STT_FILE:      return "FILE";
11571     case STT_COMMON:    return "COMMON";
11572     case STT_TLS:       return "TLS";
11573     case STT_RELC:      return "RELC";
11574     case STT_SRELC:     return "SRELC";
11575     default:
11576       if (type >= STT_LOPROC && type <= STT_HIPROC)
11577         {
11578           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
11579             return "THUMB_FUNC";
11580
11581           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
11582             return "REGISTER";
11583
11584           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
11585             return "PARISC_MILLI";
11586
11587           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
11588         }
11589       else if (type >= STT_LOOS && type <= STT_HIOS)
11590         {
11591           if (filedata->file_header.e_machine == EM_PARISC)
11592             {
11593               if (type == STT_HP_OPAQUE)
11594                 return "HP_OPAQUE";
11595               if (type == STT_HP_STUB)
11596                 return "HP_STUB";
11597             }
11598
11599           if (type == STT_GNU_IFUNC
11600               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11601                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD))
11602             return "IFUNC";
11603
11604           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11605         }
11606       else
11607         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11608       return buff;
11609     }
11610 }
11611
11612 static const char *
11613 get_symbol_visibility (unsigned int visibility)
11614 {
11615   switch (visibility)
11616     {
11617     case STV_DEFAULT:   return "DEFAULT";
11618     case STV_INTERNAL:  return "INTERNAL";
11619     case STV_HIDDEN:    return "HIDDEN";
11620     case STV_PROTECTED: return "PROTECTED";
11621     default:
11622       error (_("Unrecognized visibility value: %u\n"), visibility);
11623       return _("<unknown>");
11624     }
11625 }
11626
11627 static const char *
11628 get_alpha_symbol_other (unsigned int other)
11629 {
11630   switch (other)
11631     {
11632     case STO_ALPHA_NOPV:       return "NOPV";
11633     case STO_ALPHA_STD_GPLOAD: return "STD GPLOAD";
11634     default:
11635       error (_("Unrecognized alpha specific other value: %u\n"), other);
11636       return _("<unknown>");
11637     }
11638 }
11639
11640 static const char *
11641 get_solaris_symbol_visibility (unsigned int visibility)
11642 {
11643   switch (visibility)
11644     {
11645     case 4: return "EXPORTED";
11646     case 5: return "SINGLETON";
11647     case 6: return "ELIMINATE";
11648     default: return get_symbol_visibility (visibility);
11649     }
11650 }
11651
11652 static const char *
11653 get_aarch64_symbol_other (unsigned int other)
11654 {
11655   static char buf[32];
11656
11657   if (other & STO_AARCH64_VARIANT_PCS)
11658     {
11659       other &= ~STO_AARCH64_VARIANT_PCS;
11660       if (other == 0)
11661         return "VARIANT_PCS";
11662       snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other);
11663       return buf;
11664     }
11665   return NULL;
11666 }
11667
11668 static const char *
11669 get_mips_symbol_other (unsigned int other)
11670 {
11671   switch (other)
11672     {
11673     case STO_OPTIONAL:      return "OPTIONAL";
11674     case STO_MIPS_PLT:      return "MIPS PLT";
11675     case STO_MIPS_PIC:      return "MIPS PIC";
11676     case STO_MICROMIPS:     return "MICROMIPS";
11677     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
11678     case STO_MIPS16:        return "MIPS16";
11679     default:                return NULL;
11680     }
11681 }
11682
11683 static const char *
11684 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11685 {
11686   if (is_ia64_vms (filedata))
11687     {
11688       static char res[32];
11689
11690       res[0] = 0;
11691
11692       /* Function types is for images and .STB files only.  */
11693       switch (filedata->file_header.e_type)
11694         {
11695         case ET_DYN:
11696         case ET_EXEC:
11697           switch (VMS_ST_FUNC_TYPE (other))
11698             {
11699             case VMS_SFT_CODE_ADDR:
11700               strcat (res, " CA");
11701               break;
11702             case VMS_SFT_SYMV_IDX:
11703               strcat (res, " VEC");
11704               break;
11705             case VMS_SFT_FD:
11706               strcat (res, " FD");
11707               break;
11708             case VMS_SFT_RESERVE:
11709               strcat (res, " RSV");
11710               break;
11711             default:
11712               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11713                     VMS_ST_FUNC_TYPE (other));
11714               strcat (res, " <unknown>");
11715               break;
11716             }
11717           break;
11718         default:
11719           break;
11720         }
11721       switch (VMS_ST_LINKAGE (other))
11722         {
11723         case VMS_STL_IGNORE:
11724           strcat (res, " IGN");
11725           break;
11726         case VMS_STL_RESERVE:
11727           strcat (res, " RSV");
11728           break;
11729         case VMS_STL_STD:
11730           strcat (res, " STD");
11731           break;
11732         case VMS_STL_LNK:
11733           strcat (res, " LNK");
11734           break;
11735         default:
11736           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11737                 VMS_ST_LINKAGE (other));
11738           strcat (res, " <unknown>");
11739           break;
11740         }
11741
11742       if (res[0] != 0)
11743         return res + 1;
11744       else
11745         return res;
11746     }
11747   return NULL;
11748 }
11749
11750 static const char *
11751 get_ppc64_symbol_other (unsigned int other)
11752 {
11753   if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11754     return NULL;
11755
11756   other >>= STO_PPC64_LOCAL_BIT;
11757   if (other <= 6)
11758     {
11759       static char buf[64];
11760       if (other >= 2)
11761         other = ppc64_decode_local_entry (other);
11762       snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11763       return buf;
11764     }
11765   return NULL;
11766 }
11767
11768 static const char *
11769 get_symbol_other (Filedata * filedata, unsigned int other)
11770 {
11771   const char * result = NULL;
11772   static char buff [64];
11773
11774   if (other == 0)
11775     return "";
11776
11777   switch (filedata->file_header.e_machine)
11778     {
11779     case EM_ALPHA:
11780       result = get_alpha_symbol_other (other);
11781       break;
11782     case EM_AARCH64:
11783       result = get_aarch64_symbol_other (other);
11784       break;
11785     case EM_MIPS:
11786       result = get_mips_symbol_other (other);
11787       break;
11788     case EM_IA_64:
11789       result = get_ia64_symbol_other (filedata, other);
11790       break;
11791     case EM_PPC64:
11792       result = get_ppc64_symbol_other (other);
11793       break;
11794     default:
11795       result = NULL;
11796       break;
11797     }
11798
11799   if (result)
11800     return result;
11801
11802   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11803   return buff;
11804 }
11805
11806 static const char *
11807 get_symbol_index_type (Filedata * filedata, unsigned int type)
11808 {
11809   static char buff[32];
11810
11811   switch (type)
11812     {
11813     case SHN_UNDEF:     return "UND";
11814     case SHN_ABS:       return "ABS";
11815     case SHN_COMMON:    return "COM";
11816     default:
11817       if (type == SHN_IA_64_ANSI_COMMON
11818           && filedata->file_header.e_machine == EM_IA_64
11819           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11820         return "ANSI_COM";
11821       else if ((filedata->file_header.e_machine == EM_X86_64
11822                 || filedata->file_header.e_machine == EM_L1OM
11823                 || filedata->file_header.e_machine == EM_K1OM)
11824                && type == SHN_X86_64_LCOMMON)
11825         return "LARGE_COM";
11826       else if ((type == SHN_MIPS_SCOMMON
11827                 && filedata->file_header.e_machine == EM_MIPS)
11828                || (type == SHN_TIC6X_SCOMMON
11829                    && filedata->file_header.e_machine == EM_TI_C6000))
11830         return "SCOM";
11831       else if (type == SHN_MIPS_SUNDEFINED
11832                && filedata->file_header.e_machine == EM_MIPS)
11833         return "SUND";
11834       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11835         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11836       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11837         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11838       else if (type >= SHN_LORESERVE)
11839         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11840       else if (filedata->file_header.e_shnum != 0
11841                && type >= filedata->file_header.e_shnum)
11842         sprintf (buff, _("bad section index[%3d]"), type);
11843       else
11844         sprintf (buff, "%3d", type);
11845       break;
11846     }
11847
11848   return buff;
11849 }
11850
11851 static const char *
11852 get_symbol_version_string (Filedata *                   filedata,
11853                            bfd_boolean                  is_dynsym,
11854                            const char *                 strtab,
11855                            unsigned long int            strtab_size,
11856                            unsigned int                 si,
11857                            Elf_Internal_Sym *           psym,
11858                            enum versioned_symbol_info * sym_info,
11859                            unsigned short *             vna_other)
11860 {
11861   unsigned char data[2];
11862   unsigned short vers_data;
11863   unsigned long offset;
11864   unsigned short max_vd_ndx;
11865
11866   if (!is_dynsym
11867       || filedata->version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11868     return NULL;
11869
11870   offset = offset_from_vma (filedata,
11871                             filedata->version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11872                             sizeof data + si * sizeof (vers_data));
11873
11874   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11875                 sizeof (data), 1, _("version data")) == NULL)
11876     return NULL;
11877
11878   vers_data = byte_get (data, 2);
11879
11880   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11881     return NULL;
11882
11883   *sym_info = (vers_data & VERSYM_HIDDEN) != 0 ? symbol_hidden : symbol_public;
11884   max_vd_ndx = 0;
11885
11886   /* Usually we'd only see verdef for defined symbols, and verneed for
11887      undefined symbols.  However, symbols defined by the linker in
11888      .dynbss for variables copied from a shared library in order to
11889      avoid text relocations are defined yet have verneed.  We could
11890      use a heuristic to detect the special case, for example, check
11891      for verneed first on symbols defined in SHT_NOBITS sections, but
11892      it is simpler and more reliable to just look for both verdef and
11893      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11894
11895   if (psym->st_shndx != SHN_UNDEF
11896       && vers_data != 0x8001
11897       && filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11898     {
11899       Elf_Internal_Verdef ivd;
11900       Elf_Internal_Verdaux ivda;
11901       Elf_External_Verdaux evda;
11902       unsigned long off;
11903
11904       off = offset_from_vma (filedata,
11905                              filedata->version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11906                              sizeof (Elf_External_Verdef));
11907
11908       do
11909         {
11910           Elf_External_Verdef evd;
11911
11912           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11913                         _("version def")) == NULL)
11914             {
11915               ivd.vd_ndx = 0;
11916               ivd.vd_aux = 0;
11917               ivd.vd_next = 0;
11918               ivd.vd_flags = 0;
11919             }
11920           else
11921             {
11922               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11923               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11924               ivd.vd_next = BYTE_GET (evd.vd_next);
11925               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11926             }
11927
11928           if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11929             max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11930
11931           off += ivd.vd_next;
11932         }
11933       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11934
11935       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11936         {
11937           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11938             return NULL;
11939
11940           off -= ivd.vd_next;
11941           off += ivd.vd_aux;
11942
11943           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11944                         _("version def aux")) != NULL)
11945             {
11946               ivda.vda_name = BYTE_GET (evda.vda_name);
11947
11948               if (psym->st_name != ivda.vda_name)
11949                 return (ivda.vda_name < strtab_size
11950                         ? strtab + ivda.vda_name : _("<corrupt>"));
11951             }
11952         }
11953     }
11954
11955   if (filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11956     {
11957       Elf_External_Verneed evn;
11958       Elf_Internal_Verneed ivn;
11959       Elf_Internal_Vernaux ivna;
11960
11961       offset = offset_from_vma (filedata,
11962                                 filedata->version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11963                                 sizeof evn);
11964       do
11965         {
11966           unsigned long vna_off;
11967
11968           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11969                         _("version need")) == NULL)
11970             {
11971               ivna.vna_next = 0;
11972               ivna.vna_other = 0;
11973               ivna.vna_name = 0;
11974               break;
11975             }
11976
11977           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11978           ivn.vn_next = BYTE_GET (evn.vn_next);
11979
11980           vna_off = offset + ivn.vn_aux;
11981
11982           do
11983             {
11984               Elf_External_Vernaux evna;
11985
11986               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11987                             _("version need aux (3)")) == NULL)
11988                 {
11989                   ivna.vna_next = 0;
11990                   ivna.vna_other = 0;
11991                   ivna.vna_name = 0;
11992                 }
11993               else
11994                 {
11995                   ivna.vna_other = BYTE_GET (evna.vna_other);
11996                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11997                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11998                 }
11999
12000               vna_off += ivna.vna_next;
12001             }
12002           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
12003
12004           if (ivna.vna_other == vers_data)
12005             break;
12006
12007           offset += ivn.vn_next;
12008         }
12009       while (ivn.vn_next != 0);
12010
12011       if (ivna.vna_other == vers_data)
12012         {
12013           *sym_info = symbol_undefined;
12014           *vna_other = ivna.vna_other;
12015           return (ivna.vna_name < strtab_size
12016                   ? strtab + ivna.vna_name : _("<corrupt>"));
12017         }
12018       else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
12019                && (vers_data & VERSYM_VERSION) > max_vd_ndx)
12020         return _("<corrupt>");
12021     }
12022   return NULL;
12023 }
12024
12025 static void
12026 print_dynamic_symbol (Filedata *filedata, unsigned long si,
12027                       Elf_Internal_Sym *symtab,
12028                       Elf_Internal_Shdr *section,
12029                       char *strtab, size_t strtab_size)
12030 {
12031   const char *version_string;
12032   enum versioned_symbol_info sym_info;
12033   unsigned short vna_other;
12034   Elf_Internal_Sym *psym = symtab + si;
12035
12036   printf ("%6ld: ", si);
12037   print_vma (psym->st_value, LONG_HEX);
12038   putchar (' ');
12039   print_vma (psym->st_size, DEC_5);
12040   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
12041   printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
12042   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
12043     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
12044   else
12045     {
12046       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
12047
12048       printf (" %-7s", get_symbol_visibility (vis));
12049       /* Check to see if any other bits in the st_other field are set.
12050          Note - displaying this information disrupts the layout of the
12051          table being generated, but for the moment this case is very rare.  */
12052       if (psym->st_other ^ vis)
12053         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
12054     }
12055   printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
12056   print_symbol (25, VALID_SYMBOL_NAME (strtab, strtab_size,
12057                                        psym->st_name)
12058                 ? strtab + psym->st_name : _("<corrupt>"));
12059
12060   version_string
12061     = get_symbol_version_string (filedata,
12062                                  (section == NULL
12063                                   || section->sh_type == SHT_DYNSYM),
12064                                  strtab, strtab_size, si,
12065                                  psym, &sym_info, &vna_other);
12066   if (version_string)
12067     {
12068       if (sym_info == symbol_undefined)
12069         printf ("@%s (%d)", version_string, vna_other);
12070       else
12071         printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
12072                 version_string);
12073     }
12074
12075   putchar ('\n');
12076
12077   if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
12078       && section != NULL
12079       && si >= section->sh_info
12080       /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
12081       && filedata->file_header.e_machine != EM_MIPS
12082       /* Solaris binaries have been found to violate this requirement as
12083          well.  Not sure if this is a bug or an ABI requirement.  */
12084       && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
12085     warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12086           si, printable_section_name (filedata, section), section->sh_info);
12087 }
12088
12089 /* Dump the symbol table.  */
12090 static bfd_boolean
12091 process_symbol_table (Filedata * filedata)
12092 {
12093   Elf_Internal_Shdr * section;
12094
12095   if (!do_syms && !do_dyn_syms && !do_histogram)
12096     return TRUE;
12097
12098   if ((filedata->dynamic_info[DT_HASH] || filedata->dynamic_info_DT_GNU_HASH)
12099       && do_syms
12100       && do_using_dynamic
12101       && filedata->dynamic_strings != NULL
12102       && filedata->dynamic_symbols != NULL)
12103     {
12104       unsigned long si;
12105
12106       printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12107                         "\nSymbol table for image contains %lu entries:\n",
12108                         filedata->num_dynamic_syms),
12109               filedata->num_dynamic_syms);
12110       if (is_32bit_elf)
12111         printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
12112       else
12113         printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
12114
12115       for (si = 0; si < filedata->num_dynamic_syms; si++)
12116         print_dynamic_symbol (filedata, si, filedata->dynamic_symbols, NULL,
12117                               filedata->dynamic_strings,
12118                               filedata->dynamic_strings_length);
12119     }
12120   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
12121            && filedata->section_headers != NULL)
12122     {
12123       unsigned int i;
12124
12125       for (i = 0, section = filedata->section_headers;
12126            i < filedata->file_header.e_shnum;
12127            i++, section++)
12128         {
12129           char * strtab = NULL;
12130           unsigned long int strtab_size = 0;
12131           Elf_Internal_Sym * symtab;
12132           unsigned long si, num_syms;
12133
12134           if ((section->sh_type != SHT_SYMTAB
12135                && section->sh_type != SHT_DYNSYM)
12136               || (!do_syms
12137                   && section->sh_type == SHT_SYMTAB))
12138             continue;
12139
12140           if (section->sh_entsize == 0)
12141             {
12142               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12143                       printable_section_name (filedata, section));
12144               continue;
12145             }
12146
12147           num_syms = section->sh_size / section->sh_entsize;
12148           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12149                             "\nSymbol table '%s' contains %lu entries:\n",
12150                             num_syms),
12151                   printable_section_name (filedata, section),
12152                   num_syms);
12153
12154           if (is_32bit_elf)
12155             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
12156           else
12157             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
12158
12159           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
12160           if (symtab == NULL)
12161             continue;
12162
12163           if (section->sh_link == filedata->file_header.e_shstrndx)
12164             {
12165               strtab = filedata->string_table;
12166               strtab_size = filedata->string_table_length;
12167             }
12168           else if (section->sh_link < filedata->file_header.e_shnum)
12169             {
12170               Elf_Internal_Shdr * string_sec;
12171
12172               string_sec = filedata->section_headers + section->sh_link;
12173
12174               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
12175                                           1, string_sec->sh_size,
12176                                           _("string table"));
12177               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
12178             }
12179
12180           for (si = 0; si < num_syms; si++)
12181             print_dynamic_symbol (filedata, si, symtab, section,
12182                                   strtab, strtab_size);
12183
12184           free (symtab);
12185           if (strtab != filedata->string_table)
12186             free (strtab);
12187         }
12188     }
12189   else if (do_syms)
12190     printf
12191       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12192
12193   if (do_histogram && filedata->buckets != NULL)
12194     {
12195       unsigned long * lengths;
12196       unsigned long * counts;
12197       unsigned long hn;
12198       bfd_vma si;
12199       unsigned long maxlength = 0;
12200       unsigned long nzero_counts = 0;
12201       unsigned long nsyms = 0;
12202       char *visited;
12203
12204       printf (ngettext ("\nHistogram for bucket list length "
12205                         "(total of %lu bucket):\n",
12206                         "\nHistogram for bucket list length "
12207                         "(total of %lu buckets):\n",
12208                         (unsigned long) filedata->nbuckets),
12209               (unsigned long) filedata->nbuckets);
12210
12211       lengths = (unsigned long *) calloc (filedata->nbuckets,
12212                                           sizeof (*lengths));
12213       if (lengths == NULL)
12214         {
12215           error (_("Out of memory allocating space for histogram buckets\n"));
12216           goto err_out;
12217         }
12218       visited = xcmalloc (filedata->nchains, 1);
12219       memset (visited, 0, filedata->nchains);
12220
12221       printf (_(" Length  Number     %% of total  Coverage\n"));
12222       for (hn = 0; hn < filedata->nbuckets; ++hn)
12223         {
12224           for (si = filedata->buckets[hn]; si > 0; si = filedata->chains[si])
12225             {
12226               ++nsyms;
12227               if (maxlength < ++lengths[hn])
12228                 ++maxlength;
12229               if (si >= filedata->nchains || visited[si])
12230                 {
12231                   error (_("histogram chain is corrupt\n"));
12232                   break;
12233                 }
12234               visited[si] = 1;
12235             }
12236         }
12237       free (visited);
12238
12239       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12240       if (counts == NULL)
12241         {
12242           free (lengths);
12243           error (_("Out of memory allocating space for histogram counts\n"));
12244           goto err_out;
12245         }
12246
12247       for (hn = 0; hn < filedata->nbuckets; ++hn)
12248         ++counts[lengths[hn]];
12249
12250       if (filedata->nbuckets > 0)
12251         {
12252           unsigned long i;
12253           printf ("      0  %-10lu (%5.1f%%)\n",
12254                   counts[0], (counts[0] * 100.0) / filedata->nbuckets);
12255           for (i = 1; i <= maxlength; ++i)
12256             {
12257               nzero_counts += counts[i] * i;
12258               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
12259                       i, counts[i], (counts[i] * 100.0) / filedata->nbuckets,
12260                       (nzero_counts * 100.0) / nsyms);
12261             }
12262         }
12263
12264       free (counts);
12265       free (lengths);
12266     }
12267
12268   free (filedata->buckets);
12269   filedata->buckets = NULL;
12270   filedata->nbuckets = 0;
12271   free (filedata->chains);
12272   filedata->chains = NULL;
12273
12274   if (do_histogram && filedata->gnubuckets != NULL)
12275     {
12276       unsigned long * lengths;
12277       unsigned long * counts;
12278       unsigned long hn;
12279       unsigned long maxlength = 0;
12280       unsigned long nzero_counts = 0;
12281       unsigned long nsyms = 0;
12282
12283       printf (ngettext ("\nHistogram for `%s' bucket list length "
12284                         "(total of %lu bucket):\n",
12285                         "\nHistogram for `%s' bucket list length "
12286                         "(total of %lu buckets):\n",
12287                         (unsigned long) filedata->ngnubuckets),
12288               GNU_HASH_SECTION_NAME (filedata),
12289               (unsigned long) filedata->ngnubuckets);
12290
12291       lengths = (unsigned long *) calloc (filedata->ngnubuckets,
12292                                           sizeof (*lengths));
12293       if (lengths == NULL)
12294         {
12295           error (_("Out of memory allocating space for gnu histogram buckets\n"));
12296           goto err_out;
12297         }
12298
12299       printf (_(" Length  Number     %% of total  Coverage\n"));
12300
12301       for (hn = 0; hn < filedata->ngnubuckets; ++hn)
12302         if (filedata->gnubuckets[hn] != 0)
12303           {
12304             bfd_vma off, length = 1;
12305
12306             for (off = filedata->gnubuckets[hn] - filedata->gnusymidx;
12307                  /* PR 17531 file: 010-77222-0.004.  */
12308                  off < filedata->ngnuchains
12309                    && (filedata->gnuchains[off] & 1) == 0;
12310                  ++off)
12311               ++length;
12312             lengths[hn] = length;
12313             if (length > maxlength)
12314               maxlength = length;
12315             nsyms += length;
12316           }
12317
12318       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12319       if (counts == NULL)
12320         {
12321           free (lengths);
12322           error (_("Out of memory allocating space for gnu histogram counts\n"));
12323           goto err_out;
12324         }
12325
12326       for (hn = 0; hn < filedata->ngnubuckets; ++hn)
12327         ++counts[lengths[hn]];
12328
12329       if (filedata->ngnubuckets > 0)
12330         {
12331           unsigned long j;
12332           printf ("      0  %-10lu (%5.1f%%)\n",
12333                   counts[0], (counts[0] * 100.0) / filedata->ngnubuckets);
12334           for (j = 1; j <= maxlength; ++j)
12335             {
12336               nzero_counts += counts[j] * j;
12337               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
12338                       j, counts[j], (counts[j] * 100.0) / filedata->ngnubuckets,
12339                       (nzero_counts * 100.0) / nsyms);
12340             }
12341         }
12342
12343       free (counts);
12344       free (lengths);
12345     }
12346   free (filedata->gnubuckets);
12347   filedata->gnubuckets = NULL;
12348   filedata->ngnubuckets = 0;
12349   free (filedata->gnuchains);
12350   filedata->gnuchains = NULL;
12351   filedata->ngnuchains = 0;
12352   free (filedata->mipsxlat);
12353   filedata->mipsxlat = NULL;
12354   return TRUE;
12355
12356  err_out:
12357   free (filedata->gnubuckets);
12358   filedata->gnubuckets = NULL;
12359   filedata->ngnubuckets = 0;
12360   free (filedata->gnuchains);
12361   filedata->gnuchains = NULL;
12362   filedata->ngnuchains = 0;
12363   free (filedata->mipsxlat);
12364   filedata->mipsxlat = NULL;
12365   free (filedata->buckets);
12366   filedata->buckets = NULL;
12367   filedata->nbuckets = 0;
12368   free (filedata->chains);
12369   filedata->chains = NULL;
12370   return FALSE;
12371 }
12372
12373 static bfd_boolean
12374 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12375 {
12376   unsigned int i;
12377
12378   if (filedata->dynamic_syminfo == NULL
12379       || !do_dynamic)
12380     /* No syminfo, this is ok.  */
12381     return TRUE;
12382
12383   /* There better should be a dynamic symbol section.  */
12384   if (filedata->dynamic_symbols == NULL || filedata->dynamic_strings == NULL)
12385     return FALSE;
12386
12387   if (filedata->dynamic_addr)
12388     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12389                       "contains %d entry:\n",
12390                       "\nDynamic info segment at offset 0x%lx "
12391                       "contains %d entries:\n",
12392                       filedata->dynamic_syminfo_nent),
12393             filedata->dynamic_syminfo_offset, filedata->dynamic_syminfo_nent);
12394
12395   printf (_(" Num: Name                           BoundTo     Flags\n"));
12396   for (i = 0; i < filedata->dynamic_syminfo_nent; ++i)
12397     {
12398       unsigned short int flags = filedata->dynamic_syminfo[i].si_flags;
12399
12400       printf ("%4d: ", i);
12401       if (i >= filedata->num_dynamic_syms)
12402         printf (_("<corrupt index>"));
12403       else if (VALID_DYNAMIC_NAME (filedata, filedata->dynamic_symbols[i].st_name))
12404         print_symbol (30, GET_DYNAMIC_NAME (filedata,
12405                                             filedata->dynamic_symbols[i].st_name));
12406       else
12407         printf (_("<corrupt: %19ld>"), filedata->dynamic_symbols[i].st_name);
12408       putchar (' ');
12409
12410       switch (filedata->dynamic_syminfo[i].si_boundto)
12411         {
12412         case SYMINFO_BT_SELF:
12413           fputs ("SELF       ", stdout);
12414           break;
12415         case SYMINFO_BT_PARENT:
12416           fputs ("PARENT     ", stdout);
12417           break;
12418         default:
12419           if (filedata->dynamic_syminfo[i].si_boundto > 0
12420               && filedata->dynamic_syminfo[i].si_boundto < filedata->dynamic_nent
12421               && VALID_DYNAMIC_NAME (filedata,
12422                                      filedata->dynamic_section[filedata->dynamic_syminfo[i].si_boundto].d_un.d_val))
12423             {
12424               print_symbol (10, GET_DYNAMIC_NAME (filedata,
12425                                                   filedata->dynamic_section[filedata->dynamic_syminfo[i].si_boundto].d_un.d_val));
12426               putchar (' ' );
12427             }
12428           else
12429             printf ("%-10d ", filedata->dynamic_syminfo[i].si_boundto);
12430           break;
12431         }
12432
12433       if (flags & SYMINFO_FLG_DIRECT)
12434         printf (" DIRECT");
12435       if (flags & SYMINFO_FLG_PASSTHRU)
12436         printf (" PASSTHRU");
12437       if (flags & SYMINFO_FLG_COPY)
12438         printf (" COPY");
12439       if (flags & SYMINFO_FLG_LAZYLOAD)
12440         printf (" LAZYLOAD");
12441
12442       puts ("");
12443     }
12444
12445   return TRUE;
12446 }
12447
12448 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12449    is contained by the region START .. END.  The types of ADDR, START
12450    and END should all be the same.  Note both ADDR + NELEM and END
12451    point to just beyond the end of the regions that are being tested.  */
12452 #define IN_RANGE(START,END,ADDR,NELEM)          \
12453   (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12454
12455 /* Check to see if the given reloc needs to be handled in a target specific
12456    manner.  If so then process the reloc and return TRUE otherwise return
12457    FALSE.
12458
12459    If called with reloc == NULL, then this is a signal that reloc processing
12460    for the current section has finished, and any saved state should be
12461    discarded.  */
12462
12463 static bfd_boolean
12464 target_specific_reloc_handling (Filedata *           filedata,
12465                                 Elf_Internal_Rela *  reloc,
12466                                 unsigned char *      start,
12467                                 unsigned char *      end,
12468                                 Elf_Internal_Sym *   symtab,
12469                                 unsigned long        num_syms)
12470 {
12471   unsigned int reloc_type = 0;
12472   unsigned long sym_index = 0;
12473
12474   if (reloc)
12475     {
12476       reloc_type = get_reloc_type (filedata, reloc->r_info);
12477       sym_index = get_reloc_symindex (reloc->r_info);
12478     }
12479
12480   switch (filedata->file_header.e_machine)
12481     {
12482     case EM_MSP430:
12483     case EM_MSP430_OLD:
12484       {
12485         static Elf_Internal_Sym * saved_sym = NULL;
12486
12487         if (reloc == NULL)
12488           {
12489             saved_sym = NULL;
12490             return TRUE;
12491           }
12492
12493         switch (reloc_type)
12494           {
12495           case 10: /* R_MSP430_SYM_DIFF */
12496             if (uses_msp430x_relocs (filedata))
12497               break;
12498             /* Fall through.  */
12499           case 21: /* R_MSP430X_SYM_DIFF */
12500             /* PR 21139.  */
12501             if (sym_index >= num_syms)
12502               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12503                      sym_index);
12504             else
12505               saved_sym = symtab + sym_index;
12506             return TRUE;
12507
12508           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12509           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12510             goto handle_sym_diff;
12511
12512           case 5: /* R_MSP430_16_BYTE */
12513           case 9: /* R_MSP430_8 */
12514             if (uses_msp430x_relocs (filedata))
12515               break;
12516             goto handle_sym_diff;
12517
12518           case 2: /* R_MSP430_ABS16 */
12519           case 15: /* R_MSP430X_ABS16 */
12520             if (! uses_msp430x_relocs (filedata))
12521               break;
12522             goto handle_sym_diff;
12523
12524           handle_sym_diff:
12525             if (saved_sym != NULL)
12526               {
12527                 int reloc_size = reloc_type == 1 ? 4 : 2;
12528                 bfd_vma value;
12529
12530                 if (sym_index >= num_syms)
12531                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12532                          sym_index);
12533                 else
12534                   {
12535                     value = reloc->r_addend + (symtab[sym_index].st_value
12536                                                - saved_sym->st_value);
12537
12538                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12539                       byte_put (start + reloc->r_offset, value, reloc_size);
12540                     else
12541                       /* PR 21137 */
12542                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12543                              (long) reloc->r_offset);
12544                   }
12545
12546                 saved_sym = NULL;
12547                 return TRUE;
12548               }
12549             break;
12550
12551           default:
12552             if (saved_sym != NULL)
12553               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12554             break;
12555           }
12556         break;
12557       }
12558
12559     case EM_MN10300:
12560     case EM_CYGNUS_MN10300:
12561       {
12562         static Elf_Internal_Sym * saved_sym = NULL;
12563
12564         if (reloc == NULL)
12565           {
12566             saved_sym = NULL;
12567             return TRUE;
12568           }
12569
12570         switch (reloc_type)
12571           {
12572           case 34: /* R_MN10300_ALIGN */
12573             return TRUE;
12574           case 33: /* R_MN10300_SYM_DIFF */
12575             if (sym_index >= num_syms)
12576               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12577                      sym_index);
12578             else
12579               saved_sym = symtab + sym_index;
12580             return TRUE;
12581
12582           case 1: /* R_MN10300_32 */
12583           case 2: /* R_MN10300_16 */
12584             if (saved_sym != NULL)
12585               {
12586                 int reloc_size = reloc_type == 1 ? 4 : 2;
12587                 bfd_vma value;
12588
12589                 if (sym_index >= num_syms)
12590                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12591                          sym_index);
12592                 else
12593                   {
12594                     value = reloc->r_addend + (symtab[sym_index].st_value
12595                                                - saved_sym->st_value);
12596
12597                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12598                       byte_put (start + reloc->r_offset, value, reloc_size);
12599                     else
12600                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12601                              (long) reloc->r_offset);
12602                   }
12603
12604                 saved_sym = NULL;
12605                 return TRUE;
12606               }
12607             break;
12608           default:
12609             if (saved_sym != NULL)
12610               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12611             break;
12612           }
12613         break;
12614       }
12615
12616     case EM_RL78:
12617       {
12618         static bfd_vma saved_sym1 = 0;
12619         static bfd_vma saved_sym2 = 0;
12620         static bfd_vma value;
12621
12622         if (reloc == NULL)
12623           {
12624             saved_sym1 = saved_sym2 = 0;
12625             return TRUE;
12626           }
12627
12628         switch (reloc_type)
12629           {
12630           case 0x80: /* R_RL78_SYM.  */
12631             saved_sym1 = saved_sym2;
12632             if (sym_index >= num_syms)
12633               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12634                      sym_index);
12635             else
12636               {
12637                 saved_sym2 = symtab[sym_index].st_value;
12638                 saved_sym2 += reloc->r_addend;
12639               }
12640             return TRUE;
12641
12642           case 0x83: /* R_RL78_OPsub.  */
12643             value = saved_sym1 - saved_sym2;
12644             saved_sym2 = saved_sym1 = 0;
12645             return TRUE;
12646             break;
12647
12648           case 0x41: /* R_RL78_ABS32.  */
12649             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12650               byte_put (start + reloc->r_offset, value, 4);
12651             else
12652               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12653                      (long) reloc->r_offset);
12654             value = 0;
12655             return TRUE;
12656
12657           case 0x43: /* R_RL78_ABS16.  */
12658             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12659               byte_put (start + reloc->r_offset, value, 2);
12660             else
12661               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12662                      (long) reloc->r_offset);
12663             value = 0;
12664             return TRUE;
12665
12666           default:
12667             break;
12668           }
12669         break;
12670       }
12671     }
12672
12673   return FALSE;
12674 }
12675
12676 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12677    DWARF debug sections.  This is a target specific test.  Note - we do not
12678    go through the whole including-target-headers-multiple-times route, (as
12679    we have already done with <elf/h8.h>) because this would become very
12680    messy and even then this function would have to contain target specific
12681    information (the names of the relocs instead of their numeric values).
12682    FIXME: This is not the correct way to solve this problem.  The proper way
12683    is to have target specific reloc sizing and typing functions created by
12684    the reloc-macros.h header, in the same way that it already creates the
12685    reloc naming functions.  */
12686
12687 static bfd_boolean
12688 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12689 {
12690   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12691   switch (filedata->file_header.e_machine)
12692     {
12693     case EM_386:
12694     case EM_IAMCU:
12695       return reloc_type == 1; /* R_386_32.  */
12696     case EM_68K:
12697       return reloc_type == 1; /* R_68K_32.  */
12698     case EM_860:
12699       return reloc_type == 1; /* R_860_32.  */
12700     case EM_960:
12701       return reloc_type == 2; /* R_960_32.  */
12702     case EM_AARCH64:
12703       return (reloc_type == 258
12704               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12705     case EM_BPF:
12706       return reloc_type == 11; /* R_BPF_DATA_32 */
12707     case EM_ADAPTEVA_EPIPHANY:
12708       return reloc_type == 3;
12709     case EM_ALPHA:
12710       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12711     case EM_ARC:
12712       return reloc_type == 1; /* R_ARC_32.  */
12713     case EM_ARC_COMPACT:
12714     case EM_ARC_COMPACT2:
12715       return reloc_type == 4; /* R_ARC_32.  */
12716     case EM_ARM:
12717       return reloc_type == 2; /* R_ARM_ABS32 */
12718     case EM_AVR_OLD:
12719     case EM_AVR:
12720       return reloc_type == 1;
12721     case EM_BLACKFIN:
12722       return reloc_type == 0x12; /* R_byte4_data.  */
12723     case EM_CRIS:
12724       return reloc_type == 3; /* R_CRIS_32.  */
12725     case EM_CR16:
12726       return reloc_type == 3; /* R_CR16_NUM32.  */
12727     case EM_CRX:
12728       return reloc_type == 15; /* R_CRX_NUM32.  */
12729     case EM_CSKY:
12730       return reloc_type == 1; /* R_CKCORE_ADDR32.  */
12731     case EM_CYGNUS_FRV:
12732       return reloc_type == 1;
12733     case EM_CYGNUS_D10V:
12734     case EM_D10V:
12735       return reloc_type == 6; /* R_D10V_32.  */
12736     case EM_CYGNUS_D30V:
12737     case EM_D30V:
12738       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12739     case EM_DLX:
12740       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12741     case EM_CYGNUS_FR30:
12742     case EM_FR30:
12743       return reloc_type == 3; /* R_FR30_32.  */
12744     case EM_FT32:
12745       return reloc_type == 1; /* R_FT32_32.  */
12746     case EM_H8S:
12747     case EM_H8_300:
12748     case EM_H8_300H:
12749       return reloc_type == 1; /* R_H8_DIR32.  */
12750     case EM_IA_64:
12751       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12752               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12753               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12754               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12755     case EM_IP2K_OLD:
12756     case EM_IP2K:
12757       return reloc_type == 2; /* R_IP2K_32.  */
12758     case EM_IQ2000:
12759       return reloc_type == 2; /* R_IQ2000_32.  */
12760     case EM_LATTICEMICO32:
12761       return reloc_type == 3; /* R_LM32_32.  */
12762     case EM_M32C_OLD:
12763     case EM_M32C:
12764       return reloc_type == 3; /* R_M32C_32.  */
12765     case EM_M32R:
12766       return reloc_type == 34; /* R_M32R_32_RELA.  */
12767     case EM_68HC11:
12768     case EM_68HC12:
12769       return reloc_type == 6; /* R_M68HC11_32.  */
12770     case EM_S12Z:
12771       return reloc_type == 7 || /* R_S12Z_EXT32 */
12772         reloc_type == 6;        /* R_S12Z_CW32.  */
12773     case EM_MCORE:
12774       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12775     case EM_CYGNUS_MEP:
12776       return reloc_type == 4; /* R_MEP_32.  */
12777     case EM_METAG:
12778       return reloc_type == 2; /* R_METAG_ADDR32.  */
12779     case EM_MICROBLAZE:
12780       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12781     case EM_MIPS:
12782       return reloc_type == 2; /* R_MIPS_32.  */
12783     case EM_MMIX:
12784       return reloc_type == 4; /* R_MMIX_32.  */
12785     case EM_CYGNUS_MN10200:
12786     case EM_MN10200:
12787       return reloc_type == 1; /* R_MN10200_32.  */
12788     case EM_CYGNUS_MN10300:
12789     case EM_MN10300:
12790       return reloc_type == 1; /* R_MN10300_32.  */
12791     case EM_MOXIE:
12792       return reloc_type == 1; /* R_MOXIE_32.  */
12793     case EM_MSP430_OLD:
12794     case EM_MSP430:
12795       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12796     case EM_MT:
12797       return reloc_type == 2; /* R_MT_32.  */
12798     case EM_NDS32:
12799       return reloc_type == 20; /* R_NDS32_RELA.  */
12800     case EM_ALTERA_NIOS2:
12801       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12802     case EM_NIOS32:
12803       return reloc_type == 1; /* R_NIOS_32.  */
12804     case EM_OR1K:
12805       return reloc_type == 1; /* R_OR1K_32.  */
12806     case EM_PARISC:
12807       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12808               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12809               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12810     case EM_PJ:
12811     case EM_PJ_OLD:
12812       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12813     case EM_PPC64:
12814       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12815     case EM_PPC:
12816       return reloc_type == 1; /* R_PPC_ADDR32.  */
12817     case EM_TI_PRU:
12818       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12819     case EM_RISCV:
12820       return reloc_type == 1; /* R_RISCV_32.  */
12821     case EM_RL78:
12822       return reloc_type == 1; /* R_RL78_DIR32.  */
12823     case EM_RX:
12824       return reloc_type == 1; /* R_RX_DIR32.  */
12825     case EM_S370:
12826       return reloc_type == 1; /* R_I370_ADDR31.  */
12827     case EM_S390_OLD:
12828     case EM_S390:
12829       return reloc_type == 4; /* R_S390_32.  */
12830     case EM_SCORE:
12831       return reloc_type == 8; /* R_SCORE_ABS32.  */
12832     case EM_SH:
12833       return reloc_type == 1; /* R_SH_DIR32.  */
12834     case EM_SPARC32PLUS:
12835     case EM_SPARCV9:
12836     case EM_SPARC:
12837       return reloc_type == 3 /* R_SPARC_32.  */
12838         || reloc_type == 23; /* R_SPARC_UA32.  */
12839     case EM_SPU:
12840       return reloc_type == 6; /* R_SPU_ADDR32 */
12841     case EM_TI_C6000:
12842       return reloc_type == 1; /* R_C6000_ABS32.  */
12843     case EM_TILEGX:
12844       return reloc_type == 2; /* R_TILEGX_32.  */
12845     case EM_TILEPRO:
12846       return reloc_type == 1; /* R_TILEPRO_32.  */
12847     case EM_CYGNUS_V850:
12848     case EM_V850:
12849       return reloc_type == 6; /* R_V850_ABS32.  */
12850     case EM_V800:
12851       return reloc_type == 0x33; /* R_V810_WORD.  */
12852     case EM_VAX:
12853       return reloc_type == 1; /* R_VAX_32.  */
12854     case EM_VISIUM:
12855       return reloc_type == 3;  /* R_VISIUM_32. */
12856     case EM_WEBASSEMBLY:
12857       return reloc_type == 1;  /* R_WASM32_32.  */
12858     case EM_X86_64:
12859     case EM_L1OM:
12860     case EM_K1OM:
12861       return reloc_type == 10; /* R_X86_64_32.  */
12862     case EM_XC16X:
12863     case EM_C166:
12864       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12865     case EM_XGATE:
12866       return reloc_type == 4; /* R_XGATE_32.  */
12867     case EM_XSTORMY16:
12868       return reloc_type == 1; /* R_XSTROMY16_32.  */
12869     case EM_XTENSA_OLD:
12870     case EM_XTENSA:
12871       return reloc_type == 1; /* R_XTENSA_32.  */
12872     case EM_Z80:
12873       return reloc_type == 6; /* R_Z80_32.  */
12874     default:
12875       {
12876         static unsigned int prev_warn = 0;
12877
12878         /* Avoid repeating the same warning multiple times.  */
12879         if (prev_warn != filedata->file_header.e_machine)
12880           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12881                  filedata->file_header.e_machine);
12882         prev_warn = filedata->file_header.e_machine;
12883         return FALSE;
12884       }
12885     }
12886 }
12887
12888 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12889    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12890
12891 static bfd_boolean
12892 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12893 {
12894   switch (filedata->file_header.e_machine)
12895   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12896     {
12897     case EM_386:
12898     case EM_IAMCU:
12899       return reloc_type == 2;  /* R_386_PC32.  */
12900     case EM_68K:
12901       return reloc_type == 4;  /* R_68K_PC32.  */
12902     case EM_AARCH64:
12903       return reloc_type == 261; /* R_AARCH64_PREL32 */
12904     case EM_ADAPTEVA_EPIPHANY:
12905       return reloc_type == 6;
12906     case EM_ALPHA:
12907       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12908     case EM_ARC_COMPACT:
12909     case EM_ARC_COMPACT2:
12910       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12911     case EM_ARM:
12912       return reloc_type == 3;  /* R_ARM_REL32 */
12913     case EM_AVR_OLD:
12914     case EM_AVR:
12915       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12916     case EM_MICROBLAZE:
12917       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12918     case EM_OR1K:
12919       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12920     case EM_PARISC:
12921       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12922     case EM_PPC:
12923       return reloc_type == 26; /* R_PPC_REL32.  */
12924     case EM_PPC64:
12925       return reloc_type == 26; /* R_PPC64_REL32.  */
12926     case EM_RISCV:
12927       return reloc_type == 57;  /* R_RISCV_32_PCREL.  */
12928     case EM_S390_OLD:
12929     case EM_S390:
12930       return reloc_type == 5;  /* R_390_PC32.  */
12931     case EM_SH:
12932       return reloc_type == 2;  /* R_SH_REL32.  */
12933     case EM_SPARC32PLUS:
12934     case EM_SPARCV9:
12935     case EM_SPARC:
12936       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12937     case EM_SPU:
12938       return reloc_type == 13; /* R_SPU_REL32.  */
12939     case EM_TILEGX:
12940       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12941     case EM_TILEPRO:
12942       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12943     case EM_VISIUM:
12944       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12945     case EM_X86_64:
12946     case EM_L1OM:
12947     case EM_K1OM:
12948       return reloc_type == 2;  /* R_X86_64_PC32.  */
12949     case EM_VAX:
12950       return reloc_type == 4;  /* R_VAX_PCREL32.  */
12951     case EM_XTENSA_OLD:
12952     case EM_XTENSA:
12953       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12954     default:
12955       /* Do not abort or issue an error message here.  Not all targets use
12956          pc-relative 32-bit relocs in their DWARF debug information and we
12957          have already tested for target coverage in is_32bit_abs_reloc.  A
12958          more helpful warning message will be generated by apply_relocations
12959          anyway, so just return.  */
12960       return FALSE;
12961     }
12962 }
12963
12964 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12965    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12966
12967 static bfd_boolean
12968 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12969 {
12970   switch (filedata->file_header.e_machine)
12971     {
12972     case EM_AARCH64:
12973       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12974     case EM_ALPHA:
12975       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12976     case EM_IA_64:
12977       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12978               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12979     case EM_PARISC:
12980       return reloc_type == 80; /* R_PARISC_DIR64.  */
12981     case EM_PPC64:
12982       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12983     case EM_RISCV:
12984       return reloc_type == 2; /* R_RISCV_64.  */
12985     case EM_SPARC32PLUS:
12986     case EM_SPARCV9:
12987     case EM_SPARC:
12988       return reloc_type == 32 /* R_SPARC_64.  */
12989         || reloc_type == 54; /* R_SPARC_UA64.  */
12990     case EM_X86_64:
12991     case EM_L1OM:
12992     case EM_K1OM:
12993       return reloc_type == 1; /* R_X86_64_64.  */
12994     case EM_S390_OLD:
12995     case EM_S390:
12996       return reloc_type == 22;  /* R_S390_64.  */
12997     case EM_TILEGX:
12998       return reloc_type == 1; /* R_TILEGX_64.  */
12999     case EM_MIPS:
13000       return reloc_type == 18;  /* R_MIPS_64.  */
13001     default:
13002       return FALSE;
13003     }
13004 }
13005
13006 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13007    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
13008
13009 static bfd_boolean
13010 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
13011 {
13012   switch (filedata->file_header.e_machine)
13013     {
13014     case EM_AARCH64:
13015       return reloc_type == 260; /* R_AARCH64_PREL64.  */
13016     case EM_ALPHA:
13017       return reloc_type == 11; /* R_ALPHA_SREL64.  */
13018     case EM_IA_64:
13019       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
13020               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
13021     case EM_PARISC:
13022       return reloc_type == 72; /* R_PARISC_PCREL64.  */
13023     case EM_PPC64:
13024       return reloc_type == 44; /* R_PPC64_REL64.  */
13025     case EM_SPARC32PLUS:
13026     case EM_SPARCV9:
13027     case EM_SPARC:
13028       return reloc_type == 46; /* R_SPARC_DISP64.  */
13029     case EM_X86_64:
13030     case EM_L1OM:
13031     case EM_K1OM:
13032       return reloc_type == 24; /* R_X86_64_PC64.  */
13033     case EM_S390_OLD:
13034     case EM_S390:
13035       return reloc_type == 23;  /* R_S390_PC64.  */
13036     case EM_TILEGX:
13037       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
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 24-bit absolute RELA relocation used in DWARF debug sections.  */
13045
13046 static bfd_boolean
13047 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13048 {
13049   switch (filedata->file_header.e_machine)
13050     {
13051     case EM_CYGNUS_MN10200:
13052     case EM_MN10200:
13053       return reloc_type == 4; /* R_MN10200_24.  */
13054     case EM_FT32:
13055       return reloc_type == 5; /* R_FT32_20.  */
13056     case EM_Z80:
13057       return reloc_type == 5; /* R_Z80_24. */
13058     default:
13059       return FALSE;
13060     }
13061 }
13062
13063 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13064    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
13065
13066 static bfd_boolean
13067 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13068 {
13069   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13070   switch (filedata->file_header.e_machine)
13071     {
13072     case EM_ARC:
13073     case EM_ARC_COMPACT:
13074     case EM_ARC_COMPACT2:
13075       return reloc_type == 2; /* R_ARC_16.  */
13076     case EM_ADAPTEVA_EPIPHANY:
13077       return reloc_type == 5;
13078     case EM_AVR_OLD:
13079     case EM_AVR:
13080       return reloc_type == 4; /* R_AVR_16.  */
13081     case EM_CYGNUS_D10V:
13082     case EM_D10V:
13083       return reloc_type == 3; /* R_D10V_16.  */
13084     case EM_FT32:
13085       return reloc_type == 2; /* R_FT32_16.  */
13086     case EM_H8S:
13087     case EM_H8_300:
13088     case EM_H8_300H:
13089       return reloc_type == R_H8_DIR16;
13090     case EM_IP2K_OLD:
13091     case EM_IP2K:
13092       return reloc_type == 1; /* R_IP2K_16.  */
13093     case EM_M32C_OLD:
13094     case EM_M32C:
13095       return reloc_type == 1; /* R_M32C_16 */
13096     case EM_CYGNUS_MN10200:
13097     case EM_MN10200:
13098       return reloc_type == 2; /* R_MN10200_16.  */
13099     case EM_CYGNUS_MN10300:
13100     case EM_MN10300:
13101       return reloc_type == 2; /* R_MN10300_16.  */
13102     case EM_MSP430:
13103       if (uses_msp430x_relocs (filedata))
13104         return reloc_type == 2; /* R_MSP430_ABS16.  */
13105       /* Fall through.  */
13106     case EM_MSP430_OLD:
13107       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
13108     case EM_NDS32:
13109       return reloc_type == 19; /* R_NDS32_RELA.  */
13110     case EM_ALTERA_NIOS2:
13111       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
13112     case EM_NIOS32:
13113       return reloc_type == 9; /* R_NIOS_16.  */
13114     case EM_OR1K:
13115       return reloc_type == 2; /* R_OR1K_16.  */
13116     case EM_RISCV:
13117       return reloc_type == 55; /* R_RISCV_SET16.  */
13118     case EM_TI_PRU:
13119       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
13120     case EM_TI_C6000:
13121       return reloc_type == 2; /* R_C6000_ABS16.  */
13122     case EM_VISIUM:
13123       return reloc_type == 2; /* R_VISIUM_16. */
13124     case EM_XC16X:
13125     case EM_C166:
13126       return reloc_type == 2; /* R_XC16C_ABS_16.  */
13127     case EM_XGATE:
13128       return reloc_type == 3; /* R_XGATE_16.  */
13129     case EM_Z80:
13130       return reloc_type == 4; /* R_Z80_16.  */
13131     default:
13132       return FALSE;
13133     }
13134 }
13135
13136 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13137    a 8-bit absolute RELA relocation used in DWARF debug sections.  */
13138
13139 static bfd_boolean
13140 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13141 {
13142   switch (filedata->file_header.e_machine)
13143     {
13144     case EM_RISCV:
13145       return reloc_type == 54; /* R_RISCV_SET8.  */
13146     case EM_Z80:
13147       return reloc_type == 1;  /* R_Z80_8.  */
13148     default:
13149       return FALSE;
13150     }
13151 }
13152
13153 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13154    a 6-bit absolute RELA relocation used in DWARF debug sections.  */
13155
13156 static bfd_boolean
13157 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13158 {
13159   switch (filedata->file_header.e_machine)
13160     {
13161     case EM_RISCV:
13162       return reloc_type == 53; /* R_RISCV_SET6.  */
13163     default:
13164       return FALSE;
13165     }
13166 }
13167
13168 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13169    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
13170
13171 static bfd_boolean
13172 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13173 {
13174   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13175   switch (filedata->file_header.e_machine)
13176     {
13177     case EM_RISCV:
13178       return reloc_type == 35; /* R_RISCV_ADD32.  */
13179     default:
13180       return FALSE;
13181     }
13182 }
13183
13184 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13185    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
13186
13187 static bfd_boolean
13188 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13189 {
13190   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13191   switch (filedata->file_header.e_machine)
13192     {
13193     case EM_RISCV:
13194       return reloc_type == 39; /* R_RISCV_SUB32.  */
13195     default:
13196       return FALSE;
13197     }
13198 }
13199
13200 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13201    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
13202
13203 static bfd_boolean
13204 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13205 {
13206   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13207   switch (filedata->file_header.e_machine)
13208     {
13209     case EM_RISCV:
13210       return reloc_type == 36; /* R_RISCV_ADD64.  */
13211     default:
13212       return FALSE;
13213     }
13214 }
13215
13216 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13217    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
13218
13219 static bfd_boolean
13220 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13221 {
13222   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13223   switch (filedata->file_header.e_machine)
13224     {
13225     case EM_RISCV:
13226       return reloc_type == 40; /* R_RISCV_SUB64.  */
13227     default:
13228       return FALSE;
13229     }
13230 }
13231
13232 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13233    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
13234
13235 static bfd_boolean
13236 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13237 {
13238   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13239   switch (filedata->file_header.e_machine)
13240     {
13241     case EM_RISCV:
13242       return reloc_type == 34; /* R_RISCV_ADD16.  */
13243     default:
13244       return FALSE;
13245     }
13246 }
13247
13248 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13249    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
13250
13251 static bfd_boolean
13252 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13253 {
13254   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13255   switch (filedata->file_header.e_machine)
13256     {
13257     case EM_RISCV:
13258       return reloc_type == 38; /* R_RISCV_SUB16.  */
13259     default:
13260       return FALSE;
13261     }
13262 }
13263
13264 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13265    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
13266
13267 static bfd_boolean
13268 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13269 {
13270   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13271   switch (filedata->file_header.e_machine)
13272     {
13273     case EM_RISCV:
13274       return reloc_type == 33; /* R_RISCV_ADD8.  */
13275     default:
13276       return FALSE;
13277     }
13278 }
13279
13280 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13281    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
13282
13283 static bfd_boolean
13284 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13285 {
13286   /* Please keep this table alpha-sorted for ease of visual lookup.  */
13287   switch (filedata->file_header.e_machine)
13288     {
13289     case EM_RISCV:
13290       return reloc_type == 37; /* R_RISCV_SUB8.  */
13291     default:
13292       return FALSE;
13293     }
13294 }
13295
13296 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13297    a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
13298
13299 static bfd_boolean
13300 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13301 {
13302   switch (filedata->file_header.e_machine)
13303     {
13304     case EM_RISCV:
13305       return reloc_type == 52; /* R_RISCV_SUB6.  */
13306     default:
13307       return FALSE;
13308     }
13309 }
13310
13311 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13312    relocation entries (possibly formerly used for SHT_GROUP sections).  */
13313
13314 static bfd_boolean
13315 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
13316 {
13317   switch (filedata->file_header.e_machine)
13318     {
13319     case EM_386:     /* R_386_NONE.  */
13320     case EM_68K:     /* R_68K_NONE.  */
13321     case EM_ADAPTEVA_EPIPHANY:
13322     case EM_ALPHA:   /* R_ALPHA_NONE.  */
13323     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
13324     case EM_ARC:     /* R_ARC_NONE.  */
13325     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
13326     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
13327     case EM_ARM:     /* R_ARM_NONE.  */
13328     case EM_C166:    /* R_XC16X_NONE.  */
13329     case EM_CRIS:    /* R_CRIS_NONE.  */
13330     case EM_FT32:    /* R_FT32_NONE.  */
13331     case EM_IA_64:   /* R_IA64_NONE.  */
13332     case EM_K1OM:    /* R_X86_64_NONE.  */
13333     case EM_L1OM:    /* R_X86_64_NONE.  */
13334     case EM_M32R:    /* R_M32R_NONE.  */
13335     case EM_MIPS:    /* R_MIPS_NONE.  */
13336     case EM_MN10300: /* R_MN10300_NONE.  */
13337     case EM_MOXIE:   /* R_MOXIE_NONE.  */
13338     case EM_NIOS32:  /* R_NIOS_NONE.  */
13339     case EM_OR1K:    /* R_OR1K_NONE. */
13340     case EM_PARISC:  /* R_PARISC_NONE.  */
13341     case EM_PPC64:   /* R_PPC64_NONE.  */
13342     case EM_PPC:     /* R_PPC_NONE.  */
13343     case EM_RISCV:   /* R_RISCV_NONE.  */
13344     case EM_S390:    /* R_390_NONE.  */
13345     case EM_S390_OLD:
13346     case EM_SH:      /* R_SH_NONE.  */
13347     case EM_SPARC32PLUS:
13348     case EM_SPARC:   /* R_SPARC_NONE.  */
13349     case EM_SPARCV9:
13350     case EM_TILEGX:  /* R_TILEGX_NONE.  */
13351     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
13352     case EM_TI_C6000:/* R_C6000_NONE.  */
13353     case EM_X86_64:  /* R_X86_64_NONE.  */
13354     case EM_XC16X:
13355     case EM_Z80:     /* R_Z80_NONE. */
13356     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
13357       return reloc_type == 0;
13358
13359     case EM_AARCH64:
13360       return reloc_type == 0 || reloc_type == 256;
13361     case EM_AVR_OLD:
13362     case EM_AVR:
13363       return (reloc_type == 0 /* R_AVR_NONE.  */
13364               || reloc_type == 30 /* R_AVR_DIFF8.  */
13365               || reloc_type == 31 /* R_AVR_DIFF16.  */
13366               || reloc_type == 32 /* R_AVR_DIFF32.  */);
13367     case EM_METAG:
13368       return reloc_type == 3; /* R_METAG_NONE.  */
13369     case EM_NDS32:
13370       return (reloc_type == 0       /* R_XTENSA_NONE.  */
13371               || reloc_type == 204  /* R_NDS32_DIFF8.  */
13372               || reloc_type == 205  /* R_NDS32_DIFF16.  */
13373               || reloc_type == 206  /* R_NDS32_DIFF32.  */
13374               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
13375     case EM_TI_PRU:
13376       return (reloc_type == 0       /* R_PRU_NONE.  */
13377               || reloc_type == 65   /* R_PRU_DIFF8.  */
13378               || reloc_type == 66   /* R_PRU_DIFF16.  */
13379               || reloc_type == 67   /* R_PRU_DIFF32.  */);
13380     case EM_XTENSA_OLD:
13381     case EM_XTENSA:
13382       return (reloc_type == 0      /* R_XTENSA_NONE.  */
13383               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
13384               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
13385               || reloc_type == 19  /* R_XTENSA_DIFF32.  */
13386               || reloc_type == 57  /* R_XTENSA_PDIFF8.  */
13387               || reloc_type == 58  /* R_XTENSA_PDIFF16.  */
13388               || reloc_type == 59  /* R_XTENSA_PDIFF32.  */
13389               || reloc_type == 60  /* R_XTENSA_NDIFF8.  */
13390               || reloc_type == 61  /* R_XTENSA_NDIFF16.  */
13391               || reloc_type == 62  /* R_XTENSA_NDIFF32.  */);
13392     }
13393   return FALSE;
13394 }
13395
13396 /* Returns TRUE if there is a relocation against
13397    section NAME at OFFSET bytes.  */
13398
13399 bfd_boolean
13400 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13401 {
13402   Elf_Internal_Rela * relocs;
13403   Elf_Internal_Rela * rp;
13404
13405   if (dsec == NULL || dsec->reloc_info == NULL)
13406     return FALSE;
13407
13408   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13409
13410   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13411     if (rp->r_offset == offset)
13412       return TRUE;
13413
13414    return FALSE;
13415 }
13416
13417 /* Apply relocations to a section.
13418    Returns TRUE upon success, FALSE otherwise.
13419    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13420    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
13421    will be set to the number of relocs loaded.
13422
13423    Note: So far support has been added only for those relocations
13424    which can be found in debug sections. FIXME: Add support for
13425    more relocations ?  */
13426
13427 static bfd_boolean
13428 apply_relocations (Filedata *                 filedata,
13429                    const Elf_Internal_Shdr *  section,
13430                    unsigned char *            start,
13431                    bfd_size_type              size,
13432                    void **                    relocs_return,
13433                    unsigned long *            num_relocs_return)
13434 {
13435   Elf_Internal_Shdr * relsec;
13436   unsigned char * end = start + size;
13437
13438   if (relocs_return != NULL)
13439     {
13440       * (Elf_Internal_Rela **) relocs_return = NULL;
13441       * num_relocs_return = 0;
13442     }
13443
13444   if (filedata->file_header.e_type != ET_REL)
13445     /* No relocs to apply.  */
13446     return TRUE;
13447
13448   /* Find the reloc section associated with the section.  */
13449   for (relsec = filedata->section_headers;
13450        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13451        ++relsec)
13452     {
13453       bfd_boolean is_rela;
13454       unsigned long num_relocs;
13455       Elf_Internal_Rela * relocs;
13456       Elf_Internal_Rela * rp;
13457       Elf_Internal_Shdr * symsec;
13458       Elf_Internal_Sym * symtab;
13459       unsigned long num_syms;
13460       Elf_Internal_Sym * sym;
13461
13462       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13463           || relsec->sh_info >= filedata->file_header.e_shnum
13464           || filedata->section_headers + relsec->sh_info != section
13465           || relsec->sh_size == 0
13466           || relsec->sh_link >= filedata->file_header.e_shnum)
13467         continue;
13468
13469       symsec = filedata->section_headers + relsec->sh_link;
13470       if (symsec->sh_type != SHT_SYMTAB
13471           && symsec->sh_type != SHT_DYNSYM)
13472         return FALSE;
13473
13474       is_rela = relsec->sh_type == SHT_RELA;
13475
13476       if (is_rela)
13477         {
13478           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13479                                   relsec->sh_size, & relocs, & num_relocs))
13480             return FALSE;
13481         }
13482       else
13483         {
13484           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13485                                  relsec->sh_size, & relocs, & num_relocs))
13486             return FALSE;
13487         }
13488
13489       /* SH uses RELA but uses in place value instead of the addend field.  */
13490       if (filedata->file_header.e_machine == EM_SH)
13491         is_rela = FALSE;
13492
13493       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13494
13495       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13496         {
13497           bfd_vma         addend;
13498           unsigned int    reloc_type;
13499           unsigned int    reloc_size;
13500           bfd_boolean     reloc_inplace = FALSE;
13501           bfd_boolean     reloc_subtract = FALSE;
13502           unsigned char * rloc;
13503           unsigned long   sym_index;
13504
13505           reloc_type = get_reloc_type (filedata, rp->r_info);
13506
13507           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13508             continue;
13509           else if (is_none_reloc (filedata, reloc_type))
13510             continue;
13511           else if (is_32bit_abs_reloc (filedata, reloc_type)
13512                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13513             reloc_size = 4;
13514           else if (is_64bit_abs_reloc (filedata, reloc_type)
13515                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13516             reloc_size = 8;
13517           else if (is_24bit_abs_reloc (filedata, reloc_type))
13518             reloc_size = 3;
13519           else if (is_16bit_abs_reloc (filedata, reloc_type))
13520             reloc_size = 2;
13521           else if (is_8bit_abs_reloc (filedata, reloc_type)
13522                    || is_6bit_abs_reloc (filedata, reloc_type))
13523             reloc_size = 1;
13524           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13525                                                                  reloc_type))
13526                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13527             {
13528               reloc_size = 4;
13529               reloc_inplace = TRUE;
13530             }
13531           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13532                                                                  reloc_type))
13533                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13534             {
13535               reloc_size = 8;
13536               reloc_inplace = TRUE;
13537             }
13538           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13539                                                                  reloc_type))
13540                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13541             {
13542               reloc_size = 2;
13543               reloc_inplace = TRUE;
13544             }
13545           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13546                                                                 reloc_type))
13547                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13548             {
13549               reloc_size = 1;
13550               reloc_inplace = TRUE;
13551             }
13552           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13553                                                                 reloc_type)))
13554             {
13555               reloc_size = 1;
13556               reloc_inplace = TRUE;
13557             }
13558           else
13559             {
13560               static unsigned int prev_reloc = 0;
13561
13562               if (reloc_type != prev_reloc)
13563                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13564                       reloc_type, printable_section_name (filedata, section));
13565               prev_reloc = reloc_type;
13566               continue;
13567             }
13568
13569           rloc = start + rp->r_offset;
13570           if (!IN_RANGE (start, end, rloc, reloc_size))
13571             {
13572               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13573                     (unsigned long) rp->r_offset,
13574                     printable_section_name (filedata, section));
13575               continue;
13576             }
13577
13578           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13579           if (sym_index >= num_syms)
13580             {
13581               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13582                     sym_index, printable_section_name (filedata, section));
13583               continue;
13584             }
13585           sym = symtab + sym_index;
13586
13587           /* If the reloc has a symbol associated with it,
13588              make sure that it is of an appropriate type.
13589
13590              Relocations against symbols without type can happen.
13591              Gcc -feliminate-dwarf2-dups may generate symbols
13592              without type for debug info.
13593
13594              Icc generates relocations against function symbols
13595              instead of local labels.
13596
13597              Relocations against object symbols can happen, eg when
13598              referencing a global array.  For an example of this see
13599              the _clz.o binary in libgcc.a.  */
13600           if (sym != symtab
13601               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13602               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13603             {
13604               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13605                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13606                     printable_section_name (filedata, relsec),
13607                     (long int)(rp - relocs));
13608               continue;
13609             }
13610
13611           addend = 0;
13612           if (is_rela)
13613             addend += rp->r_addend;
13614           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13615              partial_inplace.  */
13616           if (!is_rela
13617               || (filedata->file_header.e_machine == EM_XTENSA
13618                   && reloc_type == 1)
13619               || ((filedata->file_header.e_machine == EM_PJ
13620                    || filedata->file_header.e_machine == EM_PJ_OLD)
13621                   && reloc_type == 1)
13622               || ((filedata->file_header.e_machine == EM_D30V
13623                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13624                   && reloc_type == 12)
13625               || reloc_inplace)
13626             {
13627               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13628                 addend += byte_get (rloc, reloc_size) & 0x3f;
13629               else
13630                 addend += byte_get (rloc, reloc_size);
13631             }
13632
13633           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13634               || is_64bit_pcrel_reloc (filedata, reloc_type))
13635             {
13636               /* On HPPA, all pc-relative relocations are biased by 8.  */
13637               if (filedata->file_header.e_machine == EM_PARISC)
13638                 addend -= 8;
13639               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13640                         reloc_size);
13641             }
13642           else if (is_6bit_abs_reloc (filedata, reloc_type)
13643                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13644             {
13645               if (reloc_subtract)
13646                 addend -= sym->st_value;
13647               else
13648                 addend += sym->st_value;
13649               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13650               byte_put (rloc, addend, reloc_size);
13651             }
13652           else if (reloc_subtract)
13653             byte_put (rloc, addend - sym->st_value, reloc_size);
13654           else
13655             byte_put (rloc, addend + sym->st_value, reloc_size);
13656         }
13657
13658       free (symtab);
13659       /* Let the target specific reloc processing code know that
13660          we have finished with these relocs.  */
13661       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13662
13663       if (relocs_return)
13664         {
13665           * (Elf_Internal_Rela **) relocs_return = relocs;
13666           * num_relocs_return = num_relocs;
13667         }
13668       else
13669         free (relocs);
13670
13671       break;
13672     }
13673
13674   return TRUE;
13675 }
13676
13677 #ifdef SUPPORT_DISASSEMBLY
13678 static bfd_boolean
13679 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13680 {
13681   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13682
13683   /* FIXME: XXX -- to be done --- XXX */
13684
13685   return TRUE;
13686 }
13687 #endif
13688
13689 /* Reads in the contents of SECTION from FILE, returning a pointer
13690    to a malloc'ed buffer or NULL if something went wrong.  */
13691
13692 static char *
13693 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13694 {
13695   bfd_size_type num_bytes = section->sh_size;
13696
13697   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13698     {
13699       printf (_("Section '%s' has no data to dump.\n"),
13700               printable_section_name (filedata, section));
13701       return NULL;
13702     }
13703
13704   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13705                              _("section contents"));
13706 }
13707
13708 /* Uncompresses a section that was compressed using zlib, in place.  */
13709
13710 static bfd_boolean
13711 uncompress_section_contents (unsigned char **   buffer,
13712                              dwarf_size_type    uncompressed_size,
13713                              dwarf_size_type *  size)
13714 {
13715   dwarf_size_type compressed_size = *size;
13716   unsigned char * compressed_buffer = *buffer;
13717   unsigned char * uncompressed_buffer;
13718   z_stream strm;
13719   int rc;
13720
13721   /* It is possible the section consists of several compressed
13722      buffers concatenated together, so we uncompress in a loop.  */
13723   /* PR 18313: The state field in the z_stream structure is supposed
13724      to be invisible to the user (ie us), but some compilers will
13725      still complain about it being used without initialisation.  So
13726      we first zero the entire z_stream structure and then set the fields
13727      that we need.  */
13728   memset (& strm, 0, sizeof strm);
13729   strm.avail_in = compressed_size;
13730   strm.next_in = (Bytef *) compressed_buffer;
13731   strm.avail_out = uncompressed_size;
13732   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13733
13734   rc = inflateInit (& strm);
13735   while (strm.avail_in > 0)
13736     {
13737       if (rc != Z_OK)
13738         goto fail;
13739       strm.next_out = ((Bytef *) uncompressed_buffer
13740                        + (uncompressed_size - strm.avail_out));
13741       rc = inflate (&strm, Z_FINISH);
13742       if (rc != Z_STREAM_END)
13743         goto fail;
13744       rc = inflateReset (& strm);
13745     }
13746   rc = inflateEnd (& strm);
13747   if (rc != Z_OK
13748       || strm.avail_out != 0)
13749     goto fail;
13750
13751   *buffer = uncompressed_buffer;
13752   *size = uncompressed_size;
13753   return TRUE;
13754
13755  fail:
13756   free (uncompressed_buffer);
13757   /* Indicate decompression failure.  */
13758   *buffer = NULL;
13759   return FALSE;
13760 }
13761
13762 static bfd_boolean
13763 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13764 {
13765   Elf_Internal_Shdr *  relsec;
13766   bfd_size_type        num_bytes;
13767   unsigned char *      data;
13768   unsigned char *      end;
13769   unsigned char *      real_start;
13770   unsigned char *      start;
13771   bfd_boolean          some_strings_shown;
13772
13773   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13774   if (start == NULL)
13775     /* PR 21820: Do not fail if the section was empty.  */
13776     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13777
13778   num_bytes = section->sh_size;
13779
13780   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13781
13782   if (decompress_dumps)
13783     {
13784       dwarf_size_type new_size = num_bytes;
13785       dwarf_size_type uncompressed_size = 0;
13786
13787       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13788         {
13789           Elf_Internal_Chdr chdr;
13790           unsigned int compression_header_size
13791             = get_compression_header (& chdr, (unsigned char *) start,
13792                                       num_bytes);
13793           if (compression_header_size == 0)
13794             /* An error message will have already been generated
13795                by get_compression_header.  */
13796             goto error_out;
13797
13798           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13799             {
13800               warn (_("section '%s' has unsupported compress type: %d\n"),
13801                     printable_section_name (filedata, section), chdr.ch_type);
13802               goto error_out;
13803             }
13804           uncompressed_size = chdr.ch_size;
13805           start += compression_header_size;
13806           new_size -= compression_header_size;
13807         }
13808       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13809         {
13810           /* Read the zlib header.  In this case, it should be "ZLIB"
13811              followed by the uncompressed section size, 8 bytes in
13812              big-endian order.  */
13813           uncompressed_size = start[4]; uncompressed_size <<= 8;
13814           uncompressed_size += start[5]; uncompressed_size <<= 8;
13815           uncompressed_size += start[6]; uncompressed_size <<= 8;
13816           uncompressed_size += start[7]; uncompressed_size <<= 8;
13817           uncompressed_size += start[8]; uncompressed_size <<= 8;
13818           uncompressed_size += start[9]; uncompressed_size <<= 8;
13819           uncompressed_size += start[10]; uncompressed_size <<= 8;
13820           uncompressed_size += start[11];
13821           start += 12;
13822           new_size -= 12;
13823         }
13824
13825       if (uncompressed_size)
13826         {
13827           if (uncompress_section_contents (& start,
13828                                            uncompressed_size, & new_size))
13829             num_bytes = new_size;
13830           else
13831             {
13832               error (_("Unable to decompress section %s\n"),
13833                      printable_section_name (filedata, section));
13834               goto error_out;
13835             }
13836         }
13837       else
13838         start = real_start;
13839     }
13840
13841   /* If the section being dumped has relocations against it the user might
13842      be expecting these relocations to have been applied.  Check for this
13843      case and issue a warning message in order to avoid confusion.
13844      FIXME: Maybe we ought to have an option that dumps a section with
13845      relocs applied ?  */
13846   for (relsec = filedata->section_headers;
13847        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13848        ++relsec)
13849     {
13850       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13851           || relsec->sh_info >= filedata->file_header.e_shnum
13852           || filedata->section_headers + relsec->sh_info != section
13853           || relsec->sh_size == 0
13854           || relsec->sh_link >= filedata->file_header.e_shnum)
13855         continue;
13856
13857       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13858       break;
13859     }
13860
13861   data = start;
13862   end  = start + num_bytes;
13863   some_strings_shown = FALSE;
13864
13865 #ifdef HAVE_MBSTATE_T
13866   mbstate_t state;
13867   /* Initialise the multibyte conversion state.  */
13868   memset (& state, 0, sizeof (state));
13869 #endif
13870
13871   bfd_boolean continuing = FALSE;
13872
13873   while (data < end)
13874     {
13875       while (!ISPRINT (* data))
13876         if (++ data >= end)
13877           break;
13878
13879       if (data < end)
13880         {
13881           size_t maxlen = end - data;
13882
13883           if (continuing)
13884             {
13885               printf ("            ");
13886               continuing = FALSE;
13887             }
13888           else
13889             {
13890 #ifndef __MSVCRT__
13891               /* PR 11128: Use two separate invocations in order to work
13892                  around bugs in the Solaris 8 implementation of printf.  */
13893               printf ("  [%6tx]  ", data - start);
13894 #else
13895               printf ("  [%6Ix]  ", (size_t) (data - start));
13896 #endif
13897             }
13898
13899           if (maxlen > 0)
13900             {
13901               char c;
13902
13903               while (maxlen)
13904                 {
13905                   c = *data++;
13906
13907                   if (c == 0)
13908                     break;
13909
13910                   /* PR 25543: Treat new-lines as string-ending characters.  */
13911                   if (c == '\n')
13912                     {
13913                       printf ("\\n\n");
13914                       if (*data != 0)
13915                         continuing = TRUE;
13916                       break;
13917                     }
13918
13919                   /* Do not print control characters directly as they can affect terminal
13920                      settings.  Such characters usually appear in the names generated
13921                      by the assembler for local labels.  */
13922                   if (ISCNTRL (c))
13923                     {
13924                       printf ("^%c", c + 0x40);
13925                     }
13926                   else if (ISPRINT (c))
13927                     {
13928                       putchar (c);
13929                     }
13930                   else
13931                     {
13932                       size_t  n;
13933 #ifdef HAVE_MBSTATE_T
13934                       wchar_t w;
13935 #endif
13936                       /* Let printf do the hard work of displaying multibyte characters.  */
13937                       printf ("%.1s", data - 1);
13938 #ifdef HAVE_MBSTATE_T
13939                       /* Try to find out how many bytes made up the character that was
13940                          just printed.  Advance the symbol pointer past the bytes that
13941                          were displayed.  */
13942                       n = mbrtowc (& w, (char *)(data - 1), MB_CUR_MAX, & state);
13943 #else
13944                       n = 1;
13945 #endif
13946                       if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
13947                         data += (n - 1);
13948                     }
13949                 }
13950
13951               if (c != '\n')
13952                 putchar ('\n');
13953             }
13954           else
13955             {
13956               printf (_("<corrupt>\n"));
13957               data = end;
13958             }
13959           some_strings_shown = TRUE;
13960         }
13961     }
13962
13963   if (! some_strings_shown)
13964     printf (_("  No strings found in this section."));
13965
13966   free (real_start);
13967
13968   putchar ('\n');
13969   return TRUE;
13970
13971 error_out:
13972   free (real_start);
13973   return FALSE;
13974 }
13975
13976 static bfd_boolean
13977 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13978                        Filedata *           filedata,
13979                        bfd_boolean          relocate)
13980 {
13981   Elf_Internal_Shdr * relsec;
13982   bfd_size_type       bytes;
13983   bfd_size_type       section_size;
13984   bfd_vma             addr;
13985   unsigned char *     data;
13986   unsigned char *     real_start;
13987   unsigned char *     start;
13988
13989   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13990   if (start == NULL)
13991     /* PR 21820: Do not fail if the section was empty.  */
13992     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13993
13994   section_size = section->sh_size;
13995
13996   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13997
13998   if (decompress_dumps)
13999     {
14000       dwarf_size_type new_size = section_size;
14001       dwarf_size_type uncompressed_size = 0;
14002
14003       if ((section->sh_flags & SHF_COMPRESSED) != 0)
14004         {
14005           Elf_Internal_Chdr chdr;
14006           unsigned int compression_header_size
14007             = get_compression_header (& chdr, start, section_size);
14008
14009           if (compression_header_size == 0)
14010             /* An error message will have already been generated
14011                by get_compression_header.  */
14012             goto error_out;
14013
14014           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
14015             {
14016               warn (_("section '%s' has unsupported compress type: %d\n"),
14017                     printable_section_name (filedata, section), chdr.ch_type);
14018               goto error_out;
14019             }
14020           uncompressed_size = chdr.ch_size;
14021           start += compression_header_size;
14022           new_size -= compression_header_size;
14023         }
14024       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
14025         {
14026           /* Read the zlib header.  In this case, it should be "ZLIB"
14027              followed by the uncompressed section size, 8 bytes in
14028              big-endian order.  */
14029           uncompressed_size = start[4]; uncompressed_size <<= 8;
14030           uncompressed_size += start[5]; uncompressed_size <<= 8;
14031           uncompressed_size += start[6]; uncompressed_size <<= 8;
14032           uncompressed_size += start[7]; uncompressed_size <<= 8;
14033           uncompressed_size += start[8]; uncompressed_size <<= 8;
14034           uncompressed_size += start[9]; uncompressed_size <<= 8;
14035           uncompressed_size += start[10]; uncompressed_size <<= 8;
14036           uncompressed_size += start[11];
14037           start += 12;
14038           new_size -= 12;
14039         }
14040
14041       if (uncompressed_size)
14042         {
14043           if (uncompress_section_contents (& start, uncompressed_size,
14044                                            & new_size))
14045             {
14046               section_size = new_size;
14047             }
14048           else
14049             {
14050               error (_("Unable to decompress section %s\n"),
14051                      printable_section_name (filedata, section));
14052               /* FIXME: Print the section anyway ?  */
14053               goto error_out;
14054             }
14055         }
14056       else
14057         start = real_start;
14058     }
14059
14060   if (relocate)
14061     {
14062       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
14063         goto error_out;
14064     }
14065   else
14066     {
14067       /* If the section being dumped has relocations against it the user might
14068          be expecting these relocations to have been applied.  Check for this
14069          case and issue a warning message in order to avoid confusion.
14070          FIXME: Maybe we ought to have an option that dumps a section with
14071          relocs applied ?  */
14072       for (relsec = filedata->section_headers;
14073            relsec < filedata->section_headers + filedata->file_header.e_shnum;
14074            ++relsec)
14075         {
14076           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
14077               || relsec->sh_info >= filedata->file_header.e_shnum
14078               || filedata->section_headers + relsec->sh_info != section
14079               || relsec->sh_size == 0
14080               || relsec->sh_link >= filedata->file_header.e_shnum)
14081             continue;
14082
14083           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14084           break;
14085         }
14086     }
14087
14088   addr = section->sh_addr;
14089   bytes = section_size;
14090   data = start;
14091
14092   while (bytes)
14093     {
14094       int j;
14095       int k;
14096       int lbytes;
14097
14098       lbytes = (bytes > 16 ? 16 : bytes);
14099
14100       printf ("  0x%8.8lx ", (unsigned long) addr);
14101
14102       for (j = 0; j < 16; j++)
14103         {
14104           if (j < lbytes)
14105             printf ("%2.2x", data[j]);
14106           else
14107             printf ("  ");
14108
14109           if ((j & 3) == 3)
14110             printf (" ");
14111         }
14112
14113       for (j = 0; j < lbytes; j++)
14114         {
14115           k = data[j];
14116           if (k >= ' ' && k < 0x7f)
14117             printf ("%c", k);
14118           else
14119             printf (".");
14120         }
14121
14122       putchar ('\n');
14123
14124       data  += lbytes;
14125       addr  += lbytes;
14126       bytes -= lbytes;
14127     }
14128
14129   free (real_start);
14130
14131   putchar ('\n');
14132   return TRUE;
14133
14134  error_out:
14135   free (real_start);
14136   return FALSE;
14137 }
14138
14139 #ifdef ENABLE_LIBCTF
14140 static ctf_sect_t *
14141 shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata)
14142 {
14143   buf->cts_name = SECTION_NAME (shdr);
14144   buf->cts_size = shdr->sh_size;
14145   buf->cts_entsize = shdr->sh_entsize;
14146
14147   return buf;
14148 }
14149
14150 /* Formatting callback function passed to ctf_dump.  Returns either the pointer
14151    it is passed, or a pointer to newly-allocated storage, in which case
14152    dump_ctf() will free it when it no longer needs it.  */
14153
14154 static char *
14155 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
14156                        char *s, void *arg)
14157 {
14158   const char *blanks = arg;
14159   char *new_s;
14160
14161   if (asprintf (&new_s, "%s%s", blanks, s) < 0)
14162     return s;
14163   return new_s;
14164 }
14165
14166 /* Dump one CTF archive member.  */
14167
14168 static int
14169 dump_ctf_archive_member (ctf_file_t *ctf, const char *name, void *arg)
14170 {
14171   ctf_file_t *parent = (ctf_file_t *) arg;
14172   const char *things[] = {"Header", "Labels", "Data objects",
14173                           "Function objects", "Variables", "Types", "Strings",
14174                           ""};
14175   const char **thing;
14176   size_t i;
14177
14178   /* Only print out the name of non-default-named archive members.
14179      The name .ctf appears everywhere, even for things that aren't
14180      really archives, so printing it out is liable to be confusing.
14181
14182      The parent, if there is one, is the default-owned archive member:
14183      avoid importing it into itself.  (This does no harm, but looks
14184      confusing.)  */
14185
14186   if (strcmp (name, ".ctf") != 0)
14187     {
14188       printf (_("\nCTF archive member: %s:\n"), name);
14189       ctf_import (ctf, parent);
14190     }
14191
14192   for (i = 0, thing = things; *thing[0]; thing++, i++)
14193     {
14194       ctf_dump_state_t *s = NULL;
14195       char *item;
14196
14197       printf ("\n  %s:\n", *thing);
14198       while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
14199                                (void *) "    ")) != NULL)
14200         {
14201           printf ("%s\n", item);
14202           free (item);
14203         }
14204
14205       if (ctf_errno (ctf))
14206         {
14207           error (_("Iteration failed: %s, %s\n"), *thing,
14208                  ctf_errmsg (ctf_errno (ctf)));
14209           return 1;
14210         }
14211     }
14212   return 0;
14213 }
14214
14215 static bfd_boolean
14216 dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
14217 {
14218   Elf_Internal_Shdr *  parent_sec = NULL;
14219   Elf_Internal_Shdr *  symtab_sec = NULL;
14220   Elf_Internal_Shdr *  strtab_sec = NULL;
14221   void *               data = NULL;
14222   void *               symdata = NULL;
14223   void *               strdata = NULL;
14224   void *               parentdata = NULL;
14225   ctf_sect_t           ctfsect, symsect, strsect, parentsect;
14226   ctf_sect_t *         symsectp = NULL;
14227   ctf_sect_t *         strsectp = NULL;
14228   ctf_archive_t *      ctfa = NULL;
14229   ctf_archive_t *      parenta = NULL, *lookparent;
14230   ctf_file_t *         parent = NULL;
14231
14232   int err;
14233   bfd_boolean ret = FALSE;
14234
14235   shdr_to_ctf_sect (&ctfsect, section, filedata);
14236   data = get_section_contents (section, filedata);
14237   ctfsect.cts_data = data;
14238
14239   if (!dump_ctf_symtab_name)
14240     dump_ctf_symtab_name = strdup (".symtab");
14241
14242   if (!dump_ctf_strtab_name)
14243     dump_ctf_strtab_name = strdup (".strtab");
14244
14245   if (dump_ctf_symtab_name && dump_ctf_symtab_name[0] != 0)
14246     {
14247       if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL)
14248         {
14249           error (_("No symbol section named %s\n"), dump_ctf_symtab_name);
14250           goto fail;
14251         }
14252       if ((symdata = (void *) get_data (NULL, filedata,
14253                                         symtab_sec->sh_offset, 1,
14254                                         symtab_sec->sh_size,
14255                                         _("symbols"))) == NULL)
14256         goto fail;
14257       symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
14258       symsect.cts_data = symdata;
14259     }
14260   if (dump_ctf_strtab_name && dump_ctf_symtab_name[0] != 0)
14261     {
14262       if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
14263         {
14264           error (_("No string table section named %s\n"),
14265                  dump_ctf_strtab_name);
14266           goto fail;
14267         }
14268       if ((strdata = (void *) get_data (NULL, filedata,
14269                                         strtab_sec->sh_offset, 1,
14270                                         strtab_sec->sh_size,
14271                                         _("strings"))) == NULL)
14272         goto fail;
14273       strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata);
14274       strsect.cts_data = strdata;
14275     }
14276   if (dump_ctf_parent_name)
14277     {
14278       if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL)
14279         {
14280           error (_("No CTF parent section named %s\n"), dump_ctf_parent_name);
14281           goto fail;
14282         }
14283       if ((parentdata = (void *) get_data (NULL, filedata,
14284                                            parent_sec->sh_offset, 1,
14285                                            parent_sec->sh_size,
14286                                            _("CTF parent"))) == NULL)
14287         goto fail;
14288       shdr_to_ctf_sect (&parentsect, parent_sec, filedata);
14289       parentsect.cts_data = parentdata;
14290     }
14291
14292   /* Load the CTF file and dump it.  It may be a raw CTF section, or an archive:
14293      libctf papers over the difference, so we can pretend it is always an
14294      archive.  Possibly open the parent as well, if one was specified.  */
14295
14296   if ((ctfa = ctf_arc_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL)
14297     {
14298       error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14299       goto fail;
14300     }
14301
14302   if (parentdata)
14303     {
14304       if ((parenta = ctf_arc_bufopen (&parentsect, symsectp, strsectp,
14305                                       &err)) == NULL)
14306         {
14307           error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14308           goto fail;
14309         }
14310       lookparent = parenta;
14311     }
14312   else
14313     lookparent = ctfa;
14314
14315   /* Assume that the applicable parent archive member is the default one.
14316      (This is what all known implementations are expected to do, if they
14317      put CTFs and their parents in archives together.)  */
14318   if ((parent = ctf_arc_open_by_name (lookparent, NULL, &err)) == NULL)
14319     {
14320       error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14321       goto fail;
14322     }
14323
14324   ret = TRUE;
14325
14326   printf (_("\nDump of CTF section '%s':\n"),
14327           printable_section_name (filedata, section));
14328
14329   if (ctf_archive_iter (ctfa, dump_ctf_archive_member, parent) != 0)
14330     ret = FALSE;
14331
14332  fail:
14333   ctf_file_close (parent);
14334   ctf_close (ctfa);
14335   ctf_close (parenta);
14336   free (parentdata);
14337   free (data);
14338   free (symdata);
14339   free (strdata);
14340   return ret;
14341 }
14342 #endif
14343
14344 static bfd_boolean
14345 load_specific_debug_section (enum dwarf_section_display_enum  debug,
14346                              const Elf_Internal_Shdr *        sec,
14347                              void *                           data)
14348 {
14349   struct dwarf_section * section = &debug_displays [debug].section;
14350   char buf [64];
14351   Filedata * filedata = (Filedata *) data;
14352
14353   if (section->start != NULL)
14354     {
14355       /* If it is already loaded, do nothing.  */
14356       if (streq (section->filename, filedata->file_name))
14357         return TRUE;
14358       free (section->start);
14359     }
14360
14361   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
14362   section->address = sec->sh_addr;
14363   section->user_data = NULL;
14364   section->filename = filedata->file_name;
14365   section->start = (unsigned char *) get_data (NULL, filedata,
14366                                                sec->sh_offset, 1,
14367                                                sec->sh_size, buf);
14368   if (section->start == NULL)
14369     section->size = 0;
14370   else
14371     {
14372       unsigned char *start = section->start;
14373       dwarf_size_type size = sec->sh_size;
14374       dwarf_size_type uncompressed_size = 0;
14375
14376       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
14377         {
14378           Elf_Internal_Chdr chdr;
14379           unsigned int compression_header_size;
14380
14381           if (size < (is_32bit_elf
14382                       ? sizeof (Elf32_External_Chdr)
14383                       : sizeof (Elf64_External_Chdr)))
14384             {
14385               warn (_("compressed section %s is too small to contain a compression header\n"),
14386                     section->name);
14387               return FALSE;
14388             }
14389
14390           compression_header_size = get_compression_header (&chdr, start, size);
14391           if (compression_header_size == 0)
14392             /* An error message will have already been generated
14393                by get_compression_header.  */
14394             return FALSE;
14395
14396           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
14397             {
14398               warn (_("section '%s' has unsupported compress type: %d\n"),
14399                     section->name, chdr.ch_type);
14400               return FALSE;
14401             }
14402           uncompressed_size = chdr.ch_size;
14403           start += compression_header_size;
14404           size -= compression_header_size;
14405         }
14406       else if (size > 12 && streq ((char *) start, "ZLIB"))
14407         {
14408           /* Read the zlib header.  In this case, it should be "ZLIB"
14409              followed by the uncompressed section size, 8 bytes in
14410              big-endian order.  */
14411           uncompressed_size = start[4]; uncompressed_size <<= 8;
14412           uncompressed_size += start[5]; uncompressed_size <<= 8;
14413           uncompressed_size += start[6]; uncompressed_size <<= 8;
14414           uncompressed_size += start[7]; uncompressed_size <<= 8;
14415           uncompressed_size += start[8]; uncompressed_size <<= 8;
14416           uncompressed_size += start[9]; uncompressed_size <<= 8;
14417           uncompressed_size += start[10]; uncompressed_size <<= 8;
14418           uncompressed_size += start[11];
14419           start += 12;
14420           size -= 12;
14421         }
14422
14423       if (uncompressed_size)
14424         {
14425           if (uncompress_section_contents (&start, uncompressed_size,
14426                                            &size))
14427             {
14428               /* Free the compressed buffer, update the section buffer
14429                  and the section size if uncompress is successful.  */
14430               free (section->start);
14431               section->start = start;
14432             }
14433           else
14434             {
14435               error (_("Unable to decompress section %s\n"),
14436                      printable_section_name (filedata, sec));
14437               return FALSE;
14438             }
14439         }
14440
14441       section->size = size;
14442     }
14443
14444   if (section->start == NULL)
14445     return FALSE;
14446
14447   if (debug_displays [debug].relocate)
14448     {
14449       if (! apply_relocations (filedata, sec, section->start, section->size,
14450                                & section->reloc_info, & section->num_relocs))
14451         return FALSE;
14452     }
14453   else
14454     {
14455       section->reloc_info = NULL;
14456       section->num_relocs = 0;
14457     }
14458
14459   return TRUE;
14460 }
14461
14462 #if HAVE_LIBDEBUGINFOD
14463 /* Return a hex string representation of the build-id.  */
14464 unsigned char *
14465 get_build_id (void * data)
14466 {
14467   Filedata * filedata = (Filedata *)data;
14468   Elf_Internal_Shdr * shdr;
14469   unsigned long i;
14470
14471   /* Iterate through notes to find note.gnu.build-id.
14472      FIXME: Only the first note in any note section is examined.  */
14473   for (i = 0, shdr = filedata->section_headers;
14474        i < filedata->file_header.e_shnum && shdr != NULL;
14475        i++, shdr++)
14476     {
14477       if (shdr->sh_type != SHT_NOTE)
14478         continue;
14479
14480       char * next;
14481       char * end;
14482       size_t data_remaining;
14483       size_t min_notesz;
14484       Elf_External_Note * enote;
14485       Elf_Internal_Note inote;
14486
14487       bfd_vma offset = shdr->sh_offset;
14488       bfd_vma align = shdr->sh_addralign;
14489       bfd_vma length = shdr->sh_size;
14490
14491       enote = (Elf_External_Note *) get_section_contents (shdr, filedata);
14492       if (enote == NULL)
14493         continue;
14494
14495       if (align < 4)
14496         align = 4;
14497       else if (align != 4 && align != 8)
14498         {
14499           free (enote);
14500           continue;
14501         }
14502
14503       end = (char *) enote + length;
14504       data_remaining = end - (char *) enote;
14505
14506       if (!is_ia64_vms (filedata))
14507         {
14508           min_notesz = offsetof (Elf_External_Note, name);
14509           if (data_remaining < min_notesz)
14510             {
14511               warn (_("\
14512 malformed note encountered in section %s whilst scanning for build-id note\n"),
14513                     printable_section_name (filedata, shdr));
14514               free (enote);
14515               continue;
14516             }
14517           data_remaining -= min_notesz;
14518
14519           inote.type     = BYTE_GET (enote->type);
14520           inote.namesz   = BYTE_GET (enote->namesz);
14521           inote.namedata = enote->name;
14522           inote.descsz   = BYTE_GET (enote->descsz);
14523           inote.descdata = ((char *) enote
14524                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
14525           inote.descpos  = offset + (inote.descdata - (char *) enote);
14526           next = ((char *) enote
14527                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
14528         }
14529       else
14530         {
14531           Elf64_External_VMS_Note *vms_enote;
14532
14533           /* PR binutils/15191
14534              Make sure that there is enough data to read.  */
14535           min_notesz = offsetof (Elf64_External_VMS_Note, name);
14536           if (data_remaining < min_notesz)
14537             {
14538               warn (_("\
14539 malformed note encountered in section %s whilst scanning for build-id note\n"),
14540                     printable_section_name (filedata, shdr));
14541               free (enote);
14542               continue;
14543             }
14544           data_remaining -= min_notesz;
14545
14546           vms_enote = (Elf64_External_VMS_Note *) enote;
14547           inote.type     = BYTE_GET (vms_enote->type);
14548           inote.namesz   = BYTE_GET (vms_enote->namesz);
14549           inote.namedata = vms_enote->name;
14550           inote.descsz   = BYTE_GET (vms_enote->descsz);
14551           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14552           inote.descpos  = offset + (inote.descdata - (char *) enote);
14553           next = inote.descdata + align_power (inote.descsz, 3);
14554         }
14555
14556       /* Skip malformed notes.  */
14557       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
14558           || (size_t) (inote.descdata - inote.namedata) > data_remaining
14559           || (size_t) (next - inote.descdata) < inote.descsz
14560           || ((size_t) (next - inote.descdata)
14561               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
14562         {
14563           warn (_("\
14564 malformed note encountered in section %s whilst scanning for build-id note\n"),
14565                 printable_section_name (filedata, shdr));
14566           free (enote);
14567           continue;
14568         }
14569
14570       /* Check if this is the build-id note. If so then convert the build-id
14571          bytes to a hex string.  */
14572       if (inote.namesz > 0
14573           && const_strneq (inote.namedata, "GNU")
14574           && inote.type == NT_GNU_BUILD_ID)
14575         {
14576           unsigned long j;
14577           char * build_id;
14578
14579           build_id = malloc (inote.descsz * 2 + 1);
14580           if (build_id == NULL)
14581             {
14582               free (enote);
14583               return NULL;
14584             }
14585
14586           for (j = 0; j < inote.descsz; ++j)
14587             sprintf (build_id + (j * 2), "%02x", inote.descdata[j] & 0xff);
14588           build_id[inote.descsz * 2] = '\0';
14589           free (enote);
14590
14591           return (unsigned char *) build_id;
14592         }
14593       free (enote);
14594     }
14595
14596   return NULL;
14597 }
14598 #endif /* HAVE_LIBDEBUGINFOD */
14599
14600 /* If this is not NULL, load_debug_section will only look for sections
14601    within the list of sections given here.  */
14602 static unsigned int * section_subset = NULL;
14603
14604 bfd_boolean
14605 load_debug_section (enum dwarf_section_display_enum debug, void * data)
14606 {
14607   struct dwarf_section * section = &debug_displays [debug].section;
14608   Elf_Internal_Shdr * sec;
14609   Filedata * filedata = (Filedata *) data;
14610
14611   /* Without section headers we cannot find any sections.  */
14612   if (filedata->section_headers == NULL)
14613     return FALSE;
14614
14615   if (filedata->string_table == NULL
14616       && filedata->file_header.e_shstrndx != SHN_UNDEF
14617       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
14618     {
14619       Elf_Internal_Shdr * strs;
14620
14621       /* Read in the string table, so that we have section names to scan.  */
14622       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
14623
14624       if (strs != NULL && strs->sh_size != 0)
14625         {
14626           filedata->string_table
14627             = (char *) get_data (NULL, filedata, strs->sh_offset,
14628                                  1, strs->sh_size, _("string table"));
14629
14630           filedata->string_table_length
14631             = filedata->string_table != NULL ? strs->sh_size : 0;
14632         }
14633     }
14634
14635   /* Locate the debug section.  */
14636   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
14637   if (sec != NULL)
14638     section->name = section->uncompressed_name;
14639   else
14640     {
14641       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
14642       if (sec != NULL)
14643         section->name = section->compressed_name;
14644     }
14645   if (sec == NULL)
14646     return FALSE;
14647
14648   /* If we're loading from a subset of sections, and we've loaded
14649      a section matching this name before, it's likely that it's a
14650      different one.  */
14651   if (section_subset != NULL)
14652     free_debug_section (debug);
14653
14654   return load_specific_debug_section (debug, sec, data);
14655 }
14656
14657 void
14658 free_debug_section (enum dwarf_section_display_enum debug)
14659 {
14660   struct dwarf_section * section = &debug_displays [debug].section;
14661
14662   if (section->start == NULL)
14663     return;
14664
14665   free ((char *) section->start);
14666   section->start = NULL;
14667   section->address = 0;
14668   section->size = 0;
14669
14670   free (section->reloc_info);
14671   section->reloc_info = NULL;
14672   section->num_relocs = 0;
14673 }
14674
14675 static bfd_boolean
14676 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
14677 {
14678   char * name = SECTION_NAME (section);
14679   const char * print_name = printable_section_name (filedata, section);
14680   bfd_size_type length;
14681   bfd_boolean result = TRUE;
14682   int i;
14683
14684   length = section->sh_size;
14685   if (length == 0)
14686     {
14687       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
14688       return TRUE;
14689     }
14690   if (section->sh_type == SHT_NOBITS)
14691     {
14692       /* There is no point in dumping the contents of a debugging section
14693          which has the NOBITS type - the bits in the file will be random.
14694          This can happen when a file containing a .eh_frame section is
14695          stripped with the --only-keep-debug command line option.  */
14696       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14697               print_name);
14698       return FALSE;
14699     }
14700
14701   if (const_strneq (name, ".gnu.linkonce.wi."))
14702     name = ".debug_info";
14703
14704   /* See if we know how to display the contents of this section.  */
14705   for (i = 0; i < max; i++)
14706     {
14707       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
14708       struct dwarf_section_display *   display = debug_displays + i;
14709       struct dwarf_section *           sec = & display->section;
14710
14711       if (streq (sec->uncompressed_name, name)
14712           || (id == line && const_strneq (name, ".debug_line."))
14713           || streq (sec->compressed_name, name))
14714         {
14715           bfd_boolean secondary = (section != find_section (filedata, name));
14716
14717           if (secondary)
14718             free_debug_section (id);
14719
14720           if (i == line && const_strneq (name, ".debug_line."))
14721             sec->name = name;
14722           else if (streq (sec->uncompressed_name, name))
14723             sec->name = sec->uncompressed_name;
14724           else
14725             sec->name = sec->compressed_name;
14726
14727           if (load_specific_debug_section (id, section, filedata))
14728             {
14729               /* If this debug section is part of a CU/TU set in a .dwp file,
14730                  restrict load_debug_section to the sections in that set.  */
14731               section_subset = find_cu_tu_set (filedata, shndx);
14732
14733               result &= display->display (sec, filedata);
14734
14735               section_subset = NULL;
14736
14737               if (secondary || (id != info && id != abbrev))
14738                 free_debug_section (id);
14739             }
14740           break;
14741         }
14742     }
14743
14744   if (i == max)
14745     {
14746       printf (_("Unrecognized debug section: %s\n"), print_name);
14747       result = FALSE;
14748     }
14749
14750   return result;
14751 }
14752
14753 /* Set DUMP_SECTS for all sections where dumps were requested
14754    based on section name.  */
14755
14756 static void
14757 initialise_dumps_byname (Filedata * filedata)
14758 {
14759   struct dump_list_entry * cur;
14760
14761   for (cur = dump_sects_byname; cur; cur = cur->next)
14762     {
14763       unsigned int i;
14764       bfd_boolean any = FALSE;
14765
14766       for (i = 0; i < filedata->file_header.e_shnum; i++)
14767         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
14768           {
14769             request_dump_bynumber (&filedata->dump, i, cur->type);
14770             any = TRUE;
14771           }
14772
14773       if (!any)
14774         warn (_("Section '%s' was not dumped because it does not exist!\n"),
14775               cur->name);
14776     }
14777 }
14778
14779 static bfd_boolean
14780 process_section_contents (Filedata * filedata)
14781 {
14782   Elf_Internal_Shdr * section;
14783   unsigned int i;
14784   bfd_boolean res = TRUE;
14785
14786   if (! do_dump)
14787     return TRUE;
14788
14789   initialise_dumps_byname (filedata);
14790
14791   for (i = 0, section = filedata->section_headers;
14792        i < filedata->file_header.e_shnum && i < filedata->dump.num_dump_sects;
14793        i++, section++)
14794     {
14795       dump_type dump = filedata->dump.dump_sects[i];
14796
14797 #ifdef SUPPORT_DISASSEMBLY
14798       if (dump & DISASS_DUMP)
14799         {
14800           if (! disassemble_section (section, filedata))
14801             res = FALSE;
14802         }
14803 #endif
14804       if (dump & HEX_DUMP)
14805         {
14806           if (! dump_section_as_bytes (section, filedata, FALSE))
14807             res = FALSE;
14808         }
14809
14810       if (dump & RELOC_DUMP)
14811         {
14812           if (! dump_section_as_bytes (section, filedata, TRUE))
14813             res = FALSE;
14814         }
14815
14816       if (dump & STRING_DUMP)
14817         {
14818           if (! dump_section_as_strings (section, filedata))
14819             res = FALSE;
14820         }
14821
14822       if (dump & DEBUG_DUMP)
14823         {
14824           if (! display_debug_section (i, section, filedata))
14825             res = FALSE;
14826         }
14827
14828 #ifdef ENABLE_LIBCTF
14829       if (dump & CTF_DUMP)
14830         {
14831           if (! dump_section_as_ctf (section, filedata))
14832             res = FALSE;
14833         }
14834 #endif
14835     }
14836
14837   /* Check to see if the user requested a
14838      dump of a section that does not exist.  */
14839   while (i < filedata->dump.num_dump_sects)
14840     {
14841       if (filedata->dump.dump_sects[i])
14842         {
14843           warn (_("Section %d was not dumped because it does not exist!\n"), i);
14844           res = FALSE;
14845         }
14846       i++;
14847     }
14848
14849   return res;
14850 }
14851
14852 static void
14853 process_mips_fpe_exception (int mask)
14854 {
14855   if (mask)
14856     {
14857       bfd_boolean first = TRUE;
14858
14859       if (mask & OEX_FPU_INEX)
14860         fputs ("INEX", stdout), first = FALSE;
14861       if (mask & OEX_FPU_UFLO)
14862         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14863       if (mask & OEX_FPU_OFLO)
14864         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14865       if (mask & OEX_FPU_DIV0)
14866         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14867       if (mask & OEX_FPU_INVAL)
14868         printf ("%sINVAL", first ? "" : "|");
14869     }
14870   else
14871     fputs ("0", stdout);
14872 }
14873
14874 /* Display's the value of TAG at location P.  If TAG is
14875    greater than 0 it is assumed to be an unknown tag, and
14876    a message is printed to this effect.  Otherwise it is
14877    assumed that a message has already been printed.
14878
14879    If the bottom bit of TAG is set it assumed to have a
14880    string value, otherwise it is assumed to have an integer
14881    value.
14882
14883    Returns an updated P pointing to the first unread byte
14884    beyond the end of TAG's value.
14885
14886    Reads at or beyond END will not be made.  */
14887
14888 static unsigned char *
14889 display_tag_value (signed int tag,
14890                    unsigned char * p,
14891                    const unsigned char * const end)
14892 {
14893   unsigned long val;
14894
14895   if (tag > 0)
14896     printf ("  Tag_unknown_%d: ", tag);
14897
14898   if (p >= end)
14899     {
14900       warn (_("<corrupt tag>\n"));
14901     }
14902   else if (tag & 1)
14903     {
14904       /* PR 17531 file: 027-19978-0.004.  */
14905       size_t maxlen = (end - p) - 1;
14906
14907       putchar ('"');
14908       if (maxlen > 0)
14909         {
14910           print_symbol ((int) maxlen, (const char *) p);
14911           p += strnlen ((char *) p, maxlen) + 1;
14912         }
14913       else
14914         {
14915           printf (_("<corrupt string tag>"));
14916           p = (unsigned char *) end;
14917         }
14918       printf ("\"\n");
14919     }
14920   else
14921     {
14922       READ_ULEB (val, p, end);
14923       printf ("%ld (0x%lx)\n", val, val);
14924     }
14925
14926   assert (p <= end);
14927   return p;
14928 }
14929
14930 /* ARC ABI attributes section.  */
14931
14932 static unsigned char *
14933 display_arc_attribute (unsigned char * p,
14934                        const unsigned char * const end)
14935 {
14936   unsigned int tag;
14937   unsigned int val;
14938
14939   READ_ULEB (tag, p, end);
14940
14941   switch (tag)
14942     {
14943     case Tag_ARC_PCS_config:
14944       READ_ULEB (val, p, end);
14945       printf ("  Tag_ARC_PCS_config: ");
14946       switch (val)
14947         {
14948         case 0:
14949           printf (_("Absent/Non standard\n"));
14950           break;
14951         case 1:
14952           printf (_("Bare metal/mwdt\n"));
14953           break;
14954         case 2:
14955           printf (_("Bare metal/newlib\n"));
14956           break;
14957         case 3:
14958           printf (_("Linux/uclibc\n"));
14959           break;
14960         case 4:
14961           printf (_("Linux/glibc\n"));
14962           break;
14963         default:
14964           printf (_("Unknown\n"));
14965           break;
14966         }
14967       break;
14968
14969     case Tag_ARC_CPU_base:
14970       READ_ULEB (val, p, end);
14971       printf ("  Tag_ARC_CPU_base: ");
14972       switch (val)
14973         {
14974         default:
14975         case TAG_CPU_NONE:
14976           printf (_("Absent\n"));
14977           break;
14978         case TAG_CPU_ARC6xx:
14979           printf ("ARC6xx\n");
14980           break;
14981         case TAG_CPU_ARC7xx:
14982           printf ("ARC7xx\n");
14983           break;
14984         case TAG_CPU_ARCEM:
14985           printf ("ARCEM\n");
14986           break;
14987         case TAG_CPU_ARCHS:
14988           printf ("ARCHS\n");
14989           break;
14990         }
14991       break;
14992
14993     case Tag_ARC_CPU_variation:
14994       READ_ULEB (val, p, end);
14995       printf ("  Tag_ARC_CPU_variation: ");
14996       switch (val)
14997         {
14998         default:
14999           if (val > 0 && val < 16)
15000               printf ("Core%d\n", val);
15001           else
15002               printf ("Unknown\n");
15003           break;
15004
15005         case 0:
15006           printf (_("Absent\n"));
15007           break;
15008         }
15009       break;
15010
15011     case Tag_ARC_CPU_name:
15012       printf ("  Tag_ARC_CPU_name: ");
15013       p = display_tag_value (-1, p, end);
15014       break;
15015
15016     case Tag_ARC_ABI_rf16:
15017       READ_ULEB (val, p, end);
15018       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
15019       break;
15020
15021     case Tag_ARC_ABI_osver:
15022       READ_ULEB (val, p, end);
15023       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
15024       break;
15025
15026     case Tag_ARC_ABI_pic:
15027     case Tag_ARC_ABI_sda:
15028       READ_ULEB (val, p, end);
15029       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
15030               : "  Tag_ARC_ABI_pic: ");
15031       switch (val)
15032         {
15033         case 0:
15034           printf (_("Absent\n"));
15035           break;
15036         case 1:
15037           printf ("MWDT\n");
15038           break;
15039         case 2:
15040           printf ("GNU\n");
15041           break;
15042         default:
15043           printf (_("Unknown\n"));
15044           break;
15045         }
15046       break;
15047
15048     case Tag_ARC_ABI_tls:
15049       READ_ULEB (val, p, end);
15050       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
15051       break;
15052
15053     case Tag_ARC_ABI_enumsize:
15054       READ_ULEB (val, p, end);
15055       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
15056               _("smallest"));
15057       break;
15058
15059     case Tag_ARC_ABI_exceptions:
15060       READ_ULEB (val, p, end);
15061       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
15062               : _("default"));
15063       break;
15064
15065     case Tag_ARC_ABI_double_size:
15066       READ_ULEB (val, p, end);
15067       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
15068       break;
15069
15070     case Tag_ARC_ISA_config:
15071       printf ("  Tag_ARC_ISA_config: ");
15072       p = display_tag_value (-1, p, end);
15073       break;
15074
15075     case Tag_ARC_ISA_apex:
15076       printf ("  Tag_ARC_ISA_apex: ");
15077       p = display_tag_value (-1, p, end);
15078       break;
15079
15080     case Tag_ARC_ISA_mpy_option:
15081       READ_ULEB (val, p, end);
15082       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
15083       break;
15084
15085     case Tag_ARC_ATR_version:
15086       READ_ULEB (val, p, end);
15087       printf ("  Tag_ARC_ATR_version: %d\n", val);
15088       break;
15089
15090     default:
15091       return display_tag_value (tag & 1, p, end);
15092     }
15093
15094   return p;
15095 }
15096
15097 /* ARM EABI attributes section.  */
15098 typedef struct
15099 {
15100   unsigned int tag;
15101   const char * name;
15102   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
15103   unsigned int type;
15104   const char ** table;
15105 } arm_attr_public_tag;
15106
15107 static const char * arm_attr_tag_CPU_arch[] =
15108   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15109    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15110    "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15111 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
15112 static const char * arm_attr_tag_THUMB_ISA_use[] =
15113   {"No", "Thumb-1", "Thumb-2", "Yes"};
15114 static const char * arm_attr_tag_FP_arch[] =
15115   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15116    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15117 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
15118 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
15119   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15120    "NEON for ARMv8.1"};
15121 static const char * arm_attr_tag_PCS_config[] =
15122   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15123    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15124 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
15125   {"V6", "SB", "TLS", "Unused"};
15126 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
15127   {"Absolute", "PC-relative", "SB-relative", "None"};
15128 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
15129   {"Absolute", "PC-relative", "None"};
15130 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
15131   {"None", "direct", "GOT-indirect"};
15132 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
15133   {"None", "??? 1", "2", "??? 3", "4"};
15134 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
15135 static const char * arm_attr_tag_ABI_FP_denormal[] =
15136   {"Unused", "Needed", "Sign only"};
15137 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
15138 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
15139 static const char * arm_attr_tag_ABI_FP_number_model[] =
15140   {"Unused", "Finite", "RTABI", "IEEE 754"};
15141 static const char * arm_attr_tag_ABI_enum_size[] =
15142   {"Unused", "small", "int", "forced to int"};
15143 static const char * arm_attr_tag_ABI_HardFP_use[] =
15144   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15145 static const char * arm_attr_tag_ABI_VFP_args[] =
15146   {"AAPCS", "VFP registers", "custom", "compatible"};
15147 static const char * arm_attr_tag_ABI_WMMX_args[] =
15148   {"AAPCS", "WMMX registers", "custom"};
15149 static const char * arm_attr_tag_ABI_optimization_goals[] =
15150   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15151     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15152 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
15153   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15154     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15155 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
15156 static const char * arm_attr_tag_FP_HP_extension[] =
15157   {"Not Allowed", "Allowed"};
15158 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
15159   {"None", "IEEE 754", "Alternative Format"};
15160 static const char * arm_attr_tag_DSP_extension[] =
15161   {"Follow architecture", "Allowed"};
15162 static const char * arm_attr_tag_MPextension_use[] =
15163   {"Not Allowed", "Allowed"};
15164 static const char * arm_attr_tag_DIV_use[] =
15165   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15166     "Allowed in v7-A with integer division extension"};
15167 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
15168 static const char * arm_attr_tag_Virtualization_use[] =
15169   {"Not Allowed", "TrustZone", "Virtualization Extensions",
15170     "TrustZone and Virtualization Extensions"};
15171 static const char * arm_attr_tag_MPextension_use_legacy[] =
15172   {"Not Allowed", "Allowed"};
15173
15174 static const char * arm_attr_tag_MVE_arch[] =
15175   {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15176
15177 #define LOOKUP(id, name) \
15178   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15179 static arm_attr_public_tag arm_attr_public_tags[] =
15180 {
15181   {4, "CPU_raw_name", 1, NULL},
15182   {5, "CPU_name", 1, NULL},
15183   LOOKUP(6, CPU_arch),
15184   {7, "CPU_arch_profile", 0, NULL},
15185   LOOKUP(8, ARM_ISA_use),
15186   LOOKUP(9, THUMB_ISA_use),
15187   LOOKUP(10, FP_arch),
15188   LOOKUP(11, WMMX_arch),
15189   LOOKUP(12, Advanced_SIMD_arch),
15190   LOOKUP(13, PCS_config),
15191   LOOKUP(14, ABI_PCS_R9_use),
15192   LOOKUP(15, ABI_PCS_RW_data),
15193   LOOKUP(16, ABI_PCS_RO_data),
15194   LOOKUP(17, ABI_PCS_GOT_use),
15195   LOOKUP(18, ABI_PCS_wchar_t),
15196   LOOKUP(19, ABI_FP_rounding),
15197   LOOKUP(20, ABI_FP_denormal),
15198   LOOKUP(21, ABI_FP_exceptions),
15199   LOOKUP(22, ABI_FP_user_exceptions),
15200   LOOKUP(23, ABI_FP_number_model),
15201   {24, "ABI_align_needed", 0, NULL},
15202   {25, "ABI_align_preserved", 0, NULL},
15203   LOOKUP(26, ABI_enum_size),
15204   LOOKUP(27, ABI_HardFP_use),
15205   LOOKUP(28, ABI_VFP_args),
15206   LOOKUP(29, ABI_WMMX_args),
15207   LOOKUP(30, ABI_optimization_goals),
15208   LOOKUP(31, ABI_FP_optimization_goals),
15209   {32, "compatibility", 0, NULL},
15210   LOOKUP(34, CPU_unaligned_access),
15211   LOOKUP(36, FP_HP_extension),
15212   LOOKUP(38, ABI_FP_16bit_format),
15213   LOOKUP(42, MPextension_use),
15214   LOOKUP(44, DIV_use),
15215   LOOKUP(46, DSP_extension),
15216   LOOKUP(48, MVE_arch),
15217   {64, "nodefaults", 0, NULL},
15218   {65, "also_compatible_with", 0, NULL},
15219   LOOKUP(66, T2EE_use),
15220   {67, "conformance", 1, NULL},
15221   LOOKUP(68, Virtualization_use),
15222   LOOKUP(70, MPextension_use_legacy)
15223 };
15224 #undef LOOKUP
15225
15226 static unsigned char *
15227 display_arm_attribute (unsigned char * p,
15228                        const unsigned char * const end)
15229 {
15230   unsigned int tag;
15231   unsigned int val;
15232   arm_attr_public_tag * attr;
15233   unsigned i;
15234   unsigned int type;
15235
15236   READ_ULEB (tag, p, end);
15237   attr = NULL;
15238   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
15239     {
15240       if (arm_attr_public_tags[i].tag == tag)
15241         {
15242           attr = &arm_attr_public_tags[i];
15243           break;
15244         }
15245     }
15246
15247   if (attr)
15248     {
15249       printf ("  Tag_%s: ", attr->name);
15250       switch (attr->type)
15251         {
15252         case 0:
15253           switch (tag)
15254             {
15255             case 7: /* Tag_CPU_arch_profile.  */
15256               READ_ULEB (val, p, end);
15257               switch (val)
15258                 {
15259                 case 0: printf (_("None\n")); break;
15260                 case 'A': printf (_("Application\n")); break;
15261                 case 'R': printf (_("Realtime\n")); break;
15262                 case 'M': printf (_("Microcontroller\n")); break;
15263                 case 'S': printf (_("Application or Realtime\n")); break;
15264                 default: printf ("??? (%d)\n", val); break;
15265                 }
15266               break;
15267
15268             case 24: /* Tag_align_needed.  */
15269               READ_ULEB (val, p, end);
15270               switch (val)
15271                 {
15272                 case 0: printf (_("None\n")); break;
15273                 case 1: printf (_("8-byte\n")); break;
15274                 case 2: printf (_("4-byte\n")); break;
15275                 case 3: printf ("??? 3\n"); break;
15276                 default:
15277                   if (val <= 12)
15278                     printf (_("8-byte and up to %d-byte extended\n"),
15279                             1 << val);
15280                   else
15281                     printf ("??? (%d)\n", val);
15282                   break;
15283                 }
15284               break;
15285
15286             case 25: /* Tag_align_preserved.  */
15287               READ_ULEB (val, p, end);
15288               switch (val)
15289                 {
15290                 case 0: printf (_("None\n")); break;
15291                 case 1: printf (_("8-byte, except leaf SP\n")); break;
15292                 case 2: printf (_("8-byte\n")); break;
15293                 case 3: printf ("??? 3\n"); break;
15294                 default:
15295                   if (val <= 12)
15296                     printf (_("8-byte and up to %d-byte extended\n"),
15297                             1 << val);
15298                   else
15299                     printf ("??? (%d)\n", val);
15300                   break;
15301                 }
15302               break;
15303
15304             case 32: /* Tag_compatibility.  */
15305               {
15306                 READ_ULEB (val, p, end);
15307                 printf (_("flag = %d, vendor = "), val);
15308                 if (p < end - 1)
15309                   {
15310                     size_t maxlen = (end - p) - 1;
15311
15312                     print_symbol ((int) maxlen, (const char *) p);
15313                     p += strnlen ((char *) p, maxlen) + 1;
15314                   }
15315                 else
15316                   {
15317                     printf (_("<corrupt>"));
15318                     p = (unsigned char *) end;
15319                   }
15320                 putchar ('\n');
15321               }
15322               break;
15323
15324             case 64: /* Tag_nodefaults.  */
15325               /* PR 17531: file: 001-505008-0.01.  */
15326               if (p < end)
15327                 p++;
15328               printf (_("True\n"));
15329               break;
15330
15331             case 65: /* Tag_also_compatible_with.  */
15332               READ_ULEB (val, p, end);
15333               if (val == 6 /* Tag_CPU_arch.  */)
15334                 {
15335                   READ_ULEB (val, p, end);
15336                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
15337                     printf ("??? (%d)\n", val);
15338                   else
15339                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
15340                 }
15341               else
15342                 printf ("???\n");
15343               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
15344                 ;
15345               break;
15346
15347             default:
15348               printf (_("<unknown: %d>\n"), tag);
15349               break;
15350             }
15351           return p;
15352
15353         case 1:
15354           return display_tag_value (-1, p, end);
15355         case 2:
15356           return display_tag_value (0, p, end);
15357
15358         default:
15359           assert (attr->type & 0x80);
15360           READ_ULEB (val, p, end);
15361           type = attr->type & 0x7f;
15362           if (val >= type)
15363             printf ("??? (%d)\n", val);
15364           else
15365             printf ("%s\n", attr->table[val]);
15366           return p;
15367         }
15368     }
15369
15370   return display_tag_value (tag, p, end);
15371 }
15372
15373 static unsigned char *
15374 display_gnu_attribute (unsigned char * p,
15375                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
15376                        const unsigned char * const end)
15377 {
15378   unsigned int tag;
15379   unsigned int val;
15380
15381   READ_ULEB (tag, p, end);
15382
15383   /* Tag_compatibility is the only generic GNU attribute defined at
15384      present.  */
15385   if (tag == 32)
15386     {
15387       READ_ULEB (val, p, end);
15388
15389       printf (_("flag = %d, vendor = "), val);
15390       if (p == end)
15391         {
15392           printf (_("<corrupt>\n"));
15393           warn (_("corrupt vendor attribute\n"));
15394         }
15395       else
15396         {
15397           if (p < end - 1)
15398             {
15399               size_t maxlen = (end - p) - 1;
15400
15401               print_symbol ((int) maxlen, (const char *) p);
15402               p += strnlen ((char *) p, maxlen) + 1;
15403             }
15404           else
15405             {
15406               printf (_("<corrupt>"));
15407               p = (unsigned char *) end;
15408             }
15409           putchar ('\n');
15410         }
15411       return p;
15412     }
15413
15414   if ((tag & 2) == 0 && display_proc_gnu_attribute)
15415     return display_proc_gnu_attribute (p, tag, end);
15416
15417   return display_tag_value (tag, p, end);
15418 }
15419
15420 static unsigned char *
15421 display_m68k_gnu_attribute (unsigned char * p,
15422                             unsigned int tag,
15423                             const unsigned char * const end)
15424 {
15425   unsigned int val;
15426
15427   if (tag == Tag_GNU_M68K_ABI_FP)
15428     {
15429       printf ("  Tag_GNU_M68K_ABI_FP: ");
15430       if (p == end)
15431         {
15432           printf (_("<corrupt>\n"));
15433           return p;
15434         }
15435       READ_ULEB (val, p, end);
15436
15437       if (val > 3)
15438         printf ("(%#x), ", val);
15439
15440       switch (val & 3)
15441         {
15442         case 0:
15443           printf (_("unspecified hard/soft float\n"));
15444           break;
15445         case 1:
15446           printf (_("hard float\n"));
15447           break;
15448         case 2:
15449           printf (_("soft float\n"));
15450           break;
15451         }
15452       return p;
15453     }
15454
15455   return display_tag_value (tag & 1, p, end);
15456 }
15457
15458 static unsigned char *
15459 display_power_gnu_attribute (unsigned char * p,
15460                              unsigned int tag,
15461                              const unsigned char * const end)
15462 {
15463   unsigned int val;
15464
15465   if (tag == Tag_GNU_Power_ABI_FP)
15466     {
15467       printf ("  Tag_GNU_Power_ABI_FP: ");
15468       if (p == end)
15469         {
15470           printf (_("<corrupt>\n"));
15471           return p;
15472         }
15473       READ_ULEB (val, p, end);
15474
15475       if (val > 15)
15476         printf ("(%#x), ", val);
15477
15478       switch (val & 3)
15479         {
15480         case 0:
15481           printf (_("unspecified hard/soft float, "));
15482           break;
15483         case 1:
15484           printf (_("hard float, "));
15485           break;
15486         case 2:
15487           printf (_("soft float, "));
15488           break;
15489         case 3:
15490           printf (_("single-precision hard float, "));
15491           break;
15492         }
15493
15494       switch (val & 0xC)
15495         {
15496         case 0:
15497           printf (_("unspecified long double\n"));
15498           break;
15499         case 4:
15500           printf (_("128-bit IBM long double\n"));
15501           break;
15502         case 8:
15503           printf (_("64-bit long double\n"));
15504           break;
15505         case 12:
15506           printf (_("128-bit IEEE long double\n"));
15507           break;
15508         }
15509       return p;
15510     }
15511
15512   if (tag == Tag_GNU_Power_ABI_Vector)
15513     {
15514       printf ("  Tag_GNU_Power_ABI_Vector: ");
15515       if (p == end)
15516         {
15517           printf (_("<corrupt>\n"));
15518           return p;
15519         }
15520       READ_ULEB (val, p, end);
15521
15522       if (val > 3)
15523         printf ("(%#x), ", val);
15524
15525       switch (val & 3)
15526         {
15527         case 0:
15528           printf (_("unspecified\n"));
15529           break;
15530         case 1:
15531           printf (_("generic\n"));
15532           break;
15533         case 2:
15534           printf ("AltiVec\n");
15535           break;
15536         case 3:
15537           printf ("SPE\n");
15538           break;
15539         }
15540       return p;
15541     }
15542
15543   if (tag == Tag_GNU_Power_ABI_Struct_Return)
15544     {
15545       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
15546       if (p == end)
15547         {
15548           printf (_("<corrupt>\n"));
15549           return p;
15550         }
15551       READ_ULEB (val, p, end);
15552
15553       if (val > 2)
15554         printf ("(%#x), ", val);
15555
15556       switch (val & 3)
15557         {
15558         case 0:
15559           printf (_("unspecified\n"));
15560           break;
15561         case 1:
15562           printf ("r3/r4\n");
15563           break;
15564         case 2:
15565           printf (_("memory\n"));
15566           break;
15567         case 3:
15568           printf ("???\n");
15569           break;
15570         }
15571       return p;
15572     }
15573
15574   return display_tag_value (tag & 1, p, end);
15575 }
15576
15577 static unsigned char *
15578 display_s390_gnu_attribute (unsigned char * p,
15579                             unsigned int tag,
15580                             const unsigned char * const end)
15581 {
15582   unsigned int val;
15583
15584   if (tag == Tag_GNU_S390_ABI_Vector)
15585     {
15586       printf ("  Tag_GNU_S390_ABI_Vector: ");
15587       READ_ULEB (val, p, end);
15588
15589       switch (val)
15590         {
15591         case 0:
15592           printf (_("any\n"));
15593           break;
15594         case 1:
15595           printf (_("software\n"));
15596           break;
15597         case 2:
15598           printf (_("hardware\n"));
15599           break;
15600         default:
15601           printf ("??? (%d)\n", val);
15602           break;
15603         }
15604       return p;
15605    }
15606
15607   return display_tag_value (tag & 1, p, end);
15608 }
15609
15610 static void
15611 display_sparc_hwcaps (unsigned int mask)
15612 {
15613   if (mask)
15614     {
15615       bfd_boolean first = TRUE;
15616
15617       if (mask & ELF_SPARC_HWCAP_MUL32)
15618         fputs ("mul32", stdout), first = FALSE;
15619       if (mask & ELF_SPARC_HWCAP_DIV32)
15620         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
15621       if (mask & ELF_SPARC_HWCAP_FSMULD)
15622         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
15623       if (mask & ELF_SPARC_HWCAP_V8PLUS)
15624         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
15625       if (mask & ELF_SPARC_HWCAP_POPC)
15626         printf ("%spopc", first ? "" : "|"), first = FALSE;
15627       if (mask & ELF_SPARC_HWCAP_VIS)
15628         printf ("%svis", first ? "" : "|"), first = FALSE;
15629       if (mask & ELF_SPARC_HWCAP_VIS2)
15630         printf ("%svis2", first ? "" : "|"), first = FALSE;
15631       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
15632         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
15633       if (mask & ELF_SPARC_HWCAP_FMAF)
15634         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
15635       if (mask & ELF_SPARC_HWCAP_VIS3)
15636         printf ("%svis3", first ? "" : "|"), first = FALSE;
15637       if (mask & ELF_SPARC_HWCAP_HPC)
15638         printf ("%shpc", first ? "" : "|"), first = FALSE;
15639       if (mask & ELF_SPARC_HWCAP_RANDOM)
15640         printf ("%srandom", first ? "" : "|"), first = FALSE;
15641       if (mask & ELF_SPARC_HWCAP_TRANS)
15642         printf ("%strans", first ? "" : "|"), first = FALSE;
15643       if (mask & ELF_SPARC_HWCAP_FJFMAU)
15644         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
15645       if (mask & ELF_SPARC_HWCAP_IMA)
15646         printf ("%sima", first ? "" : "|"), first = FALSE;
15647       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
15648         printf ("%scspare", first ? "" : "|"), first = FALSE;
15649     }
15650   else
15651     fputc ('0', stdout);
15652   fputc ('\n', stdout);
15653 }
15654
15655 static void
15656 display_sparc_hwcaps2 (unsigned int mask)
15657 {
15658   if (mask)
15659     {
15660       bfd_boolean first = TRUE;
15661
15662       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
15663         fputs ("fjathplus", stdout), first = FALSE;
15664       if (mask & ELF_SPARC_HWCAP2_VIS3B)
15665         printf ("%svis3b", first ? "" : "|"), first = FALSE;
15666       if (mask & ELF_SPARC_HWCAP2_ADP)
15667         printf ("%sadp", first ? "" : "|"), first = FALSE;
15668       if (mask & ELF_SPARC_HWCAP2_SPARC5)
15669         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
15670       if (mask & ELF_SPARC_HWCAP2_MWAIT)
15671         printf ("%smwait", first ? "" : "|"), first = FALSE;
15672       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
15673         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
15674       if (mask & ELF_SPARC_HWCAP2_XMONT)
15675         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
15676       if (mask & ELF_SPARC_HWCAP2_NSEC)
15677         printf ("%snsec", first ? "" : "|"), first = FALSE;
15678       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
15679         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
15680       if (mask & ELF_SPARC_HWCAP2_FJDES)
15681         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
15682       if (mask & ELF_SPARC_HWCAP2_FJAES)
15683         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
15684     }
15685   else
15686     fputc ('0', stdout);
15687   fputc ('\n', stdout);
15688 }
15689
15690 static unsigned char *
15691 display_sparc_gnu_attribute (unsigned char * p,
15692                              unsigned int tag,
15693                              const unsigned char * const end)
15694 {
15695   unsigned int val;
15696
15697   if (tag == Tag_GNU_Sparc_HWCAPS)
15698     {
15699       READ_ULEB (val, p, end);
15700       printf ("  Tag_GNU_Sparc_HWCAPS: ");
15701       display_sparc_hwcaps (val);
15702       return p;
15703     }
15704   if (tag == Tag_GNU_Sparc_HWCAPS2)
15705     {
15706       READ_ULEB (val, p, end);
15707       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
15708       display_sparc_hwcaps2 (val);
15709       return p;
15710     }
15711
15712   return display_tag_value (tag, p, end);
15713 }
15714
15715 static void
15716 print_mips_fp_abi_value (unsigned int val)
15717 {
15718   switch (val)
15719     {
15720     case Val_GNU_MIPS_ABI_FP_ANY:
15721       printf (_("Hard or soft float\n"));
15722       break;
15723     case Val_GNU_MIPS_ABI_FP_DOUBLE:
15724       printf (_("Hard float (double precision)\n"));
15725       break;
15726     case Val_GNU_MIPS_ABI_FP_SINGLE:
15727       printf (_("Hard float (single precision)\n"));
15728       break;
15729     case Val_GNU_MIPS_ABI_FP_SOFT:
15730       printf (_("Soft float\n"));
15731       break;
15732     case Val_GNU_MIPS_ABI_FP_OLD_64:
15733       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15734       break;
15735     case Val_GNU_MIPS_ABI_FP_XX:
15736       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15737       break;
15738     case Val_GNU_MIPS_ABI_FP_64:
15739       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15740       break;
15741     case Val_GNU_MIPS_ABI_FP_64A:
15742       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15743       break;
15744     case Val_GNU_MIPS_ABI_FP_NAN2008:
15745       printf (_("NaN 2008 compatibility\n"));
15746       break;
15747     default:
15748       printf ("??? (%d)\n", val);
15749       break;
15750     }
15751 }
15752
15753 static unsigned char *
15754 display_mips_gnu_attribute (unsigned char * p,
15755                             unsigned int tag,
15756                             const unsigned char * const end)
15757 {
15758   if (tag == Tag_GNU_MIPS_ABI_FP)
15759     {
15760       unsigned int val;
15761
15762       printf ("  Tag_GNU_MIPS_ABI_FP: ");
15763       READ_ULEB (val, p, end);
15764       print_mips_fp_abi_value (val);
15765       return p;
15766    }
15767
15768   if (tag == Tag_GNU_MIPS_ABI_MSA)
15769     {
15770       unsigned int val;
15771
15772       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
15773       READ_ULEB (val, p, end);
15774
15775       switch (val)
15776         {
15777         case Val_GNU_MIPS_ABI_MSA_ANY:
15778           printf (_("Any MSA or not\n"));
15779           break;
15780         case Val_GNU_MIPS_ABI_MSA_128:
15781           printf (_("128-bit MSA\n"));
15782           break;
15783         default:
15784           printf ("??? (%d)\n", val);
15785           break;
15786         }
15787       return p;
15788     }
15789
15790   return display_tag_value (tag & 1, p, end);
15791 }
15792
15793 static unsigned char *
15794 display_tic6x_attribute (unsigned char * p,
15795                          const unsigned char * const end)
15796 {
15797   unsigned int tag;
15798   unsigned int val;
15799
15800   READ_ULEB (tag, p, end);
15801
15802   switch (tag)
15803     {
15804     case Tag_ISA:
15805       printf ("  Tag_ISA: ");
15806       READ_ULEB (val, p, end);
15807
15808       switch (val)
15809         {
15810         case C6XABI_Tag_ISA_none:
15811           printf (_("None\n"));
15812           break;
15813         case C6XABI_Tag_ISA_C62X:
15814           printf ("C62x\n");
15815           break;
15816         case C6XABI_Tag_ISA_C67X:
15817           printf ("C67x\n");
15818           break;
15819         case C6XABI_Tag_ISA_C67XP:
15820           printf ("C67x+\n");
15821           break;
15822         case C6XABI_Tag_ISA_C64X:
15823           printf ("C64x\n");
15824           break;
15825         case C6XABI_Tag_ISA_C64XP:
15826           printf ("C64x+\n");
15827           break;
15828         case C6XABI_Tag_ISA_C674X:
15829           printf ("C674x\n");
15830           break;
15831         default:
15832           printf ("??? (%d)\n", val);
15833           break;
15834         }
15835       return p;
15836
15837     case Tag_ABI_wchar_t:
15838       printf ("  Tag_ABI_wchar_t: ");
15839       READ_ULEB (val, p, end);
15840       switch (val)
15841         {
15842         case 0:
15843           printf (_("Not used\n"));
15844           break;
15845         case 1:
15846           printf (_("2 bytes\n"));
15847           break;
15848         case 2:
15849           printf (_("4 bytes\n"));
15850           break;
15851         default:
15852           printf ("??? (%d)\n", val);
15853           break;
15854         }
15855       return p;
15856
15857     case Tag_ABI_stack_align_needed:
15858       printf ("  Tag_ABI_stack_align_needed: ");
15859       READ_ULEB (val, p, end);
15860       switch (val)
15861         {
15862         case 0:
15863           printf (_("8-byte\n"));
15864           break;
15865         case 1:
15866           printf (_("16-byte\n"));
15867           break;
15868         default:
15869           printf ("??? (%d)\n", val);
15870           break;
15871         }
15872       return p;
15873
15874     case Tag_ABI_stack_align_preserved:
15875       READ_ULEB (val, p, end);
15876       printf ("  Tag_ABI_stack_align_preserved: ");
15877       switch (val)
15878         {
15879         case 0:
15880           printf (_("8-byte\n"));
15881           break;
15882         case 1:
15883           printf (_("16-byte\n"));
15884           break;
15885         default:
15886           printf ("??? (%d)\n", val);
15887           break;
15888         }
15889       return p;
15890
15891     case Tag_ABI_DSBT:
15892       READ_ULEB (val, p, end);
15893       printf ("  Tag_ABI_DSBT: ");
15894       switch (val)
15895         {
15896         case 0:
15897           printf (_("DSBT addressing not used\n"));
15898           break;
15899         case 1:
15900           printf (_("DSBT addressing used\n"));
15901           break;
15902         default:
15903           printf ("??? (%d)\n", val);
15904           break;
15905         }
15906       return p;
15907
15908     case Tag_ABI_PID:
15909       READ_ULEB (val, p, end);
15910       printf ("  Tag_ABI_PID: ");
15911       switch (val)
15912         {
15913         case 0:
15914           printf (_("Data addressing position-dependent\n"));
15915           break;
15916         case 1:
15917           printf (_("Data addressing position-independent, GOT near DP\n"));
15918           break;
15919         case 2:
15920           printf (_("Data addressing position-independent, GOT far from DP\n"));
15921           break;
15922         default:
15923           printf ("??? (%d)\n", val);
15924           break;
15925         }
15926       return p;
15927
15928     case Tag_ABI_PIC:
15929       READ_ULEB (val, p, end);
15930       printf ("  Tag_ABI_PIC: ");
15931       switch (val)
15932         {
15933         case 0:
15934           printf (_("Code addressing position-dependent\n"));
15935           break;
15936         case 1:
15937           printf (_("Code addressing position-independent\n"));
15938           break;
15939         default:
15940           printf ("??? (%d)\n", val);
15941           break;
15942         }
15943       return p;
15944
15945     case Tag_ABI_array_object_alignment:
15946       READ_ULEB (val, p, end);
15947       printf ("  Tag_ABI_array_object_alignment: ");
15948       switch (val)
15949         {
15950         case 0:
15951           printf (_("8-byte\n"));
15952           break;
15953         case 1:
15954           printf (_("4-byte\n"));
15955           break;
15956         case 2:
15957           printf (_("16-byte\n"));
15958           break;
15959         default:
15960           printf ("??? (%d)\n", val);
15961           break;
15962         }
15963       return p;
15964
15965     case Tag_ABI_array_object_align_expected:
15966       READ_ULEB (val, p, end);
15967       printf ("  Tag_ABI_array_object_align_expected: ");
15968       switch (val)
15969         {
15970         case 0:
15971           printf (_("8-byte\n"));
15972           break;
15973         case 1:
15974           printf (_("4-byte\n"));
15975           break;
15976         case 2:
15977           printf (_("16-byte\n"));
15978           break;
15979         default:
15980           printf ("??? (%d)\n", val);
15981           break;
15982         }
15983       return p;
15984
15985     case Tag_ABI_compatibility:
15986       {
15987         READ_ULEB (val, p, end);
15988         printf ("  Tag_ABI_compatibility: ");
15989         printf (_("flag = %d, vendor = "), val);
15990         if (p < end - 1)
15991           {
15992             size_t maxlen = (end - p) - 1;
15993
15994             print_symbol ((int) maxlen, (const char *) p);
15995             p += strnlen ((char *) p, maxlen) + 1;
15996           }
15997         else
15998           {
15999             printf (_("<corrupt>"));
16000             p = (unsigned char *) end;
16001           }
16002         putchar ('\n');
16003         return p;
16004       }
16005
16006     case Tag_ABI_conformance:
16007       {
16008         printf ("  Tag_ABI_conformance: \"");
16009         if (p < end - 1)
16010           {
16011             size_t maxlen = (end - p) - 1;
16012
16013             print_symbol ((int) maxlen, (const char *) p);
16014             p += strnlen ((char *) p, maxlen) + 1;
16015           }
16016         else
16017           {
16018             printf (_("<corrupt>"));
16019             p = (unsigned char *) end;
16020           }
16021         printf ("\"\n");
16022         return p;
16023       }
16024     }
16025
16026   return display_tag_value (tag, p, end);
16027 }
16028
16029 static void
16030 display_raw_attribute (unsigned char * p, unsigned char const * const end)
16031 {
16032   unsigned long addr = 0;
16033   size_t bytes = end - p;
16034
16035   assert (end >= p);
16036   while (bytes)
16037     {
16038       int j;
16039       int k;
16040       int lbytes = (bytes > 16 ? 16 : bytes);
16041
16042       printf ("  0x%8.8lx ", addr);
16043
16044       for (j = 0; j < 16; j++)
16045         {
16046           if (j < lbytes)
16047             printf ("%2.2x", p[j]);
16048           else
16049             printf ("  ");
16050
16051           if ((j & 3) == 3)
16052             printf (" ");
16053         }
16054
16055       for (j = 0; j < lbytes; j++)
16056         {
16057           k = p[j];
16058           if (k >= ' ' && k < 0x7f)
16059             printf ("%c", k);
16060           else
16061             printf (".");
16062         }
16063
16064       putchar ('\n');
16065
16066       p  += lbytes;
16067       bytes -= lbytes;
16068       addr += lbytes;
16069     }
16070
16071   putchar ('\n');
16072 }
16073
16074 static unsigned char *
16075 display_msp430x_attribute (unsigned char * p,
16076                            const unsigned char * const end)
16077 {
16078   unsigned int val;
16079   unsigned int tag;
16080
16081   READ_ULEB (tag, p, end);
16082
16083   switch (tag)
16084     {
16085     case OFBA_MSPABI_Tag_ISA:
16086       printf ("  Tag_ISA: ");
16087       READ_ULEB (val, p, end);
16088       switch (val)
16089         {
16090         case 0: printf (_("None\n")); break;
16091         case 1: printf (_("MSP430\n")); break;
16092         case 2: printf (_("MSP430X\n")); break;
16093         default: printf ("??? (%d)\n", val); break;
16094         }
16095       break;
16096
16097     case OFBA_MSPABI_Tag_Code_Model:
16098       printf ("  Tag_Code_Model: ");
16099       READ_ULEB (val, p, end);
16100       switch (val)
16101         {
16102         case 0: printf (_("None\n")); break;
16103         case 1: printf (_("Small\n")); break;
16104         case 2: printf (_("Large\n")); break;
16105         default: printf ("??? (%d)\n", val); break;
16106         }
16107       break;
16108
16109     case OFBA_MSPABI_Tag_Data_Model:
16110       printf ("  Tag_Data_Model: ");
16111       READ_ULEB (val, p, end);
16112       switch (val)
16113         {
16114         case 0: printf (_("None\n")); break;
16115         case 1: printf (_("Small\n")); break;
16116         case 2: printf (_("Large\n")); break;
16117         case 3: printf (_("Restricted Large\n")); break;
16118         default: printf ("??? (%d)\n", val); break;
16119         }
16120       break;
16121
16122     default:
16123       printf (_("  <unknown tag %d>: "), tag);
16124
16125       if (tag & 1)
16126         {
16127           putchar ('"');
16128           if (p < end - 1)
16129             {
16130               size_t maxlen = (end - p) - 1;
16131
16132               print_symbol ((int) maxlen, (const char *) p);
16133               p += strnlen ((char *) p, maxlen) + 1;
16134             }
16135           else
16136             {
16137               printf (_("<corrupt>"));
16138               p = (unsigned char *) end;
16139             }
16140           printf ("\"\n");
16141         }
16142       else
16143         {
16144           READ_ULEB (val, p, end);
16145           printf ("%d (0x%x)\n", val, val);
16146         }
16147       break;
16148    }
16149
16150   assert (p <= end);
16151   return p;
16152 }
16153
16154 static unsigned char *
16155 display_msp430_gnu_attribute (unsigned char * p,
16156                               unsigned int tag,
16157                               const unsigned char * const end)
16158 {
16159   if (tag == Tag_GNU_MSP430_Data_Region)
16160     {
16161       unsigned int val;
16162
16163       printf ("  Tag_GNU_MSP430_Data_Region: ");
16164       READ_ULEB (val, p, end);
16165
16166       switch (val)
16167         {
16168         case Val_GNU_MSP430_Data_Region_Any:
16169           printf (_("Any Region\n"));
16170           break;
16171         case Val_GNU_MSP430_Data_Region_Lower:
16172           printf (_("Lower Region Only\n"));
16173           break;
16174         default:
16175           printf ("??? (%u)\n", val);
16176         }
16177       return p;
16178     }
16179   return display_tag_value (tag & 1, p, end);
16180 }
16181
16182 struct riscv_attr_tag_t {
16183   const char *name;
16184   unsigned int tag;
16185 };
16186
16187 static struct riscv_attr_tag_t riscv_attr_tag[] =
16188 {
16189 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16190   T(arch),
16191   T(priv_spec),
16192   T(priv_spec_minor),
16193   T(priv_spec_revision),
16194   T(unaligned_access),
16195   T(stack_align),
16196 #undef T
16197 };
16198
16199 static unsigned char *
16200 display_riscv_attribute (unsigned char *p,
16201                          const unsigned char * const end)
16202 {
16203   unsigned int val;
16204   unsigned int tag;
16205   struct riscv_attr_tag_t *attr = NULL;
16206   unsigned i;
16207
16208   READ_ULEB (tag, p, end);
16209
16210   /* Find the name of attribute. */
16211   for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
16212     {
16213       if (riscv_attr_tag[i].tag == tag)
16214         {
16215           attr = &riscv_attr_tag[i];
16216           break;
16217         }
16218     }
16219
16220   if (attr)
16221     printf ("  %s: ", attr->name);
16222   else
16223     return display_tag_value (tag, p, end);
16224
16225   switch (tag)
16226     {
16227     case Tag_RISCV_priv_spec:
16228     case Tag_RISCV_priv_spec_minor:
16229     case Tag_RISCV_priv_spec_revision:
16230       READ_ULEB (val, p, end);
16231       printf (_("%u\n"), val);
16232       break;
16233     case Tag_RISCV_unaligned_access:
16234       READ_ULEB (val, p, end);
16235       switch (val)
16236         {
16237         case 0:
16238           printf (_("No unaligned access\n"));
16239           break;
16240         case 1:
16241           printf (_("Unaligned access\n"));
16242           break;
16243         }
16244       break;
16245     case Tag_RISCV_stack_align:
16246       READ_ULEB (val, p, end);
16247       printf (_("%u-bytes\n"), val);
16248       break;
16249     case Tag_RISCV_arch:
16250       p = display_tag_value (-1, p, end);
16251       break;
16252     default:
16253       return display_tag_value (tag, p, end);
16254     }
16255
16256   return p;
16257 }
16258
16259 static bfd_boolean
16260 process_attributes (Filedata * filedata,
16261                     const char * public_name,
16262                     unsigned int proc_type,
16263                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
16264                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
16265 {
16266   Elf_Internal_Shdr * sect;
16267   unsigned i;
16268   bfd_boolean res = TRUE;
16269
16270   /* Find the section header so that we get the size.  */
16271   for (i = 0, sect = filedata->section_headers;
16272        i < filedata->file_header.e_shnum;
16273        i++, sect++)
16274     {
16275       unsigned char * contents;
16276       unsigned char * p;
16277
16278       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
16279         continue;
16280
16281       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
16282                                              sect->sh_size, _("attributes"));
16283       if (contents == NULL)
16284         {
16285           res = FALSE;
16286           continue;
16287         }
16288
16289       p = contents;
16290       /* The first character is the version of the attributes.
16291          Currently only version 1, (aka 'A') is recognised here.  */
16292       if (*p != 'A')
16293         {
16294           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
16295           res = FALSE;
16296         }
16297       else
16298         {
16299           bfd_vma section_len;
16300
16301           section_len = sect->sh_size - 1;
16302           p++;
16303
16304           while (section_len > 0)
16305             {
16306               bfd_vma attr_len;
16307               unsigned int namelen;
16308               bfd_boolean public_section;
16309               bfd_boolean gnu_section;
16310
16311               if (section_len <= 4)
16312                 {
16313                   error (_("Tag section ends prematurely\n"));
16314                   res = FALSE;
16315                   break;
16316                 }
16317               attr_len = byte_get (p, 4);
16318               p += 4;
16319
16320               if (attr_len > section_len)
16321                 {
16322                   error (_("Bad attribute length (%u > %u)\n"),
16323                           (unsigned) attr_len, (unsigned) section_len);
16324                   attr_len = section_len;
16325                   res = FALSE;
16326                 }
16327               /* PR 17531: file: 001-101425-0.004  */
16328               else if (attr_len < 5)
16329                 {
16330                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
16331                   res = FALSE;
16332                   break;
16333                 }
16334
16335               section_len -= attr_len;
16336               attr_len -= 4;
16337
16338               namelen = strnlen ((char *) p, attr_len) + 1;
16339               if (namelen == 0 || namelen >= attr_len)
16340                 {
16341                   error (_("Corrupt attribute section name\n"));
16342                   res = FALSE;
16343                   break;
16344                 }
16345
16346               printf (_("Attribute Section: "));
16347               print_symbol (INT_MAX, (const char *) p);
16348               putchar ('\n');
16349
16350               if (public_name && streq ((char *) p, public_name))
16351                 public_section = TRUE;
16352               else
16353                 public_section = FALSE;
16354
16355               if (streq ((char *) p, "gnu"))
16356                 gnu_section = TRUE;
16357               else
16358                 gnu_section = FALSE;
16359
16360               p += namelen;
16361               attr_len -= namelen;
16362
16363               while (attr_len > 0 && p < contents + sect->sh_size)
16364                 {
16365                   int tag;
16366                   unsigned int val;
16367                   bfd_vma size;
16368                   unsigned char * end;
16369
16370                   /* PR binutils/17531: Safe handling of corrupt files.  */
16371                   if (attr_len < 6)
16372                     {
16373                       error (_("Unused bytes at end of section\n"));
16374                       res = FALSE;
16375                       section_len = 0;
16376                       break;
16377                     }
16378
16379                   tag = *(p++);
16380                   size = byte_get (p, 4);
16381                   if (size > attr_len)
16382                     {
16383                       error (_("Bad subsection length (%u > %u)\n"),
16384                               (unsigned) size, (unsigned) attr_len);
16385                       res = FALSE;
16386                       size = attr_len;
16387                     }
16388                   /* PR binutils/17531: Safe handling of corrupt files.  */
16389                   if (size < 6)
16390                     {
16391                       error (_("Bad subsection length (%u < 6)\n"),
16392                               (unsigned) size);
16393                       res = FALSE;
16394                       section_len = 0;
16395                       break;
16396                     }
16397
16398                   attr_len -= size;
16399                   end = p + size - 1;
16400                   assert (end <= contents + sect->sh_size);
16401                   p += 4;
16402
16403                   switch (tag)
16404                     {
16405                     case 1:
16406                       printf (_("File Attributes\n"));
16407                       break;
16408                     case 2:
16409                       printf (_("Section Attributes:"));
16410                       goto do_numlist;
16411                     case 3:
16412                       printf (_("Symbol Attributes:"));
16413                       /* Fall through.  */
16414                     do_numlist:
16415                       for (;;)
16416                         {
16417                           READ_ULEB (val, p, end);
16418                           if (val == 0)
16419                             break;
16420                           printf (" %d", val);
16421                         }
16422                       printf ("\n");
16423                       break;
16424                     default:
16425                       printf (_("Unknown tag: %d\n"), tag);
16426                       public_section = FALSE;
16427                       break;
16428                     }
16429
16430                   if (public_section && display_pub_attribute != NULL)
16431                     {
16432                       while (p < end)
16433                         p = display_pub_attribute (p, end);
16434                       assert (p == end);
16435                     }
16436                   else if (gnu_section && display_proc_gnu_attribute != NULL)
16437                     {
16438                       while (p < end)
16439                         p = display_gnu_attribute (p,
16440                                                    display_proc_gnu_attribute,
16441                                                    end);
16442                       assert (p == end);
16443                     }
16444                   else if (p < end)
16445                     {
16446                       printf (_("  Unknown attribute:\n"));
16447                       display_raw_attribute (p, end);
16448                       p = end;
16449                     }
16450                   else
16451                     attr_len = 0;
16452                 }
16453             }
16454         }
16455
16456       free (contents);
16457     }
16458
16459   return res;
16460 }
16461
16462 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16463    Print the Address, Access and Initial fields of an entry at VMA ADDR
16464    and return the VMA of the next entry, or -1 if there was a problem.
16465    Does not read from DATA_END or beyond.  */
16466
16467 static bfd_vma
16468 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
16469                       unsigned char * data_end)
16470 {
16471   printf ("  ");
16472   print_vma (addr, LONG_HEX);
16473   printf (" ");
16474   if (addr < pltgot + 0xfff0)
16475     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
16476   else
16477     printf ("%10s", "");
16478   printf (" ");
16479   if (data == NULL)
16480     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16481   else
16482     {
16483       bfd_vma entry;
16484       unsigned char * from = data + addr - pltgot;
16485
16486       if (from + (is_32bit_elf ? 4 : 8) > data_end)
16487         {
16488           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16489           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
16490           return (bfd_vma) -1;
16491         }
16492       else
16493         {
16494           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16495           print_vma (entry, LONG_HEX);
16496         }
16497     }
16498   return addr + (is_32bit_elf ? 4 : 8);
16499 }
16500
16501 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16502    PLTGOT.  Print the Address and Initial fields of an entry at VMA
16503    ADDR and return the VMA of the next entry.  */
16504
16505 static bfd_vma
16506 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
16507 {
16508   printf ("  ");
16509   print_vma (addr, LONG_HEX);
16510   printf (" ");
16511   if (data == NULL)
16512     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16513   else
16514     {
16515       bfd_vma entry;
16516
16517       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16518       print_vma (entry, LONG_HEX);
16519     }
16520   return addr + (is_32bit_elf ? 4 : 8);
16521 }
16522
16523 static void
16524 print_mips_ases (unsigned int mask)
16525 {
16526   if (mask & AFL_ASE_DSP)
16527     fputs ("\n\tDSP ASE", stdout);
16528   if (mask & AFL_ASE_DSPR2)
16529     fputs ("\n\tDSP R2 ASE", stdout);
16530   if (mask & AFL_ASE_DSPR3)
16531     fputs ("\n\tDSP R3 ASE", stdout);
16532   if (mask & AFL_ASE_EVA)
16533     fputs ("\n\tEnhanced VA Scheme", stdout);
16534   if (mask & AFL_ASE_MCU)
16535     fputs ("\n\tMCU (MicroController) ASE", stdout);
16536   if (mask & AFL_ASE_MDMX)
16537     fputs ("\n\tMDMX ASE", stdout);
16538   if (mask & AFL_ASE_MIPS3D)
16539     fputs ("\n\tMIPS-3D ASE", stdout);
16540   if (mask & AFL_ASE_MT)
16541     fputs ("\n\tMT ASE", stdout);
16542   if (mask & AFL_ASE_SMARTMIPS)
16543     fputs ("\n\tSmartMIPS ASE", stdout);
16544   if (mask & AFL_ASE_VIRT)
16545     fputs ("\n\tVZ ASE", stdout);
16546   if (mask & AFL_ASE_MSA)
16547     fputs ("\n\tMSA ASE", stdout);
16548   if (mask & AFL_ASE_MIPS16)
16549     fputs ("\n\tMIPS16 ASE", stdout);
16550   if (mask & AFL_ASE_MICROMIPS)
16551     fputs ("\n\tMICROMIPS ASE", stdout);
16552   if (mask & AFL_ASE_XPA)
16553     fputs ("\n\tXPA ASE", stdout);
16554   if (mask & AFL_ASE_MIPS16E2)
16555     fputs ("\n\tMIPS16e2 ASE", stdout);
16556   if (mask & AFL_ASE_CRC)
16557     fputs ("\n\tCRC ASE", stdout);
16558   if (mask & AFL_ASE_GINV)
16559     fputs ("\n\tGINV ASE", stdout);
16560   if (mask & AFL_ASE_LOONGSON_MMI)
16561     fputs ("\n\tLoongson MMI ASE", stdout);
16562   if (mask & AFL_ASE_LOONGSON_CAM)
16563     fputs ("\n\tLoongson CAM ASE", stdout);
16564   if (mask & AFL_ASE_LOONGSON_EXT)
16565     fputs ("\n\tLoongson EXT ASE", stdout);
16566   if (mask & AFL_ASE_LOONGSON_EXT2)
16567     fputs ("\n\tLoongson EXT2 ASE", stdout);
16568   if (mask == 0)
16569     fprintf (stdout, "\n\t%s", _("None"));
16570   else if ((mask & ~AFL_ASE_MASK) != 0)
16571     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
16572 }
16573
16574 static void
16575 print_mips_isa_ext (unsigned int isa_ext)
16576 {
16577   switch (isa_ext)
16578     {
16579     case 0:
16580       fputs (_("None"), stdout);
16581       break;
16582     case AFL_EXT_XLR:
16583       fputs ("RMI XLR", stdout);
16584       break;
16585     case AFL_EXT_OCTEON3:
16586       fputs ("Cavium Networks Octeon3", stdout);
16587       break;
16588     case AFL_EXT_OCTEON2:
16589       fputs ("Cavium Networks Octeon2", stdout);
16590       break;
16591     case AFL_EXT_OCTEONP:
16592       fputs ("Cavium Networks OcteonP", stdout);
16593       break;
16594     case AFL_EXT_OCTEON:
16595       fputs ("Cavium Networks Octeon", stdout);
16596       break;
16597     case AFL_EXT_5900:
16598       fputs ("Toshiba R5900", stdout);
16599       break;
16600     case AFL_EXT_4650:
16601       fputs ("MIPS R4650", stdout);
16602       break;
16603     case AFL_EXT_4010:
16604       fputs ("LSI R4010", stdout);
16605       break;
16606     case AFL_EXT_4100:
16607       fputs ("NEC VR4100", stdout);
16608       break;
16609     case AFL_EXT_3900:
16610       fputs ("Toshiba R3900", stdout);
16611       break;
16612     case AFL_EXT_10000:
16613       fputs ("MIPS R10000", stdout);
16614       break;
16615     case AFL_EXT_SB1:
16616       fputs ("Broadcom SB-1", stdout);
16617       break;
16618     case AFL_EXT_4111:
16619       fputs ("NEC VR4111/VR4181", stdout);
16620       break;
16621     case AFL_EXT_4120:
16622       fputs ("NEC VR4120", stdout);
16623       break;
16624     case AFL_EXT_5400:
16625       fputs ("NEC VR5400", stdout);
16626       break;
16627     case AFL_EXT_5500:
16628       fputs ("NEC VR5500", stdout);
16629       break;
16630     case AFL_EXT_LOONGSON_2E:
16631       fputs ("ST Microelectronics Loongson 2E", stdout);
16632       break;
16633     case AFL_EXT_LOONGSON_2F:
16634       fputs ("ST Microelectronics Loongson 2F", stdout);
16635       break;
16636     case AFL_EXT_INTERAPTIV_MR2:
16637       fputs ("Imagination interAptiv MR2", stdout);
16638       break;
16639     default:
16640       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
16641     }
16642 }
16643
16644 static signed int
16645 get_mips_reg_size (int reg_size)
16646 {
16647   return (reg_size == AFL_REG_NONE) ? 0
16648          : (reg_size == AFL_REG_32) ? 32
16649          : (reg_size == AFL_REG_64) ? 64
16650          : (reg_size == AFL_REG_128) ? 128
16651          : -1;
16652 }
16653
16654 static bfd_boolean
16655 process_mips_specific (Filedata * filedata)
16656 {
16657   Elf_Internal_Dyn * entry;
16658   Elf_Internal_Shdr *sect = NULL;
16659   size_t liblist_offset = 0;
16660   size_t liblistno = 0;
16661   size_t conflictsno = 0;
16662   size_t options_offset = 0;
16663   size_t conflicts_offset = 0;
16664   size_t pltrelsz = 0;
16665   size_t pltrel = 0;
16666   bfd_vma pltgot = 0;
16667   bfd_vma mips_pltgot = 0;
16668   bfd_vma jmprel = 0;
16669   bfd_vma local_gotno = 0;
16670   bfd_vma gotsym = 0;
16671   bfd_vma symtabno = 0;
16672   bfd_boolean res = TRUE;
16673
16674   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
16675                             display_mips_gnu_attribute))
16676     res = FALSE;
16677
16678   sect = find_section (filedata, ".MIPS.abiflags");
16679
16680   if (sect != NULL)
16681     {
16682       Elf_External_ABIFlags_v0 *abiflags_ext;
16683       Elf_Internal_ABIFlags_v0 abiflags_in;
16684
16685       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
16686         {
16687           error (_("Corrupt MIPS ABI Flags section.\n"));
16688           res = FALSE;
16689         }
16690       else
16691         {
16692           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
16693                                    sect->sh_size, _("MIPS ABI Flags section"));
16694           if (abiflags_ext)
16695             {
16696               abiflags_in.version = BYTE_GET (abiflags_ext->version);
16697               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
16698               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
16699               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
16700               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
16701               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
16702               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
16703               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
16704               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
16705               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
16706               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
16707
16708               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
16709               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
16710               if (abiflags_in.isa_rev > 1)
16711                 printf ("r%d", abiflags_in.isa_rev);
16712               printf ("\nGPR size: %d",
16713                       get_mips_reg_size (abiflags_in.gpr_size));
16714               printf ("\nCPR1 size: %d",
16715                       get_mips_reg_size (abiflags_in.cpr1_size));
16716               printf ("\nCPR2 size: %d",
16717                       get_mips_reg_size (abiflags_in.cpr2_size));
16718               fputs ("\nFP ABI: ", stdout);
16719               print_mips_fp_abi_value (abiflags_in.fp_abi);
16720               fputs ("ISA Extension: ", stdout);
16721               print_mips_isa_ext (abiflags_in.isa_ext);
16722               fputs ("\nASEs:", stdout);
16723               print_mips_ases (abiflags_in.ases);
16724               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
16725               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
16726               fputc ('\n', stdout);
16727               free (abiflags_ext);
16728             }
16729         }
16730     }
16731
16732   /* We have a lot of special sections.  Thanks SGI!  */
16733   if (filedata->dynamic_section == NULL)
16734     {
16735       /* No dynamic information available.  See if there is static GOT.  */
16736       sect = find_section (filedata, ".got");
16737       if (sect != NULL)
16738         {
16739           unsigned char *data_end;
16740           unsigned char *data;
16741           bfd_vma ent, end;
16742           int addr_size;
16743
16744           pltgot = sect->sh_addr;
16745
16746           ent = pltgot;
16747           addr_size = (is_32bit_elf ? 4 : 8);
16748           end = pltgot + sect->sh_size;
16749
16750           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
16751                                              end - pltgot, 1,
16752                                              _("Global Offset Table data"));
16753           /* PR 12855: Null data is handled gracefully throughout.  */
16754           data_end = data + (end - pltgot);
16755
16756           printf (_("\nStatic GOT:\n"));
16757           printf (_(" Canonical gp value: "));
16758           print_vma (ent + 0x7ff0, LONG_HEX);
16759           printf ("\n\n");
16760
16761           /* In a dynamic binary GOT[0] is reserved for the dynamic
16762              loader to store the lazy resolver pointer, however in
16763              a static binary it may well have been omitted and GOT
16764              reduced to a table of addresses.
16765              PR 21344: Check for the entry being fully available
16766              before fetching it.  */
16767           if (data
16768               && data + ent - pltgot + addr_size <= data_end
16769               && byte_get (data + ent - pltgot, addr_size) == 0)
16770             {
16771               printf (_(" Reserved entries:\n"));
16772               printf (_("  %*s %10s %*s\n"),
16773                       addr_size * 2, _("Address"), _("Access"),
16774                       addr_size * 2, _("Value"));
16775               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16776               printf ("\n");
16777               if (ent == (bfd_vma) -1)
16778                 goto sgot_print_fail;
16779
16780               /* Check for the MSB of GOT[1] being set, identifying a
16781                  GNU object.  This entry will be used by some runtime
16782                  loaders, to store the module pointer.  Otherwise this
16783                  is an ordinary local entry.
16784                  PR 21344: Check for the entry being fully available
16785                  before fetching it.  */
16786               if (data
16787                   && data + ent - pltgot + addr_size <= data_end
16788                   && (byte_get (data + ent - pltgot, addr_size)
16789                       >> (addr_size * 8 - 1)) != 0)
16790                 {
16791                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
16792                   printf ("\n");
16793                   if (ent == (bfd_vma) -1)
16794                     goto sgot_print_fail;
16795                 }
16796               printf ("\n");
16797             }
16798
16799           if (data != NULL && ent < end)
16800             {
16801               printf (_(" Local entries:\n"));
16802               printf ("  %*s %10s %*s\n",
16803                       addr_size * 2, _("Address"), _("Access"),
16804                       addr_size * 2, _("Value"));
16805               while (ent < end)
16806                 {
16807                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
16808                   printf ("\n");
16809                   if (ent == (bfd_vma) -1)
16810                     goto sgot_print_fail;
16811                 }
16812               printf ("\n");
16813             }
16814
16815         sgot_print_fail:
16816           free (data);
16817         }
16818       return res;
16819     }
16820
16821   for (entry = filedata->dynamic_section;
16822        /* PR 17531 file: 012-50589-0.004.  */
16823        (entry < filedata->dynamic_section + filedata->dynamic_nent
16824         && entry->d_tag != DT_NULL);
16825        ++entry)
16826     switch (entry->d_tag)
16827       {
16828       case DT_MIPS_LIBLIST:
16829         liblist_offset
16830           = offset_from_vma (filedata, entry->d_un.d_val,
16831                              liblistno * sizeof (Elf32_External_Lib));
16832         break;
16833       case DT_MIPS_LIBLISTNO:
16834         liblistno = entry->d_un.d_val;
16835         break;
16836       case DT_MIPS_OPTIONS:
16837         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
16838         break;
16839       case DT_MIPS_CONFLICT:
16840         conflicts_offset
16841           = offset_from_vma (filedata, entry->d_un.d_val,
16842                              conflictsno * sizeof (Elf32_External_Conflict));
16843         break;
16844       case DT_MIPS_CONFLICTNO:
16845         conflictsno = entry->d_un.d_val;
16846         break;
16847       case DT_PLTGOT:
16848         pltgot = entry->d_un.d_ptr;
16849         break;
16850       case DT_MIPS_LOCAL_GOTNO:
16851         local_gotno = entry->d_un.d_val;
16852         break;
16853       case DT_MIPS_GOTSYM:
16854         gotsym = entry->d_un.d_val;
16855         break;
16856       case DT_MIPS_SYMTABNO:
16857         symtabno = entry->d_un.d_val;
16858         break;
16859       case DT_MIPS_PLTGOT:
16860         mips_pltgot = entry->d_un.d_ptr;
16861         break;
16862       case DT_PLTREL:
16863         pltrel = entry->d_un.d_val;
16864         break;
16865       case DT_PLTRELSZ:
16866         pltrelsz = entry->d_un.d_val;
16867         break;
16868       case DT_JMPREL:
16869         jmprel = entry->d_un.d_ptr;
16870         break;
16871       default:
16872         break;
16873       }
16874
16875   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
16876     {
16877       Elf32_External_Lib * elib;
16878       size_t cnt;
16879
16880       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
16881                                               sizeof (Elf32_External_Lib),
16882                                               liblistno,
16883                                               _("liblist section data"));
16884       if (elib)
16885         {
16886           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16887                             "\nSection '.liblist' contains %lu entries:\n",
16888                             (unsigned long) liblistno),
16889                   (unsigned long) liblistno);
16890           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
16891                  stdout);
16892
16893           for (cnt = 0; cnt < liblistno; ++cnt)
16894             {
16895               Elf32_Lib liblist;
16896               time_t atime;
16897               char timebuf[128];
16898               struct tm * tmp;
16899
16900               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16901               atime = BYTE_GET (elib[cnt].l_time_stamp);
16902               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16903               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16904               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16905
16906               tmp = gmtime (&atime);
16907               snprintf (timebuf, sizeof (timebuf),
16908                         "%04u-%02u-%02uT%02u:%02u:%02u",
16909                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16910                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16911
16912               printf ("%3lu: ", (unsigned long) cnt);
16913               if (VALID_DYNAMIC_NAME (filedata, liblist.l_name))
16914                 print_symbol (20, GET_DYNAMIC_NAME (filedata, liblist.l_name));
16915               else
16916                 printf (_("<corrupt: %9ld>"), liblist.l_name);
16917               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16918                       liblist.l_version);
16919
16920               if (liblist.l_flags == 0)
16921                 puts (_(" NONE"));
16922               else
16923                 {
16924                   static const struct
16925                   {
16926                     const char * name;
16927                     int bit;
16928                   }
16929                   l_flags_vals[] =
16930                   {
16931                     { " EXACT_MATCH", LL_EXACT_MATCH },
16932                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16933                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16934                     { " EXPORTS", LL_EXPORTS },
16935                     { " DELAY_LOAD", LL_DELAY_LOAD },
16936                     { " DELTA", LL_DELTA }
16937                   };
16938                   int flags = liblist.l_flags;
16939                   size_t fcnt;
16940
16941                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16942                     if ((flags & l_flags_vals[fcnt].bit) != 0)
16943                       {
16944                         fputs (l_flags_vals[fcnt].name, stdout);
16945                         flags ^= l_flags_vals[fcnt].bit;
16946                       }
16947                   if (flags != 0)
16948                     printf (" %#x", (unsigned int) flags);
16949
16950                   puts ("");
16951                 }
16952             }
16953
16954           free (elib);
16955         }
16956       else
16957         res = FALSE;
16958     }
16959
16960   if (options_offset != 0)
16961     {
16962       Elf_External_Options * eopt;
16963       size_t offset;
16964       int cnt;
16965       sect = filedata->section_headers;
16966
16967       /* Find the section header so that we get the size.  */
16968       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16969       /* PR 17533 file: 012-277276-0.004.  */
16970       if (sect == NULL)
16971         {
16972           error (_("No MIPS_OPTIONS header found\n"));
16973           return FALSE;
16974         }
16975       /* PR 24243  */
16976       if (sect->sh_size < sizeof (* eopt))
16977         {
16978           error (_("The MIPS options section is too small.\n"));
16979           return FALSE;
16980         }
16981
16982       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16983                                                 sect->sh_size, _("options"));
16984       if (eopt)
16985         {
16986           Elf_Internal_Options option;
16987
16988           offset = cnt = 0;
16989           while (offset <= sect->sh_size - sizeof (* eopt))
16990             {
16991               Elf_External_Options * eoption;
16992               unsigned int optsize;
16993
16994               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16995
16996               optsize = BYTE_GET (eoption->size);
16997
16998               /* PR 17531: file: ffa0fa3b.  */
16999               if (optsize < sizeof (* eopt)
17000                   || optsize > sect->sh_size - offset)
17001                 {
17002                   error (_("Invalid size (%u) for MIPS option\n"),
17003                          optsize);
17004                   free (eopt);
17005                   return FALSE;
17006                 }
17007               offset += optsize;
17008               ++cnt;
17009             }
17010
17011           printf (ngettext ("\nSection '%s' contains %d entry:\n",
17012                             "\nSection '%s' contains %d entries:\n",
17013                             cnt),
17014                   printable_section_name (filedata, sect), cnt);
17015
17016           offset = 0;
17017           while (cnt-- > 0)
17018             {
17019               size_t len;
17020               Elf_External_Options * eoption;
17021
17022               eoption = (Elf_External_Options *) ((char *) eopt + offset);
17023
17024               option.kind = BYTE_GET (eoption->kind);
17025               option.size = BYTE_GET (eoption->size);
17026               option.section = BYTE_GET (eoption->section);
17027               option.info = BYTE_GET (eoption->info);
17028
17029               switch (option.kind)
17030                 {
17031                 case ODK_NULL:
17032                   /* This shouldn't happen.  */
17033                   printf (" NULL       %" PRId16 " %" PRIx32,
17034                           option.section, option.info);
17035                   break;
17036
17037                 case ODK_REGINFO:
17038                   printf (" REGINFO    ");
17039                   if (filedata->file_header.e_machine == EM_MIPS)
17040                     {
17041                       Elf32_External_RegInfo * ereg;
17042                       Elf32_RegInfo reginfo;
17043
17044                       /* 32bit form.  */
17045                       if (option.size < (sizeof (Elf_External_Options)
17046                                          + sizeof (Elf32_External_RegInfo)))
17047                         {
17048                           printf (_("<corrupt>\n"));
17049                           error (_("Truncated MIPS REGINFO option\n"));
17050                           cnt = 0;
17051                           break;
17052                         }
17053
17054                       ereg = (Elf32_External_RegInfo *) (eoption + 1);
17055
17056                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
17057                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
17058                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
17059                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
17060                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
17061                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
17062
17063                       printf ("GPR %08" PRIx32 "  GP 0x%" PRIx32 "\n",
17064                               reginfo.ri_gprmask, reginfo.ri_gp_value);
17065                       printf ("          "
17066                               "  CPR0 %08" PRIx32 "  CPR1 %08" PRIx32
17067                               "  CPR2 %08" PRIx32 "  CPR3 %08" PRIx32 "\n",
17068                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
17069                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
17070                     }
17071                   else
17072                     {
17073                       /* 64 bit form.  */
17074                       Elf64_External_RegInfo * ereg;
17075                       Elf64_Internal_RegInfo reginfo;
17076
17077                       if (option.size < (sizeof (Elf_External_Options)
17078                                          + sizeof (Elf64_External_RegInfo)))
17079                         {
17080                           printf (_("<corrupt>\n"));
17081                           error (_("Truncated MIPS REGINFO option\n"));
17082                           cnt = 0;
17083                           break;
17084                         }
17085
17086                       ereg = (Elf64_External_RegInfo *) (eoption + 1);
17087                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
17088                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
17089                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
17090                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
17091                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
17092                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
17093
17094                       printf ("GPR %08" PRIx32 "  GP 0x%" PRIx64 "\n",
17095                               reginfo.ri_gprmask, reginfo.ri_gp_value);
17096                       printf ("          "
17097                               "  CPR0 %08" PRIx32 "  CPR1 %08" PRIx32
17098                               "  CPR2 %08" PRIx32 "  CPR3 %08" PRIx32 "\n",
17099                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
17100                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
17101                     }
17102                   offset += option.size;
17103                   continue;
17104
17105                 case ODK_EXCEPTIONS:
17106                   fputs (" EXCEPTIONS fpe_min(", stdout);
17107                   process_mips_fpe_exception (option.info & OEX_FPU_MIN);
17108                   fputs (") fpe_max(", stdout);
17109                   process_mips_fpe_exception ((option.info & OEX_FPU_MAX) >> 8);
17110                   fputs (")", stdout);
17111
17112                   if (option.info & OEX_PAGE0)
17113                     fputs (" PAGE0", stdout);
17114                   if (option.info & OEX_SMM)
17115                     fputs (" SMM", stdout);
17116                   if (option.info & OEX_FPDBUG)
17117                     fputs (" FPDBUG", stdout);
17118                   if (option.info & OEX_DISMISS)
17119                     fputs (" DISMISS", stdout);
17120                   break;
17121
17122                 case ODK_PAD:
17123                   fputs (" PAD       ", stdout);
17124                   if (option.info & OPAD_PREFIX)
17125                     fputs (" PREFIX", stdout);
17126                   if (option.info & OPAD_POSTFIX)
17127                     fputs (" POSTFIX", stdout);
17128                   if (option.info & OPAD_SYMBOL)
17129                     fputs (" SYMBOL", stdout);
17130                   break;
17131
17132                 case ODK_HWPATCH:
17133                   fputs (" HWPATCH   ", stdout);
17134                   if (option.info & OHW_R4KEOP)
17135                     fputs (" R4KEOP", stdout);
17136                   if (option.info & OHW_R8KPFETCH)
17137                     fputs (" R8KPFETCH", stdout);
17138                   if (option.info & OHW_R5KEOP)
17139                     fputs (" R5KEOP", stdout);
17140                   if (option.info & OHW_R5KCVTL)
17141                     fputs (" R5KCVTL", stdout);
17142                   break;
17143
17144                 case ODK_FILL:
17145                   fputs (" FILL       ", stdout);
17146                   /* XXX Print content of info word?  */
17147                   break;
17148
17149                 case ODK_TAGS:
17150                   fputs (" TAGS       ", stdout);
17151                   /* XXX Print content of info word?  */
17152                   break;
17153
17154                 case ODK_HWAND:
17155                   fputs (" HWAND     ", stdout);
17156                   if (option.info & OHWA0_R4KEOP_CHECKED)
17157                     fputs (" R4KEOP_CHECKED", stdout);
17158                   if (option.info & OHWA0_R4KEOP_CLEAN)
17159                     fputs (" R4KEOP_CLEAN", stdout);
17160                   break;
17161
17162                 case ODK_HWOR:
17163                   fputs (" HWOR      ", stdout);
17164                   if (option.info & OHWA0_R4KEOP_CHECKED)
17165                     fputs (" R4KEOP_CHECKED", stdout);
17166                   if (option.info & OHWA0_R4KEOP_CLEAN)
17167                     fputs (" R4KEOP_CLEAN", stdout);
17168                   break;
17169
17170                 case ODK_GP_GROUP:
17171                   printf (" GP_GROUP  %#06x  self-contained %#06x",
17172                           option.info & OGP_GROUP,
17173                           (option.info & OGP_SELF) >> 16);
17174                   break;
17175
17176                 case ODK_IDENT:
17177                   printf (" IDENT     %#06x  self-contained %#06x",
17178                           option.info & OGP_GROUP,
17179                           (option.info & OGP_SELF) >> 16);
17180                   break;
17181
17182                 default:
17183                   /* This shouldn't happen.  */
17184                   printf (" %3d ???     %" PRId16 " %" PRIx32,
17185                           option.kind, option.section, option.info);
17186                   break;
17187                 }
17188
17189               len = sizeof (* eopt);
17190               while (len < option.size)
17191                 {
17192                   unsigned char datum = *((unsigned char *) eoption + len);
17193
17194                   if (ISPRINT (datum))
17195                     printf ("%c", datum);
17196                   else
17197                     printf ("\\%03o", datum);
17198                   len ++;
17199                 }
17200               fputs ("\n", stdout);
17201
17202               offset += option.size;
17203             }
17204           free (eopt);
17205         }
17206       else
17207         res = FALSE;
17208     }
17209
17210   if (conflicts_offset != 0 && conflictsno != 0)
17211     {
17212       Elf32_Conflict * iconf;
17213       size_t cnt;
17214
17215       if (filedata->dynamic_symbols == NULL)
17216         {
17217           error (_("conflict list found without a dynamic symbol table\n"));
17218           return FALSE;
17219         }
17220
17221       /* PR 21345 - print a slightly more helpful error message
17222          if we are sure that the cmalloc will fail.  */
17223       if (conflictsno > filedata->file_size / sizeof (* iconf))
17224         {
17225           error (_("Overlarge number of conflicts detected: %lx\n"),
17226                  (long) conflictsno);
17227           return FALSE;
17228         }
17229
17230       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
17231       if (iconf == NULL)
17232         {
17233           error (_("Out of memory allocating space for dynamic conflicts\n"));
17234           return FALSE;
17235         }
17236
17237       if (is_32bit_elf)
17238         {
17239           Elf32_External_Conflict * econf32;
17240
17241           econf32 = (Elf32_External_Conflict *)
17242             get_data (NULL, filedata, conflicts_offset,
17243                       sizeof (*econf32), conflictsno, _("conflict"));
17244           if (!econf32)
17245             {
17246               free (iconf);
17247               return FALSE;
17248             }
17249
17250           for (cnt = 0; cnt < conflictsno; ++cnt)
17251             iconf[cnt] = BYTE_GET (econf32[cnt]);
17252
17253           free (econf32);
17254         }
17255       else
17256         {
17257           Elf64_External_Conflict * econf64;
17258
17259           econf64 = (Elf64_External_Conflict *)
17260             get_data (NULL, filedata, conflicts_offset,
17261                       sizeof (*econf64), conflictsno, _("conflict"));
17262           if (!econf64)
17263             {
17264               free (iconf);
17265               return FALSE;
17266             }
17267
17268           for (cnt = 0; cnt < conflictsno; ++cnt)
17269             iconf[cnt] = BYTE_GET (econf64[cnt]);
17270
17271           free (econf64);
17272         }
17273
17274       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17275                         "\nSection '.conflict' contains %lu entries:\n",
17276                         (unsigned long) conflictsno),
17277               (unsigned long) conflictsno);
17278       puts (_("  Num:    Index       Value  Name"));
17279
17280       for (cnt = 0; cnt < conflictsno; ++cnt)
17281         {
17282           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
17283
17284           if (iconf[cnt] >= filedata->num_dynamic_syms)
17285             printf (_("<corrupt symbol index>"));
17286           else
17287             {
17288               Elf_Internal_Sym * psym;
17289
17290               psym = & filedata->dynamic_symbols[iconf[cnt]];
17291               print_vma (psym->st_value, FULL_HEX);
17292               putchar (' ');
17293               if (VALID_DYNAMIC_NAME (filedata, psym->st_name))
17294                 print_symbol (25, GET_DYNAMIC_NAME (filedata, psym->st_name));
17295               else
17296                 printf (_("<corrupt: %14ld>"), psym->st_name);
17297             }
17298           putchar ('\n');
17299         }
17300
17301       free (iconf);
17302     }
17303
17304   if (pltgot != 0 && local_gotno != 0)
17305     {
17306       bfd_vma ent, local_end, global_end;
17307       size_t i, offset;
17308       unsigned char * data;
17309       unsigned char * data_end;
17310       int addr_size;
17311
17312       ent = pltgot;
17313       addr_size = (is_32bit_elf ? 4 : 8);
17314       local_end = pltgot + local_gotno * addr_size;
17315
17316       /* PR binutils/17533 file: 012-111227-0.004  */
17317       if (symtabno < gotsym)
17318         {
17319           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17320                  (unsigned long) gotsym, (unsigned long) symtabno);
17321           return FALSE;
17322         }
17323
17324       global_end = local_end + (symtabno - gotsym) * addr_size;
17325       /* PR 17531: file: 54c91a34.  */
17326       if (global_end < local_end)
17327         {
17328           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
17329           return FALSE;
17330         }
17331
17332       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
17333       data = (unsigned char *) get_data (NULL, filedata, offset,
17334                                          global_end - pltgot, 1,
17335                                          _("Global Offset Table data"));
17336       /* PR 12855: Null data is handled gracefully throughout.  */
17337       data_end = data + (global_end - pltgot);
17338
17339       printf (_("\nPrimary GOT:\n"));
17340       printf (_(" Canonical gp value: "));
17341       print_vma (pltgot + 0x7ff0, LONG_HEX);
17342       printf ("\n\n");
17343
17344       printf (_(" Reserved entries:\n"));
17345       printf (_("  %*s %10s %*s Purpose\n"),
17346               addr_size * 2, _("Address"), _("Access"),
17347               addr_size * 2, _("Initial"));
17348       ent = print_mips_got_entry (data, pltgot, ent, data_end);
17349       printf (_(" Lazy resolver\n"));
17350       if (ent == (bfd_vma) -1)
17351         goto got_print_fail;
17352
17353       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17354          This entry will be used by some runtime loaders, to store the
17355          module pointer.  Otherwise this is an ordinary local entry.
17356          PR 21344: Check for the entry being fully available before
17357          fetching it.  */
17358       if (data
17359           && data + ent - pltgot + addr_size <= data_end
17360           && (byte_get (data + ent - pltgot, addr_size)
17361               >> (addr_size * 8 - 1)) != 0)
17362         {
17363           ent = print_mips_got_entry (data, pltgot, ent, data_end);
17364           printf (_(" Module pointer (GNU extension)\n"));
17365           if (ent == (bfd_vma) -1)
17366             goto got_print_fail;
17367         }
17368       printf ("\n");
17369
17370       if (data != NULL && ent < local_end)
17371         {
17372           printf (_(" Local entries:\n"));
17373           printf ("  %*s %10s %*s\n",
17374                   addr_size * 2, _("Address"), _("Access"),
17375                   addr_size * 2, _("Initial"));
17376           while (ent < local_end)
17377             {
17378               ent = print_mips_got_entry (data, pltgot, ent, data_end);
17379               printf ("\n");
17380               if (ent == (bfd_vma) -1)
17381                 goto got_print_fail;
17382             }
17383           printf ("\n");
17384         }
17385
17386       if (data != NULL && gotsym < symtabno)
17387         {
17388           int sym_width;
17389
17390           printf (_(" Global entries:\n"));
17391           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
17392                   addr_size * 2, _("Address"),
17393                   _("Access"),
17394                   addr_size * 2, _("Initial"),
17395                   addr_size * 2, _("Sym.Val."),
17396                   _("Type"),
17397                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
17398                   _("Ndx"), _("Name"));
17399
17400           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
17401
17402           for (i = gotsym; i < symtabno; i++)
17403             {
17404               ent = print_mips_got_entry (data, pltgot, ent, data_end);
17405               printf (" ");
17406
17407               if (filedata->dynamic_symbols == NULL)
17408                 printf (_("<no dynamic symbols>"));
17409               else if (i < filedata->num_dynamic_syms)
17410                 {
17411                   Elf_Internal_Sym * psym = filedata->dynamic_symbols + i;
17412
17413                   print_vma (psym->st_value, LONG_HEX);
17414                   printf (" %-7s %3s ",
17415                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17416                           get_symbol_index_type (filedata, psym->st_shndx));
17417
17418                   if (VALID_DYNAMIC_NAME (filedata, psym->st_name))
17419                     print_symbol (sym_width,
17420                                   GET_DYNAMIC_NAME (filedata, psym->st_name));
17421                   else
17422                     printf (_("<corrupt: %14ld>"), psym->st_name);
17423                 }
17424               else
17425                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17426                         (unsigned long) i);
17427
17428               printf ("\n");
17429               if (ent == (bfd_vma) -1)
17430                 break;
17431             }
17432           printf ("\n");
17433         }
17434
17435     got_print_fail:
17436       free (data);
17437     }
17438
17439   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
17440     {
17441       bfd_vma ent, end;
17442       size_t offset, rel_offset;
17443       unsigned long count, i;
17444       unsigned char * data;
17445       int addr_size, sym_width;
17446       Elf_Internal_Rela * rels;
17447
17448       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
17449       if (pltrel == DT_RELA)
17450         {
17451           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17452             return FALSE;
17453         }
17454       else
17455         {
17456           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17457             return FALSE;
17458         }
17459
17460       ent = mips_pltgot;
17461       addr_size = (is_32bit_elf ? 4 : 8);
17462       end = mips_pltgot + (2 + count) * addr_size;
17463
17464       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
17465       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
17466                                          1, _("Procedure Linkage Table data"));
17467       if (data == NULL)
17468         return FALSE;
17469
17470       printf ("\nPLT GOT:\n\n");
17471       printf (_(" Reserved entries:\n"));
17472       printf (_("  %*s %*s Purpose\n"),
17473               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
17474       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17475       printf (_(" PLT lazy resolver\n"));
17476       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17477       printf (_(" Module pointer\n"));
17478       printf ("\n");
17479
17480       printf (_(" Entries:\n"));
17481       printf ("  %*s %*s %*s %-7s %3s %s\n",
17482               addr_size * 2, _("Address"),
17483               addr_size * 2, _("Initial"),
17484               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17485       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
17486       for (i = 0; i < count; i++)
17487         {
17488           unsigned long idx = get_reloc_symindex (rels[i].r_info);
17489
17490           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17491           printf (" ");
17492
17493           if (idx >= filedata->num_dynamic_syms)
17494             printf (_("<corrupt symbol index: %lu>"), idx);
17495           else
17496             {
17497               Elf_Internal_Sym * psym = filedata->dynamic_symbols + idx;
17498
17499               print_vma (psym->st_value, LONG_HEX);
17500               printf (" %-7s %3s ",
17501                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17502                       get_symbol_index_type (filedata, psym->st_shndx));
17503               if (VALID_DYNAMIC_NAME (filedata, psym->st_name))
17504                 print_symbol (sym_width,
17505                               GET_DYNAMIC_NAME (filedata, psym->st_name));
17506               else
17507                 printf (_("<corrupt: %14ld>"), psym->st_name);
17508             }
17509           printf ("\n");
17510         }
17511       printf ("\n");
17512
17513       free (data);
17514       free (rels);
17515     }
17516
17517   return res;
17518 }
17519
17520 static bfd_boolean
17521 process_nds32_specific (Filedata * filedata)
17522 {
17523   Elf_Internal_Shdr *sect = NULL;
17524
17525   sect = find_section (filedata, ".nds32_e_flags");
17526   if (sect != NULL && sect->sh_size >= 4)
17527     {
17528       unsigned char *buf;
17529       unsigned int flag;
17530
17531       printf ("\nNDS32 elf flags section:\n");
17532       buf = get_data (NULL, filedata, sect->sh_offset, 1, 4,
17533                       _("NDS32 elf flags section"));
17534
17535       if (buf == NULL)
17536         return FALSE;
17537
17538       flag = byte_get (buf, 4);
17539       free (buf);
17540       switch (flag & 0x3)
17541         {
17542         case 0:
17543           printf ("(VEC_SIZE):\tNo entry.\n");
17544           break;
17545         case 1:
17546           printf ("(VEC_SIZE):\t4 bytes\n");
17547           break;
17548         case 2:
17549           printf ("(VEC_SIZE):\t16 bytes\n");
17550           break;
17551         case 3:
17552           printf ("(VEC_SIZE):\treserved\n");
17553           break;
17554         }
17555     }
17556
17557   return TRUE;
17558 }
17559
17560 static bfd_boolean
17561 process_gnu_liblist (Filedata * filedata)
17562 {
17563   Elf_Internal_Shdr * section;
17564   Elf_Internal_Shdr * string_sec;
17565   Elf32_External_Lib * elib;
17566   char * strtab;
17567   size_t strtab_size;
17568   size_t cnt;
17569   unsigned long num_liblist;
17570   unsigned i;
17571   bfd_boolean res = TRUE;
17572
17573   if (! do_arch)
17574     return TRUE;
17575
17576   for (i = 0, section = filedata->section_headers;
17577        i < filedata->file_header.e_shnum;
17578        i++, section++)
17579     {
17580       switch (section->sh_type)
17581         {
17582         case SHT_GNU_LIBLIST:
17583           if (section->sh_link >= filedata->file_header.e_shnum)
17584             break;
17585
17586           elib = (Elf32_External_Lib *)
17587               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
17588                         _("liblist section data"));
17589
17590           if (elib == NULL)
17591             {
17592               res = FALSE;
17593               break;
17594             }
17595
17596           string_sec = filedata->section_headers + section->sh_link;
17597           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
17598                                       string_sec->sh_size,
17599                                       _("liblist string table"));
17600           if (strtab == NULL
17601               || section->sh_entsize != sizeof (Elf32_External_Lib))
17602             {
17603               free (elib);
17604               free (strtab);
17605               res = FALSE;
17606               break;
17607             }
17608           strtab_size = string_sec->sh_size;
17609
17610           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
17611           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17612                             "\nLibrary list section '%s' contains %lu entries:\n",
17613                             num_liblist),
17614                   printable_section_name (filedata, section),
17615                   num_liblist);
17616
17617           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
17618
17619           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
17620                ++cnt)
17621             {
17622               Elf32_Lib liblist;
17623               time_t atime;
17624               char timebuf[128];
17625               struct tm * tmp;
17626
17627               liblist.l_name = BYTE_GET (elib[cnt].l_name);
17628               atime = BYTE_GET (elib[cnt].l_time_stamp);
17629               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
17630               liblist.l_version = BYTE_GET (elib[cnt].l_version);
17631               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
17632
17633               tmp = gmtime (&atime);
17634               snprintf (timebuf, sizeof (timebuf),
17635                         "%04u-%02u-%02uT%02u:%02u:%02u",
17636                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
17637                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
17638
17639               printf ("%3lu: ", (unsigned long) cnt);
17640               if (do_wide)
17641                 printf ("%-20s", liblist.l_name < strtab_size
17642                         ? strtab + liblist.l_name : _("<corrupt>"));
17643               else
17644                 printf ("%-20.20s", liblist.l_name < strtab_size
17645                         ? strtab + liblist.l_name : _("<corrupt>"));
17646               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
17647                       liblist.l_version, liblist.l_flags);
17648             }
17649
17650           free (elib);
17651           free (strtab);
17652         }
17653     }
17654
17655   return res;
17656 }
17657
17658 static const char *
17659 get_note_type (Filedata * filedata, unsigned e_type)
17660 {
17661   static char buff[64];
17662
17663   if (filedata->file_header.e_type == ET_CORE)
17664     switch (e_type)
17665       {
17666       case NT_AUXV:
17667         return _("NT_AUXV (auxiliary vector)");
17668       case NT_PRSTATUS:
17669         return _("NT_PRSTATUS (prstatus structure)");
17670       case NT_FPREGSET:
17671         return _("NT_FPREGSET (floating point registers)");
17672       case NT_PRPSINFO:
17673         return _("NT_PRPSINFO (prpsinfo structure)");
17674       case NT_TASKSTRUCT:
17675         return _("NT_TASKSTRUCT (task structure)");
17676       case NT_PRXFPREG:
17677         return _("NT_PRXFPREG (user_xfpregs structure)");
17678       case NT_PPC_VMX:
17679         return _("NT_PPC_VMX (ppc Altivec registers)");
17680       case NT_PPC_VSX:
17681         return _("NT_PPC_VSX (ppc VSX registers)");
17682       case NT_PPC_TAR:
17683         return _("NT_PPC_TAR (ppc TAR register)");
17684       case NT_PPC_PPR:
17685         return _("NT_PPC_PPR (ppc PPR register)");
17686       case NT_PPC_DSCR:
17687         return _("NT_PPC_DSCR (ppc DSCR register)");
17688       case NT_PPC_EBB:
17689         return _("NT_PPC_EBB (ppc EBB registers)");
17690       case NT_PPC_PMU:
17691         return _("NT_PPC_PMU (ppc PMU registers)");
17692       case NT_PPC_TM_CGPR:
17693         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17694       case NT_PPC_TM_CFPR:
17695         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17696       case NT_PPC_TM_CVMX:
17697         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17698       case NT_PPC_TM_CVSX:
17699         return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17700       case NT_PPC_TM_SPR:
17701         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17702       case NT_PPC_TM_CTAR:
17703         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17704       case NT_PPC_TM_CPPR:
17705         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17706       case NT_PPC_TM_CDSCR:
17707         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17708       case NT_386_TLS:
17709         return _("NT_386_TLS (x86 TLS information)");
17710       case NT_386_IOPERM:
17711         return _("NT_386_IOPERM (x86 I/O permissions)");
17712       case NT_X86_XSTATE:
17713         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17714       case NT_S390_HIGH_GPRS:
17715         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17716       case NT_S390_TIMER:
17717         return _("NT_S390_TIMER (s390 timer register)");
17718       case NT_S390_TODCMP:
17719         return _("NT_S390_TODCMP (s390 TOD comparator register)");
17720       case NT_S390_TODPREG:
17721         return _("NT_S390_TODPREG (s390 TOD programmable register)");
17722       case NT_S390_CTRS:
17723         return _("NT_S390_CTRS (s390 control registers)");
17724       case NT_S390_PREFIX:
17725         return _("NT_S390_PREFIX (s390 prefix register)");
17726       case NT_S390_LAST_BREAK:
17727         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17728       case NT_S390_SYSTEM_CALL:
17729         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17730       case NT_S390_TDB:
17731         return _("NT_S390_TDB (s390 transaction diagnostic block)");
17732       case NT_S390_VXRS_LOW:
17733         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17734       case NT_S390_VXRS_HIGH:
17735         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17736       case NT_S390_GS_CB:
17737         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17738       case NT_S390_GS_BC:
17739         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17740       case NT_ARM_VFP:
17741         return _("NT_ARM_VFP (arm VFP registers)");
17742       case NT_ARM_TLS:
17743         return _("NT_ARM_TLS (AArch TLS registers)");
17744       case NT_ARM_HW_BREAK:
17745         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17746       case NT_ARM_HW_WATCH:
17747         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17748       case NT_ARC_V2:
17749         return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
17750       case NT_PSTATUS:
17751         return _("NT_PSTATUS (pstatus structure)");
17752       case NT_FPREGS:
17753         return _("NT_FPREGS (floating point registers)");
17754       case NT_PSINFO:
17755         return _("NT_PSINFO (psinfo structure)");
17756       case NT_LWPSTATUS:
17757         return _("NT_LWPSTATUS (lwpstatus_t structure)");
17758       case NT_LWPSINFO:
17759         return _("NT_LWPSINFO (lwpsinfo_t structure)");
17760       case NT_WIN32PSTATUS:
17761         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17762       case NT_SIGINFO:
17763         return _("NT_SIGINFO (siginfo_t data)");
17764       case NT_FILE:
17765         return _("NT_FILE (mapped files)");
17766       default:
17767         break;
17768       }
17769   else
17770     switch (e_type)
17771       {
17772       case NT_VERSION:
17773         return _("NT_VERSION (version)");
17774       case NT_ARCH:
17775         return _("NT_ARCH (architecture)");
17776       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17777         return _("OPEN");
17778       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17779         return _("func");
17780       default:
17781         break;
17782       }
17783
17784   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17785   return buff;
17786 }
17787
17788 static bfd_boolean
17789 print_core_note (Elf_Internal_Note *pnote)
17790 {
17791   unsigned int addr_size = is_32bit_elf ? 4 : 8;
17792   bfd_vma count, page_size;
17793   unsigned char *descdata, *filenames, *descend;
17794
17795   if (pnote->type != NT_FILE)
17796     {
17797       if (do_wide)
17798         printf ("\n");
17799       return TRUE;
17800     }
17801
17802 #ifndef BFD64
17803   if (!is_32bit_elf)
17804     {
17805       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
17806       /* Still "successful".  */
17807       return TRUE;
17808     }
17809 #endif
17810
17811   if (pnote->descsz < 2 * addr_size)
17812     {
17813       error (_("    Malformed note - too short for header\n"));
17814       return FALSE;
17815     }
17816
17817   descdata = (unsigned char *) pnote->descdata;
17818   descend = descdata + pnote->descsz;
17819
17820   if (descdata[pnote->descsz - 1] != '\0')
17821     {
17822       error (_("    Malformed note - does not end with \\0\n"));
17823       return FALSE;
17824     }
17825
17826   count = byte_get (descdata, addr_size);
17827   descdata += addr_size;
17828
17829   page_size = byte_get (descdata, addr_size);
17830   descdata += addr_size;
17831
17832   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
17833       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
17834     {
17835       error (_("    Malformed note - too short for supplied file count\n"));
17836       return FALSE;
17837     }
17838
17839   printf (_("    Page size: "));
17840   print_vma (page_size, DEC);
17841   printf ("\n");
17842
17843   printf (_("    %*s%*s%*s\n"),
17844           (int) (2 + 2 * addr_size), _("Start"),
17845           (int) (4 + 2 * addr_size), _("End"),
17846           (int) (4 + 2 * addr_size), _("Page Offset"));
17847   filenames = descdata + count * 3 * addr_size;
17848   while (count-- > 0)
17849     {
17850       bfd_vma start, end, file_ofs;
17851
17852       if (filenames == descend)
17853         {
17854           error (_("    Malformed note - filenames end too early\n"));
17855           return FALSE;
17856         }
17857
17858       start = byte_get (descdata, addr_size);
17859       descdata += addr_size;
17860       end = byte_get (descdata, addr_size);
17861       descdata += addr_size;
17862       file_ofs = byte_get (descdata, addr_size);
17863       descdata += addr_size;
17864
17865       printf ("    ");
17866       print_vma (start, FULL_HEX);
17867       printf ("  ");
17868       print_vma (end, FULL_HEX);
17869       printf ("  ");
17870       print_vma (file_ofs, FULL_HEX);
17871       printf ("\n        %s\n", filenames);
17872
17873       filenames += 1 + strlen ((char *) filenames);
17874     }
17875
17876   return TRUE;
17877 }
17878
17879 static const char *
17880 get_gnu_elf_note_type (unsigned e_type)
17881 {
17882   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
17883   switch (e_type)
17884     {
17885     case NT_GNU_ABI_TAG:
17886       return _("NT_GNU_ABI_TAG (ABI version tag)");
17887     case NT_GNU_HWCAP:
17888       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17889     case NT_GNU_BUILD_ID:
17890       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17891     case NT_GNU_GOLD_VERSION:
17892       return _("NT_GNU_GOLD_VERSION (gold version)");
17893     case NT_GNU_PROPERTY_TYPE_0:
17894       return _("NT_GNU_PROPERTY_TYPE_0");
17895     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17896       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17897     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17898       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17899     default:
17900       {
17901         static char buff[64];
17902
17903         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17904         return buff;
17905       }
17906     }
17907 }
17908
17909 static void
17910 decode_x86_compat_isa (unsigned int bitmask)
17911 {
17912   while (bitmask)
17913     {
17914       unsigned int bit = bitmask & (- bitmask);
17915
17916       bitmask &= ~ bit;
17917       switch (bit)
17918         {
17919         case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
17920           printf ("i486");
17921           break;
17922         case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
17923           printf ("586");
17924           break;
17925         case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
17926           printf ("686");
17927           break;
17928         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
17929           printf ("SSE");
17930           break;
17931         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17932           printf ("SSE2");
17933           break;
17934         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17935           printf ("SSE3");
17936           break;
17937         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17938           printf ("SSSE3");
17939           break;
17940         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17941           printf ("SSE4_1");
17942           break;
17943         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17944           printf ("SSE4_2");
17945           break;
17946         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17947           printf ("AVX");
17948           break;
17949         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17950           printf ("AVX2");
17951           break;
17952         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17953           printf ("AVX512F");
17954           break;
17955         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17956           printf ("AVX512CD");
17957           break;
17958         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17959           printf ("AVX512ER");
17960           break;
17961         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17962           printf ("AVX512PF");
17963           break;
17964         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17965           printf ("AVX512VL");
17966           break;
17967         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17968           printf ("AVX512DQ");
17969           break;
17970         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17971           printf ("AVX512BW");
17972           break;
17973         default:
17974           printf (_("<unknown: %x>"), bit);
17975           break;
17976         }
17977       if (bitmask)
17978         printf (", ");
17979     }
17980 }
17981
17982 static void
17983 decode_x86_isa (unsigned int bitmask)
17984 {
17985   if (!bitmask)
17986     {
17987       printf (_("<None>"));
17988       return;
17989     }
17990
17991   while (bitmask)
17992     {
17993       unsigned int bit = bitmask & (- bitmask);
17994
17995       bitmask &= ~ bit;
17996       switch (bit)
17997         {
17998         case GNU_PROPERTY_X86_ISA_1_CMOV:
17999           printf ("CMOV");
18000           break;
18001         case GNU_PROPERTY_X86_ISA_1_SSE:
18002           printf ("SSE");
18003           break;
18004         case GNU_PROPERTY_X86_ISA_1_SSE2:
18005           printf ("SSE2");
18006           break;
18007         case GNU_PROPERTY_X86_ISA_1_SSE3:
18008           printf ("SSE3");
18009           break;
18010         case GNU_PROPERTY_X86_ISA_1_SSSE3:
18011           printf ("SSSE3");
18012           break;
18013         case GNU_PROPERTY_X86_ISA_1_SSE4_1:
18014           printf ("SSE4_1");
18015           break;
18016         case GNU_PROPERTY_X86_ISA_1_SSE4_2:
18017           printf ("SSE4_2");
18018           break;
18019         case GNU_PROPERTY_X86_ISA_1_AVX:
18020           printf ("AVX");
18021           break;
18022         case GNU_PROPERTY_X86_ISA_1_AVX2:
18023           printf ("AVX2");
18024           break;
18025         case GNU_PROPERTY_X86_ISA_1_FMA:
18026           printf ("FMA");
18027           break;
18028         case GNU_PROPERTY_X86_ISA_1_AVX512F:
18029           printf ("AVX512F");
18030           break;
18031         case GNU_PROPERTY_X86_ISA_1_AVX512CD:
18032           printf ("AVX512CD");
18033           break;
18034         case GNU_PROPERTY_X86_ISA_1_AVX512ER:
18035           printf ("AVX512ER");
18036           break;
18037         case GNU_PROPERTY_X86_ISA_1_AVX512PF:
18038           printf ("AVX512PF");
18039           break;
18040         case GNU_PROPERTY_X86_ISA_1_AVX512VL:
18041           printf ("AVX512VL");
18042           break;
18043         case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
18044           printf ("AVX512DQ");
18045           break;
18046         case GNU_PROPERTY_X86_ISA_1_AVX512BW:
18047           printf ("AVX512BW");
18048           break;
18049         case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
18050           printf ("AVX512_4FMAPS");
18051           break;
18052         case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
18053           printf ("AVX512_4VNNIW");
18054           break;
18055         case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
18056           printf ("AVX512_BITALG");
18057           break;
18058         case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
18059           printf ("AVX512_IFMA");
18060           break;
18061         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
18062           printf ("AVX512_VBMI");
18063           break;
18064         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
18065           printf ("AVX512_VBMI2");
18066           break;
18067         case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
18068           printf ("AVX512_VNNI");
18069           break;
18070         case GNU_PROPERTY_X86_ISA_1_AVX512_BF16:
18071           printf ("AVX512_BF16");
18072           break;
18073         default:
18074           printf (_("<unknown: %x>"), bit);
18075           break;
18076         }
18077       if (bitmask)
18078         printf (", ");
18079     }
18080 }
18081
18082 static void
18083 decode_x86_feature_1 (unsigned int bitmask)
18084 {
18085   if (!bitmask)
18086     {
18087       printf (_("<None>"));
18088       return;
18089     }
18090
18091   while (bitmask)
18092     {
18093       unsigned int bit = bitmask & (- bitmask);
18094
18095       bitmask &= ~ bit;
18096       switch (bit)
18097         {
18098         case GNU_PROPERTY_X86_FEATURE_1_IBT:
18099           printf ("IBT");
18100           break;
18101         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
18102           printf ("SHSTK");
18103           break;
18104         default:
18105           printf (_("<unknown: %x>"), bit);
18106           break;
18107         }
18108       if (bitmask)
18109         printf (", ");
18110     }
18111 }
18112
18113 static void
18114 decode_x86_feature_2 (unsigned int bitmask)
18115 {
18116   if (!bitmask)
18117     {
18118       printf (_("<None>"));
18119       return;
18120     }
18121
18122   while (bitmask)
18123     {
18124       unsigned int bit = bitmask & (- bitmask);
18125
18126       bitmask &= ~ bit;
18127       switch (bit)
18128         {
18129         case GNU_PROPERTY_X86_FEATURE_2_X86:
18130           printf ("x86");
18131           break;
18132         case GNU_PROPERTY_X86_FEATURE_2_X87:
18133           printf ("x87");
18134           break;
18135         case GNU_PROPERTY_X86_FEATURE_2_MMX:
18136           printf ("MMX");
18137           break;
18138         case GNU_PROPERTY_X86_FEATURE_2_XMM:
18139           printf ("XMM");
18140           break;
18141         case GNU_PROPERTY_X86_FEATURE_2_YMM:
18142           printf ("YMM");
18143           break;
18144         case GNU_PROPERTY_X86_FEATURE_2_ZMM:
18145           printf ("ZMM");
18146           break;
18147         case GNU_PROPERTY_X86_FEATURE_2_FXSR:
18148           printf ("FXSR");
18149           break;
18150         case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
18151           printf ("XSAVE");
18152           break;
18153         case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
18154           printf ("XSAVEOPT");
18155           break;
18156         case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
18157           printf ("XSAVEC");
18158           break;
18159         default:
18160           printf (_("<unknown: %x>"), bit);
18161           break;
18162         }
18163       if (bitmask)
18164         printf (", ");
18165     }
18166 }
18167
18168 static void
18169 decode_aarch64_feature_1_and (unsigned int bitmask)
18170 {
18171   while (bitmask)
18172     {
18173       unsigned int bit = bitmask & (- bitmask);
18174
18175       bitmask &= ~ bit;
18176       switch (bit)
18177         {
18178         case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
18179           printf ("BTI");
18180           break;
18181
18182         case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
18183           printf ("PAC");
18184           break;
18185
18186         default:
18187           printf (_("<unknown: %x>"), bit);
18188           break;
18189         }
18190       if (bitmask)
18191         printf (", ");
18192     }
18193 }
18194
18195 static void
18196 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
18197 {
18198   unsigned char * ptr = (unsigned char *) pnote->descdata;
18199   unsigned char * ptr_end = ptr + pnote->descsz;
18200   unsigned int    size = is_32bit_elf ? 4 : 8;
18201
18202   printf (_("      Properties: "));
18203
18204   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
18205     {
18206       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
18207       return;
18208     }
18209
18210   while (ptr < ptr_end)
18211     {
18212       unsigned int j;
18213       unsigned int type;
18214       unsigned int datasz;
18215
18216       if ((size_t) (ptr_end - ptr) < 8)
18217         {
18218           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
18219           break;
18220         }
18221
18222       type = byte_get (ptr, 4);
18223       datasz = byte_get (ptr + 4, 4);
18224
18225       ptr += 8;
18226
18227       if (datasz > (size_t) (ptr_end - ptr))
18228         {
18229           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18230                   type, datasz);
18231           break;
18232         }
18233
18234       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
18235         {
18236           if (filedata->file_header.e_machine == EM_X86_64
18237               || filedata->file_header.e_machine == EM_IAMCU
18238               || filedata->file_header.e_machine == EM_386)
18239             {
18240               unsigned int bitmask;
18241
18242               if (datasz == 4)
18243                 bitmask = byte_get (ptr, 4);
18244               else
18245                 bitmask = 0;
18246
18247               switch (type)
18248                 {
18249                 case GNU_PROPERTY_X86_ISA_1_USED:
18250                   if (datasz != 4)
18251                     printf (_("x86 ISA used: <corrupt length: %#x> "),
18252                             datasz);
18253                   else
18254                     {
18255                       printf ("x86 ISA used: ");
18256                       decode_x86_isa (bitmask);
18257                     }
18258                   goto next;
18259
18260                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
18261                   if (datasz != 4)
18262                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
18263                             datasz);
18264                   else
18265                     {
18266                       printf ("x86 ISA needed: ");
18267                       decode_x86_isa (bitmask);
18268                     }
18269                   goto next;
18270
18271                 case GNU_PROPERTY_X86_FEATURE_1_AND:
18272                   if (datasz != 4)
18273                     printf (_("x86 feature: <corrupt length: %#x> "),
18274                             datasz);
18275                   else
18276                     {
18277                       printf ("x86 feature: ");
18278                       decode_x86_feature_1 (bitmask);
18279                     }
18280                   goto next;
18281
18282                 case GNU_PROPERTY_X86_FEATURE_2_USED:
18283                   if (datasz != 4)
18284                     printf (_("x86 feature used: <corrupt length: %#x> "),
18285                             datasz);
18286                   else
18287                     {
18288                       printf ("x86 feature used: ");
18289                       decode_x86_feature_2 (bitmask);
18290                     }
18291                   goto next;
18292
18293                 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
18294                   if (datasz != 4)
18295                     printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
18296                   else
18297                     {
18298                       printf ("x86 feature needed: ");
18299                       decode_x86_feature_2 (bitmask);
18300                     }
18301                   goto next;
18302
18303                 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
18304                   if (datasz != 4)
18305                     printf (_("x86 ISA used: <corrupt length: %#x> "),
18306                             datasz);
18307                   else
18308                     {
18309                       printf ("x86 ISA used: ");
18310                       decode_x86_compat_isa (bitmask);
18311                     }
18312                   goto next;
18313
18314                 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
18315                   if (datasz != 4)
18316                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
18317                             datasz);
18318                   else
18319                     {
18320                       printf ("x86 ISA needed: ");
18321                       decode_x86_compat_isa (bitmask);
18322                     }
18323                   goto next;
18324
18325                 default:
18326                   break;
18327                 }
18328             }
18329           else if (filedata->file_header.e_machine == EM_AARCH64)
18330             {
18331               if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
18332                 {
18333                   printf ("AArch64 feature: ");
18334                   if (datasz != 4)
18335                     printf (_("<corrupt length: %#x> "), datasz);
18336                   else
18337                     decode_aarch64_feature_1_and (byte_get (ptr, 4));
18338                   goto next;
18339                 }
18340             }
18341         }
18342       else
18343         {
18344           switch (type)
18345             {
18346             case GNU_PROPERTY_STACK_SIZE:
18347               printf (_("stack size: "));
18348               if (datasz != size)
18349                 printf (_("<corrupt length: %#x> "), datasz);
18350               else
18351                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
18352               goto next;
18353
18354             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
18355               printf ("no copy on protected ");
18356               if (datasz)
18357                 printf (_("<corrupt length: %#x> "), datasz);
18358               goto next;
18359
18360             default:
18361               break;
18362             }
18363         }
18364
18365       if (type < GNU_PROPERTY_LOPROC)
18366         printf (_("<unknown type %#x data: "), type);
18367       else if (type < GNU_PROPERTY_LOUSER)
18368         printf (_("<procesor-specific type %#x data: "), type);
18369       else
18370         printf (_("<application-specific type %#x data: "), type);
18371       for (j = 0; j < datasz; ++j)
18372         printf ("%02x ", ptr[j] & 0xff);
18373       printf (">");
18374
18375     next:
18376       ptr += ((datasz + (size - 1)) & ~ (size - 1));
18377       if (ptr == ptr_end)
18378         break;
18379
18380       if (do_wide)
18381         printf (", ");
18382       else
18383         printf ("\n\t");
18384     }
18385
18386   printf ("\n");
18387 }
18388
18389 static bfd_boolean
18390 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
18391 {
18392   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
18393   switch (pnote->type)
18394     {
18395     case NT_GNU_BUILD_ID:
18396       {
18397         unsigned long i;
18398
18399         printf (_("    Build ID: "));
18400         for (i = 0; i < pnote->descsz; ++i)
18401           printf ("%02x", pnote->descdata[i] & 0xff);
18402         printf ("\n");
18403       }
18404       break;
18405
18406     case NT_GNU_ABI_TAG:
18407       {
18408         unsigned long os, major, minor, subminor;
18409         const char *osname;
18410
18411         /* PR 17531: file: 030-599401-0.004.  */
18412         if (pnote->descsz < 16)
18413           {
18414             printf (_("    <corrupt GNU_ABI_TAG>\n"));
18415             break;
18416           }
18417
18418         os = byte_get ((unsigned char *) pnote->descdata, 4);
18419         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18420         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
18421         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
18422
18423         switch (os)
18424           {
18425           case GNU_ABI_TAG_LINUX:
18426             osname = "Linux";
18427             break;
18428           case GNU_ABI_TAG_HURD:
18429             osname = "Hurd";
18430             break;
18431           case GNU_ABI_TAG_SOLARIS:
18432             osname = "Solaris";
18433             break;
18434           case GNU_ABI_TAG_FREEBSD:
18435             osname = "FreeBSD";
18436             break;
18437           case GNU_ABI_TAG_NETBSD:
18438             osname = "NetBSD";
18439             break;
18440           case GNU_ABI_TAG_SYLLABLE:
18441             osname = "Syllable";
18442             break;
18443           case GNU_ABI_TAG_NACL:
18444             osname = "NaCl";
18445             break;
18446           default:
18447             osname = "Unknown";
18448             break;
18449           }
18450
18451         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
18452                 major, minor, subminor);
18453       }
18454       break;
18455
18456     case NT_GNU_GOLD_VERSION:
18457       {
18458         unsigned long i;
18459
18460         printf (_("    Version: "));
18461         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
18462           printf ("%c", pnote->descdata[i]);
18463         printf ("\n");
18464       }
18465       break;
18466
18467     case NT_GNU_HWCAP:
18468       {
18469         unsigned long num_entries, mask;
18470
18471         /* Hardware capabilities information.  Word 0 is the number of entries.
18472            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
18473            is a series of entries, where each entry is a single byte followed
18474            by a nul terminated string.  The byte gives the bit number to test
18475            if enabled in the bitmask.  */
18476         printf (_("      Hardware Capabilities: "));
18477         if (pnote->descsz < 8)
18478           {
18479             error (_("<corrupt GNU_HWCAP>\n"));
18480             return FALSE;
18481           }
18482         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
18483         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18484         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
18485         /* FIXME: Add code to display the entries... */
18486       }
18487       break;
18488
18489     case NT_GNU_PROPERTY_TYPE_0:
18490       print_gnu_property_note (filedata, pnote);
18491       break;
18492
18493     default:
18494       /* Handle unrecognised types.  An error message should have already been
18495          created by get_gnu_elf_note_type(), so all that we need to do is to
18496          display the data.  */
18497       {
18498         unsigned long i;
18499
18500         printf (_("    Description data: "));
18501         for (i = 0; i < pnote->descsz; ++i)
18502           printf ("%02x ", pnote->descdata[i] & 0xff);
18503         printf ("\n");
18504       }
18505       break;
18506     }
18507
18508   return TRUE;
18509 }
18510
18511 static const char *
18512 get_v850_elf_note_type (enum v850_notes n_type)
18513 {
18514   static char buff[64];
18515
18516   switch (n_type)
18517     {
18518     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
18519     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
18520     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
18521     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
18522     case V850_NOTE_CACHE_INFO: return _("Use of cache");
18523     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
18524     default:
18525       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
18526       return buff;
18527     }
18528 }
18529
18530 static bfd_boolean
18531 print_v850_note (Elf_Internal_Note * pnote)
18532 {
18533   unsigned int val;
18534
18535   if (pnote->descsz != 4)
18536     return FALSE;
18537
18538   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
18539
18540   if (val == 0)
18541     {
18542       printf (_("not set\n"));
18543       return TRUE;
18544     }
18545
18546   switch (pnote->type)
18547     {
18548     case V850_NOTE_ALIGNMENT:
18549       switch (val)
18550         {
18551         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
18552         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
18553         }
18554       break;
18555
18556     case V850_NOTE_DATA_SIZE:
18557       switch (val)
18558         {
18559         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
18560         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
18561         }
18562       break;
18563
18564     case V850_NOTE_FPU_INFO:
18565       switch (val)
18566         {
18567         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
18568         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
18569         }
18570       break;
18571
18572     case V850_NOTE_MMU_INFO:
18573     case V850_NOTE_CACHE_INFO:
18574     case V850_NOTE_SIMD_INFO:
18575       if (val == EF_RH850_SIMD)
18576         {
18577           printf (_("yes\n"));
18578           return TRUE;
18579         }
18580       break;
18581
18582     default:
18583       /* An 'unknown note type' message will already have been displayed.  */
18584       break;
18585     }
18586
18587   printf (_("unknown value: %x\n"), val);
18588   return FALSE;
18589 }
18590
18591 static bfd_boolean
18592 process_netbsd_elf_note (Elf_Internal_Note * pnote)
18593 {
18594   unsigned int version;
18595
18596   switch (pnote->type)
18597     {
18598     case NT_NETBSD_IDENT:
18599       if (pnote->descsz < 1)
18600         break;
18601       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18602       if ((version / 10000) % 100)
18603         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
18604                 version, version / 100000000, (version / 1000000) % 100,
18605                 (version / 10000) % 100 > 26 ? "Z" : "",
18606                 'A' + (version / 10000) % 26);
18607       else
18608         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
18609                 version, version / 100000000, (version / 1000000) % 100,
18610                 (version / 100) % 100);
18611       return TRUE;
18612
18613     case NT_NETBSD_MARCH:
18614       printf ("  NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
18615               pnote->descdata);
18616       return TRUE;
18617
18618 #ifdef   NT_NETBSD_PAX
18619     case NT_NETBSD_PAX:
18620       if (pnote->descsz < 1)
18621         break;
18622       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18623       printf ("  NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote->descsz,
18624               ((version & NT_NETBSD_PAX_MPROTECT) ? "+mprotect" : ""),
18625               ((version & NT_NETBSD_PAX_NOMPROTECT) ? "-mprotect" : ""),
18626               ((version & NT_NETBSD_PAX_GUARD) ? "+guard" : ""),
18627               ((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""),
18628               ((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""),
18629               ((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : ""));
18630       return TRUE;
18631 #endif
18632     }
18633
18634   printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
18635           pnote->descsz, pnote->type);
18636   return FALSE;
18637 }
18638
18639 static const char *
18640 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18641 {
18642   switch (e_type)
18643     {
18644     case NT_FREEBSD_THRMISC:
18645       return _("NT_THRMISC (thrmisc structure)");
18646     case NT_FREEBSD_PROCSTAT_PROC:
18647       return _("NT_PROCSTAT_PROC (proc data)");
18648     case NT_FREEBSD_PROCSTAT_FILES:
18649       return _("NT_PROCSTAT_FILES (files data)");
18650     case NT_FREEBSD_PROCSTAT_VMMAP:
18651       return _("NT_PROCSTAT_VMMAP (vmmap data)");
18652     case NT_FREEBSD_PROCSTAT_GROUPS:
18653       return _("NT_PROCSTAT_GROUPS (groups data)");
18654     case NT_FREEBSD_PROCSTAT_UMASK:
18655       return _("NT_PROCSTAT_UMASK (umask data)");
18656     case NT_FREEBSD_PROCSTAT_RLIMIT:
18657       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18658     case NT_FREEBSD_PROCSTAT_OSREL:
18659       return _("NT_PROCSTAT_OSREL (osreldate data)");
18660     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
18661       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18662     case NT_FREEBSD_PROCSTAT_AUXV:
18663       return _("NT_PROCSTAT_AUXV (auxv data)");
18664     case NT_FREEBSD_PTLWPINFO:
18665       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18666     }
18667   return get_note_type (filedata, e_type);
18668 }
18669
18670 static const char *
18671 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18672 {
18673   static char buff[64];
18674
18675   switch (e_type)
18676     {
18677     case NT_NETBSDCORE_PROCINFO:
18678       /* NetBSD core "procinfo" structure.  */
18679       return _("NetBSD procinfo structure");
18680
18681 #ifdef NT_NETBSDCORE_AUXV
18682     case NT_NETBSDCORE_AUXV:
18683       return _("NetBSD ELF auxiliary vector data");
18684 #endif
18685
18686 #ifdef NT_NETBSDCORE_LWPSTATUS
18687     case NT_NETBSDCORE_LWPSTATUS:
18688       return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
18689 #endif
18690
18691     default:
18692       /* As of Jan 2020 there are no other machine-independent notes
18693          defined for NetBSD core files.  If the note type is less
18694          than the start of the machine-dependent note types, we don't
18695          understand it.  */
18696
18697       if (e_type < NT_NETBSDCORE_FIRSTMACH)
18698         {
18699           snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18700           return buff;
18701         }
18702       break;
18703     }
18704
18705   switch (filedata->file_header.e_machine)
18706     {
18707     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18708        and PT_GETFPREGS == mach+2.  */
18709
18710     case EM_OLD_ALPHA:
18711     case EM_ALPHA:
18712     case EM_SPARC:
18713     case EM_SPARC32PLUS:
18714     case EM_SPARCV9:
18715       switch (e_type)
18716         {
18717         case NT_NETBSDCORE_FIRSTMACH + 0:
18718           return _("PT_GETREGS (reg structure)");
18719         case NT_NETBSDCORE_FIRSTMACH + 2:
18720           return _("PT_GETFPREGS (fpreg structure)");
18721         default:
18722           break;
18723         }
18724       break;
18725
18726     /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18727        There's also old PT___GETREGS40 == mach + 1 for old reg
18728        structure which lacks GBR.  */
18729     case EM_SH:
18730       switch (e_type)
18731         {
18732         case NT_NETBSDCORE_FIRSTMACH + 1:
18733           return _("PT___GETREGS40 (old reg structure)");
18734         case NT_NETBSDCORE_FIRSTMACH + 3:
18735           return _("PT_GETREGS (reg structure)");
18736         case NT_NETBSDCORE_FIRSTMACH + 5:
18737           return _("PT_GETFPREGS (fpreg structure)");
18738         default:
18739           break;
18740         }
18741       break;
18742
18743     /* On all other arch's, PT_GETREGS == mach+1 and
18744        PT_GETFPREGS == mach+3.  */
18745     default:
18746       switch (e_type)
18747         {
18748         case NT_NETBSDCORE_FIRSTMACH + 1:
18749           return _("PT_GETREGS (reg structure)");
18750         case NT_NETBSDCORE_FIRSTMACH + 3:
18751           return _("PT_GETFPREGS (fpreg structure)");
18752         default:
18753           break;
18754         }
18755     }
18756
18757   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
18758             e_type - NT_NETBSDCORE_FIRSTMACH);
18759   return buff;
18760 }
18761
18762 static const char *
18763 get_stapsdt_note_type (unsigned e_type)
18764 {
18765   static char buff[64];
18766
18767   switch (e_type)
18768     {
18769     case NT_STAPSDT:
18770       return _("NT_STAPSDT (SystemTap probe descriptors)");
18771
18772     default:
18773       break;
18774     }
18775
18776   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18777   return buff;
18778 }
18779
18780 static bfd_boolean
18781 print_stapsdt_note (Elf_Internal_Note *pnote)
18782 {
18783   size_t len, maxlen;
18784   unsigned long addr_size = is_32bit_elf ? 4 : 8;
18785   char *data = pnote->descdata;
18786   char *data_end = pnote->descdata + pnote->descsz;
18787   bfd_vma pc, base_addr, semaphore;
18788   char *provider, *probe, *arg_fmt;
18789
18790   if (pnote->descsz < (addr_size * 3))
18791     goto stapdt_note_too_small;
18792
18793   pc = byte_get ((unsigned char *) data, addr_size);
18794   data += addr_size;
18795
18796   base_addr = byte_get ((unsigned char *) data, addr_size);
18797   data += addr_size;
18798
18799   semaphore = byte_get ((unsigned char *) data, addr_size);
18800   data += addr_size;
18801
18802   if (data >= data_end)
18803     goto stapdt_note_too_small;
18804   maxlen = data_end - data;
18805   len = strnlen (data, maxlen);
18806   if (len < maxlen)
18807     {
18808       provider = data;
18809       data += len + 1;
18810     }
18811   else
18812     goto stapdt_note_too_small;
18813
18814   if (data >= data_end)
18815     goto stapdt_note_too_small;
18816   maxlen = data_end - data;
18817   len = strnlen (data, maxlen);
18818   if (len < maxlen)
18819     {
18820       probe = data;
18821       data += len + 1;
18822     }
18823   else
18824     goto stapdt_note_too_small;
18825
18826   if (data >= data_end)
18827     goto stapdt_note_too_small;
18828   maxlen = data_end - data;
18829   len = strnlen (data, maxlen);
18830   if (len < maxlen)
18831     {
18832       arg_fmt = data;
18833       data += len + 1;
18834     }
18835   else
18836     goto stapdt_note_too_small;
18837
18838   printf (_("    Provider: %s\n"), provider);
18839   printf (_("    Name: %s\n"), probe);
18840   printf (_("    Location: "));
18841   print_vma (pc, FULL_HEX);
18842   printf (_(", Base: "));
18843   print_vma (base_addr, FULL_HEX);
18844   printf (_(", Semaphore: "));
18845   print_vma (semaphore, FULL_HEX);
18846   printf ("\n");
18847   printf (_("    Arguments: %s\n"), arg_fmt);
18848
18849   return data == data_end;
18850
18851  stapdt_note_too_small:
18852   printf (_("  <corrupt - note is too small>\n"));
18853   error (_("corrupt stapdt note - the data size is too small\n"));
18854   return FALSE;
18855 }
18856
18857 static const char *
18858 get_ia64_vms_note_type (unsigned e_type)
18859 {
18860   static char buff[64];
18861
18862   switch (e_type)
18863     {
18864     case NT_VMS_MHD:
18865       return _("NT_VMS_MHD (module header)");
18866     case NT_VMS_LNM:
18867       return _("NT_VMS_LNM (language name)");
18868     case NT_VMS_SRC:
18869       return _("NT_VMS_SRC (source files)");
18870     case NT_VMS_TITLE:
18871       return "NT_VMS_TITLE";
18872     case NT_VMS_EIDC:
18873       return _("NT_VMS_EIDC (consistency check)");
18874     case NT_VMS_FPMODE:
18875       return _("NT_VMS_FPMODE (FP mode)");
18876     case NT_VMS_LINKTIME:
18877       return "NT_VMS_LINKTIME";
18878     case NT_VMS_IMGNAM:
18879       return _("NT_VMS_IMGNAM (image name)");
18880     case NT_VMS_IMGID:
18881       return _("NT_VMS_IMGID (image id)");
18882     case NT_VMS_LINKID:
18883       return _("NT_VMS_LINKID (link id)");
18884     case NT_VMS_IMGBID:
18885       return _("NT_VMS_IMGBID (build id)");
18886     case NT_VMS_GSTNAM:
18887       return _("NT_VMS_GSTNAM (sym table name)");
18888     case NT_VMS_ORIG_DYN:
18889       return "NT_VMS_ORIG_DYN";
18890     case NT_VMS_PATCHTIME:
18891       return "NT_VMS_PATCHTIME";
18892     default:
18893       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18894       return buff;
18895     }
18896 }
18897
18898 static bfd_boolean
18899 print_ia64_vms_note (Elf_Internal_Note * pnote)
18900 {
18901   int maxlen = pnote->descsz;
18902
18903   if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
18904     goto desc_size_fail;
18905
18906   switch (pnote->type)
18907     {
18908     case NT_VMS_MHD:
18909       if (maxlen <= 36)
18910         goto desc_size_fail;
18911
18912       int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
18913
18914       printf (_("    Creation date  : %.17s\n"), pnote->descdata);
18915       printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
18916       if (l + 34 < maxlen)
18917         {
18918           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
18919           if (l + 35 < maxlen)
18920             printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
18921           else
18922             printf (_("    Module version : <missing>\n"));
18923         }
18924       else
18925         {
18926           printf (_("    Module name    : <missing>\n"));
18927           printf (_("    Module version : <missing>\n"));
18928         }
18929       break;
18930
18931     case NT_VMS_LNM:
18932       printf (_("   Language: %.*s\n"), maxlen, pnote->descdata);
18933       break;
18934
18935 #ifdef BFD64
18936     case NT_VMS_FPMODE:
18937       printf (_("   Floating Point mode: "));
18938       if (maxlen < 8)
18939         goto desc_size_fail;
18940       /* FIXME: Generate an error if descsz > 8 ?  */
18941
18942       printf ("0x%016" BFD_VMA_FMT "x\n",
18943               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
18944       break;
18945
18946     case NT_VMS_LINKTIME:
18947       printf (_("   Link time: "));
18948       if (maxlen < 8)
18949         goto desc_size_fail;
18950       /* FIXME: Generate an error if descsz > 8 ?  */
18951
18952       print_vms_time
18953         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18954       printf ("\n");
18955       break;
18956
18957     case NT_VMS_PATCHTIME:
18958       printf (_("   Patch time: "));
18959       if (maxlen < 8)
18960         goto desc_size_fail;
18961       /* FIXME: Generate an error if descsz > 8 ?  */
18962
18963       print_vms_time
18964         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18965       printf ("\n");
18966       break;
18967
18968     case NT_VMS_ORIG_DYN:
18969       if (maxlen < 34)
18970         goto desc_size_fail;
18971
18972       printf (_("   Major id: %u,  minor id: %u\n"),
18973               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
18974               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
18975       printf (_("   Last modified  : "));
18976       print_vms_time
18977         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
18978       printf (_("\n   Link flags  : "));
18979       printf ("0x%016" BFD_VMA_FMT "x\n",
18980               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
18981       printf (_("   Header flags: 0x%08x\n"),
18982               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
18983       printf (_("   Image id    : %.*s\n"), maxlen - 32, pnote->descdata + 32);
18984       break;
18985 #endif
18986
18987     case NT_VMS_IMGNAM:
18988       printf (_("    Image name: %.*s\n"), maxlen, pnote->descdata);
18989       break;
18990
18991     case NT_VMS_GSTNAM:
18992       printf (_("    Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
18993       break;
18994
18995     case NT_VMS_IMGID:
18996       printf (_("    Image id: %.*s\n"), maxlen, pnote->descdata);
18997       break;
18998
18999     case NT_VMS_LINKID:
19000       printf (_("    Linker id: %.*s\n"), maxlen, pnote->descdata);
19001       break;
19002
19003     default:
19004       return FALSE;
19005     }
19006
19007   return TRUE;
19008
19009  desc_size_fail:
19010   printf (_("  <corrupt - data size is too small>\n"));
19011   error (_("corrupt IA64 note: data size is too small\n"));
19012   return FALSE;
19013 }
19014
19015 struct build_attr_cache {
19016   Filedata *filedata;
19017   char *strtab;
19018   unsigned long strtablen;
19019   Elf_Internal_Sym *symtab;
19020   unsigned long nsyms;
19021 } ba_cache;
19022
19023 /* Find the symbol associated with a build attribute that is attached
19024    to address OFFSET.  If PNAME is non-NULL then store the name of
19025    the symbol (if found) in the provided pointer,  Returns NULL if a
19026    symbol could not be found.  */
19027
19028 static Elf_Internal_Sym *
19029 get_symbol_for_build_attribute (Filedata *       filedata,
19030                                 unsigned long    offset,
19031                                 bfd_boolean      is_open_attr,
19032                                 const char **    pname)
19033 {
19034   Elf_Internal_Sym *saved_sym = NULL;
19035   Elf_Internal_Sym *sym;
19036
19037   if (filedata->section_headers != NULL
19038       && (ba_cache.filedata == NULL || filedata != ba_cache.filedata))
19039     {
19040       Elf_Internal_Shdr * symsec;
19041
19042       free (ba_cache.strtab);
19043       ba_cache.strtab = NULL;
19044       free (ba_cache.symtab);
19045       ba_cache.symtab = NULL;
19046
19047       /* Load the symbol and string sections.  */
19048       for (symsec = filedata->section_headers;
19049            symsec < filedata->section_headers + filedata->file_header.e_shnum;
19050            symsec ++)
19051         {
19052           if (symsec->sh_type == SHT_SYMTAB
19053               && get_symtab (filedata, symsec,
19054                              &ba_cache.symtab, &ba_cache.nsyms,
19055                              &ba_cache.strtab, &ba_cache.strtablen))
19056             break;
19057         }
19058       ba_cache.filedata = filedata;
19059     }
19060
19061   if (ba_cache.symtab == NULL)
19062     return NULL;
19063
19064   /* Find a symbol whose value matches offset.  */
19065   for (sym = ba_cache.symtab; sym < ba_cache.symtab + ba_cache.nsyms; sym ++)
19066     if (sym->st_value == offset)
19067       {
19068         if (sym->st_name >= ba_cache.strtablen)
19069           /* Huh ?  This should not happen.  */
19070           continue;
19071
19072         if (ba_cache.strtab[sym->st_name] == 0)
19073           continue;
19074
19075         /* The AArch64 and ARM architectures define mapping symbols
19076            (eg $d, $x, $t) which we want to ignore.  */
19077         if (ba_cache.strtab[sym->st_name] == '$'
19078             && ba_cache.strtab[sym->st_name + 1] != 0
19079             && ba_cache.strtab[sym->st_name + 2] == 0)
19080           continue;
19081
19082         if (is_open_attr)
19083           {
19084             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19085                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
19086                FUNC symbols entirely.  */
19087             switch (ELF_ST_TYPE (sym->st_info))
19088               {
19089               case STT_OBJECT:
19090               case STT_FILE:
19091                 saved_sym = sym;
19092                 if (sym->st_size)
19093                   {
19094                     /* If the symbol has a size associated
19095                        with it then we can stop searching.  */
19096                     sym = ba_cache.symtab + ba_cache.nsyms;
19097                   }
19098                 continue;
19099
19100               case STT_FUNC:
19101                 /* Ignore function symbols.  */
19102                 continue;
19103
19104               default:
19105                 break;
19106               }
19107
19108             switch (ELF_ST_BIND (sym->st_info))
19109               {
19110               case STB_GLOBAL:
19111                 if (saved_sym == NULL
19112                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
19113                   saved_sym = sym;
19114                 break;
19115
19116               case STB_LOCAL:
19117                 if (saved_sym == NULL)
19118                   saved_sym = sym;
19119                 break;
19120
19121               default:
19122                 break;
19123               }
19124           }
19125         else
19126           {
19127             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
19128               continue;
19129
19130             saved_sym = sym;
19131             break;
19132           }
19133       }
19134
19135   if (saved_sym && pname)
19136     * pname = ba_cache.strtab + saved_sym->st_name;
19137
19138   return saved_sym;
19139 }
19140
19141 /* Returns true iff addr1 and addr2 are in the same section.  */
19142
19143 static bfd_boolean
19144 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
19145 {
19146   Elf_Internal_Shdr * a1;
19147   Elf_Internal_Shdr * a2;
19148
19149   a1 = find_section_by_address (filedata, addr1);
19150   a2 = find_section_by_address (filedata, addr2);
19151
19152   return a1 == a2 && a1 != NULL;
19153 }
19154
19155 static bfd_boolean
19156 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
19157                                        Filedata *           filedata)
19158 {
19159   static unsigned long  global_offset = 0;
19160   static unsigned long  global_end = 0;
19161   static unsigned long  func_offset = 0;
19162   static unsigned long  func_end = 0;
19163
19164   Elf_Internal_Sym *    sym;
19165   const char *          name;
19166   unsigned long         start;
19167   unsigned long         end;
19168   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
19169
19170   switch (pnote->descsz)
19171     {
19172     case 0:
19173       /* A zero-length description means that the range of
19174          the previous note of the same type should be used.  */
19175       if (is_open_attr)
19176         {
19177           if (global_end > global_offset)
19178             printf (_("    Applies to region from %#lx to %#lx\n"),
19179                     global_offset, global_end);
19180           else
19181             printf (_("    Applies to region from %#lx\n"), global_offset);
19182         }
19183       else
19184         {
19185           if (func_end > func_offset)
19186             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
19187           else
19188             printf (_("    Applies to region from %#lx\n"), func_offset);
19189         }
19190       return TRUE;
19191
19192     case 4:
19193       start = byte_get ((unsigned char *) pnote->descdata, 4);
19194       end = 0;
19195       break;
19196
19197     case 8:
19198       if (is_32bit_elf)
19199         {
19200           /* FIXME: We should check that version 3+ notes are being used here...  */
19201           start = byte_get ((unsigned char *) pnote->descdata, 4);
19202           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
19203         }
19204       else
19205         {
19206           start = byte_get ((unsigned char *) pnote->descdata, 8);
19207           end = 0;
19208         }
19209       break;
19210
19211     case 16:
19212       start = byte_get ((unsigned char *) pnote->descdata, 8);
19213       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
19214       break;
19215
19216     default:
19217       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
19218       printf (_("    <invalid descsz>"));
19219       return FALSE;
19220     }
19221
19222   name = NULL;
19223   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
19224   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19225      in order to avoid them being confused with the start address of the
19226      first function in the file...  */
19227   if (sym == NULL && is_open_attr)
19228     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
19229                                           & name);
19230
19231   if (end == 0 && sym != NULL && sym->st_size > 0)
19232     end = start + sym->st_size;
19233
19234   if (is_open_attr)
19235     {
19236       /* FIXME: Need to properly allow for section alignment.
19237          16 is just the alignment used on x86_64.  */
19238       if (global_end > 0
19239           && start > BFD_ALIGN (global_end, 16)
19240           /* Build notes are not guaranteed to be organised in order of
19241              increasing address, but we should find the all of the notes
19242              for one section in the same place.  */
19243           && same_section (filedata, start, global_end))
19244         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19245               global_end + 1, start - 1);
19246
19247       printf (_("    Applies to region from %#lx"), start);
19248       global_offset = start;
19249
19250       if (end)
19251         {
19252           printf (_(" to %#lx"), end);
19253           global_end = end;
19254         }
19255     }
19256   else
19257     {
19258       printf (_("    Applies to region from %#lx"), start);
19259       func_offset = start;
19260
19261       if (end)
19262         {
19263           printf (_(" to %#lx"), end);
19264           func_end = end;
19265         }
19266     }
19267
19268   if (sym && name)
19269     printf (_(" (%s)"), name);
19270
19271   printf ("\n");
19272   return TRUE;
19273 }
19274
19275 static bfd_boolean
19276 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
19277 {
19278   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
19279   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
19280   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
19281   char         name_type;
19282   char         name_attribute;
19283   const char * expected_types;
19284   const char * name = pnote->namedata;
19285   const char * text;
19286   signed int   left;
19287
19288   if (name == NULL || pnote->namesz < 2)
19289     {
19290       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
19291       print_symbol (-20, _("  <corrupt name>"));
19292       return FALSE;
19293     }
19294
19295   if (do_wide)
19296     left = 28;
19297   else
19298     left = 20;
19299
19300   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
19301   if (name[0] == 'G' && name[1] == 'A')
19302     {
19303       if (pnote->namesz < 4)
19304         {
19305           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
19306           print_symbol (-20, _("  <corrupt name>"));
19307           return FALSE;
19308         }
19309
19310       printf ("GA");
19311       name += 2;
19312       left -= 2;
19313     }
19314
19315   switch ((name_type = * name))
19316     {
19317     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
19318     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19319     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19320     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19321       printf ("%c", * name);
19322       left --;
19323       break;
19324     default:
19325       error (_("unrecognised attribute type in name field: %d\n"), name_type);
19326       print_symbol (-20, _("<unknown name type>"));
19327       return FALSE;
19328     }
19329
19330   ++ name;
19331   text = NULL;
19332
19333   switch ((name_attribute = * name))
19334     {
19335     case GNU_BUILD_ATTRIBUTE_VERSION:
19336       text = _("<version>");
19337       expected_types = string_expected;
19338       ++ name;
19339       break;
19340     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
19341       text = _("<stack prot>");
19342       expected_types = "!+*";
19343       ++ name;
19344       break;
19345     case GNU_BUILD_ATTRIBUTE_RELRO:
19346       text = _("<relro>");
19347       expected_types = bool_expected;
19348       ++ name;
19349       break;
19350     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
19351       text = _("<stack size>");
19352       expected_types = number_expected;
19353       ++ name;
19354       break;
19355     case GNU_BUILD_ATTRIBUTE_TOOL:
19356       text = _("<tool>");
19357       expected_types = string_expected;
19358       ++ name;
19359       break;
19360     case GNU_BUILD_ATTRIBUTE_ABI:
19361       text = _("<ABI>");
19362       expected_types = "$*";
19363       ++ name;
19364       break;
19365     case GNU_BUILD_ATTRIBUTE_PIC:
19366       text = _("<PIC>");
19367       expected_types = number_expected;
19368       ++ name;
19369       break;
19370     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
19371       text = _("<short enum>");
19372       expected_types = bool_expected;
19373       ++ name;
19374       break;
19375     default:
19376       if (ISPRINT (* name))
19377         {
19378           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
19379
19380           if (len > left && ! do_wide)
19381             len = left;
19382           printf ("%.*s:", len, name);
19383           left -= len;
19384           name += len;
19385         }
19386       else
19387         {
19388           static char tmpbuf [128];
19389
19390           error (_("unrecognised byte in name field: %d\n"), * name);
19391           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
19392           text = tmpbuf;
19393           name ++;
19394         }
19395       expected_types = "*$!+";
19396       break;
19397     }
19398
19399   if (text)
19400     left -= printf ("%s", text);
19401
19402   if (strchr (expected_types, name_type) == NULL)
19403     warn (_("attribute does not have an expected type (%c)\n"), name_type);
19404
19405   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
19406     {
19407       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19408              (unsigned long) pnote->namesz,
19409              (long) (name - pnote->namedata));
19410       return FALSE;
19411     }
19412
19413   if (left < 1 && ! do_wide)
19414     return TRUE;
19415
19416   switch (name_type)
19417     {
19418     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
19419       {
19420         unsigned int        bytes;
19421         unsigned long long  val = 0;
19422         unsigned int        shift = 0;
19423         char *              decoded = NULL;
19424
19425         bytes = pnote->namesz - (name - pnote->namedata);
19426         if (bytes > 0)
19427           /* The -1 is because the name field is always 0 terminated, and we
19428              want to be able to ensure that the shift in the while loop below
19429              will not overflow.  */
19430           -- bytes;
19431
19432         if (bytes > sizeof (val))
19433           {
19434             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19435                    bytes);
19436             bytes = sizeof (val);
19437           }
19438         /* We do not bother to warn if bytes == 0 as this can
19439            happen with some early versions of the gcc plugin.  */
19440
19441         while (bytes --)
19442           {
19443             unsigned long byte = (* name ++) & 0xff;
19444
19445             val |= byte << shift;
19446             shift += 8;
19447           }
19448
19449         switch (name_attribute)
19450           {
19451           case GNU_BUILD_ATTRIBUTE_PIC:
19452             switch (val)
19453               {
19454               case 0: decoded = "static"; break;
19455               case 1: decoded = "pic"; break;
19456               case 2: decoded = "PIC"; break;
19457               case 3: decoded = "pie"; break;
19458               case 4: decoded = "PIE"; break;
19459               default: break;
19460               }
19461             break;
19462           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
19463             switch (val)
19464               {
19465                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
19466               case 0: decoded = "off"; break;
19467               case 1: decoded = "on"; break;
19468               case 2: decoded = "all"; break;
19469               case 3: decoded = "strong"; break;
19470               case 4: decoded = "explicit"; break;
19471               default: break;
19472               }
19473             break;
19474           default:
19475             break;
19476           }
19477
19478         if (decoded != NULL)
19479           {
19480             print_symbol (-left, decoded);
19481             left = 0;
19482           }
19483         else if (val == 0)
19484           {
19485             printf ("0x0");
19486             left -= 3;
19487           }
19488         else
19489           {
19490             if (do_wide)
19491               left -= printf ("0x%llx", val);
19492             else
19493               left -= printf ("0x%-.*llx", left, val);
19494           }
19495       }
19496       break;
19497     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19498       left -= print_symbol (- left, name);
19499       break;
19500     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19501       left -= print_symbol (- left, "true");
19502       break;
19503     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19504       left -= print_symbol (- left, "false");
19505       break;
19506     }
19507
19508   if (do_wide && left > 0)
19509     printf ("%-*s", left, " ");
19510
19511   return TRUE;
19512 }
19513
19514 /* Note that by the ELF standard, the name field is already null byte
19515    terminated, and namesz includes the terminating null byte.
19516    I.E. the value of namesz for the name "FSF" is 4.
19517
19518    If the value of namesz is zero, there is no name present.  */
19519
19520 static bfd_boolean
19521 process_note (Elf_Internal_Note *  pnote,
19522               Filedata *           filedata)
19523 {
19524   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
19525   const char * nt;
19526
19527   if (pnote->namesz == 0)
19528     /* If there is no note name, then use the default set of
19529        note type strings.  */
19530     nt = get_note_type (filedata, pnote->type);
19531
19532   else if (const_strneq (pnote->namedata, "GNU"))
19533     /* GNU-specific object file notes.  */
19534     nt = get_gnu_elf_note_type (pnote->type);
19535
19536   else if (const_strneq (pnote->namedata, "FreeBSD"))
19537     /* FreeBSD-specific core file notes.  */
19538     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
19539
19540   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
19541     /* NetBSD-specific core file notes.  */
19542     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
19543
19544   else if (const_strneq (pnote->namedata, "NetBSD"))
19545     /* NetBSD-specific core file notes.  */
19546     return process_netbsd_elf_note (pnote);
19547
19548   else if (const_strneq (pnote->namedata, "PaX"))
19549     /* NetBSD-specific core file notes.  */
19550     return process_netbsd_elf_note (pnote);
19551
19552   else if (strneq (pnote->namedata, "SPU/", 4))
19553     {
19554       /* SPU-specific core file notes.  */
19555       nt = pnote->namedata + 4;
19556       name = "SPU";
19557     }
19558
19559   else if (const_strneq (pnote->namedata, "IPF/VMS"))
19560     /* VMS/ia64-specific file notes.  */
19561     nt = get_ia64_vms_note_type (pnote->type);
19562
19563   else if (const_strneq (pnote->namedata, "stapsdt"))
19564     nt = get_stapsdt_note_type (pnote->type);
19565
19566   else
19567     /* Don't recognize this note name; just use the default set of
19568        note type strings.  */
19569     nt = get_note_type (filedata, pnote->type);
19570
19571   printf ("  ");
19572
19573   if (((const_strneq (pnote->namedata, "GA")
19574         && strchr ("*$!+", pnote->namedata[2]) != NULL)
19575        || strchr ("*$!+", pnote->namedata[0]) != NULL)
19576       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19577           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19578     print_gnu_build_attribute_name (pnote);
19579   else
19580     print_symbol (-20, name);
19581
19582   if (do_wide)
19583     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
19584   else
19585     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
19586
19587   if (const_strneq (pnote->namedata, "IPF/VMS"))
19588     return print_ia64_vms_note (pnote);
19589   else if (const_strneq (pnote->namedata, "GNU"))
19590     return print_gnu_note (filedata, pnote);
19591   else if (const_strneq (pnote->namedata, "stapsdt"))
19592     return print_stapsdt_note (pnote);
19593   else if (const_strneq (pnote->namedata, "CORE"))
19594     return print_core_note (pnote);
19595   else if (((const_strneq (pnote->namedata, "GA")
19596              && strchr ("*$!+", pnote->namedata[2]) != NULL)
19597             || strchr ("*$!+", pnote->namedata[0]) != NULL)
19598            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19599                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19600     return print_gnu_build_attribute_description (pnote, filedata);
19601
19602   if (pnote->descsz)
19603     {
19604       unsigned long i;
19605
19606       printf (_("   description data: "));
19607       for (i = 0; i < pnote->descsz; i++)
19608         printf ("%02x ", pnote->descdata[i] & 0xff);
19609       if (!do_wide)
19610         printf ("\n");
19611     }
19612
19613   if (do_wide)
19614     printf ("\n");
19615
19616   return TRUE;
19617 }
19618
19619 static bfd_boolean
19620 process_notes_at (Filedata *           filedata,
19621                   Elf_Internal_Shdr *  section,
19622                   bfd_vma              offset,
19623                   bfd_vma              length,
19624                   bfd_vma              align)
19625 {
19626   Elf_External_Note * pnotes;
19627   Elf_External_Note * external;
19628   char *              end;
19629   bfd_boolean         res = TRUE;
19630
19631   if (length <= 0)
19632     return FALSE;
19633
19634   if (section)
19635     {
19636       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
19637       if (pnotes)
19638         {
19639           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
19640             {
19641               free (pnotes);
19642               return FALSE;
19643             }
19644         }
19645     }
19646   else
19647     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19648                                              _("notes"));
19649
19650   if (pnotes == NULL)
19651     return FALSE;
19652
19653   external = pnotes;
19654
19655   if (section)
19656     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
19657   else
19658     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19659             (unsigned long) offset, (unsigned long) length);
19660
19661   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
19662      specifies that notes should be aligned to 4 bytes in 32-bit
19663      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
19664      we also support 4 byte alignment in 64-bit objects.  If section
19665      alignment is less than 4, we treate alignment as 4 bytes.   */
19666   if (align < 4)
19667     align = 4;
19668   else if (align != 4 && align != 8)
19669     {
19670       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19671             (long) align);
19672       free (pnotes);
19673       return FALSE;
19674     }
19675
19676   printf (_("  %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19677
19678   end = (char *) pnotes + length;
19679   while ((char *) external < end)
19680     {
19681       Elf_Internal_Note inote;
19682       size_t min_notesz;
19683       char * next;
19684       char * temp = NULL;
19685       size_t data_remaining = end - (char *) external;
19686
19687       if (!is_ia64_vms (filedata))
19688         {
19689           /* PR binutils/15191
19690              Make sure that there is enough data to read.  */
19691           min_notesz = offsetof (Elf_External_Note, name);
19692           if (data_remaining < min_notesz)
19693             {
19694               warn (ngettext ("Corrupt note: only %ld byte remains, "
19695                               "not enough for a full note\n",
19696                               "Corrupt note: only %ld bytes remain, "
19697                               "not enough for a full note\n",
19698                               data_remaining),
19699                     (long) data_remaining);
19700               break;
19701             }
19702           data_remaining -= min_notesz;
19703
19704           inote.type     = BYTE_GET (external->type);
19705           inote.namesz   = BYTE_GET (external->namesz);
19706           inote.namedata = external->name;
19707           inote.descsz   = BYTE_GET (external->descsz);
19708           inote.descdata = ((char *) external
19709                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
19710           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19711           next = ((char *) external
19712                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
19713         }
19714       else
19715         {
19716           Elf64_External_VMS_Note *vms_external;
19717
19718           /* PR binutils/15191
19719              Make sure that there is enough data to read.  */
19720           min_notesz = offsetof (Elf64_External_VMS_Note, name);
19721           if (data_remaining < min_notesz)
19722             {
19723               warn (ngettext ("Corrupt note: only %ld byte remains, "
19724                               "not enough for a full note\n",
19725                               "Corrupt note: only %ld bytes remain, "
19726                               "not enough for a full note\n",
19727                               data_remaining),
19728                     (long) data_remaining);
19729               break;
19730             }
19731           data_remaining -= min_notesz;
19732
19733           vms_external = (Elf64_External_VMS_Note *) external;
19734           inote.type     = BYTE_GET (vms_external->type);
19735           inote.namesz   = BYTE_GET (vms_external->namesz);
19736           inote.namedata = vms_external->name;
19737           inote.descsz   = BYTE_GET (vms_external->descsz);
19738           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
19739           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19740           next = inote.descdata + align_power (inote.descsz, 3);
19741         }
19742
19743       /* PR 17531: file: 3443835e.  */
19744       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
19745       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
19746           || (size_t) (inote.descdata - inote.namedata) > data_remaining
19747           || (size_t) (next - inote.descdata) < inote.descsz
19748           || ((size_t) (next - inote.descdata)
19749               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
19750         {
19751           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19752                 (unsigned long) ((char *) external - (char *) pnotes));
19753           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19754                 inote.type, inote.namesz, inote.descsz, (int) align);
19755           break;
19756         }
19757
19758       external = (Elf_External_Note *) next;
19759
19760       /* Verify that name is null terminated.  It appears that at least
19761          one version of Linux (RedHat 6.0) generates corefiles that don't
19762          comply with the ELF spec by failing to include the null byte in
19763          namesz.  */
19764       if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
19765         {
19766           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
19767             {
19768               temp = (char *) malloc (inote.namesz + 1);
19769               if (temp == NULL)
19770                 {
19771                   error (_("Out of memory allocating space for inote name\n"));
19772                   res = FALSE;
19773                   break;
19774                 }
19775
19776               memcpy (temp, inote.namedata, inote.namesz);
19777               inote.namedata = temp;
19778             }
19779           inote.namedata[inote.namesz] = 0;
19780         }
19781
19782       if (! process_note (& inote, filedata))
19783         res = FALSE;
19784
19785       free (temp);
19786       temp = NULL;
19787     }
19788
19789   free (pnotes);
19790
19791   return res;
19792 }
19793
19794 static bfd_boolean
19795 process_corefile_note_segments (Filedata * filedata)
19796 {
19797   Elf_Internal_Phdr * segment;
19798   unsigned int i;
19799   bfd_boolean res = TRUE;
19800
19801   if (! get_program_headers (filedata))
19802     return TRUE;
19803
19804   for (i = 0, segment = filedata->program_headers;
19805        i < filedata->file_header.e_phnum;
19806        i++, segment++)
19807     {
19808       if (segment->p_type == PT_NOTE)
19809         if (! process_notes_at (filedata, NULL,
19810                                 (bfd_vma) segment->p_offset,
19811                                 (bfd_vma) segment->p_filesz,
19812                                 (bfd_vma) segment->p_align))
19813           res = FALSE;
19814     }
19815
19816   return res;
19817 }
19818
19819 static bfd_boolean
19820 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
19821 {
19822   Elf_External_Note * pnotes;
19823   Elf_External_Note * external;
19824   char * end;
19825   bfd_boolean res = TRUE;
19826
19827   if (length <= 0)
19828     return FALSE;
19829
19830   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19831                                            _("v850 notes"));
19832   if (pnotes == NULL)
19833     return FALSE;
19834
19835   external = pnotes;
19836   end = (char*) pnotes + length;
19837
19838   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19839           (unsigned long) offset, (unsigned long) length);
19840
19841   while ((char *) external + sizeof (Elf_External_Note) < end)
19842     {
19843       Elf_External_Note * next;
19844       Elf_Internal_Note inote;
19845
19846       inote.type     = BYTE_GET (external->type);
19847       inote.namesz   = BYTE_GET (external->namesz);
19848       inote.namedata = external->name;
19849       inote.descsz   = BYTE_GET (external->descsz);
19850       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
19851       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
19852
19853       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
19854         {
19855           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
19856           inote.descdata = inote.namedata;
19857           inote.namesz   = 0;
19858         }
19859
19860       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
19861
19862       if (   ((char *) next > end)
19863           || ((char *) next <  (char *) pnotes))
19864         {
19865           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19866                 (unsigned long) ((char *) external - (char *) pnotes));
19867           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19868                 inote.type, inote.namesz, inote.descsz);
19869           break;
19870         }
19871
19872       external = next;
19873
19874       /* Prevent out-of-bounds indexing.  */
19875       if (   inote.namedata + inote.namesz > end
19876           || inote.namedata + inote.namesz < inote.namedata)
19877         {
19878           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19879                 (unsigned long) ((char *) external - (char *) pnotes));
19880           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19881                 inote.type, inote.namesz, inote.descsz);
19882           break;
19883         }
19884
19885       printf ("  %s: ", get_v850_elf_note_type (inote.type));
19886
19887       if (! print_v850_note (& inote))
19888         {
19889           res = FALSE;
19890           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19891                   inote.namesz, inote.descsz);
19892         }
19893     }
19894
19895   free (pnotes);
19896
19897   return res;
19898 }
19899
19900 static bfd_boolean
19901 process_note_sections (Filedata * filedata)
19902 {
19903   Elf_Internal_Shdr * section;
19904   unsigned long i;
19905   unsigned int n = 0;
19906   bfd_boolean res = TRUE;
19907
19908   for (i = 0, section = filedata->section_headers;
19909        i < filedata->file_header.e_shnum && section != NULL;
19910        i++, section++)
19911     {
19912       if (section->sh_type == SHT_NOTE)
19913         {
19914           if (! process_notes_at (filedata, section,
19915                                   (bfd_vma) section->sh_offset,
19916                                   (bfd_vma) section->sh_size,
19917                                   (bfd_vma) section->sh_addralign))
19918             res = FALSE;
19919           n++;
19920         }
19921
19922       if ((   filedata->file_header.e_machine == EM_V800
19923            || filedata->file_header.e_machine == EM_V850
19924            || filedata->file_header.e_machine == EM_CYGNUS_V850)
19925           && section->sh_type == SHT_RENESAS_INFO)
19926         {
19927           if (! process_v850_notes (filedata,
19928                                     (bfd_vma) section->sh_offset,
19929                                     (bfd_vma) section->sh_size))
19930             res = FALSE;
19931           n++;
19932         }
19933     }
19934
19935   if (n == 0)
19936     /* Try processing NOTE segments instead.  */
19937     return process_corefile_note_segments (filedata);
19938
19939   return res;
19940 }
19941
19942 static bfd_boolean
19943 process_notes (Filedata * filedata)
19944 {
19945   /* If we have not been asked to display the notes then do nothing.  */
19946   if (! do_notes)
19947     return TRUE;
19948
19949   if (filedata->file_header.e_type != ET_CORE)
19950     return process_note_sections (filedata);
19951
19952   /* No program headers means no NOTE segment.  */
19953   if (filedata->file_header.e_phnum > 0)
19954     return process_corefile_note_segments (filedata);
19955
19956   printf (_("No note segments present in the core file.\n"));
19957   return TRUE;
19958 }
19959
19960 static unsigned char *
19961 display_public_gnu_attributes (unsigned char * start,
19962                                const unsigned char * const end)
19963 {
19964   printf (_("  Unknown GNU attribute: %s\n"), start);
19965
19966   start += strnlen ((char *) start, end - start);
19967   display_raw_attribute (start, end);
19968
19969   return (unsigned char *) end;
19970 }
19971
19972 static unsigned char *
19973 display_generic_attribute (unsigned char * start,
19974                            unsigned int tag,
19975                            const unsigned char * const end)
19976 {
19977   if (tag == 0)
19978     return (unsigned char *) end;
19979
19980   return display_tag_value (tag, start, end);
19981 }
19982
19983 static bfd_boolean
19984 process_arch_specific (Filedata * filedata)
19985 {
19986   if (! do_arch)
19987     return TRUE;
19988
19989   switch (filedata->file_header.e_machine)
19990     {
19991     case EM_ARC:
19992     case EM_ARC_COMPACT:
19993     case EM_ARC_COMPACT2:
19994       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
19995                                  display_arc_attribute,
19996                                  display_generic_attribute);
19997     case EM_ARM:
19998       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
19999                                  display_arm_attribute,
20000                                  display_generic_attribute);
20001
20002     case EM_MIPS:
20003     case EM_MIPS_RS3_LE:
20004       return process_mips_specific (filedata);
20005
20006     case EM_MSP430:
20007      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
20008                                 display_msp430x_attribute,
20009                                 display_msp430_gnu_attribute);
20010
20011     case EM_RISCV:
20012      return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
20013                                 display_riscv_attribute,
20014                                 display_generic_attribute);
20015
20016     case EM_NDS32:
20017       return process_nds32_specific (filedata);
20018
20019     case EM_68K:
20020       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
20021                                  display_m68k_gnu_attribute);
20022
20023     case EM_PPC:
20024     case EM_PPC64:
20025       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
20026                                  display_power_gnu_attribute);
20027
20028     case EM_S390:
20029     case EM_S390_OLD:
20030       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
20031                                  display_s390_gnu_attribute);
20032
20033     case EM_SPARC:
20034     case EM_SPARC32PLUS:
20035     case EM_SPARCV9:
20036       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
20037                                  display_sparc_gnu_attribute);
20038
20039     case EM_TI_C6000:
20040       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
20041                                  display_tic6x_attribute,
20042                                  display_generic_attribute);
20043
20044     default:
20045       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
20046                                  display_public_gnu_attributes,
20047                                  display_generic_attribute);
20048     }
20049 }
20050
20051 static bfd_boolean
20052 get_file_header (Filedata * filedata)
20053 {
20054   /* Read in the identity array.  */
20055   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
20056     return FALSE;
20057
20058   /* Determine how to read the rest of the header.  */
20059   switch (filedata->file_header.e_ident[EI_DATA])
20060     {
20061     default:
20062     case ELFDATANONE:
20063     case ELFDATA2LSB:
20064       byte_get = byte_get_little_endian;
20065       byte_put = byte_put_little_endian;
20066       break;
20067     case ELFDATA2MSB:
20068       byte_get = byte_get_big_endian;
20069       byte_put = byte_put_big_endian;
20070       break;
20071     }
20072
20073   /* For now we only support 32 bit and 64 bit ELF files.  */
20074   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
20075
20076   /* Read in the rest of the header.  */
20077   if (is_32bit_elf)
20078     {
20079       Elf32_External_Ehdr ehdr32;
20080
20081       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
20082         return FALSE;
20083
20084       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
20085       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
20086       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
20087       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
20088       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
20089       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
20090       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
20091       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
20092       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
20093       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
20094       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
20095       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
20096       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
20097     }
20098   else
20099     {
20100       Elf64_External_Ehdr ehdr64;
20101
20102       /* If we have been compiled with sizeof (bfd_vma) == 4, then
20103          we will not be able to cope with the 64bit data found in
20104          64 ELF files.  Detect this now and abort before we start
20105          overwriting things.  */
20106       if (sizeof (bfd_vma) < 8)
20107         {
20108           error (_("This instance of readelf has been built without support for a\n\
20109 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20110           return FALSE;
20111         }
20112
20113       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
20114         return FALSE;
20115
20116       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
20117       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
20118       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
20119       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
20120       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
20121       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
20122       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
20123       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
20124       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
20125       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
20126       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
20127       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
20128       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
20129     }
20130
20131   if (filedata->file_header.e_shoff)
20132     {
20133       /* There may be some extensions in the first section header.  Don't
20134          bomb if we can't read it.  */
20135       if (is_32bit_elf)
20136         get_32bit_section_headers (filedata, TRUE);
20137       else
20138         get_64bit_section_headers (filedata, TRUE);
20139     }
20140
20141   return TRUE;
20142 }
20143
20144 static void
20145 close_file (Filedata * filedata)
20146 {
20147   if (filedata)
20148     {
20149       if (filedata->handle)
20150         fclose (filedata->handle);
20151       free (filedata);
20152     }
20153 }
20154
20155 void
20156 close_debug_file (void * data)
20157 {
20158   close_file ((Filedata *) data);
20159 }
20160
20161 static Filedata *
20162 open_file (const char * pathname)
20163 {
20164   struct stat  statbuf;
20165   Filedata *   filedata = NULL;
20166
20167   if (stat (pathname, & statbuf) < 0
20168       || ! S_ISREG (statbuf.st_mode))
20169     goto fail;
20170
20171   filedata = calloc (1, sizeof * filedata);
20172   if (filedata == NULL)
20173     goto fail;
20174
20175   filedata->handle = fopen (pathname, "rb");
20176   if (filedata->handle == NULL)
20177     goto fail;
20178
20179   filedata->file_size = (bfd_size_type) statbuf.st_size;
20180   filedata->file_name = pathname;
20181
20182   if (! get_file_header (filedata))
20183     goto fail;
20184
20185   if (filedata->file_header.e_shoff)
20186     {
20187       bfd_boolean res;
20188
20189       /* Read the section headers again, this time for real.  */
20190       if (is_32bit_elf)
20191         res = get_32bit_section_headers (filedata, FALSE);
20192       else
20193         res = get_64bit_section_headers (filedata, FALSE);
20194
20195       if (!res)
20196         goto fail;
20197     }
20198
20199   return filedata;
20200
20201  fail:
20202   if (filedata)
20203     {
20204       if (filedata->handle)
20205         fclose (filedata->handle);
20206       free (filedata);
20207     }
20208   return NULL;
20209 }
20210
20211 void *
20212 open_debug_file (const char * pathname)
20213 {
20214   return open_file (pathname);
20215 }
20216
20217 /* Process one ELF object file according to the command line options.
20218    This file may actually be stored in an archive.  The file is
20219    positioned at the start of the ELF object.  Returns TRUE if no
20220    problems were encountered, FALSE otherwise.  */
20221
20222 static bfd_boolean
20223 process_object (Filedata * filedata)
20224 {
20225   bfd_boolean  have_separate_files;
20226   unsigned int i;
20227   bfd_boolean res;
20228
20229   if (! get_file_header (filedata))
20230     {
20231       error (_("%s: Failed to read file header\n"), filedata->file_name);
20232       return FALSE;
20233     }
20234
20235   /* Initialise per file variables.  */
20236   for (i = ARRAY_SIZE (filedata->version_info); i--;)
20237     filedata->version_info[i] = 0;
20238
20239   for (i = ARRAY_SIZE (filedata->dynamic_info); i--;)
20240     filedata->dynamic_info[i] = 0;
20241   filedata->dynamic_info_DT_GNU_HASH = 0;
20242   filedata->dynamic_info_DT_MIPS_XHASH = 0;
20243
20244   /* Process the file.  */
20245   if (show_name)
20246     printf (_("\nFile: %s\n"), filedata->file_name);
20247
20248   /* Initialise the dump_sects array from the cmdline_dump_sects array.
20249      Note we do this even if cmdline_dump_sects is empty because we
20250      must make sure that the dump_sets array is zeroed out before each
20251      object file is processed.  */
20252   if (filedata->dump.num_dump_sects > cmdline.num_dump_sects)
20253     memset (filedata->dump.dump_sects, 0,
20254             filedata->dump.num_dump_sects * sizeof (*filedata->dump.dump_sects));
20255
20256   if (cmdline.num_dump_sects > 0)
20257     {
20258       if (filedata->dump.num_dump_sects == 0)
20259         /* A sneaky way of allocating the dump_sects array.  */
20260         request_dump_bynumber (&filedata->dump, cmdline.num_dump_sects, 0);
20261
20262       assert (filedata->dump.num_dump_sects >= cmdline.num_dump_sects);
20263       memcpy (filedata->dump.dump_sects, cmdline.dump_sects,
20264               cmdline.num_dump_sects * sizeof (*filedata->dump.dump_sects));
20265     }
20266
20267   if (! process_file_header (filedata))
20268     return FALSE;
20269
20270   if (! process_section_headers (filedata))
20271     {
20272       /* Without loaded section headers we cannot process lots of things.  */
20273       do_unwind = do_version = do_dump = do_arch = FALSE;
20274
20275       if (! do_using_dynamic)
20276         do_syms = do_dyn_syms = do_reloc = FALSE;
20277     }
20278
20279   if (! process_section_groups (filedata))
20280     /* Without loaded section groups we cannot process unwind.  */
20281     do_unwind = FALSE;
20282
20283   res = process_program_headers (filedata);
20284   if (res)
20285     res = process_dynamic_section (filedata);
20286
20287   if (! process_relocs (filedata))
20288     res = FALSE;
20289
20290   if (! process_unwind (filedata))
20291     res = FALSE;
20292
20293   if (! process_symbol_table (filedata))
20294     res = FALSE;
20295
20296   if (! process_syminfo (filedata))
20297     res = FALSE;
20298
20299   if (! process_version_sections (filedata))
20300     res = FALSE;
20301
20302   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
20303     have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
20304   else
20305     have_separate_files = FALSE;
20306
20307   if (! process_section_contents (filedata))
20308     res = FALSE;
20309
20310   if (have_separate_files)
20311     {
20312       separate_info * d;
20313
20314       for (d = first_separate_info; d != NULL; d = d->next)
20315         {
20316           if (! process_section_headers (d->handle))
20317             res = FALSE;
20318           else if (! process_section_contents (d->handle))
20319             res = FALSE;
20320         }
20321
20322       /* The file handles are closed by the call to free_debug_memory() below.  */
20323     }
20324
20325   if (! process_notes (filedata))
20326     res = FALSE;
20327
20328   if (! process_gnu_liblist (filedata))
20329     res = FALSE;
20330
20331   if (! process_arch_specific (filedata))
20332     res = FALSE;
20333
20334   free (filedata->program_headers);
20335   filedata->program_headers = NULL;
20336
20337   free (filedata->section_headers);
20338   filedata->section_headers = NULL;
20339
20340   free (filedata->string_table);
20341   filedata->string_table = NULL;
20342   filedata->string_table_length = 0;
20343
20344   free (filedata->dump.dump_sects);
20345   filedata->dump.dump_sects = NULL;
20346   filedata->dump.num_dump_sects = 0;
20347
20348   free (filedata->dynamic_strings);
20349   filedata->dynamic_strings = NULL;
20350   filedata->dynamic_strings_length = 0;
20351
20352   free (filedata->dynamic_symbols);
20353   filedata->dynamic_symbols = NULL;
20354   filedata->num_dynamic_syms = 0;
20355
20356   free (filedata->dynamic_syminfo);
20357   filedata->dynamic_syminfo = NULL;
20358
20359   free (filedata->dynamic_section);
20360   filedata->dynamic_section = NULL;
20361
20362   while (filedata->symtab_shndx_list != NULL)
20363     {
20364       elf_section_list *next = filedata->symtab_shndx_list->next;
20365       free (filedata->symtab_shndx_list);
20366       filedata->symtab_shndx_list = next;
20367     }
20368
20369   free (filedata->section_headers_groups);
20370   filedata->section_headers_groups = NULL;
20371
20372   if (filedata->section_groups)
20373     {
20374       struct group_list * g;
20375       struct group_list * next;
20376
20377       for (i = 0; i < filedata->group_count; i++)
20378         {
20379           for (g = filedata->section_groups [i].root; g != NULL; g = next)
20380             {
20381               next = g->next;
20382               free (g);
20383             }
20384         }
20385
20386       free (filedata->section_groups);
20387       filedata->section_groups = NULL;
20388     }
20389
20390   free_debug_memory ();
20391
20392   return res;
20393 }
20394
20395 /* Process an ELF archive.
20396    On entry the file is positioned just after the ARMAG string.
20397    Returns TRUE upon success, FALSE otherwise.  */
20398
20399 static bfd_boolean
20400 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
20401 {
20402   struct archive_info arch;
20403   struct archive_info nested_arch;
20404   size_t got;
20405   bfd_boolean ret = TRUE;
20406
20407   show_name = TRUE;
20408
20409   /* The ARCH structure is used to hold information about this archive.  */
20410   arch.file_name = NULL;
20411   arch.file = NULL;
20412   arch.index_array = NULL;
20413   arch.sym_table = NULL;
20414   arch.longnames = NULL;
20415
20416   /* The NESTED_ARCH structure is used as a single-item cache of information
20417      about a nested archive (when members of a thin archive reside within
20418      another regular archive file).  */
20419   nested_arch.file_name = NULL;
20420   nested_arch.file = NULL;
20421   nested_arch.index_array = NULL;
20422   nested_arch.sym_table = NULL;
20423   nested_arch.longnames = NULL;
20424
20425   if (setup_archive (&arch, filedata->file_name, filedata->handle,
20426                      filedata->file_size, is_thin_archive,
20427                      do_archive_index) != 0)
20428     {
20429       ret = FALSE;
20430       goto out;
20431     }
20432
20433   if (do_archive_index)
20434     {
20435       if (arch.sym_table == NULL)
20436         error (_("%s: unable to dump the index as none was found\n"),
20437                filedata->file_name);
20438       else
20439         {
20440           unsigned long i, l;
20441           unsigned long current_pos;
20442
20443           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
20444                     "in the symbol table)\n"),
20445                   filedata->file_name, (unsigned long) arch.index_num,
20446                   arch.sym_size);
20447
20448           current_pos = ftell (filedata->handle);
20449
20450           for (i = l = 0; i < arch.index_num; i++)
20451             {
20452               if (i == 0
20453                   || (i > 0 && arch.index_array[i] != arch.index_array[i - 1]))
20454                 {
20455                   char * member_name
20456                     = get_archive_member_name_at (&arch, arch.index_array[i],
20457                                                   &nested_arch);
20458
20459                   if (member_name != NULL)
20460                     {
20461                       char * qualified_name
20462                         = make_qualified_name (&arch, &nested_arch,
20463                                                member_name);
20464
20465                       if (qualified_name != NULL)
20466                         {
20467                           printf (_("Contents of binary %s at offset "),
20468                                   qualified_name);
20469                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
20470                           putchar ('\n');
20471                           free (qualified_name);
20472                         }
20473                       free (member_name);
20474                     }
20475                 }
20476
20477               if (l >= arch.sym_size)
20478                 {
20479                   error (_("%s: end of the symbol table reached "
20480                            "before the end of the index\n"),
20481                          filedata->file_name);
20482                   ret = FALSE;
20483                   break;
20484                 }
20485               /* PR 17531: file: 0b6630b2.  */
20486               printf ("\t%.*s\n",
20487                       (int) (arch.sym_size - l), arch.sym_table + l);
20488               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
20489             }
20490
20491           if (arch.uses_64bit_indices)
20492             l = (l + 7) & ~ 7;
20493           else
20494             l += l & 1;
20495
20496           if (l < arch.sym_size)
20497             {
20498               error (ngettext ("%s: %ld byte remains in the symbol table, "
20499                                "but without corresponding entries in "
20500                                "the index table\n",
20501                                "%s: %ld bytes remain in the symbol table, "
20502                                "but without corresponding entries in "
20503                                "the index table\n",
20504                                arch.sym_size - l),
20505                      filedata->file_name, arch.sym_size - l);
20506               ret = FALSE;
20507             }
20508
20509           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
20510             {
20511               error (_("%s: failed to seek back to start of object files "
20512                        "in the archive\n"),
20513                      filedata->file_name);
20514               ret = FALSE;
20515               goto out;
20516             }
20517         }
20518
20519       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
20520           && !do_segments && !do_header && !do_dump && !do_version
20521           && !do_histogram && !do_debugging && !do_arch && !do_notes
20522           && !do_section_groups && !do_dyn_syms)
20523         {
20524           ret = TRUE; /* Archive index only.  */
20525           goto out;
20526         }
20527     }
20528
20529   while (1)
20530     {
20531       char * name;
20532       size_t namelen;
20533       char * qualified_name;
20534
20535       /* Read the next archive header.  */
20536       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
20537         {
20538           error (_("%s: failed to seek to next archive header\n"),
20539                  arch.file_name);
20540           ret = FALSE;
20541           break;
20542         }
20543       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
20544       if (got != sizeof arch.arhdr)
20545         {
20546           if (got == 0)
20547             break;
20548           /* PR 24049 - we cannot use filedata->file_name as this will
20549              have already been freed.  */
20550           error (_("%s: failed to read archive header\n"), arch.file_name);
20551
20552           ret = FALSE;
20553           break;
20554         }
20555       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
20556         {
20557           error (_("%s: did not find a valid archive header\n"),
20558                  arch.file_name);
20559           ret = FALSE;
20560           break;
20561         }
20562
20563       arch.next_arhdr_offset += sizeof arch.arhdr;
20564
20565       filedata->archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
20566       if (filedata->archive_file_size & 01)
20567         ++filedata->archive_file_size;
20568
20569       name = get_archive_member_name (&arch, &nested_arch);
20570       if (name == NULL)
20571         {
20572           error (_("%s: bad archive file name\n"), arch.file_name);
20573           ret = FALSE;
20574           break;
20575         }
20576       namelen = strlen (name);
20577
20578       qualified_name = make_qualified_name (&arch, &nested_arch, name);
20579       if (qualified_name == NULL)
20580         {
20581           error (_("%s: bad archive file name\n"), arch.file_name);
20582           free (name);
20583           ret = FALSE;
20584           break;
20585         }
20586
20587       if (is_thin_archive && arch.nested_member_origin == 0)
20588         {
20589           /* This is a proxy for an external member of a thin archive.  */
20590           Filedata * member_filedata;
20591           char * member_file_name = adjust_relative_path
20592             (filedata->file_name, name, namelen);
20593
20594           free (name);
20595           if (member_file_name == NULL)
20596             {
20597               free (qualified_name);
20598               ret = FALSE;
20599               break;
20600             }
20601
20602           member_filedata = open_file (member_file_name);
20603           if (member_filedata == NULL)
20604             {
20605               error (_("Input file '%s' is not readable.\n"), member_file_name);
20606               free (member_file_name);
20607               free (qualified_name);
20608               ret = FALSE;
20609               break;
20610             }
20611
20612           filedata->archive_file_offset = arch.nested_member_origin;
20613           member_filedata->file_name = qualified_name;
20614
20615           if (! process_object (member_filedata))
20616             ret = FALSE;
20617
20618           close_file (member_filedata);
20619           free (member_file_name);
20620         }
20621       else if (is_thin_archive)
20622         {
20623           Filedata thin_filedata;
20624
20625           memset (&thin_filedata, 0, sizeof (thin_filedata));
20626
20627           /* PR 15140: Allow for corrupt thin archives.  */
20628           if (nested_arch.file == NULL)
20629             {
20630               error (_("%s: contains corrupt thin archive: %s\n"),
20631                      qualified_name, name);
20632               free (qualified_name);
20633               free (name);
20634               ret = FALSE;
20635               break;
20636             }
20637           free (name);
20638
20639           /* This is a proxy for a member of a nested archive.  */
20640           filedata->archive_file_offset
20641             = arch.nested_member_origin + sizeof arch.arhdr;
20642
20643           /* The nested archive file will have been opened and setup by
20644              get_archive_member_name.  */
20645           if (fseek (nested_arch.file, filedata->archive_file_offset,
20646                      SEEK_SET) != 0)
20647             {
20648               error (_("%s: failed to seek to archive member.\n"),
20649                      nested_arch.file_name);
20650               free (qualified_name);
20651               ret = FALSE;
20652               break;
20653             }
20654
20655           thin_filedata.handle = nested_arch.file;
20656           thin_filedata.file_name = qualified_name;
20657
20658           if (! process_object (& thin_filedata))
20659             ret = FALSE;
20660         }
20661       else
20662         {
20663           free (name);
20664           filedata->archive_file_offset = arch.next_arhdr_offset;
20665           filedata->file_name = qualified_name;
20666           if (! process_object (filedata))
20667             ret = FALSE;
20668           arch.next_arhdr_offset += filedata->archive_file_size;
20669           /* Stop looping with "negative" archive_file_size.  */
20670           if (arch.next_arhdr_offset < filedata->archive_file_size)
20671             arch.next_arhdr_offset = -1ul;
20672         }
20673
20674       free (qualified_name);
20675     }
20676
20677  out:
20678   if (nested_arch.file != NULL)
20679     fclose (nested_arch.file);
20680   release_archive (&nested_arch);
20681   release_archive (&arch);
20682
20683   return ret;
20684 }
20685
20686 static bfd_boolean
20687 process_file (char * file_name)
20688 {
20689   Filedata * filedata = NULL;
20690   struct stat statbuf;
20691   char armag[SARMAG];
20692   bfd_boolean ret = TRUE;
20693
20694   if (stat (file_name, &statbuf) < 0)
20695     {
20696       if (errno == ENOENT)
20697         error (_("'%s': No such file\n"), file_name);
20698       else
20699         error (_("Could not locate '%s'.  System error message: %s\n"),
20700                file_name, strerror (errno));
20701       return FALSE;
20702     }
20703
20704   if (! S_ISREG (statbuf.st_mode))
20705     {
20706       error (_("'%s' is not an ordinary file\n"), file_name);
20707       return FALSE;
20708     }
20709
20710   filedata = calloc (1, sizeof * filedata);
20711   if (filedata == NULL)
20712     {
20713       error (_("Out of memory allocating file data structure\n"));
20714       return FALSE;
20715     }
20716
20717   filedata->file_name = file_name;
20718   filedata->handle = fopen (file_name, "rb");
20719   if (filedata->handle == NULL)
20720     {
20721       error (_("Input file '%s' is not readable.\n"), file_name);
20722       free (filedata);
20723       return FALSE;
20724     }
20725
20726   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
20727     {
20728       error (_("%s: Failed to read file's magic number\n"), file_name);
20729       fclose (filedata->handle);
20730       free (filedata);
20731       return FALSE;
20732     }
20733
20734   filedata->file_size = (bfd_size_type) statbuf.st_size;
20735
20736   if (memcmp (armag, ARMAG, SARMAG) == 0)
20737     {
20738       if (! process_archive (filedata, FALSE))
20739         ret = FALSE;
20740     }
20741   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
20742     {
20743       if ( ! process_archive (filedata, TRUE))
20744         ret = FALSE;
20745     }
20746   else
20747     {
20748       if (do_archive_index && !check_all)
20749         error (_("File %s is not an archive so its index cannot be displayed.\n"),
20750                file_name);
20751
20752       rewind (filedata->handle);
20753       filedata->archive_file_size = filedata->archive_file_offset = 0;
20754
20755       if (! process_object (filedata))
20756         ret = FALSE;
20757     }
20758
20759   fclose (filedata->handle);
20760   free (filedata->section_headers);
20761   free (filedata->program_headers);
20762   free (filedata->string_table);
20763   free (filedata->dump.dump_sects);
20764   free (filedata);
20765
20766   free (ba_cache.strtab);
20767   ba_cache.strtab = NULL;
20768   free (ba_cache.symtab);
20769   ba_cache.symtab = NULL;
20770   ba_cache.filedata = NULL;
20771
20772   return ret;
20773 }
20774
20775 #ifdef SUPPORT_DISASSEMBLY
20776 /* Needed by the i386 disassembler.  For extra credit, someone could
20777    fix this so that we insert symbolic addresses here, esp for GOT/PLT
20778    symbols.  */
20779
20780 void
20781 print_address (unsigned int addr, FILE * outfile)
20782 {
20783   fprintf (outfile,"0x%8.8x", addr);
20784 }
20785
20786 /* Needed by the i386 disassembler.  */
20787
20788 void
20789 db_task_printsym (unsigned int addr)
20790 {
20791   print_address (addr, stderr);
20792 }
20793 #endif
20794
20795 int
20796 main (int argc, char ** argv)
20797 {
20798   int err;
20799
20800 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20801   setlocale (LC_MESSAGES, "");
20802 #endif
20803 #if defined (HAVE_SETLOCALE)
20804   setlocale (LC_CTYPE, "");
20805 #endif
20806   bindtextdomain (PACKAGE, LOCALEDIR);
20807   textdomain (PACKAGE);
20808
20809   expandargv (&argc, &argv);
20810
20811   parse_args (& cmdline, argc, argv);
20812
20813   if (optind < (argc - 1))
20814     /* When displaying information for more than one file,
20815        prefix the information with the file name.  */
20816     show_name = TRUE;
20817   else if (optind >= argc)
20818     {
20819       /* Ensure that the warning is always displayed.  */
20820       do_checks = TRUE;
20821
20822       warn (_("Nothing to do.\n"));
20823       usage (stderr);
20824     }
20825
20826   err = FALSE;
20827   while (optind < argc)
20828     if (! process_file (argv[optind++]))
20829       err = TRUE;
20830
20831   free (cmdline.dump_sects);
20832
20833   free (dump_ctf_symtab_name);
20834   free (dump_ctf_strtab_name);
20835   free (dump_ctf_parent_name);
20836
20837   return err ? EXIT_FAILURE : EXIT_SUCCESS;
20838 }