binutils/readelf.c

   1 /* readelf.c -- display contents of an ELF format file
   2    Copyright (C) 1998-2018 Free Software Foundation, Inc.
   3
   4    Originally developed by Eric Youngdale <eric@andante.jic.com>
   5    Modifications by Nick Clifton <nickc@redhat.com>
   6
   7    This file is part of GNU Binutils.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  22    02110-1301, USA.  */
  23 \f
  24 /* The difference between readelf and objdump:
  25
  26   Both programs are capable of displaying the contents of ELF format files,
  27   so why does the binutils project have two file dumpers ?
  28
  29   The reason is that objdump sees an ELF file through a BFD filter of the
  30   world; if BFD has a bug where, say, it disagrees about a machine constant
  31   in e_flags, then the odds are good that it will remain internally
  32   consistent.  The linker sees it the BFD way, objdump sees it the BFD way,
  33   GAS sees it the BFD way.  There was need for a tool to go find out what
  34   the file actually says.
  35
  36   This is why the readelf program does not link against the BFD library - it
  37   exists as an independent program to help verify the correct working of BFD.
  38
  39   There is also the case that readelf can provide more information about an
  40   ELF file than is provided by objdump.  In particular it can display DWARF
  41   debugging information which (at the moment) objdump cannot.  */
  42 \f
  43 #include "sysdep.h"
  44 #include <assert.h>
  45 #include <time.h>
  46 #include <zlib.h>
  47 #ifdef HAVE_WCHAR_H
  48 #include <wchar.h>
  49 #endif
  50
  51 #if __GNUC__ >= 2
  52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
  53    as this will allow us to read in and parse 64bit and 32bit ELF files.
  54    Only do this if we believe that the compiler can support a 64 bit
  55    data type.  For now we only rely on GCC being able to do this.  */
  56 #define BFD64
  57 #endif
  58
  59 #include "bfd.h"
  60 #include "bucomm.h"
  61 #include "elfcomm.h"
  62 #include "dwarf.h"
  63
  64 #include "elf/common.h"
  65 #include "elf/external.h"
  66 #include "elf/internal.h"
  67
  68
  69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
  70    we can obtain the H8 reloc numbers.  We need these for the
  71    get_reloc_size() function.  We include h8.h again after defining
  72    RELOC_MACROS_GEN_FUNC so that we get the naming function as well.  */
  73
  74 #include "elf/h8.h"
  75 #undef _ELF_H8_H
  76
  77 /* Undo the effects of #including reloc-macros.h.  */
  78
  79 #undef START_RELOC_NUMBERS
  80 #undef RELOC_NUMBER
  81 #undef FAKE_RELOC
  82 #undef EMPTY_RELOC
  83 #undef END_RELOC_NUMBERS
  84 #undef _RELOC_MACROS_H
  85
  86 /* The following headers use the elf/reloc-macros.h file to
  87    automatically generate relocation recognition functions
  88    such as elf_mips_reloc_type()  */
  89
  90 #define RELOC_MACROS_GEN_FUNC
  91
  92 #include "elf/aarch64.h"
  93 #include "elf/alpha.h"
  94 #include "elf/arc.h"
  95 #include "elf/arm.h"
  96 #include "elf/avr.h"
  97 #include "elf/bfin.h"
  98 #include "elf/cr16.h"
  99 #include "elf/cris.h"
 100 #include "elf/crx.h"
 101 #include "elf/csky.h"
 102 #include "elf/d10v.h"
 103 #include "elf/d30v.h"
 104 #include "elf/dlx.h"
 105 #include "elf/epiphany.h"
 106 #include "elf/fr30.h"
 107 #include "elf/frv.h"
 108 #include "elf/ft32.h"
 109 #include "elf/h8.h"
 110 #include "elf/hppa.h"
 111 #include "elf/i386.h"
 112 #include "elf/i370.h"
 113 #include "elf/i860.h"
 114 #include "elf/i960.h"
 115 #include "elf/ia64.h"
 116 #include "elf/ip2k.h"
 117 #include "elf/lm32.h"
 118 #include "elf/iq2000.h"
 119 #include "elf/m32c.h"
 120 #include "elf/m32r.h"
 121 #include "elf/m68k.h"
 122 #include "elf/m68hc11.h"
 123 #include "elf/s12z.h"
 124 #include "elf/mcore.h"
 125 #include "elf/mep.h"
 126 #include "elf/metag.h"
 127 #include "elf/microblaze.h"
 128 #include "elf/mips.h"
 129 #include "elf/mmix.h"
 130 #include "elf/mn10200.h"
 131 #include "elf/mn10300.h"
 132 #include "elf/moxie.h"
 133 #include "elf/mt.h"
 134 #include "elf/msp430.h"
 135 #include "elf/nds32.h"
 136 #include "elf/nfp.h"
 137 #include "elf/nios2.h"
 138 #include "elf/or1k.h"
 139 #include "elf/pj.h"
 140 #include "elf/ppc.h"
 141 #include "elf/ppc64.h"
 142 #include "elf/pru.h"
 143 #include "elf/riscv.h"
 144 #include "elf/rl78.h"
 145 #include "elf/rx.h"
 146 #include "elf/s390.h"
 147 #include "elf/score.h"
 148 #include "elf/sh.h"
 149 #include "elf/sparc.h"
 150 #include "elf/spu.h"
 151 #include "elf/tic6x.h"
 152 #include "elf/tilegx.h"
 153 #include "elf/tilepro.h"
 154 #include "elf/v850.h"
 155 #include "elf/vax.h"
 156 #include "elf/visium.h"
 157 #include "elf/wasm32.h"
 158 #include "elf/x86-64.h"
 159 #include "elf/xc16x.h"
 160 #include "elf/xgate.h"
 161 #include "elf/xstormy16.h"
 162 #include "elf/xtensa.h"
 163
 164 #include "getopt.h"
 165 #include "libiberty.h"
 166 #include "safe-ctype.h"
 167 #include "filenames.h"
 168
 169 #ifndef offsetof
 170 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
 171 #endif
 172
 173 typedef struct elf_section_list
 174 {
 175   Elf_Internal_Shdr *        hdr;
 176   struct elf_section_list *  next;
 177 } elf_section_list;
 178
 179 /* Flag bits indicating particular types of dump.  */
 180 #define HEX_DUMP        (1 << 0)        /* The -x command line switch.  */
 181 #define DISASS_DUMP     (1 << 1)        /* The -i command line switch.  */
 182 #define DEBUG_DUMP      (1 << 2)        /* The -w command line switch.  */
 183 #define STRING_DUMP     (1 << 3)        /* The -p command line switch.  */
 184 #define RELOC_DUMP      (1 << 4)        /* The -R command line switch.  */
 185
 186 typedef unsigned char dump_type;
 187
 188 /* A linked list of the section names for which dumps were requested.  */
 189 struct dump_list_entry
 190 {
 191   char *                    name;
 192   dump_type                 type;
 193   struct dump_list_entry *  next;
 194 };
 195
 196 typedef struct filedata
 197 {
 198   const char *         file_name;
 199   FILE *               handle;
 200   bfd_size_type        file_size;
 201   Elf_Internal_Ehdr    file_header;
 202   Elf_Internal_Shdr *  section_headers;
 203   Elf_Internal_Phdr *  program_headers;
 204   char *               string_table;
 205   unsigned long        string_table_length;
 206   /* A dynamic array of flags indicating for which sections a dump of
 207      some kind has been requested.  It is reset on a per-object file
 208      basis and then initialised from the cmdline_dump_sects array,
 209      the results of interpreting the -w switch, and the
 210      dump_sects_byname list.  */
 211   dump_type *          dump_sects;
 212   unsigned int         num_dump_sects;
 213 } Filedata;
 214
 215 char * program_name = "readelf";
 216
 217 static unsigned long archive_file_offset;
 218 static unsigned long archive_file_size;
 219 static unsigned long dynamic_addr;
 220 static bfd_size_type dynamic_size;
 221 static size_t dynamic_nent;
 222 static char * dynamic_strings;
 223 static unsigned long dynamic_strings_length;
 224 static unsigned long num_dynamic_syms;
 225 static Elf_Internal_Sym * dynamic_symbols;
 226 static Elf_Internal_Syminfo * dynamic_syminfo;
 227 static unsigned long dynamic_syminfo_offset;
 228 static unsigned int dynamic_syminfo_nent;
 229 static char program_interpreter[PATH_MAX];
 230 static bfd_vma dynamic_info[DT_ENCODING];
 231 static bfd_vma dynamic_info_DT_GNU_HASH;
 232 static bfd_vma version_info[16];
 233 static Elf_Internal_Dyn *  dynamic_section;
 234 static elf_section_list * symtab_shndx_list;
 235 static bfd_boolean show_name = FALSE;
 236 static bfd_boolean do_dynamic = FALSE;
 237 static bfd_boolean do_syms = FALSE;
 238 static bfd_boolean do_dyn_syms = FALSE;
 239 static bfd_boolean do_reloc = FALSE;
 240 static bfd_boolean do_sections = FALSE;
 241 static bfd_boolean do_section_groups = FALSE;
 242 static bfd_boolean do_section_details = FALSE;
 243 static bfd_boolean do_segments = FALSE;
 244 static bfd_boolean do_unwind = FALSE;
 245 static bfd_boolean do_using_dynamic = FALSE;
 246 static bfd_boolean do_header = FALSE;
 247 static bfd_boolean do_dump = FALSE;
 248 static bfd_boolean do_version = FALSE;
 249 static bfd_boolean do_histogram = FALSE;
 250 static bfd_boolean do_debugging = FALSE;
 251 static bfd_boolean do_arch = FALSE;
 252 static bfd_boolean do_notes = FALSE;
 253 static bfd_boolean do_archive_index = FALSE;
 254 static bfd_boolean is_32bit_elf = FALSE;
 255 static bfd_boolean decompress_dumps = FALSE;
 256
 257 struct group_list
 258 {
 259   struct group_list *  next;
 260   unsigned int         section_index;
 261 };
 262
 263 struct group
 264 {
 265   struct group_list *  root;
 266   unsigned int         group_index;
 267 };
 268
 269 static size_t           group_count;
 270 static struct group *   section_groups;
 271 static struct group **  section_headers_groups;
 272
 273 /* A dynamic array of flags indicating for which sections a dump
 274    has been requested via command line switches.  */
 275 static Filedata         cmdline;
 276
 277 static struct dump_list_entry * dump_sects_byname;
 278
 279 /* How to print a vma value.  */
 280 typedef enum print_mode
 281 {
 282   HEX,
 283   DEC,
 284   DEC_5,
 285   UNSIGNED,
 286   PREFIX_HEX,
 287   FULL_HEX,
 288   LONG_HEX
 289 }
 290 print_mode;
 291
 292 /* Versioned symbol info.  */
 293 enum versioned_symbol_info
 294 {
 295   symbol_undefined,
 296   symbol_hidden,
 297   symbol_public
 298 };
 299
 300 static const char * get_symbol_version_string
 301   (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
 302    Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
 303
 304 #define UNKNOWN -1
 305
 306 #define SECTION_NAME(X)                                         \
 307   ((X) == NULL ? _("<none>")                                    \
 308    : filedata->string_table == NULL ? _("<no-strings>")         \
 309    : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>")    \
 310   : filedata->string_table + (X)->sh_name))
 311
 312 #define DT_VERSIONTAGIDX(tag)   (DT_VERNEEDNUM - (tag)) /* Reverse order!  */
 313
 314 #define GET_ELF_SYMBOLS(file, section, sym_count)                       \
 315   (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count)      \
 316    : get_64bit_elf_symbols (file, section, sym_count))
 317
 318 #define VALID_DYNAMIC_NAME(offset)      ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
 319 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
 320    already been called and verified that the string exists.  */
 321 #define GET_DYNAMIC_NAME(offset)        (dynamic_strings + offset)
 322
 323 #define REMOVE_ARCH_BITS(ADDR)                  \
 324   do                                            \
 325     {                                           \
 326       if (filedata->file_header.e_machine == EM_ARM)    \
 327         (ADDR) &= ~1;                           \
 328     }                                           \
 329   while (0)
 330 \f
 331 /* Print a BFD_VMA to an internal buffer, for use in error messages.
 332    BFD_FMA_FMT can't be used in translated strings.  */
 333
 334 static const char *
 335 bfd_vmatoa (char *fmtch, bfd_vma value)
 336 {
 337   /* bfd_vmatoa is used more then once in a printf call for output.
 338      Cycle through an array of buffers.  */
 339   static int buf_pos = 0;
 340   static struct bfd_vmatoa_buf
 341   {
 342     char place[64];
 343   } buf[4];
 344   char *ret;
 345   char fmt[32];
 346
 347   ret = buf[buf_pos++].place;
 348   buf_pos %= ARRAY_SIZE (buf);
 349
 350   sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
 351   snprintf (ret, sizeof (buf[0].place), fmt, value);
 352   return ret;
 353 }
 354
 355 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
 356    OFFSET + the offset of the current archive member, if we are examining an
 357    archive.  Put the retrieved data into VAR, if it is not NULL.  Otherwise
 358    allocate a buffer using malloc and fill that.  In either case return the
 359    pointer to the start of the retrieved data or NULL if something went wrong.
 360    If something does go wrong and REASON is not NULL then emit an error
 361    message using REASON as part of the context.  */
 362
 363 static void *
 364 get_data (void *         var,
 365           Filedata *     filedata,
 366           unsigned long  offset,
 367           bfd_size_type  size,
 368           bfd_size_type  nmemb,
 369           const char *   reason)
 370 {
 371   void * mvar;
 372   bfd_size_type amt = size * nmemb;
 373
 374   if (size == 0 || nmemb == 0)
 375     return NULL;
 376
 377   /* If the size_t type is smaller than the bfd_size_type, eg because
 378      you are building a 32-bit tool on a 64-bit host, then make sure
 379      that when the sizes are cast to (size_t) no information is lost.  */
 380   if (sizeof (size_t) < sizeof (bfd_size_type)
 381       && (   (bfd_size_type) ((size_t) size) != size
 382           || (bfd_size_type) ((size_t) nmemb) != nmemb))
 383     {
 384       if (reason)
 385         error (_("Size truncation prevents reading %s"
 386                  " elements of size %s for %s\n"),
 387                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 388       return NULL;
 389     }
 390
 391   /* Check for size overflow.  */
 392   if (amt < nmemb)
 393     {
 394       if (reason)
 395         error (_("Size overflow prevents reading %s"
 396                  " elements of size %s for %s\n"),
 397                bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
 398       return NULL;
 399     }
 400
 401   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
 402      attempting to allocate memory when the read is bound to fail.  */
 403   if (amt > filedata->file_size
 404       || offset + archive_file_offset + amt > filedata->file_size)
 405     {
 406       if (reason)
 407         error (_("Reading %s bytes extends past end of file for %s\n"),
 408                bfd_vmatoa ("u", amt), reason);
 409       return NULL;
 410     }
 411
 412   if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
 413     {
 414       if (reason)
 415         error (_("Unable to seek to 0x%lx for %s\n"),
 416                archive_file_offset + offset, reason);
 417       return NULL;
 418     }
 419
 420   mvar = var;
 421   if (mvar == NULL)
 422     {
 423       /* Check for overflow.  */
 424       if (nmemb < (~(bfd_size_type) 0 - 1) / size)
 425         /* + 1 so that we can '\0' terminate invalid string table sections.  */
 426         mvar = malloc ((size_t) amt + 1);
 427
 428       if (mvar == NULL)
 429         {
 430           if (reason)
 431             error (_("Out of memory allocating %s bytes for %s\n"),
 432                    bfd_vmatoa ("u", amt), reason);
 433           return NULL;
 434         }
 435
 436       ((char *) mvar)[amt] = '\0';
 437     }
 438
 439   if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
 440     {
 441       if (reason)
 442         error (_("Unable to read in %s bytes of %s\n"),
 443                bfd_vmatoa ("u", amt), reason);
 444       if (mvar != var)
 445         free (mvar);
 446       return NULL;
 447     }
 448
 449   return mvar;
 450 }
 451
 452 /* Print a VMA value in the MODE specified.
 453    Returns the number of characters displayed.  */
 454
 455 static unsigned int
 456 print_vma (bfd_vma vma, print_mode mode)
 457 {
 458   unsigned int nc = 0;
 459
 460   switch (mode)
 461     {
 462     case FULL_HEX:
 463       nc = printf ("0x");
 464       /* Fall through.  */
 465     case LONG_HEX:
 466 #ifdef BFD64
 467       if (is_32bit_elf)
 468         return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
 469 #endif
 470       printf_vma (vma);
 471       return nc + 16;
 472
 473     case DEC_5:
 474       if (vma <= 99999)
 475         return printf ("%5" BFD_VMA_FMT "d", vma);
 476       /* Fall through.  */
 477     case PREFIX_HEX:
 478       nc = printf ("0x");
 479       /* Fall through.  */
 480     case HEX:
 481       return nc + printf ("%" BFD_VMA_FMT "x", vma);
 482
 483     case DEC:
 484       return printf ("%" BFD_VMA_FMT "d", vma);
 485
 486     case UNSIGNED:
 487       return printf ("%" BFD_VMA_FMT "u", vma);
 488
 489     default:
 490       /* FIXME: Report unrecognised mode ?  */
 491       return 0;
 492     }
 493 }
 494
 495 /* Display a symbol on stdout.  Handles the display of control characters and
 496    multibye characters (assuming the host environment supports them).
 497
 498    Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
 499
 500    If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
 501    padding as necessary.
 502
 503    Returns the number of emitted characters.  */
 504
 505 static unsigned int
 506 print_symbol (signed int width, const char *symbol)
 507 {
 508   bfd_boolean extra_padding = FALSE;
 509   signed int num_printed = 0;
 510 #ifdef HAVE_MBSTATE_T
 511   mbstate_t state;
 512 #endif
 513   unsigned int width_remaining;
 514
 515   if (width < 0)
 516     {
 517       /* Keep the width positive.  This helps the code below.  */
 518       width = - width;
 519       extra_padding = TRUE;
 520     }
 521   else if (width == 0)
 522     return 0;
 523
 524   if (do_wide)
 525     /* Set the remaining width to a very large value.
 526        This simplifies the code below.  */
 527     width_remaining = INT_MAX;
 528   else
 529     width_remaining = width;
 530
 531 #ifdef HAVE_MBSTATE_T
 532   /* Initialise the multibyte conversion state.  */
 533   memset (& state, 0, sizeof (state));
 534 #endif
 535
 536   while (width_remaining)
 537     {
 538       size_t  n;
 539       const char c = *symbol++;
 540
 541       if (c == 0)
 542         break;
 543
 544       /* Do not print control characters directly as they can affect terminal
 545          settings.  Such characters usually appear in the names generated
 546          by the assembler for local labels.  */
 547       if (ISCNTRL (c))
 548         {
 549           if (width_remaining < 2)
 550             break;
 551
 552           printf ("^%c", c + 0x40);
 553           width_remaining -= 2;
 554           num_printed += 2;
 555         }
 556       else if (ISPRINT (c))
 557         {
 558           putchar (c);
 559           width_remaining --;
 560           num_printed ++;
 561         }
 562       else
 563         {
 564 #ifdef HAVE_MBSTATE_T
 565           wchar_t w;
 566 #endif
 567           /* Let printf do the hard work of displaying multibyte characters.  */
 568           printf ("%.1s", symbol - 1);
 569           width_remaining --;
 570           num_printed ++;
 571
 572 #ifdef HAVE_MBSTATE_T
 573           /* Try to find out how many bytes made up the character that was
 574              just printed.  Advance the symbol pointer past the bytes that
 575              were displayed.  */
 576           n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
 577 #else
 578           n = 1;
 579 #endif
 580           if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
 581             symbol += (n - 1);
 582         }
 583     }
 584
 585   if (extra_padding && num_printed < width)
 586     {
 587       /* Fill in the remaining spaces.  */
 588       printf ("%-*s", width - num_printed, " ");
 589       num_printed = width;
 590     }
 591
 592   return num_printed;
 593 }
 594
 595 /* Returns a pointer to a static buffer containing a printable version of
 596    the given section's name.  Like print_symbol, except that it does not try
 597    to print multibyte characters, it just interprets them as hex values.  */
 598
 599 static const char *
 600 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
 601 {
 602 #define MAX_PRINT_SEC_NAME_LEN 128
 603   static char  sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
 604   const char * name = SECTION_NAME (sec);
 605   char *       buf = sec_name_buf;
 606   char         c;
 607   unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
 608
 609   while ((c = * name ++) != 0)
 610     {
 611       if (ISCNTRL (c))
 612         {
 613           if (remaining < 2)
 614             break;
 615
 616           * buf ++ = '^';
 617           * buf ++ = c + 0x40;
 618           remaining -= 2;
 619         }
 620       else if (ISPRINT (c))
 621         {
 622           * buf ++ = c;
 623           remaining -= 1;
 624         }
 625       else
 626         {
 627           static char hex[17] = "0123456789ABCDEF";
 628
 629           if (remaining < 4)
 630             break;
 631           * buf ++ = '<';
 632           * buf ++ = hex[(c & 0xf0) >> 4];
 633           * buf ++ = hex[c & 0x0f];
 634           * buf ++ = '>';
 635           remaining -= 4;
 636         }
 637
 638       if (remaining == 0)
 639         break;
 640     }
 641
 642   * buf = 0;
 643   return sec_name_buf;
 644 }
 645
 646 static const char *
 647 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
 648 {
 649   if (ndx >= filedata->file_header.e_shnum)
 650     return _("<corrupt>");
 651
 652   return printable_section_name (filedata, filedata->section_headers + ndx);
 653 }
 654
 655 /* Return a pointer to section NAME, or NULL if no such section exists.  */
 656
 657 static Elf_Internal_Shdr *
 658 find_section (Filedata * filedata, const char * name)
 659 {
 660   unsigned int i;
 661
 662   if (filedata->section_headers == NULL)
 663     return NULL;
 664
 665   for (i = 0; i < filedata->file_header.e_shnum; i++)
 666     if (streq (SECTION_NAME (filedata->section_headers + i), name))
 667       return filedata->section_headers + i;
 668
 669   return NULL;
 670 }
 671
 672 /* Return a pointer to a section containing ADDR, or NULL if no such
 673    section exists.  */
 674
 675 static Elf_Internal_Shdr *
 676 find_section_by_address (Filedata * filedata, bfd_vma addr)
 677 {
 678   unsigned int i;
 679
 680   if (filedata->section_headers == NULL)
 681     return NULL;
 682
 683   for (i = 0; i < filedata->file_header.e_shnum; i++)
 684     {
 685       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 686
 687       if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
 688         return sec;
 689     }
 690
 691   return NULL;
 692 }
 693
 694 static Elf_Internal_Shdr *
 695 find_section_by_type (Filedata * filedata, unsigned int type)
 696 {
 697   unsigned int i;
 698
 699   if (filedata->section_headers == NULL)
 700     return NULL;
 701
 702   for (i = 0; i < filedata->file_header.e_shnum; i++)
 703     {
 704       Elf_Internal_Shdr *sec = filedata->section_headers + i;
 705
 706       if (sec->sh_type == type)
 707         return sec;
 708     }
 709
 710   return NULL;
 711 }
 712
 713 /* Return a pointer to section NAME, or NULL if no such section exists,
 714    restricted to the list of sections given in SET.  */
 715
 716 static Elf_Internal_Shdr *
 717 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
 718 {
 719   unsigned int i;
 720
 721   if (filedata->section_headers == NULL)
 722     return NULL;
 723
 724   if (set != NULL)
 725     {
 726       while ((i = *set++) > 0)
 727         {
 728           /* See PR 21156 for a reproducer.  */
 729           if (i >= filedata->file_header.e_shnum)
 730             continue; /* FIXME: Should we issue an error message ?  */
 731
 732           if (streq (SECTION_NAME (filedata->section_headers + i), name))
 733             return filedata->section_headers + i;
 734         }
 735     }
 736
 737   return find_section (filedata, name);
 738 }
 739
 740 /* Read an unsigned LEB128 encoded value from DATA.
 741    Set *LENGTH_RETURN to the number of bytes read.  */
 742
 743 static inline unsigned long
 744 read_uleb128 (unsigned char * data,
 745               unsigned int * length_return,
 746               const unsigned char * const end)
 747 {
 748   return read_leb128 (data, length_return, FALSE, end);
 749 }
 750
 751 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
 752    This OS has so many departures from the ELF standard that we test it at
 753    many places.  */
 754
 755 static inline bfd_boolean
 756 is_ia64_vms (Filedata * filedata)
 757 {
 758   return filedata->file_header.e_machine == EM_IA_64
 759     && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
 760 }
 761
 762 /* Guess the relocation size commonly used by the specific machines.  */
 763
 764 static bfd_boolean
 765 guess_is_rela (unsigned int e_machine)
 766 {
 767   switch (e_machine)
 768     {
 769       /* Targets that use REL relocations.  */
 770     case EM_386:
 771     case EM_IAMCU:
 772     case EM_960:
 773     case EM_ARM:
 774     case EM_D10V:
 775     case EM_CYGNUS_D10V:
 776     case EM_DLX:
 777     case EM_MIPS:
 778     case EM_MIPS_RS3_LE:
 779     case EM_CYGNUS_M32R:
 780     case EM_SCORE:
 781     case EM_XGATE:
 782     case EM_NFP:
 783       return FALSE;
 784
 785       /* Targets that use RELA relocations.  */
 786     case EM_68K:
 787     case EM_860:
 788     case EM_AARCH64:
 789     case EM_ADAPTEVA_EPIPHANY:
 790     case EM_ALPHA:
 791     case EM_ALTERA_NIOS2:
 792     case EM_ARC:
 793     case EM_ARC_COMPACT:
 794     case EM_ARC_COMPACT2:
 795     case EM_AVR:
 796     case EM_AVR_OLD:
 797     case EM_BLACKFIN:
 798     case EM_CR16:
 799     case EM_CRIS:
 800     case EM_CRX:
 801     case EM_CSKY:
 802     case EM_D30V:
 803     case EM_CYGNUS_D30V:
 804     case EM_FR30:
 805     case EM_FT32:
 806     case EM_CYGNUS_FR30:
 807     case EM_CYGNUS_FRV:
 808     case EM_H8S:
 809     case EM_H8_300:
 810     case EM_H8_300H:
 811     case EM_IA_64:
 812     case EM_IP2K:
 813     case EM_IP2K_OLD:
 814     case EM_IQ2000:
 815     case EM_LATTICEMICO32:
 816     case EM_M32C_OLD:
 817     case EM_M32C:
 818     case EM_M32R:
 819     case EM_MCORE:
 820     case EM_CYGNUS_MEP:
 821     case EM_METAG:
 822     case EM_MMIX:
 823     case EM_MN10200:
 824     case EM_CYGNUS_MN10200:
 825     case EM_MN10300:
 826     case EM_CYGNUS_MN10300:
 827     case EM_MOXIE:
 828     case EM_MSP430:
 829     case EM_MSP430_OLD:
 830     case EM_MT:
 831     case EM_NDS32:
 832     case EM_NIOS32:
 833     case EM_OR1K:
 834     case EM_PPC64:
 835     case EM_PPC:
 836     case EM_TI_PRU:
 837     case EM_RISCV:
 838     case EM_RL78:
 839     case EM_RX:
 840     case EM_S390:
 841     case EM_S390_OLD:
 842     case EM_SH:
 843     case EM_SPARC:
 844     case EM_SPARC32PLUS:
 845     case EM_SPARCV9:
 846     case EM_SPU:
 847     case EM_TI_C6000:
 848     case EM_TILEGX:
 849     case EM_TILEPRO:
 850     case EM_V800:
 851     case EM_V850:
 852     case EM_CYGNUS_V850:
 853     case EM_VAX:
 854     case EM_VISIUM:
 855     case EM_X86_64:
 856     case EM_L1OM:
 857     case EM_K1OM:
 858     case EM_XSTORMY16:
 859     case EM_XTENSA:
 860     case EM_XTENSA_OLD:
 861     case EM_MICROBLAZE:
 862     case EM_MICROBLAZE_OLD:
 863     case EM_WEBASSEMBLY:
 864       return TRUE;
 865
 866     case EM_68HC05:
 867     case EM_68HC08:
 868     case EM_68HC11:
 869     case EM_68HC16:
 870     case EM_FX66:
 871     case EM_ME16:
 872     case EM_MMA:
 873     case EM_NCPU:
 874     case EM_NDR1:
 875     case EM_PCP:
 876     case EM_ST100:
 877     case EM_ST19:
 878     case EM_ST7:
 879     case EM_ST9PLUS:
 880     case EM_STARCORE:
 881     case EM_SVX:
 882     case EM_TINYJ:
 883     default:
 884       warn (_("Don't know about relocations on this machine architecture\n"));
 885       return FALSE;
 886     }
 887 }
 888
 889 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 890    Returns TRUE upon success, FALSE otherwise.  If successful then a
 891    pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
 892    and the number of relocs loaded is placed in *NRELASP.  It is the caller's
 893    responsibility to free the allocated buffer.  */
 894
 895 static bfd_boolean
 896 slurp_rela_relocs (Filedata *            filedata,
 897                    unsigned long         rel_offset,
 898                    unsigned long         rel_size,
 899                    Elf_Internal_Rela **  relasp,
 900                    unsigned long *       nrelasp)
 901 {
 902   Elf_Internal_Rela * relas;
 903   size_t nrelas;
 904   unsigned int i;
 905
 906   if (is_32bit_elf)
 907     {
 908       Elf32_External_Rela * erelas;
 909
 910       erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 911                                                  rel_size, _("32-bit relocation data"));
 912       if (!erelas)
 913         return FALSE;
 914
 915       nrelas = rel_size / sizeof (Elf32_External_Rela);
 916
 917       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 918                                              sizeof (Elf_Internal_Rela));
 919
 920       if (relas == NULL)
 921         {
 922           free (erelas);
 923           error (_("out of memory parsing relocs\n"));
 924           return FALSE;
 925         }
 926
 927       for (i = 0; i < nrelas; i++)
 928         {
 929           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 930           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 931           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 932         }
 933
 934       free (erelas);
 935     }
 936   else
 937     {
 938       Elf64_External_Rela * erelas;
 939
 940       erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
 941                                                  rel_size, _("64-bit relocation data"));
 942       if (!erelas)
 943         return FALSE;
 944
 945       nrelas = rel_size / sizeof (Elf64_External_Rela);
 946
 947       relas = (Elf_Internal_Rela *) cmalloc (nrelas,
 948                                              sizeof (Elf_Internal_Rela));
 949
 950       if (relas == NULL)
 951         {
 952           free (erelas);
 953           error (_("out of memory parsing relocs\n"));
 954           return FALSE;
 955         }
 956
 957       for (i = 0; i < nrelas; i++)
 958         {
 959           relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
 960           relas[i].r_info   = BYTE_GET (erelas[i].r_info);
 961           relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
 962
 963           /* The #ifdef BFD64 below is to prevent a compile time
 964              warning.  We know that if we do not have a 64 bit data
 965              type that we will never execute this code anyway.  */
 966 #ifdef BFD64
 967           if (filedata->file_header.e_machine == EM_MIPS
 968               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
 969             {
 970               /* In little-endian objects, r_info isn't really a
 971                  64-bit little-endian value: it has a 32-bit
 972                  little-endian symbol index followed by four
 973                  individual byte fields.  Reorder INFO
 974                  accordingly.  */
 975               bfd_vma inf = relas[i].r_info;
 976               inf = (((inf & 0xffffffff) << 32)
 977                       | ((inf >> 56) & 0xff)
 978                       | ((inf >> 40) & 0xff00)
 979                       | ((inf >> 24) & 0xff0000)
 980                       | ((inf >> 8) & 0xff000000));
 981               relas[i].r_info = inf;
 982             }
 983 #endif /* BFD64 */
 984         }
 985
 986       free (erelas);
 987     }
 988
 989   *relasp = relas;
 990   *nrelasp = nrelas;
 991   return TRUE;
 992 }
 993
 994 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
 995    Returns TRUE upon success, FALSE otherwise.  If successful then a
 996    pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
 997    and the number of relocs loaded is placed in *NRELSP.  It is the caller's
 998    responsibility to free the allocated buffer.  */
 999
1000 static bfd_boolean
1001 slurp_rel_relocs (Filedata *            filedata,
1002                   unsigned long         rel_offset,
1003                   unsigned long         rel_size,
1004                   Elf_Internal_Rela **  relsp,
1005                   unsigned long *       nrelsp)
1006 {
1007   Elf_Internal_Rela * rels;
1008   size_t nrels;
1009   unsigned int i;
1010
1011   if (is_32bit_elf)
1012     {
1013       Elf32_External_Rel * erels;
1014
1015       erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1016                                                rel_size, _("32-bit relocation data"));
1017       if (!erels)
1018         return FALSE;
1019
1020       nrels = rel_size / sizeof (Elf32_External_Rel);
1021
1022       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1023
1024       if (rels == NULL)
1025         {
1026           free (erels);
1027           error (_("out of memory parsing relocs\n"));
1028           return FALSE;
1029         }
1030
1031       for (i = 0; i < nrels; i++)
1032         {
1033           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1034           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1035           rels[i].r_addend = 0;
1036         }
1037
1038       free (erels);
1039     }
1040   else
1041     {
1042       Elf64_External_Rel * erels;
1043
1044       erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1045                                                rel_size, _("64-bit relocation data"));
1046       if (!erels)
1047         return FALSE;
1048
1049       nrels = rel_size / sizeof (Elf64_External_Rel);
1050
1051       rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1052
1053       if (rels == NULL)
1054         {
1055           free (erels);
1056           error (_("out of memory parsing relocs\n"));
1057           return FALSE;
1058         }
1059
1060       for (i = 0; i < nrels; i++)
1061         {
1062           rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1063           rels[i].r_info   = BYTE_GET (erels[i].r_info);
1064           rels[i].r_addend = 0;
1065
1066           /* The #ifdef BFD64 below is to prevent a compile time
1067              warning.  We know that if we do not have a 64 bit data
1068              type that we will never execute this code anyway.  */
1069 #ifdef BFD64
1070           if (filedata->file_header.e_machine == EM_MIPS
1071               && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1072             {
1073               /* In little-endian objects, r_info isn't really a
1074                  64-bit little-endian value: it has a 32-bit
1075                  little-endian symbol index followed by four
1076                  individual byte fields.  Reorder INFO
1077                  accordingly.  */
1078               bfd_vma inf = rels[i].r_info;
1079               inf = (((inf & 0xffffffff) << 32)
1080                      | ((inf >> 56) & 0xff)
1081                      | ((inf >> 40) & 0xff00)
1082                      | ((inf >> 24) & 0xff0000)
1083                      | ((inf >> 8) & 0xff000000));
1084               rels[i].r_info = inf;
1085             }
1086 #endif /* BFD64 */
1087         }
1088
1089       free (erels);
1090     }
1091
1092   *relsp = rels;
1093   *nrelsp = nrels;
1094   return TRUE;
1095 }
1096
1097 /* Returns the reloc type extracted from the reloc info field.  */
1098
1099 static unsigned int
1100 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1101 {
1102   if (is_32bit_elf)
1103     return ELF32_R_TYPE (reloc_info);
1104
1105   switch (filedata->file_header.e_machine)
1106     {
1107     case EM_MIPS:
1108       /* Note: We assume that reloc_info has already been adjusted for us.  */
1109       return ELF64_MIPS_R_TYPE (reloc_info);
1110
1111     case EM_SPARCV9:
1112       return ELF64_R_TYPE_ID (reloc_info);
1113
1114     default:
1115       return ELF64_R_TYPE (reloc_info);
1116     }
1117 }
1118
1119 /* Return the symbol index extracted from the reloc info field.  */
1120
1121 static bfd_vma
1122 get_reloc_symindex (bfd_vma reloc_info)
1123 {
1124   return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1125 }
1126
1127 static inline bfd_boolean
1128 uses_msp430x_relocs (Filedata * filedata)
1129 {
1130   return
1131     filedata->file_header.e_machine == EM_MSP430 /* Paranoia.  */
1132     /* GCC uses osabi == ELFOSBI_STANDALONE.  */
1133     && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1134         /* TI compiler uses ELFOSABI_NONE.  */
1135         || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1136 }
1137
1138 /* Display the contents of the relocation data found at the specified
1139    offset.  */
1140
1141 static bfd_boolean
1142 dump_relocations (Filedata *          filedata,
1143                   unsigned long       rel_offset,
1144                   unsigned long       rel_size,
1145                   Elf_Internal_Sym *  symtab,
1146                   unsigned long       nsyms,
1147                   char *              strtab,
1148                   unsigned long       strtablen,
1149                   int                 is_rela,
1150                   bfd_boolean         is_dynsym)
1151 {
1152   unsigned long i;
1153   Elf_Internal_Rela * rels;
1154   bfd_boolean res = TRUE;
1155
1156   if (is_rela == UNKNOWN)
1157     is_rela = guess_is_rela (filedata->file_header.e_machine);
1158
1159   if (is_rela)
1160     {
1161       if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1162         return FALSE;
1163     }
1164   else
1165     {
1166       if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1167         return FALSE;
1168     }
1169
1170   if (is_32bit_elf)
1171     {
1172       if (is_rela)
1173         {
1174           if (do_wide)
1175             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name + Addend\n"));
1176           else
1177             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name + Addend\n"));
1178         }
1179       else
1180         {
1181           if (do_wide)
1182             printf (_(" Offset     Info    Type                Sym. Value  Symbol's Name\n"));
1183           else
1184             printf (_(" Offset     Info    Type            Sym.Value  Sym. Name\n"));
1185         }
1186     }
1187   else
1188     {
1189       if (is_rela)
1190         {
1191           if (do_wide)
1192             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend\n"));
1193           else
1194             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n"));
1195         }
1196       else
1197         {
1198           if (do_wide)
1199             printf (_("    Offset             Info             Type               Symbol's Value  Symbol's Name\n"));
1200           else
1201             printf (_("  Offset          Info           Type           Sym. Value    Sym. Name\n"));
1202         }
1203     }
1204
1205   for (i = 0; i < rel_size; i++)
1206     {
1207       const char * rtype;
1208       bfd_vma offset;
1209       bfd_vma inf;
1210       bfd_vma symtab_index;
1211       bfd_vma type;
1212
1213       offset = rels[i].r_offset;
1214       inf    = rels[i].r_info;
1215
1216       type = get_reloc_type (filedata, inf);
1217       symtab_index = get_reloc_symindex  (inf);
1218
1219       if (is_32bit_elf)
1220         {
1221           printf ("%8.8lx  %8.8lx ",
1222                   (unsigned long) offset & 0xffffffff,
1223                   (unsigned long) inf & 0xffffffff);
1224         }
1225       else
1226         {
1227 #if BFD_HOST_64BIT_LONG
1228           printf (do_wide
1229                   ? "%16.16lx  %16.16lx "
1230                   : "%12.12lx  %12.12lx ",
1231                   offset, inf);
1232 #elif BFD_HOST_64BIT_LONG_LONG
1233 #ifndef __MSVCRT__
1234           printf (do_wide
1235                   ? "%16.16llx  %16.16llx "
1236                   : "%12.12llx  %12.12llx ",
1237                   offset, inf);
1238 #else
1239           printf (do_wide
1240                   ? "%16.16I64x  %16.16I64x "
1241                   : "%12.12I64x  %12.12I64x ",
1242                   offset, inf);
1243 #endif
1244 #else
1245           printf (do_wide
1246                   ? "%8.8lx%8.8lx  %8.8lx%8.8lx "
1247                   : "%4.4lx%8.8lx  %4.4lx%8.8lx ",
1248                   _bfd_int64_high (offset),
1249                   _bfd_int64_low (offset),
1250                   _bfd_int64_high (inf),
1251                   _bfd_int64_low (inf));
1252 #endif
1253         }
1254
1255       switch (filedata->file_header.e_machine)
1256         {
1257         default:
1258           rtype = NULL;
1259           break;
1260
1261         case EM_AARCH64:
1262           rtype = elf_aarch64_reloc_type (type);
1263           break;
1264
1265         case EM_M32R:
1266         case EM_CYGNUS_M32R:
1267           rtype = elf_m32r_reloc_type (type);
1268           break;
1269
1270         case EM_386:
1271         case EM_IAMCU:
1272           rtype = elf_i386_reloc_type (type);
1273           break;
1274
1275         case EM_68HC11:
1276         case EM_68HC12:
1277           rtype = elf_m68hc11_reloc_type (type);
1278           break;
1279
1280         case EM_S12Z:
1281           rtype = elf_s12z_reloc_type (type);
1282           break;
1283
1284         case EM_68K:
1285           rtype = elf_m68k_reloc_type (type);
1286           break;
1287
1288         case EM_960:
1289           rtype = elf_i960_reloc_type (type);
1290           break;
1291
1292         case EM_AVR:
1293         case EM_AVR_OLD:
1294           rtype = elf_avr_reloc_type (type);
1295           break;
1296
1297         case EM_OLD_SPARCV9:
1298         case EM_SPARC32PLUS:
1299         case EM_SPARCV9:
1300         case EM_SPARC:
1301           rtype = elf_sparc_reloc_type (type);
1302           break;
1303
1304         case EM_SPU:
1305           rtype = elf_spu_reloc_type (type);
1306           break;
1307
1308         case EM_V800:
1309           rtype = v800_reloc_type (type);
1310           break;
1311         case EM_V850:
1312         case EM_CYGNUS_V850:
1313           rtype = v850_reloc_type (type);
1314           break;
1315
1316         case EM_D10V:
1317         case EM_CYGNUS_D10V:
1318           rtype = elf_d10v_reloc_type (type);
1319           break;
1320
1321         case EM_D30V:
1322         case EM_CYGNUS_D30V:
1323           rtype = elf_d30v_reloc_type (type);
1324           break;
1325
1326         case EM_DLX:
1327           rtype = elf_dlx_reloc_type (type);
1328           break;
1329
1330         case EM_SH:
1331           rtype = elf_sh_reloc_type (type);
1332           break;
1333
1334         case EM_MN10300:
1335         case EM_CYGNUS_MN10300:
1336           rtype = elf_mn10300_reloc_type (type);
1337           break;
1338
1339         case EM_MN10200:
1340         case EM_CYGNUS_MN10200:
1341           rtype = elf_mn10200_reloc_type (type);
1342           break;
1343
1344         case EM_FR30:
1345         case EM_CYGNUS_FR30:
1346           rtype = elf_fr30_reloc_type (type);
1347           break;
1348
1349         case EM_CYGNUS_FRV:
1350           rtype = elf_frv_reloc_type (type);
1351           break;
1352
1353         case EM_CSKY:
1354           rtype = elf_csky_reloc_type (type);
1355           break;
1356
1357         case EM_FT32:
1358           rtype = elf_ft32_reloc_type (type);
1359           break;
1360
1361         case EM_MCORE:
1362           rtype = elf_mcore_reloc_type (type);
1363           break;
1364
1365         case EM_MMIX:
1366           rtype = elf_mmix_reloc_type (type);
1367           break;
1368
1369         case EM_MOXIE:
1370           rtype = elf_moxie_reloc_type (type);
1371           break;
1372
1373         case EM_MSP430:
1374           if (uses_msp430x_relocs (filedata))
1375             {
1376               rtype = elf_msp430x_reloc_type (type);
1377               break;
1378             }
1379           /* Fall through.  */
1380         case EM_MSP430_OLD:
1381           rtype = elf_msp430_reloc_type (type);
1382           break;
1383
1384         case EM_NDS32:
1385           rtype = elf_nds32_reloc_type (type);
1386           break;
1387
1388         case EM_PPC:
1389           rtype = elf_ppc_reloc_type (type);
1390           break;
1391
1392         case EM_PPC64:
1393           rtype = elf_ppc64_reloc_type (type);
1394           break;
1395
1396         case EM_MIPS:
1397         case EM_MIPS_RS3_LE:
1398           rtype = elf_mips_reloc_type (type);
1399           break;
1400
1401         case EM_RISCV:
1402           rtype = elf_riscv_reloc_type (type);
1403           break;
1404
1405         case EM_ALPHA:
1406           rtype = elf_alpha_reloc_type (type);
1407           break;
1408
1409         case EM_ARM:
1410           rtype = elf_arm_reloc_type (type);
1411           break;
1412
1413         case EM_ARC:
1414         case EM_ARC_COMPACT:
1415         case EM_ARC_COMPACT2:
1416           rtype = elf_arc_reloc_type (type);
1417           break;
1418
1419         case EM_PARISC:
1420           rtype = elf_hppa_reloc_type (type);
1421           break;
1422
1423         case EM_H8_300:
1424         case EM_H8_300H:
1425         case EM_H8S:
1426           rtype = elf_h8_reloc_type (type);
1427           break;
1428
1429         case EM_OR1K:
1430           rtype = elf_or1k_reloc_type (type);
1431           break;
1432
1433         case EM_PJ:
1434         case EM_PJ_OLD:
1435           rtype = elf_pj_reloc_type (type);
1436           break;
1437         case EM_IA_64:
1438           rtype = elf_ia64_reloc_type (type);
1439           break;
1440
1441         case EM_CRIS:
1442           rtype = elf_cris_reloc_type (type);
1443           break;
1444
1445         case EM_860:
1446           rtype = elf_i860_reloc_type (type);
1447           break;
1448
1449         case EM_X86_64:
1450         case EM_L1OM:
1451         case EM_K1OM:
1452           rtype = elf_x86_64_reloc_type (type);
1453           break;
1454
1455         case EM_S370:
1456           rtype = i370_reloc_type (type);
1457           break;
1458
1459         case EM_S390_OLD:
1460         case EM_S390:
1461           rtype = elf_s390_reloc_type (type);
1462           break;
1463
1464         case EM_SCORE:
1465           rtype = elf_score_reloc_type (type);
1466           break;
1467
1468         case EM_XSTORMY16:
1469           rtype = elf_xstormy16_reloc_type (type);
1470           break;
1471
1472         case EM_CRX:
1473           rtype = elf_crx_reloc_type (type);
1474           break;
1475
1476         case EM_VAX:
1477           rtype = elf_vax_reloc_type (type);
1478           break;
1479
1480         case EM_VISIUM:
1481           rtype = elf_visium_reloc_type (type);
1482           break;
1483
1484         case EM_ADAPTEVA_EPIPHANY:
1485           rtype = elf_epiphany_reloc_type (type);
1486           break;
1487
1488         case EM_IP2K:
1489         case EM_IP2K_OLD:
1490           rtype = elf_ip2k_reloc_type (type);
1491           break;
1492
1493         case EM_IQ2000:
1494           rtype = elf_iq2000_reloc_type (type);
1495           break;
1496
1497         case EM_XTENSA_OLD:
1498         case EM_XTENSA:
1499           rtype = elf_xtensa_reloc_type (type);
1500           break;
1501
1502         case EM_LATTICEMICO32:
1503           rtype = elf_lm32_reloc_type (type);
1504           break;
1505
1506         case EM_M32C_OLD:
1507         case EM_M32C:
1508           rtype = elf_m32c_reloc_type (type);
1509           break;
1510
1511         case EM_MT:
1512           rtype = elf_mt_reloc_type (type);
1513           break;
1514
1515         case EM_BLACKFIN:
1516           rtype = elf_bfin_reloc_type (type);
1517           break;
1518
1519         case EM_CYGNUS_MEP:
1520           rtype = elf_mep_reloc_type (type);
1521           break;
1522
1523         case EM_CR16:
1524           rtype = elf_cr16_reloc_type (type);
1525           break;
1526
1527         case EM_MICROBLAZE:
1528         case EM_MICROBLAZE_OLD:
1529           rtype = elf_microblaze_reloc_type (type);
1530           break;
1531
1532         case EM_RL78:
1533           rtype = elf_rl78_reloc_type (type);
1534           break;
1535
1536         case EM_RX:
1537           rtype = elf_rx_reloc_type (type);
1538           break;
1539
1540         case EM_METAG:
1541           rtype = elf_metag_reloc_type (type);
1542           break;
1543
1544         case EM_XC16X:
1545         case EM_C166:
1546           rtype = elf_xc16x_reloc_type (type);
1547           break;
1548
1549         case EM_TI_C6000:
1550           rtype = elf_tic6x_reloc_type (type);
1551           break;
1552
1553         case EM_TILEGX:
1554           rtype = elf_tilegx_reloc_type (type);
1555           break;
1556
1557         case EM_TILEPRO:
1558           rtype = elf_tilepro_reloc_type (type);
1559           break;
1560
1561         case EM_WEBASSEMBLY:
1562           rtype = elf_wasm32_reloc_type (type);
1563           break;
1564
1565         case EM_XGATE:
1566           rtype = elf_xgate_reloc_type (type);
1567           break;
1568
1569         case EM_ALTERA_NIOS2:
1570           rtype = elf_nios2_reloc_type (type);
1571           break;
1572
1573         case EM_TI_PRU:
1574           rtype = elf_pru_reloc_type (type);
1575           break;
1576
1577         case EM_NFP:
1578           if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1579             rtype = elf_nfp3200_reloc_type (type);
1580           else
1581             rtype = elf_nfp_reloc_type (type);
1582           break;
1583         }
1584
1585       if (rtype == NULL)
1586         printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1587       else
1588         printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1589
1590       if (filedata->file_header.e_machine == EM_ALPHA
1591           && rtype != NULL
1592           && streq (rtype, "R_ALPHA_LITUSE")
1593           && is_rela)
1594         {
1595           switch (rels[i].r_addend)
1596             {
1597             case LITUSE_ALPHA_ADDR:   rtype = "ADDR";   break;
1598             case LITUSE_ALPHA_BASE:   rtype = "BASE";   break;
1599             case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1600             case LITUSE_ALPHA_JSR:    rtype = "JSR";    break;
1601             case LITUSE_ALPHA_TLSGD:  rtype = "TLSGD";  break;
1602             case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1603             case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1604             default: rtype = NULL;
1605             }
1606
1607           if (rtype)
1608             printf (" (%s)", rtype);
1609           else
1610             {
1611               putchar (' ');
1612               printf (_("<unknown addend: %lx>"),
1613                       (unsigned long) rels[i].r_addend);
1614               res = FALSE;
1615             }
1616         }
1617       else if (symtab_index)
1618         {
1619           if (symtab == NULL || symtab_index >= nsyms)
1620             {
1621               error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1622               res = FALSE;
1623             }
1624           else
1625             {
1626               Elf_Internal_Sym * psym;
1627               const char * version_string;
1628               enum versioned_symbol_info sym_info;
1629               unsigned short vna_other;
1630
1631               psym = symtab + symtab_index;
1632
1633               version_string
1634                 = get_symbol_version_string (filedata, is_dynsym,
1635                                              strtab, strtablen,
1636                                              symtab_index,
1637                                              psym,
1638                                              &sym_info,
1639                                              &vna_other);
1640
1641               printf (" ");
1642
1643               if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1644                 {
1645                   const char * name;
1646                   unsigned int len;
1647                   unsigned int width = is_32bit_elf ? 8 : 14;
1648
1649                   /* Relocations against GNU_IFUNC symbols do not use the value
1650                      of the symbol as the address to relocate against.  Instead
1651                      they invoke the function named by the symbol and use its
1652                      result as the address for relocation.
1653
1654                      To indicate this to the user, do not display the value of
1655                      the symbol in the "Symbols's Value" field.  Instead show
1656                      its name followed by () as a hint that the symbol is
1657                      invoked.  */
1658
1659                   if (strtab == NULL
1660                       || psym->st_name == 0
1661                       || psym->st_name >= strtablen)
1662                     name = "??";
1663                   else
1664                     name = strtab + psym->st_name;
1665
1666                   len = print_symbol (width, name);
1667                   if (version_string)
1668                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1669                             version_string);
1670                   printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1671                 }
1672               else
1673                 {
1674                   print_vma (psym->st_value, LONG_HEX);
1675
1676                   printf (is_32bit_elf ? "   " : " ");
1677                 }
1678
1679               if (psym->st_name == 0)
1680                 {
1681                   const char * sec_name = "<null>";
1682                   char name_buf[40];
1683
1684                   if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1685                     {
1686                       if (psym->st_shndx < filedata->file_header.e_shnum)
1687                         sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1688                       else if (psym->st_shndx == SHN_ABS)
1689                         sec_name = "ABS";
1690                       else if (psym->st_shndx == SHN_COMMON)
1691                         sec_name = "COMMON";
1692                       else if ((filedata->file_header.e_machine == EM_MIPS
1693                                 && psym->st_shndx == SHN_MIPS_SCOMMON)
1694                                || (filedata->file_header.e_machine == EM_TI_C6000
1695                                    && psym->st_shndx == SHN_TIC6X_SCOMMON))
1696                         sec_name = "SCOMMON";
1697                       else if (filedata->file_header.e_machine == EM_MIPS
1698                                && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1699                         sec_name = "SUNDEF";
1700                       else if ((filedata->file_header.e_machine == EM_X86_64
1701                                 || filedata->file_header.e_machine == EM_L1OM
1702                                 || filedata->file_header.e_machine == EM_K1OM)
1703                                && psym->st_shndx == SHN_X86_64_LCOMMON)
1704                         sec_name = "LARGE_COMMON";
1705                       else if (filedata->file_header.e_machine == EM_IA_64
1706                                && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1707                                && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1708                         sec_name = "ANSI_COM";
1709                       else if (is_ia64_vms (filedata)
1710                                && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1711                         sec_name = "VMS_SYMVEC";
1712                       else
1713                         {
1714                           sprintf (name_buf, "<section 0x%x>",
1715                                    (unsigned int) psym->st_shndx);
1716                           sec_name = name_buf;
1717                         }
1718                     }
1719                   print_symbol (22, sec_name);
1720                 }
1721               else if (strtab == NULL)
1722                 printf (_("<string table index: %3ld>"), psym->st_name);
1723               else if (psym->st_name >= strtablen)
1724                 {
1725                   error (_("<corrupt string table index: %3ld>"), psym->st_name);
1726                   res = FALSE;
1727                 }
1728               else
1729                 {
1730                   print_symbol (22, strtab + psym->st_name);
1731                   if (version_string)
1732                     printf (sym_info == symbol_public ? "@@%s" : "@%s",
1733                             version_string);
1734                 }
1735
1736               if (is_rela)
1737                 {
1738                   bfd_vma off = rels[i].r_addend;
1739
1740                   if ((bfd_signed_vma) off < 0)
1741                     printf (" - %" BFD_VMA_FMT "x", - off);
1742                   else
1743                     printf (" + %" BFD_VMA_FMT "x", off);
1744                 }
1745             }
1746         }
1747       else if (is_rela)
1748         {
1749           bfd_vma off = rels[i].r_addend;
1750
1751           printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1752           if ((bfd_signed_vma) off < 0)
1753             printf ("-%" BFD_VMA_FMT "x", - off);
1754           else
1755             printf ("%" BFD_VMA_FMT "x", off);
1756         }
1757
1758       if (filedata->file_header.e_machine == EM_SPARCV9
1759           && rtype != NULL
1760           && streq (rtype, "R_SPARC_OLO10"))
1761         printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1762
1763       putchar ('\n');
1764
1765 #ifdef BFD64
1766       if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1767         {
1768           bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1769           bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1770           const char * rtype2 = elf_mips_reloc_type (type2);
1771           const char * rtype3 = elf_mips_reloc_type (type3);
1772
1773           printf ("                    Type2: ");
1774
1775           if (rtype2 == NULL)
1776             printf (_("unrecognized: %-7lx"),
1777                     (unsigned long) type2 & 0xffffffff);
1778           else
1779             printf ("%-17.17s", rtype2);
1780
1781           printf ("\n                    Type3: ");
1782
1783           if (rtype3 == NULL)
1784             printf (_("unrecognized: %-7lx"),
1785                     (unsigned long) type3 & 0xffffffff);
1786           else
1787             printf ("%-17.17s", rtype3);
1788
1789           putchar ('\n');
1790         }
1791 #endif /* BFD64 */
1792     }
1793
1794   free (rels);
1795
1796   return res;
1797 }
1798
1799 static const char *
1800 get_mips_dynamic_type (unsigned long type)
1801 {
1802   switch (type)
1803     {
1804     case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1805     case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1806     case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1807     case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1808     case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1809     case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1810     case DT_MIPS_MSYM: return "MIPS_MSYM";
1811     case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1812     case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1813     case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1814     case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1815     case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1816     case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1817     case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1818     case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1819     case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1820     case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1821     case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1822     case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1823     case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1824     case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1825     case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1826     case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1827     case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1828     case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1829     case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1830     case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1831     case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1832     case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1833     case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1834     case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1835     case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1836     case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1837     case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1838     case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1839     case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1840     case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1841     case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1842     case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1843     case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1844     case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1845     case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1846     case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1847     case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1848     case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1849     case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1850     default:
1851       return NULL;
1852     }
1853 }
1854
1855 static const char *
1856 get_sparc64_dynamic_type (unsigned long type)
1857 {
1858   switch (type)
1859     {
1860     case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1861     default:
1862       return NULL;
1863     }
1864 }
1865
1866 static const char *
1867 get_ppc_dynamic_type (unsigned long type)
1868 {
1869   switch (type)
1870     {
1871     case DT_PPC_GOT:    return "PPC_GOT";
1872     case DT_PPC_OPT:    return "PPC_OPT";
1873     default:
1874       return NULL;
1875     }
1876 }
1877
1878 static const char *
1879 get_ppc64_dynamic_type (unsigned long type)
1880 {
1881   switch (type)
1882     {
1883     case DT_PPC64_GLINK:  return "PPC64_GLINK";
1884     case DT_PPC64_OPD:    return "PPC64_OPD";
1885     case DT_PPC64_OPDSZ:  return "PPC64_OPDSZ";
1886     case DT_PPC64_OPT:    return "PPC64_OPT";
1887     default:
1888       return NULL;
1889     }
1890 }
1891
1892 static const char *
1893 get_parisc_dynamic_type (unsigned long type)
1894 {
1895   switch (type)
1896     {
1897     case DT_HP_LOAD_MAP:        return "HP_LOAD_MAP";
1898     case DT_HP_DLD_FLAGS:       return "HP_DLD_FLAGS";
1899     case DT_HP_DLD_HOOK:        return "HP_DLD_HOOK";
1900     case DT_HP_UX10_INIT:       return "HP_UX10_INIT";
1901     case DT_HP_UX10_INITSZ:     return "HP_UX10_INITSZ";
1902     case DT_HP_PREINIT:         return "HP_PREINIT";
1903     case DT_HP_PREINITSZ:       return "HP_PREINITSZ";
1904     case DT_HP_NEEDED:          return "HP_NEEDED";
1905     case DT_HP_TIME_STAMP:      return "HP_TIME_STAMP";
1906     case DT_HP_CHECKSUM:        return "HP_CHECKSUM";
1907     case DT_HP_GST_SIZE:        return "HP_GST_SIZE";
1908     case DT_HP_GST_VERSION:     return "HP_GST_VERSION";
1909     case DT_HP_GST_HASHVAL:     return "HP_GST_HASHVAL";
1910     case DT_HP_EPLTREL:         return "HP_GST_EPLTREL";
1911     case DT_HP_EPLTRELSZ:       return "HP_GST_EPLTRELSZ";
1912     case DT_HP_FILTERED:        return "HP_FILTERED";
1913     case DT_HP_FILTER_TLS:      return "HP_FILTER_TLS";
1914     case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1915     case DT_HP_LAZYLOAD:        return "HP_LAZYLOAD";
1916     case DT_HP_BIND_NOW_COUNT:  return "HP_BIND_NOW_COUNT";
1917     case DT_PLT:                return "PLT";
1918     case DT_PLT_SIZE:           return "PLT_SIZE";
1919     case DT_DLT:                return "DLT";
1920     case DT_DLT_SIZE:           return "DLT_SIZE";
1921     default:
1922       return NULL;
1923     }
1924 }
1925
1926 static const char *
1927 get_ia64_dynamic_type (unsigned long type)
1928 {
1929   switch (type)
1930     {
1931     case DT_IA_64_PLT_RESERVE:         return "IA_64_PLT_RESERVE";
1932     case DT_IA_64_VMS_SUBTYPE:         return "VMS_SUBTYPE";
1933     case DT_IA_64_VMS_IMGIOCNT:        return "VMS_IMGIOCNT";
1934     case DT_IA_64_VMS_LNKFLAGS:        return "VMS_LNKFLAGS";
1935     case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1936     case DT_IA_64_VMS_IDENT:           return "VMS_IDENT";
1937     case DT_IA_64_VMS_NEEDED_IDENT:    return "VMS_NEEDED_IDENT";
1938     case DT_IA_64_VMS_IMG_RELA_CNT:    return "VMS_IMG_RELA_CNT";
1939     case DT_IA_64_VMS_SEG_RELA_CNT:    return "VMS_SEG_RELA_CNT";
1940     case DT_IA_64_VMS_FIXUP_RELA_CNT:  return "VMS_FIXUP_RELA_CNT";
1941     case DT_IA_64_VMS_FIXUP_NEEDED:    return "VMS_FIXUP_NEEDED";
1942     case DT_IA_64_VMS_SYMVEC_CNT:      return "VMS_SYMVEC_CNT";
1943     case DT_IA_64_VMS_XLATED:          return "VMS_XLATED";
1944     case DT_IA_64_VMS_STACKSIZE:       return "VMS_STACKSIZE";
1945     case DT_IA_64_VMS_UNWINDSZ:        return "VMS_UNWINDSZ";
1946     case DT_IA_64_VMS_UNWIND_CODSEG:   return "VMS_UNWIND_CODSEG";
1947     case DT_IA_64_VMS_UNWIND_INFOSEG:  return "VMS_UNWIND_INFOSEG";
1948     case DT_IA_64_VMS_LINKTIME:        return "VMS_LINKTIME";
1949     case DT_IA_64_VMS_SEG_NO:          return "VMS_SEG_NO";
1950     case DT_IA_64_VMS_SYMVEC_OFFSET:   return "VMS_SYMVEC_OFFSET";
1951     case DT_IA_64_VMS_SYMVEC_SEG:      return "VMS_SYMVEC_SEG";
1952     case DT_IA_64_VMS_UNWIND_OFFSET:   return "VMS_UNWIND_OFFSET";
1953     case DT_IA_64_VMS_UNWIND_SEG:      return "VMS_UNWIND_SEG";
1954     case DT_IA_64_VMS_STRTAB_OFFSET:   return "VMS_STRTAB_OFFSET";
1955     case DT_IA_64_VMS_SYSVER_OFFSET:   return "VMS_SYSVER_OFFSET";
1956     case DT_IA_64_VMS_IMG_RELA_OFF:    return "VMS_IMG_RELA_OFF";
1957     case DT_IA_64_VMS_SEG_RELA_OFF:    return "VMS_SEG_RELA_OFF";
1958     case DT_IA_64_VMS_FIXUP_RELA_OFF:  return "VMS_FIXUP_RELA_OFF";
1959     case DT_IA_64_VMS_PLTGOT_OFFSET:   return "VMS_PLTGOT_OFFSET";
1960     case DT_IA_64_VMS_PLTGOT_SEG:      return "VMS_PLTGOT_SEG";
1961     case DT_IA_64_VMS_FPMODE:          return "VMS_FPMODE";
1962     default:
1963       return NULL;
1964     }
1965 }
1966
1967 static const char *
1968 get_solaris_section_type (unsigned long type)
1969 {
1970   switch (type)
1971     {
1972     case 0x6fffffee: return "SUNW_ancillary";
1973     case 0x6fffffef: return "SUNW_capchain";
1974     case 0x6ffffff0: return "SUNW_capinfo";
1975     case 0x6ffffff1: return "SUNW_symsort";
1976     case 0x6ffffff2: return "SUNW_tlssort";
1977     case 0x6ffffff3: return "SUNW_LDYNSYM";
1978     case 0x6ffffff4: return "SUNW_dof";
1979     case 0x6ffffff5: return "SUNW_cap";
1980     case 0x6ffffff6: return "SUNW_SIGNATURE";
1981     case 0x6ffffff7: return "SUNW_ANNOTATE";
1982     case 0x6ffffff8: return "SUNW_DEBUGSTR";
1983     case 0x6ffffff9: return "SUNW_DEBUG";
1984     case 0x6ffffffa: return "SUNW_move";
1985     case 0x6ffffffb: return "SUNW_COMDAT";
1986     case 0x6ffffffc: return "SUNW_syminfo";
1987     case 0x6ffffffd: return "SUNW_verdef";
1988     case 0x6ffffffe: return "SUNW_verneed";
1989     case 0x6fffffff: return "SUNW_versym";
1990     case 0x70000000: return "SPARC_GOTDATA";
1991     default: return NULL;
1992     }
1993 }
1994
1995 static const char *
1996 get_alpha_dynamic_type (unsigned long type)
1997 {
1998   switch (type)
1999     {
2000     case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2001     default: return NULL;
2002     }
2003 }
2004
2005 static const char *
2006 get_score_dynamic_type (unsigned long type)
2007 {
2008   switch (type)
2009     {
2010     case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2011     case DT_SCORE_LOCAL_GOTNO:  return "SCORE_LOCAL_GOTNO";
2012     case DT_SCORE_SYMTABNO:     return "SCORE_SYMTABNO";
2013     case DT_SCORE_GOTSYM:       return "SCORE_GOTSYM";
2014     case DT_SCORE_UNREFEXTNO:   return "SCORE_UNREFEXTNO";
2015     case DT_SCORE_HIPAGENO:     return "SCORE_HIPAGENO";
2016     default:                    return NULL;
2017     }
2018 }
2019
2020 static const char *
2021 get_tic6x_dynamic_type (unsigned long type)
2022 {
2023   switch (type)
2024     {
2025     case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2026     case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2027     case DT_C6000_DSBT_BASE:   return "C6000_DSBT_BASE";
2028     case DT_C6000_DSBT_SIZE:   return "C6000_DSBT_SIZE";
2029     case DT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
2030     case DT_C6000_DSBT_INDEX:  return "C6000_DSBT_INDEX";
2031     default:                   return NULL;
2032     }
2033 }
2034
2035 static const char *
2036 get_nios2_dynamic_type (unsigned long type)
2037 {
2038   switch (type)
2039     {
2040     case DT_NIOS2_GP: return "NIOS2_GP";
2041     default:          return NULL;
2042     }
2043 }
2044
2045 static const char *
2046 get_solaris_dynamic_type (unsigned long type)
2047 {
2048   switch (type)
2049     {
2050     case 0x6000000d: return "SUNW_AUXILIARY";
2051     case 0x6000000e: return "SUNW_RTLDINF";
2052     case 0x6000000f: return "SUNW_FILTER";
2053     case 0x60000010: return "SUNW_CAP";
2054     case 0x60000011: return "SUNW_SYMTAB";
2055     case 0x60000012: return "SUNW_SYMSZ";
2056     case 0x60000013: return "SUNW_SORTENT";
2057     case 0x60000014: return "SUNW_SYMSORT";
2058     case 0x60000015: return "SUNW_SYMSORTSZ";
2059     case 0x60000016: return "SUNW_TLSSORT";
2060     case 0x60000017: return "SUNW_TLSSORTSZ";
2061     case 0x60000018: return "SUNW_CAPINFO";
2062     case 0x60000019: return "SUNW_STRPAD";
2063     case 0x6000001a: return "SUNW_CAPCHAIN";
2064     case 0x6000001b: return "SUNW_LDMACH";
2065     case 0x6000001d: return "SUNW_CAPCHAINENT";
2066     case 0x6000001f: return "SUNW_CAPCHAINSZ";
2067     case 0x60000021: return "SUNW_PARENT";
2068     case 0x60000023: return "SUNW_ASLR";
2069     case 0x60000025: return "SUNW_RELAX";
2070     case 0x60000029: return "SUNW_NXHEAP";
2071     case 0x6000002b: return "SUNW_NXSTACK";
2072
2073     case 0x70000001: return "SPARC_REGISTER";
2074     case 0x7ffffffd: return "AUXILIARY";
2075     case 0x7ffffffe: return "USED";
2076     case 0x7fffffff: return "FILTER";
2077
2078     default: return NULL;
2079     }
2080 }
2081
2082 static const char *
2083 get_dynamic_type (Filedata * filedata, unsigned long type)
2084 {
2085   static char buff[64];
2086
2087   switch (type)
2088     {
2089     case DT_NULL:       return "NULL";
2090     case DT_NEEDED:     return "NEEDED";
2091     case DT_PLTRELSZ:   return "PLTRELSZ";
2092     case DT_PLTGOT:     return "PLTGOT";
2093     case DT_HASH:       return "HASH";
2094     case DT_STRTAB:     return "STRTAB";
2095     case DT_SYMTAB:     return "SYMTAB";
2096     case DT_RELA:       return "RELA";
2097     case DT_RELASZ:     return "RELASZ";
2098     case DT_RELAENT:    return "RELAENT";
2099     case DT_STRSZ:      return "STRSZ";
2100     case DT_SYMENT:     return "SYMENT";
2101     case DT_INIT:       return "INIT";
2102     case DT_FINI:       return "FINI";
2103     case DT_SONAME:     return "SONAME";
2104     case DT_RPATH:      return "RPATH";
2105     case DT_SYMBOLIC:   return "SYMBOLIC";
2106     case DT_REL:        return "REL";
2107     case DT_RELSZ:      return "RELSZ";
2108     case DT_RELENT:     return "RELENT";
2109     case DT_PLTREL:     return "PLTREL";
2110     case DT_DEBUG:      return "DEBUG";
2111     case DT_TEXTREL:    return "TEXTREL";
2112     case DT_JMPREL:     return "JMPREL";
2113     case DT_BIND_NOW:   return "BIND_NOW";
2114     case DT_INIT_ARRAY: return "INIT_ARRAY";
2115     case DT_FINI_ARRAY: return "FINI_ARRAY";
2116     case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2117     case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2118     case DT_RUNPATH:    return "RUNPATH";
2119     case DT_FLAGS:      return "FLAGS";
2120
2121     case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2122     case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2123     case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2124
2125     case DT_CHECKSUM:   return "CHECKSUM";
2126     case DT_PLTPADSZ:   return "PLTPADSZ";
2127     case DT_MOVEENT:    return "MOVEENT";
2128     case DT_MOVESZ:     return "MOVESZ";
2129     case DT_FEATURE:    return "FEATURE";
2130     case DT_POSFLAG_1:  return "POSFLAG_1";
2131     case DT_SYMINSZ:    return "SYMINSZ";
2132     case DT_SYMINENT:   return "SYMINENT"; /* aka VALRNGHI */
2133
2134     case DT_ADDRRNGLO:  return "ADDRRNGLO";
2135     case DT_CONFIG:     return "CONFIG";
2136     case DT_DEPAUDIT:   return "DEPAUDIT";
2137     case DT_AUDIT:      return "AUDIT";
2138     case DT_PLTPAD:     return "PLTPAD";
2139     case DT_MOVETAB:    return "MOVETAB";
2140     case DT_SYMINFO:    return "SYMINFO"; /* aka ADDRRNGHI */
2141
2142     case DT_VERSYM:     return "VERSYM";
2143
2144     case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2145     case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2146     case DT_RELACOUNT:  return "RELACOUNT";
2147     case DT_RELCOUNT:   return "RELCOUNT";
2148     case DT_FLAGS_1:    return "FLAGS_1";
2149     case DT_VERDEF:     return "VERDEF";
2150     case DT_VERDEFNUM:  return "VERDEFNUM";
2151     case DT_VERNEED:    return "VERNEED";
2152     case DT_VERNEEDNUM: return "VERNEEDNUM";
2153
2154     case DT_AUXILIARY:  return "AUXILIARY";
2155     case DT_USED:       return "USED";
2156     case DT_FILTER:     return "FILTER";
2157
2158     case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2159     case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2160     case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2161     case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2162     case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2163     case DT_GNU_HASH:   return "GNU_HASH";
2164
2165     default:
2166       if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2167         {
2168           const char * result;
2169
2170           switch (filedata->file_header.e_machine)
2171             {
2172             case EM_MIPS:
2173             case EM_MIPS_RS3_LE:
2174               result = get_mips_dynamic_type (type);
2175               break;
2176             case EM_SPARCV9:
2177               result = get_sparc64_dynamic_type (type);
2178               break;
2179             case EM_PPC:
2180               result = get_ppc_dynamic_type (type);
2181               break;
2182             case EM_PPC64:
2183               result = get_ppc64_dynamic_type (type);
2184               break;
2185             case EM_IA_64:
2186               result = get_ia64_dynamic_type (type);
2187               break;
2188             case EM_ALPHA:
2189               result = get_alpha_dynamic_type (type);
2190               break;
2191             case EM_SCORE:
2192               result = get_score_dynamic_type (type);
2193               break;
2194             case EM_TI_C6000:
2195               result = get_tic6x_dynamic_type (type);
2196               break;
2197             case EM_ALTERA_NIOS2:
2198               result = get_nios2_dynamic_type (type);
2199               break;
2200             default:
2201               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2202                 result = get_solaris_dynamic_type (type);
2203               else
2204                 result = NULL;
2205               break;
2206             }
2207
2208           if (result != NULL)
2209             return result;
2210
2211           snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2212         }
2213       else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2214                || (filedata->file_header.e_machine == EM_PARISC
2215                    && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2216         {
2217           const char * result;
2218
2219           switch (filedata->file_header.e_machine)
2220             {
2221             case EM_PARISC:
2222               result = get_parisc_dynamic_type (type);
2223               break;
2224             case EM_IA_64:
2225               result = get_ia64_dynamic_type (type);
2226               break;
2227             default:
2228               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2229                 result = get_solaris_dynamic_type (type);
2230               else
2231                 result = NULL;
2232               break;
2233             }
2234
2235           if (result != NULL)
2236             return result;
2237
2238           snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2239                     type);
2240         }
2241       else
2242         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2243
2244       return buff;
2245     }
2246 }
2247
2248 static char *
2249 get_file_type (unsigned e_type)
2250 {
2251   static char buff[32];
2252
2253   switch (e_type)
2254     {
2255     case ET_NONE: return _("NONE (None)");
2256     case ET_REL:  return _("REL (Relocatable file)");
2257     case ET_EXEC: return _("EXEC (Executable file)");
2258     case ET_DYN:  return _("DYN (Shared object file)");
2259     case ET_CORE: return _("CORE (Core file)");
2260
2261     default:
2262       if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2263         snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2264       else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2265         snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2266       else
2267         snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2268       return buff;
2269     }
2270 }
2271
2272 static char *
2273 get_machine_name (unsigned e_machine)
2274 {
2275   static char buff[64]; /* XXX */
2276
2277   switch (e_machine)
2278     {
2279       /* Please keep this switch table sorted by increasing EM_ value.  */
2280       /* 0 */
2281     case EM_NONE:               return _("None");
2282     case EM_M32:                return "WE32100";
2283     case EM_SPARC:              return "Sparc";
2284     case EM_386:                return "Intel 80386";
2285     case EM_68K:                return "MC68000";
2286     case EM_88K:                return "MC88000";
2287     case EM_IAMCU:              return "Intel MCU";
2288     case EM_860:                return "Intel 80860";
2289     case EM_MIPS:               return "MIPS R3000";
2290     case EM_S370:               return "IBM System/370";
2291       /* 10 */
2292     case EM_MIPS_RS3_LE:        return "MIPS R4000 big-endian";
2293     case EM_OLD_SPARCV9:        return "Sparc v9 (old)";
2294     case EM_PARISC:             return "HPPA";
2295     case EM_VPP550:             return "Fujitsu VPP500";
2296     case EM_SPARC32PLUS:        return "Sparc v8+" ;
2297     case EM_960:                return "Intel 80960";
2298     case EM_PPC:                return "PowerPC";
2299       /* 20 */
2300     case EM_PPC64:              return "PowerPC64";
2301     case EM_S390_OLD:
2302     case EM_S390:               return "IBM S/390";
2303     case EM_SPU:                return "SPU";
2304       /* 30 */
2305     case EM_V800:               return "Renesas V850 (using RH850 ABI)";
2306     case EM_FR20:               return "Fujitsu FR20";
2307     case EM_RH32:               return "TRW RH32";
2308     case EM_MCORE:              return "MCORE";
2309       /* 40 */
2310     case EM_ARM:                return "ARM";
2311     case EM_OLD_ALPHA:          return "Digital Alpha (old)";
2312     case EM_SH:                 return "Renesas / SuperH SH";
2313     case EM_SPARCV9:            return "Sparc v9";
2314     case EM_TRICORE:            return "Siemens Tricore";
2315     case EM_ARC:                return "ARC";
2316     case EM_H8_300:             return "Renesas H8/300";
2317     case EM_H8_300H:            return "Renesas H8/300H";
2318     case EM_H8S:                return "Renesas H8S";
2319     case EM_H8_500:             return "Renesas H8/500";
2320       /* 50 */
2321     case EM_IA_64:              return "Intel IA-64";
2322     case EM_MIPS_X:             return "Stanford MIPS-X";
2323     case EM_COLDFIRE:           return "Motorola Coldfire";
2324     case EM_68HC12:             return "Motorola MC68HC12 Microcontroller";
2325     case EM_MMA:                return "Fujitsu Multimedia Accelerator";
2326     case EM_PCP:                return "Siemens PCP";
2327     case EM_NCPU:               return "Sony nCPU embedded RISC processor";
2328     case EM_NDR1:               return "Denso NDR1 microprocesspr";
2329     case EM_STARCORE:           return "Motorola Star*Core processor";
2330     case EM_ME16:               return "Toyota ME16 processor";
2331       /* 60 */
2332     case EM_ST100:              return "STMicroelectronics ST100 processor";
2333     case EM_TINYJ:              return "Advanced Logic Corp. TinyJ embedded processor";
2334     case EM_X86_64:             return "Advanced Micro Devices X86-64";
2335     case EM_PDSP:               return "Sony DSP processor";
2336     case EM_PDP10:              return "Digital Equipment Corp. PDP-10";
2337     case EM_PDP11:              return "Digital Equipment Corp. PDP-11";
2338     case EM_FX66:               return "Siemens FX66 microcontroller";
2339     case EM_ST9PLUS:            return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2340     case EM_ST7:                return "STMicroelectronics ST7 8-bit microcontroller";
2341     case EM_68HC16:             return "Motorola MC68HC16 Microcontroller";
2342       /* 70 */
2343     case EM_68HC11:             return "Motorola MC68HC11 Microcontroller";
2344     case EM_68HC08:             return "Motorola MC68HC08 Microcontroller";
2345     case EM_68HC05:             return "Motorola MC68HC05 Microcontroller";
2346     case EM_SVX:                return "Silicon Graphics SVx";
2347     case EM_ST19:               return "STMicroelectronics ST19 8-bit microcontroller";
2348     case EM_VAX:                return "Digital VAX";
2349     case EM_CRIS:               return "Axis Communications 32-bit embedded processor";
2350     case EM_JAVELIN:            return "Infineon Technologies 32-bit embedded cpu";
2351     case EM_FIREPATH:           return "Element 14 64-bit DSP processor";
2352     case EM_ZSP:                return "LSI Logic's 16-bit DSP processor";
2353       /* 80 */
2354     case EM_MMIX:               return "Donald Knuth's educational 64-bit processor";
2355     case EM_HUANY:              return "Harvard Universitys's machine-independent object format";
2356     case EM_PRISM:              return "Vitesse Prism";
2357     case EM_AVR_OLD:
2358     case EM_AVR:                return "Atmel AVR 8-bit microcontroller";
2359     case EM_CYGNUS_FR30:
2360     case EM_FR30:               return "Fujitsu FR30";
2361     case EM_CYGNUS_D10V:
2362     case EM_D10V:               return "d10v";
2363     case EM_CYGNUS_D30V:
2364     case EM_D30V:               return "d30v";
2365     case EM_CYGNUS_V850:
2366     case EM_V850:               return "Renesas V850";
2367     case EM_CYGNUS_M32R:
2368     case EM_M32R:               return "Renesas M32R (formerly Mitsubishi M32r)";
2369     case EM_CYGNUS_MN10300:
2370     case EM_MN10300:            return "mn10300";
2371       /* 90 */
2372     case EM_CYGNUS_MN10200:
2373     case EM_MN10200:            return "mn10200";
2374     case EM_PJ:                 return "picoJava";
2375     case EM_OR1K:               return "OpenRISC 1000";
2376     case EM_ARC_COMPACT:        return "ARCompact";
2377     case EM_XTENSA_OLD:
2378     case EM_XTENSA:             return "Tensilica Xtensa Processor";
2379     case EM_VIDEOCORE:          return "Alphamosaic VideoCore processor";
2380     case EM_TMM_GPP:            return "Thompson Multimedia General Purpose Processor";
2381     case EM_NS32K:              return "National Semiconductor 32000 series";
2382     case EM_TPC:                return "Tenor Network TPC processor";
2383     case EM_SNP1K:              return "Trebia SNP 1000 processor";
2384       /* 100 */
2385     case EM_ST200:              return "STMicroelectronics ST200 microcontroller";
2386     case EM_IP2K_OLD:
2387     case EM_IP2K:               return "Ubicom IP2xxx 8-bit microcontrollers";
2388     case EM_MAX:                return "MAX Processor";
2389     case EM_CR:                 return "National Semiconductor CompactRISC";
2390     case EM_F2MC16:             return "Fujitsu F2MC16";
2391     case EM_MSP430:             return "Texas Instruments msp430 microcontroller";
2392     case EM_BLACKFIN:           return "Analog Devices Blackfin";
2393     case EM_SE_C33:             return "S1C33 Family of Seiko Epson processors";
2394     case EM_SEP:                return "Sharp embedded microprocessor";
2395     case EM_ARCA:               return "Arca RISC microprocessor";
2396       /* 110 */
2397     case EM_UNICORE:            return "Unicore";
2398     case EM_EXCESS:             return "eXcess 16/32/64-bit configurable embedded CPU";
2399     case EM_DXP:                return "Icera Semiconductor Inc. Deep Execution Processor";
2400     case EM_ALTERA_NIOS2:       return "Altera Nios II";
2401     case EM_CRX:                return "National Semiconductor CRX microprocessor";
2402     case EM_XGATE:              return "Motorola XGATE embedded processor";
2403     case EM_C166:
2404     case EM_XC16X:              return "Infineon Technologies xc16x";
2405     case EM_M16C:               return "Renesas M16C series microprocessors";
2406     case EM_DSPIC30F:           return "Microchip Technology dsPIC30F Digital Signal Controller";
2407     case EM_CE:                 return "Freescale Communication Engine RISC core";
2408       /* 120 */
2409     case EM_M32C:               return "Renesas M32c";
2410       /* 130 */
2411     case EM_TSK3000:            return "Altium TSK3000 core";
2412     case EM_RS08:               return "Freescale RS08 embedded processor";
2413     case EM_ECOG2:              return "Cyan Technology eCOG2 microprocessor";
2414     case EM_SCORE:              return "SUNPLUS S+Core";
2415     case EM_DSP24:              return "New Japan Radio (NJR) 24-bit DSP Processor";
2416     case EM_VIDEOCORE3:         return "Broadcom VideoCore III processor";
2417     case EM_LATTICEMICO32:      return "Lattice Mico32";
2418     case EM_SE_C17:             return "Seiko Epson C17 family";
2419       /* 140 */
2420     case EM_TI_C6000:           return "Texas Instruments TMS320C6000 DSP family";
2421     case EM_TI_C2000:           return "Texas Instruments TMS320C2000 DSP family";
2422     case EM_TI_C5500:           return "Texas Instruments TMS320C55x DSP family";
2423     case EM_TI_PRU:             return "TI PRU I/O processor";
2424       /* 160 */
2425     case EM_MMDSP_PLUS:         return "STMicroelectronics 64bit VLIW Data Signal Processor";
2426     case EM_CYPRESS_M8C:        return "Cypress M8C microprocessor";
2427     case EM_R32C:               return "Renesas R32C series microprocessors";
2428     case EM_TRIMEDIA:           return "NXP Semiconductors TriMedia architecture family";
2429     case EM_QDSP6:              return "QUALCOMM DSP6 Processor";
2430     case EM_8051:               return "Intel 8051 and variants";
2431     case EM_STXP7X:             return "STMicroelectronics STxP7x family";
2432     case EM_NDS32:              return "Andes Technology compact code size embedded RISC processor family";
2433     case EM_ECOG1X:             return "Cyan Technology eCOG1X family";
2434     case EM_MAXQ30:             return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2435       /* 170 */
2436     case EM_XIMO16:             return "New Japan Radio (NJR) 16-bit DSP Processor";
2437     case EM_MANIK:              return "M2000 Reconfigurable RISC Microprocessor";
2438     case EM_CRAYNV2:            return "Cray Inc. NV2 vector architecture";
2439     case EM_RX:                 return "Renesas RX";
2440     case EM_METAG:              return "Imagination Technologies Meta processor architecture";
2441     case EM_MCST_ELBRUS:        return "MCST Elbrus general purpose hardware architecture";
2442     case EM_ECOG16:             return "Cyan Technology eCOG16 family";
2443     case EM_CR16:
2444     case EM_MICROBLAZE:
2445     case EM_MICROBLAZE_OLD:     return "Xilinx MicroBlaze";
2446     case EM_ETPU:               return "Freescale Extended Time Processing Unit";
2447     case EM_SLE9X:              return "Infineon Technologies SLE9X core";
2448       /* 180 */
2449     case EM_L1OM:               return "Intel L1OM";
2450     case EM_K1OM:               return "Intel K1OM";
2451     case EM_INTEL182:           return "Intel (reserved)";
2452     case EM_AARCH64:            return "AArch64";
2453     case EM_ARM184:             return "ARM (reserved)";
2454     case EM_AVR32:              return "Atmel Corporation 32-bit microprocessor";
2455     case EM_STM8:               return "STMicroeletronics STM8 8-bit microcontroller";
2456     case EM_TILE64:             return "Tilera TILE64 multicore architecture family";
2457     case EM_TILEPRO:            return "Tilera TILEPro multicore architecture family";
2458       /* 190 */
2459     case EM_CUDA:               return "NVIDIA CUDA architecture";
2460     case EM_TILEGX:             return "Tilera TILE-Gx multicore architecture family";
2461     case EM_CLOUDSHIELD:        return "CloudShield architecture family";
2462     case EM_COREA_1ST:          return "KIPO-KAIST Core-A 1st generation processor family";
2463     case EM_COREA_2ND:          return "KIPO-KAIST Core-A 2nd generation processor family";
2464     case EM_ARC_COMPACT2:       return "ARCv2";
2465     case EM_OPEN8:              return "Open8 8-bit RISC soft processor core";
2466     case EM_RL78:               return "Renesas RL78";
2467     case EM_VIDEOCORE5:         return "Broadcom VideoCore V processor";
2468     case EM_78K0R:              return "Renesas 78K0R";
2469       /* 200 */
2470     case EM_56800EX:            return "Freescale 56800EX Digital Signal Controller (DSC)";
2471     case EM_BA1:                return "Beyond BA1 CPU architecture";
2472     case EM_BA2:                return "Beyond BA2 CPU architecture";
2473     case EM_XCORE:              return "XMOS xCORE processor family";
2474     case EM_MCHP_PIC:           return "Microchip 8-bit PIC(r) family";
2475       /* 210 */
2476     case EM_KM32:               return "KM211 KM32 32-bit processor";
2477     case EM_KMX32:              return "KM211 KMX32 32-bit processor";
2478     case EM_KMX16:              return "KM211 KMX16 16-bit processor";
2479     case EM_KMX8:               return "KM211 KMX8 8-bit processor";
2480     case EM_KVARC:              return "KM211 KVARC processor";
2481     case EM_CDP:                return "Paneve CDP architecture family";
2482     case EM_COGE:               return "Cognitive Smart Memory Processor";
2483     case EM_COOL:               return "Bluechip Systems CoolEngine";
2484     case EM_NORC:               return "Nanoradio Optimized RISC";
2485     case EM_CSR_KALIMBA:        return "CSR Kalimba architecture family";
2486       /* 220 */
2487     case EM_Z80:                return "Zilog Z80";
2488     case EM_VISIUM:             return "CDS VISIUMcore processor";
2489     case EM_FT32:               return "FTDI Chip FT32";
2490     case EM_MOXIE:              return "Moxie";
2491     case EM_AMDGPU:             return "AMD GPU";
2492     case EM_RISCV:              return "RISC-V";
2493     case EM_LANAI:              return "Lanai 32-bit processor";
2494     case EM_BPF:                return "Linux BPF";
2495     case EM_NFP:                return "Netronome Flow Processor";
2496
2497       /* Large numbers...  */
2498     case EM_MT:                 return "Morpho Techologies MT processor";
2499     case EM_ALPHA:              return "Alpha";
2500     case EM_WEBASSEMBLY:        return "Web Assembly";
2501     case EM_DLX:                return "OpenDLX";
2502     case EM_XSTORMY16:          return "Sanyo XStormy16 CPU core";
2503     case EM_IQ2000:             return "Vitesse IQ2000";
2504     case EM_M32C_OLD:
2505     case EM_NIOS32:             return "Altera Nios";
2506     case EM_CYGNUS_MEP:         return "Toshiba MeP Media Engine";
2507     case EM_ADAPTEVA_EPIPHANY:  return "Adapteva EPIPHANY";
2508     case EM_CYGNUS_FRV:         return "Fujitsu FR-V";
2509     case EM_S12Z:               return "Freescale S12Z";
2510     case EM_CSKY:               return "C-SKY";
2511
2512     default:
2513       snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2514       return buff;
2515     }
2516 }
2517
2518 static void
2519 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2520 {
2521   /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2.  Some
2522      other compilers don't a specific architecture type in the e_flags, and
2523      instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2524      architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2525      architectures.
2526
2527      Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2528      but also sets a specific architecture type in the e_flags field.
2529
2530      However, when decoding the flags we don't worry if we see an
2531      unexpected pairing, for example EM_ARC_COMPACT machine type, with
2532      ARCEM architecture type.  */
2533
2534   switch (e_flags & EF_ARC_MACH_MSK)
2535     {
2536       /* We only expect these to occur for EM_ARC_COMPACT2.  */
2537     case EF_ARC_CPU_ARCV2EM:
2538       strcat (buf, ", ARC EM");
2539       break;
2540     case EF_ARC_CPU_ARCV2HS:
2541       strcat (buf, ", ARC HS");
2542       break;
2543
2544       /* We only expect these to occur for EM_ARC_COMPACT.  */
2545     case E_ARC_MACH_ARC600:
2546       strcat (buf, ", ARC600");
2547       break;
2548     case E_ARC_MACH_ARC601:
2549       strcat (buf, ", ARC601");
2550       break;
2551     case E_ARC_MACH_ARC700:
2552       strcat (buf, ", ARC700");
2553       break;
2554
2555       /* The only times we should end up here are (a) A corrupt ELF, (b) A
2556          new ELF with new architecture being read by an old version of
2557          readelf, or (c) An ELF built with non-GNU compiler that does not
2558          set the architecture in the e_flags.  */
2559     default:
2560       if (e_machine == EM_ARC_COMPACT)
2561         strcat (buf, ", Unknown ARCompact");
2562       else
2563         strcat (buf, ", Unknown ARC");
2564       break;
2565     }
2566
2567   switch (e_flags & EF_ARC_OSABI_MSK)
2568     {
2569     case E_ARC_OSABI_ORIG:
2570       strcat (buf, ", (ABI:legacy)");
2571       break;
2572     case E_ARC_OSABI_V2:
2573       strcat (buf, ", (ABI:v2)");
2574       break;
2575       /* Only upstream 3.9+ kernels will support ARCv2 ISA.  */
2576     case E_ARC_OSABI_V3:
2577       strcat (buf, ", v3 no-legacy-syscalls ABI");
2578       break;
2579     case E_ARC_OSABI_V4:
2580       strcat (buf, ", v4 ABI");
2581       break;
2582     default:
2583       strcat (buf, ", unrecognised ARC OSABI flag");
2584       break;
2585     }
2586 }
2587
2588 static void
2589 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2590 {
2591   unsigned eabi;
2592   bfd_boolean unknown = FALSE;
2593
2594   eabi = EF_ARM_EABI_VERSION (e_flags);
2595   e_flags &= ~ EF_ARM_EABIMASK;
2596
2597   /* Handle "generic" ARM flags.  */
2598   if (e_flags & EF_ARM_RELEXEC)
2599     {
2600       strcat (buf, ", relocatable executable");
2601       e_flags &= ~ EF_ARM_RELEXEC;
2602     }
2603
2604   if (e_flags & EF_ARM_PIC)
2605     {
2606       strcat (buf, ", position independent");
2607       e_flags &= ~ EF_ARM_PIC;
2608     }
2609
2610   /* Now handle EABI specific flags.  */
2611   switch (eabi)
2612     {
2613     default:
2614       strcat (buf, ", <unrecognized EABI>");
2615       if (e_flags)
2616         unknown = TRUE;
2617       break;
2618
2619     case EF_ARM_EABI_VER1:
2620       strcat (buf, ", Version1 EABI");
2621       while (e_flags)
2622         {
2623           unsigned flag;
2624
2625           /* Process flags one bit at a time.  */
2626           flag = e_flags & - e_flags;
2627           e_flags &= ~ flag;
2628
2629           switch (flag)
2630             {
2631             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2632               strcat (buf, ", sorted symbol tables");
2633               break;
2634
2635             default:
2636               unknown = TRUE;
2637               break;
2638             }
2639         }
2640       break;
2641
2642     case EF_ARM_EABI_VER2:
2643       strcat (buf, ", Version2 EABI");
2644       while (e_flags)
2645         {
2646           unsigned flag;
2647
2648           /* Process flags one bit at a time.  */
2649           flag = e_flags & - e_flags;
2650           e_flags &= ~ flag;
2651
2652           switch (flag)
2653             {
2654             case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK.  */
2655               strcat (buf, ", sorted symbol tables");
2656               break;
2657
2658             case EF_ARM_DYNSYMSUSESEGIDX:
2659               strcat (buf, ", dynamic symbols use segment index");
2660               break;
2661
2662             case EF_ARM_MAPSYMSFIRST:
2663               strcat (buf, ", mapping symbols precede others");
2664               break;
2665
2666             default:
2667               unknown = TRUE;
2668               break;
2669             }
2670         }
2671       break;
2672
2673     case EF_ARM_EABI_VER3:
2674       strcat (buf, ", Version3 EABI");
2675       break;
2676
2677     case EF_ARM_EABI_VER4:
2678       strcat (buf, ", Version4 EABI");
2679       while (e_flags)
2680         {
2681           unsigned flag;
2682
2683           /* Process flags one bit at a time.  */
2684           flag = e_flags & - e_flags;
2685           e_flags &= ~ flag;
2686
2687           switch (flag)
2688             {
2689             case EF_ARM_BE8:
2690               strcat (buf, ", BE8");
2691               break;
2692
2693             case EF_ARM_LE8:
2694               strcat (buf, ", LE8");
2695               break;
2696
2697             default:
2698               unknown = TRUE;
2699               break;
2700             }
2701         }
2702       break;
2703
2704     case EF_ARM_EABI_VER5:
2705       strcat (buf, ", Version5 EABI");
2706       while (e_flags)
2707         {
2708           unsigned flag;
2709
2710           /* Process flags one bit at a time.  */
2711           flag = e_flags & - e_flags;
2712           e_flags &= ~ flag;
2713
2714           switch (flag)
2715             {
2716             case EF_ARM_BE8:
2717               strcat (buf, ", BE8");
2718               break;
2719
2720             case EF_ARM_LE8:
2721               strcat (buf, ", LE8");
2722               break;
2723
2724             case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT.  */
2725               strcat (buf, ", soft-float ABI");
2726               break;
2727
2728             case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT.  */
2729               strcat (buf, ", hard-float ABI");
2730               break;
2731
2732             default:
2733               unknown = TRUE;
2734               break;
2735             }
2736         }
2737       break;
2738
2739     case EF_ARM_EABI_UNKNOWN:
2740       strcat (buf, ", GNU EABI");
2741       while (e_flags)
2742         {
2743           unsigned flag;
2744
2745           /* Process flags one bit at a time.  */
2746           flag = e_flags & - e_flags;
2747           e_flags &= ~ flag;
2748
2749           switch (flag)
2750             {
2751             case EF_ARM_INTERWORK:
2752               strcat (buf, ", interworking enabled");
2753               break;
2754
2755             case EF_ARM_APCS_26:
2756               strcat (buf, ", uses APCS/26");
2757               break;
2758
2759             case EF_ARM_APCS_FLOAT:
2760               strcat (buf, ", uses APCS/float");
2761               break;
2762
2763             case EF_ARM_PIC:
2764               strcat (buf, ", position independent");
2765               break;
2766
2767             case EF_ARM_ALIGN8:
2768               strcat (buf, ", 8 bit structure alignment");
2769               break;
2770
2771             case EF_ARM_NEW_ABI:
2772               strcat (buf, ", uses new ABI");
2773               break;
2774
2775             case EF_ARM_OLD_ABI:
2776               strcat (buf, ", uses old ABI");
2777               break;
2778
2779             case EF_ARM_SOFT_FLOAT:
2780               strcat (buf, ", software FP");
2781               break;
2782
2783             case EF_ARM_VFP_FLOAT:
2784               strcat (buf, ", VFP");
2785               break;
2786
2787             case EF_ARM_MAVERICK_FLOAT:
2788               strcat (buf, ", Maverick FP");
2789               break;
2790
2791             default:
2792               unknown = TRUE;
2793               break;
2794             }
2795         }
2796     }
2797
2798   if (unknown)
2799     strcat (buf,_(", <unknown>"));
2800 }
2801
2802 static void
2803 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2804 {
2805   --size; /* Leave space for null terminator.  */
2806
2807   switch (e_flags & EF_AVR_MACH)
2808     {
2809     case E_AVR_MACH_AVR1:
2810       strncat (buf, ", avr:1", size);
2811       break;
2812     case E_AVR_MACH_AVR2:
2813       strncat (buf, ", avr:2", size);
2814       break;
2815     case E_AVR_MACH_AVR25:
2816       strncat (buf, ", avr:25", size);
2817       break;
2818     case E_AVR_MACH_AVR3:
2819       strncat (buf, ", avr:3", size);
2820       break;
2821     case E_AVR_MACH_AVR31:
2822       strncat (buf, ", avr:31", size);
2823       break;
2824     case E_AVR_MACH_AVR35:
2825       strncat (buf, ", avr:35", size);
2826       break;
2827     case E_AVR_MACH_AVR4:
2828       strncat (buf, ", avr:4", size);
2829       break;
2830     case E_AVR_MACH_AVR5:
2831       strncat (buf, ", avr:5", size);
2832       break;
2833     case E_AVR_MACH_AVR51:
2834       strncat (buf, ", avr:51", size);
2835       break;
2836     case E_AVR_MACH_AVR6:
2837       strncat (buf, ", avr:6", size);
2838       break;
2839     case E_AVR_MACH_AVRTINY:
2840       strncat (buf, ", avr:100", size);
2841       break;
2842     case E_AVR_MACH_XMEGA1:
2843       strncat (buf, ", avr:101", size);
2844       break;
2845     case E_AVR_MACH_XMEGA2:
2846       strncat (buf, ", avr:102", size);
2847       break;
2848     case E_AVR_MACH_XMEGA3:
2849       strncat (buf, ", avr:103", size);
2850       break;
2851     case E_AVR_MACH_XMEGA4:
2852       strncat (buf, ", avr:104", size);
2853       break;
2854     case E_AVR_MACH_XMEGA5:
2855       strncat (buf, ", avr:105", size);
2856       break;
2857     case E_AVR_MACH_XMEGA6:
2858       strncat (buf, ", avr:106", size);
2859       break;
2860     case E_AVR_MACH_XMEGA7:
2861       strncat (buf, ", avr:107", size);
2862       break;
2863     default:
2864       strncat (buf, ", avr:<unknown>", size);
2865       break;
2866     }
2867
2868   size -= strlen (buf);
2869   if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2870     strncat (buf, ", link-relax", size);
2871 }
2872
2873 static void
2874 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2875 {
2876   unsigned abi;
2877   unsigned arch;
2878   unsigned config;
2879   unsigned version;
2880   bfd_boolean has_fpu = FALSE;
2881   unsigned int r = 0;
2882
2883   static const char *ABI_STRINGS[] =
2884   {
2885     "ABI v0", /* use r5 as return register; only used in N1213HC */
2886     "ABI v1", /* use r0 as return register */
2887     "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2888     "ABI v2fp", /* for FPU */
2889     "AABI",
2890     "ABI2 FP+"
2891   };
2892   static const char *VER_STRINGS[] =
2893   {
2894     "Andes ELF V1.3 or older",
2895     "Andes ELF V1.3.1",
2896     "Andes ELF V1.4"
2897   };
2898   static const char *ARCH_STRINGS[] =
2899   {
2900     "",
2901     "Andes Star v1.0",
2902     "Andes Star v2.0",
2903     "Andes Star v3.0",
2904     "Andes Star v3.0m"
2905   };
2906
2907   abi = EF_NDS_ABI & e_flags;
2908   arch = EF_NDS_ARCH & e_flags;
2909   config = EF_NDS_INST & e_flags;
2910   version = EF_NDS32_ELF_VERSION & e_flags;
2911
2912   memset (buf, 0, size);
2913
2914   switch (abi)
2915     {
2916     case E_NDS_ABI_V0:
2917     case E_NDS_ABI_V1:
2918     case E_NDS_ABI_V2:
2919     case E_NDS_ABI_V2FP:
2920     case E_NDS_ABI_AABI:
2921     case E_NDS_ABI_V2FP_PLUS:
2922       /* In case there are holes in the array.  */
2923       r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2924       break;
2925
2926     default:
2927       r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2928       break;
2929     }
2930
2931   switch (version)
2932     {
2933     case E_NDS32_ELF_VER_1_2:
2934     case E_NDS32_ELF_VER_1_3:
2935     case E_NDS32_ELF_VER_1_4:
2936       r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2937       break;
2938
2939     default:
2940       r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2941       break;
2942     }
2943
2944   if (E_NDS_ABI_V0 == abi)
2945     {
2946       /* OLD ABI; only used in N1213HC, has performance extension 1.  */
2947       r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2948       if (arch == E_NDS_ARCH_STAR_V1_0)
2949         r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2950       return;
2951     }
2952
2953   switch (arch)
2954     {
2955     case E_NDS_ARCH_STAR_V1_0:
2956     case E_NDS_ARCH_STAR_V2_0:
2957     case E_NDS_ARCH_STAR_V3_0:
2958     case E_NDS_ARCH_STAR_V3_M:
2959       r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2960       break;
2961
2962     default:
2963       r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2964       /* ARCH version determines how the e_flags are interpreted.
2965          If it is unknown, we cannot proceed.  */
2966       return;
2967     }
2968
2969   /* Newer ABI; Now handle architecture specific flags.  */
2970   if (arch == E_NDS_ARCH_STAR_V1_0)
2971     {
2972       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2973         r += snprintf (buf + r, size -r, ", MFUSR_PC");
2974
2975       if (!(config & E_NDS32_HAS_NO_MAC_INST))
2976         r += snprintf (buf + r, size -r, ", MAC");
2977
2978       if (config & E_NDS32_HAS_DIV_INST)
2979         r += snprintf (buf + r, size -r, ", DIV");
2980
2981       if (config & E_NDS32_HAS_16BIT_INST)
2982         r += snprintf (buf + r, size -r, ", 16b");
2983     }
2984   else
2985     {
2986       if (config & E_NDS32_HAS_MFUSR_PC_INST)
2987         {
2988           if (version <= E_NDS32_ELF_VER_1_3)
2989             r += snprintf (buf + r, size -r, ", [B8]");
2990           else
2991             r += snprintf (buf + r, size -r, ", EX9");
2992         }
2993
2994       if (config & E_NDS32_HAS_MAC_DX_INST)
2995         r += snprintf (buf + r, size -r, ", MAC_DX");
2996
2997       if (config & E_NDS32_HAS_DIV_DX_INST)
2998         r += snprintf (buf + r, size -r, ", DIV_DX");
2999
3000       if (config & E_NDS32_HAS_16BIT_INST)
3001         {
3002           if (version <= E_NDS32_ELF_VER_1_3)
3003             r += snprintf (buf + r, size -r, ", 16b");
3004           else
3005             r += snprintf (buf + r, size -r, ", IFC");
3006         }
3007     }
3008
3009   if (config & E_NDS32_HAS_EXT_INST)
3010     r += snprintf (buf + r, size -r, ", PERF1");
3011
3012   if (config & E_NDS32_HAS_EXT2_INST)
3013     r += snprintf (buf + r, size -r, ", PERF2");
3014
3015   if (config & E_NDS32_HAS_FPU_INST)
3016     {
3017       has_fpu = TRUE;
3018       r += snprintf (buf + r, size -r, ", FPU_SP");
3019     }
3020
3021   if (config & E_NDS32_HAS_FPU_DP_INST)
3022     {
3023       has_fpu = TRUE;
3024       r += snprintf (buf + r, size -r, ", FPU_DP");
3025     }
3026
3027   if (config & E_NDS32_HAS_FPU_MAC_INST)
3028     {
3029       has_fpu = TRUE;
3030       r += snprintf (buf + r, size -r, ", FPU_MAC");
3031     }
3032
3033   if (has_fpu)
3034     {
3035       switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3036         {
3037         case E_NDS32_FPU_REG_8SP_4DP:
3038           r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3039           break;
3040         case E_NDS32_FPU_REG_16SP_8DP:
3041           r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3042           break;
3043         case E_NDS32_FPU_REG_32SP_16DP:
3044           r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3045           break;
3046         case E_NDS32_FPU_REG_32SP_32DP:
3047           r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3048           break;
3049         }
3050     }
3051
3052   if (config & E_NDS32_HAS_AUDIO_INST)
3053     r += snprintf (buf + r, size -r, ", AUDIO");
3054
3055   if (config & E_NDS32_HAS_STRING_INST)
3056     r += snprintf (buf + r, size -r, ", STR");
3057
3058   if (config & E_NDS32_HAS_REDUCED_REGS)
3059     r += snprintf (buf + r, size -r, ", 16REG");
3060
3061   if (config & E_NDS32_HAS_VIDEO_INST)
3062     {
3063       if (version <= E_NDS32_ELF_VER_1_3)
3064         r += snprintf (buf + r, size -r, ", VIDEO");
3065       else
3066         r += snprintf (buf + r, size -r, ", SATURATION");
3067     }
3068
3069   if (config & E_NDS32_HAS_ENCRIPT_INST)
3070     r += snprintf (buf + r, size -r, ", ENCRP");
3071
3072   if (config & E_NDS32_HAS_L2C_INST)
3073     r += snprintf (buf + r, size -r, ", L2C");
3074 }
3075
3076 static char *
3077 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3078 {
3079   static char buf[1024];
3080
3081   buf[0] = '\0';
3082
3083   if (e_flags)
3084     {
3085       switch (e_machine)
3086         {
3087         default:
3088           break;
3089
3090         case EM_ARC_COMPACT2:
3091         case EM_ARC_COMPACT:
3092           decode_ARC_machine_flags (e_flags, e_machine, buf);
3093           break;
3094
3095         case EM_ARM:
3096           decode_ARM_machine_flags (e_flags, buf);
3097           break;
3098
3099         case EM_AVR:
3100           decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3101           break;
3102
3103         case EM_BLACKFIN:
3104           if (e_flags & EF_BFIN_PIC)
3105             strcat (buf, ", PIC");
3106
3107           if (e_flags & EF_BFIN_FDPIC)
3108             strcat (buf, ", FDPIC");
3109
3110           if (e_flags & EF_BFIN_CODE_IN_L1)
3111             strcat (buf, ", code in L1");
3112
3113           if (e_flags & EF_BFIN_DATA_IN_L1)
3114             strcat (buf, ", data in L1");
3115
3116           break;
3117
3118         case EM_CYGNUS_FRV:
3119           switch (e_flags & EF_FRV_CPU_MASK)
3120             {
3121             case EF_FRV_CPU_GENERIC:
3122               break;
3123
3124             default:
3125               strcat (buf, ", fr???");
3126               break;
3127
3128             case EF_FRV_CPU_FR300:
3129               strcat (buf, ", fr300");
3130               break;
3131
3132             case EF_FRV_CPU_FR400:
3133               strcat (buf, ", fr400");
3134               break;
3135             case EF_FRV_CPU_FR405:
3136               strcat (buf, ", fr405");
3137               break;
3138
3139             case EF_FRV_CPU_FR450:
3140               strcat (buf, ", fr450");
3141               break;
3142
3143             case EF_FRV_CPU_FR500:
3144               strcat (buf, ", fr500");
3145               break;
3146             case EF_FRV_CPU_FR550:
3147               strcat (buf, ", fr550");
3148               break;
3149
3150             case EF_FRV_CPU_SIMPLE:
3151               strcat (buf, ", simple");
3152               break;
3153             case EF_FRV_CPU_TOMCAT:
3154               strcat (buf, ", tomcat");
3155               break;
3156             }
3157           break;
3158
3159         case EM_68K:
3160           if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3161             strcat (buf, ", m68000");
3162           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3163             strcat (buf, ", cpu32");
3164           else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3165             strcat (buf, ", fido_a");
3166           else
3167             {
3168               char const * isa = _("unknown");
3169               char const * mac = _("unknown mac");
3170               char const * additional = NULL;
3171
3172               switch (e_flags & EF_M68K_CF_ISA_MASK)
3173                 {
3174                 case EF_M68K_CF_ISA_A_NODIV:
3175                   isa = "A";
3176                   additional = ", nodiv";
3177                   break;
3178                 case EF_M68K_CF_ISA_A:
3179                   isa = "A";
3180                   break;
3181                 case EF_M68K_CF_ISA_A_PLUS:
3182                   isa = "A+";
3183                   break;
3184                 case EF_M68K_CF_ISA_B_NOUSP:
3185                   isa = "B";
3186                   additional = ", nousp";
3187                   break;
3188                 case EF_M68K_CF_ISA_B:
3189                   isa = "B";
3190                   break;
3191                 case EF_M68K_CF_ISA_C:
3192                   isa = "C";
3193                   break;
3194                 case EF_M68K_CF_ISA_C_NODIV:
3195                   isa = "C";
3196                   additional = ", nodiv";
3197                   break;
3198                 }
3199               strcat (buf, ", cf, isa ");
3200               strcat (buf, isa);
3201               if (additional)
3202                 strcat (buf, additional);
3203               if (e_flags & EF_M68K_CF_FLOAT)
3204                 strcat (buf, ", float");
3205               switch (e_flags & EF_M68K_CF_MAC_MASK)
3206                 {
3207                 case 0:
3208                   mac = NULL;
3209                   break;
3210                 case EF_M68K_CF_MAC:
3211                   mac = "mac";
3212                   break;
3213                 case EF_M68K_CF_EMAC:
3214                   mac = "emac";
3215                   break;
3216                 case EF_M68K_CF_EMAC_B:
3217                   mac = "emac_b";
3218                   break;
3219                 }
3220               if (mac)
3221                 {
3222                   strcat (buf, ", ");
3223                   strcat (buf, mac);
3224                 }
3225             }
3226           break;
3227
3228         case EM_CYGNUS_MEP:
3229           switch (e_flags & EF_MEP_CPU_MASK)
3230             {
3231             case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3232             case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3233             case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3234             case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3235             case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3236             case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3237             default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3238             }
3239
3240           switch (e_flags & EF_MEP_COP_MASK)
3241             {
3242             case EF_MEP_COP_NONE: break;
3243             case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3244             case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3245             case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3246             case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3247             default: strcat (buf, _("<unknown MeP copro type>")); break;
3248             }
3249
3250           if (e_flags & EF_MEP_LIBRARY)
3251             strcat (buf, ", Built for Library");
3252
3253           if (e_flags & EF_MEP_INDEX_MASK)
3254             sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3255                      e_flags & EF_MEP_INDEX_MASK);
3256
3257           if (e_flags & ~ EF_MEP_ALL_FLAGS)
3258             sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3259                      e_flags & ~ EF_MEP_ALL_FLAGS);
3260           break;
3261
3262         case EM_PPC:
3263           if (e_flags & EF_PPC_EMB)
3264             strcat (buf, ", emb");
3265
3266           if (e_flags & EF_PPC_RELOCATABLE)
3267             strcat (buf, _(", relocatable"));
3268
3269           if (e_flags & EF_PPC_RELOCATABLE_LIB)
3270             strcat (buf, _(", relocatable-lib"));
3271           break;
3272
3273         case EM_PPC64:
3274           if (e_flags & EF_PPC64_ABI)
3275             {
3276               char abi[] = ", abiv0";
3277
3278               abi[6] += e_flags & EF_PPC64_ABI;
3279               strcat (buf, abi);
3280             }
3281           break;
3282
3283         case EM_V800:
3284           if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3285             strcat (buf, ", RH850 ABI");
3286
3287           if (e_flags & EF_V800_850E3)
3288             strcat (buf, ", V3 architecture");
3289
3290           if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3291             strcat (buf, ", FPU not used");
3292
3293           if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3294             strcat (buf, ", regmode: COMMON");
3295
3296           if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3297             strcat (buf, ", r4 not used");
3298
3299           if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3300             strcat (buf, ", r30 not used");
3301
3302           if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3303             strcat (buf, ", r5 not used");
3304
3305           if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3306             strcat (buf, ", r2 not used");
3307
3308           for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3309             {
3310               switch (e_flags & - e_flags)
3311                 {
3312                 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3313                 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3314                 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3315                 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3316                 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3317                 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3318                 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3319                 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3320                 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3321                 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3322                 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3323                 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3324                 default: break;
3325                 }
3326             }
3327           break;
3328
3329         case EM_V850:
3330         case EM_CYGNUS_V850:
3331           switch (e_flags & EF_V850_ARCH)
3332             {
3333             case E_V850E3V5_ARCH:
3334               strcat (buf, ", v850e3v5");
3335               break;
3336             case E_V850E2V3_ARCH:
3337               strcat (buf, ", v850e2v3");
3338               break;
3339             case E_V850E2_ARCH:
3340               strcat (buf, ", v850e2");
3341               break;
3342             case E_V850E1_ARCH:
3343               strcat (buf, ", v850e1");
3344               break;
3345             case E_V850E_ARCH:
3346               strcat (buf, ", v850e");
3347               break;
3348             case E_V850_ARCH:
3349               strcat (buf, ", v850");
3350               break;
3351             default:
3352               strcat (buf, _(", unknown v850 architecture variant"));
3353               break;
3354             }
3355           break;
3356
3357         case EM_M32R:
3358         case EM_CYGNUS_M32R:
3359           if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3360             strcat (buf, ", m32r");
3361           break;
3362
3363         case EM_MIPS:
3364         case EM_MIPS_RS3_LE:
3365           if (e_flags & EF_MIPS_NOREORDER)
3366             strcat (buf, ", noreorder");
3367
3368           if (e_flags & EF_MIPS_PIC)
3369             strcat (buf, ", pic");
3370
3371           if (e_flags & EF_MIPS_CPIC)
3372             strcat (buf, ", cpic");
3373
3374           if (e_flags & EF_MIPS_UCODE)
3375             strcat (buf, ", ugen_reserved");
3376
3377           if (e_flags & EF_MIPS_ABI2)
3378             strcat (buf, ", abi2");
3379
3380           if (e_flags & EF_MIPS_OPTIONS_FIRST)
3381             strcat (buf, ", odk first");
3382
3383           if (e_flags & EF_MIPS_32BITMODE)
3384             strcat (buf, ", 32bitmode");
3385
3386           if (e_flags & EF_MIPS_NAN2008)
3387             strcat (buf, ", nan2008");
3388
3389           if (e_flags & EF_MIPS_FP64)
3390             strcat (buf, ", fp64");
3391
3392           switch ((e_flags & EF_MIPS_MACH))
3393             {
3394             case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3395             case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3396             case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3397             case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3398             case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3399             case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3400             case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3401             case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3402             case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3403             case E_MIPS_MACH_SB1:  strcat (buf, ", sb1");  break;
3404             case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3405             case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3406             case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3407             case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3408             case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3409             case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3410             case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3411             case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3412             case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3413             case E_MIPS_MACH_XLR:  strcat (buf, ", xlr"); break;
3414             case E_MIPS_MACH_IAMR2:  strcat (buf, ", interaptiv-mr2"); break;
3415             case 0:
3416             /* We simply ignore the field in this case to avoid confusion:
3417                MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3418                extension.  */
3419               break;
3420             default: strcat (buf, _(", unknown CPU")); break;
3421             }
3422
3423           switch ((e_flags & EF_MIPS_ABI))
3424             {
3425             case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3426             case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3427             case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3428             case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3429             case 0:
3430             /* We simply ignore the field in this case to avoid confusion:
3431                MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3432                This means it is likely to be an o32 file, but not for
3433                sure.  */
3434               break;
3435             default: strcat (buf, _(", unknown ABI")); break;
3436             }
3437
3438           if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3439             strcat (buf, ", mdmx");
3440
3441           if (e_flags & EF_MIPS_ARCH_ASE_M16)
3442             strcat (buf, ", mips16");
3443
3444           if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3445             strcat (buf, ", micromips");
3446
3447           switch ((e_flags & EF_MIPS_ARCH))
3448             {
3449             case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3450             case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3451             case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3452             case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3453             case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3454             case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3455             case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3456             case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3457             case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3458             case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3459             case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3460             default: strcat (buf, _(", unknown ISA")); break;
3461             }
3462           break;
3463
3464         case EM_NDS32:
3465           decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3466           break;
3467
3468         case EM_NFP:
3469           switch (EF_NFP_MACH (e_flags))
3470             {
3471             case E_NFP_MACH_3200:
3472               strcat (buf, ", NFP-32xx");
3473               break;
3474             case E_NFP_MACH_6000:
3475               strcat (buf, ", NFP-6xxx");
3476               break;
3477             }
3478           break;
3479
3480         case EM_RISCV:
3481           if (e_flags & EF_RISCV_RVC)
3482             strcat (buf, ", RVC");
3483
3484           if (e_flags & EF_RISCV_RVE)
3485             strcat (buf, ", RVE");
3486
3487           switch (e_flags & EF_RISCV_FLOAT_ABI)
3488             {
3489             case EF_RISCV_FLOAT_ABI_SOFT:
3490               strcat (buf, ", soft-float ABI");
3491               break;
3492
3493             case EF_RISCV_FLOAT_ABI_SINGLE:
3494               strcat (buf, ", single-float ABI");
3495               break;
3496
3497             case EF_RISCV_FLOAT_ABI_DOUBLE:
3498               strcat (buf, ", double-float ABI");
3499               break;
3500
3501             case EF_RISCV_FLOAT_ABI_QUAD:
3502               strcat (buf, ", quad-float ABI");
3503               break;
3504             }
3505           break;
3506
3507         case EM_SH:
3508           switch ((e_flags & EF_SH_MACH_MASK))
3509             {
3510             case EF_SH1: strcat (buf, ", sh1"); break;
3511             case EF_SH2: strcat (buf, ", sh2"); break;
3512             case EF_SH3: strcat (buf, ", sh3"); break;
3513             case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3514             case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3515             case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3516             case EF_SH3E: strcat (buf, ", sh3e"); break;
3517             case EF_SH4: strcat (buf, ", sh4"); break;
3518             case EF_SH5: strcat (buf, ", sh5"); break;
3519             case EF_SH2E: strcat (buf, ", sh2e"); break;
3520             case EF_SH4A: strcat (buf, ", sh4a"); break;
3521             case EF_SH2A: strcat (buf, ", sh2a"); break;
3522             case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3523             case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3524             case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3525             case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3526             case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3527             case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3528             case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3529             case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3530             case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3531             default: strcat (buf, _(", unknown ISA")); break;
3532             }
3533
3534           if (e_flags & EF_SH_PIC)
3535             strcat (buf, ", pic");
3536
3537           if (e_flags & EF_SH_FDPIC)
3538             strcat (buf, ", fdpic");
3539           break;
3540
3541         case EM_OR1K:
3542           if (e_flags & EF_OR1K_NODELAY)
3543             strcat (buf, ", no delay");
3544           break;
3545
3546         case EM_SPARCV9:
3547           if (e_flags & EF_SPARC_32PLUS)
3548             strcat (buf, ", v8+");
3549
3550           if (e_flags & EF_SPARC_SUN_US1)
3551             strcat (buf, ", ultrasparcI");
3552
3553           if (e_flags & EF_SPARC_SUN_US3)
3554             strcat (buf, ", ultrasparcIII");
3555
3556           if (e_flags & EF_SPARC_HAL_R1)
3557             strcat (buf, ", halr1");
3558
3559           if (e_flags & EF_SPARC_LEDATA)
3560             strcat (buf, ", ledata");
3561
3562           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3563             strcat (buf, ", tso");
3564
3565           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3566             strcat (buf, ", pso");
3567
3568           if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3569             strcat (buf, ", rmo");
3570           break;
3571
3572         case EM_PARISC:
3573           switch (e_flags & EF_PARISC_ARCH)
3574             {
3575             case EFA_PARISC_1_0:
3576               strcpy (buf, ", PA-RISC 1.0");
3577               break;
3578             case EFA_PARISC_1_1:
3579               strcpy (buf, ", PA-RISC 1.1");
3580               break;
3581             case EFA_PARISC_2_0:
3582               strcpy (buf, ", PA-RISC 2.0");
3583               break;
3584             default:
3585               break;
3586             }
3587           if (e_flags & EF_PARISC_TRAPNIL)
3588             strcat (buf, ", trapnil");
3589           if (e_flags & EF_PARISC_EXT)
3590             strcat (buf, ", ext");
3591           if (e_flags & EF_PARISC_LSB)
3592             strcat (buf, ", lsb");
3593           if (e_flags & EF_PARISC_WIDE)
3594             strcat (buf, ", wide");
3595           if (e_flags & EF_PARISC_NO_KABP)
3596             strcat (buf, ", no kabp");
3597           if (e_flags & EF_PARISC_LAZYSWAP)
3598             strcat (buf, ", lazyswap");
3599           break;
3600
3601         case EM_PJ:
3602         case EM_PJ_OLD:
3603           if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3604             strcat (buf, ", new calling convention");
3605
3606           if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3607             strcat (buf, ", gnu calling convention");
3608           break;
3609
3610         case EM_IA_64:
3611           if ((e_flags & EF_IA_64_ABI64))
3612             strcat (buf, ", 64-bit");
3613           else
3614             strcat (buf, ", 32-bit");
3615           if ((e_flags & EF_IA_64_REDUCEDFP))
3616             strcat (buf, ", reduced fp model");
3617           if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3618             strcat (buf, ", no function descriptors, constant gp");
3619           else if ((e_flags & EF_IA_64_CONS_GP))
3620             strcat (buf, ", constant gp");
3621           if ((e_flags & EF_IA_64_ABSOLUTE))
3622             strcat (buf, ", absolute");
3623           if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3624             {
3625               if ((e_flags & EF_IA_64_VMS_LINKAGES))
3626                 strcat (buf, ", vms_linkages");
3627               switch ((e_flags & EF_IA_64_VMS_COMCOD))
3628                 {
3629                 case EF_IA_64_VMS_COMCOD_SUCCESS:
3630                   break;
3631                 case EF_IA_64_VMS_COMCOD_WARNING:
3632                   strcat (buf, ", warning");
3633                   break;
3634                 case EF_IA_64_VMS_COMCOD_ERROR:
3635                   strcat (buf, ", error");
3636                   break;
3637                 case EF_IA_64_VMS_COMCOD_ABORT:
3638                   strcat (buf, ", abort");
3639                   break;
3640                 default:
3641                   warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3642                         e_flags & EF_IA_64_VMS_COMCOD);
3643                   strcat (buf, ", <unknown>");
3644                 }
3645             }
3646           break;
3647
3648         case EM_VAX:
3649           if ((e_flags & EF_VAX_NONPIC))
3650             strcat (buf, ", non-PIC");
3651           if ((e_flags & EF_VAX_DFLOAT))
3652             strcat (buf, ", D-Float");
3653           if ((e_flags & EF_VAX_GFLOAT))
3654             strcat (buf, ", G-Float");
3655           break;
3656
3657         case EM_VISIUM:
3658           if (e_flags & EF_VISIUM_ARCH_MCM)
3659             strcat (buf, ", mcm");
3660           else if (e_flags & EF_VISIUM_ARCH_MCM24)
3661             strcat (buf, ", mcm24");
3662           if (e_flags & EF_VISIUM_ARCH_GR6)
3663             strcat (buf, ", gr6");
3664           break;
3665
3666         case EM_RL78:
3667           switch (e_flags & E_FLAG_RL78_CPU_MASK)
3668             {
3669             case E_FLAG_RL78_ANY_CPU: break;
3670             case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3671             case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3672             case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3673             }
3674           if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3675             strcat (buf, ", 64-bit doubles");
3676           break;
3677
3678         case EM_RX:
3679           if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3680             strcat (buf, ", 64-bit doubles");
3681           if (e_flags & E_FLAG_RX_DSP)
3682             strcat (buf, ", dsp");
3683           if (e_flags & E_FLAG_RX_PID)
3684             strcat (buf, ", pid");
3685           if (e_flags & E_FLAG_RX_ABI)
3686             strcat (buf, ", RX ABI");
3687           if (e_flags & E_FLAG_RX_SINSNS_SET)
3688             strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3689                     ? ", uses String instructions" : ", bans String instructions");
3690           if (e_flags & E_FLAG_RX_V2)
3691             strcat (buf, ", V2");
3692           break;
3693
3694         case EM_S390:
3695           if (e_flags & EF_S390_HIGH_GPRS)
3696             strcat (buf, ", highgprs");
3697           break;
3698
3699         case EM_TI_C6000:
3700           if ((e_flags & EF_C6000_REL))
3701             strcat (buf, ", relocatable module");
3702           break;
3703
3704         case EM_MSP430:
3705           strcat (buf, _(": architecture variant: "));
3706           switch (e_flags & EF_MSP430_MACH)
3707             {
3708             case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3709             case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3710             case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3711             case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3712             case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3713             case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3714             case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3715             case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3716             case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3717             case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3718             case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3719             case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3720             case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3721             case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3722             case E_MSP430_MACH_MSP430X  : strcat (buf, "MSP430X"); break;
3723             default:
3724               strcat (buf, _(": unknown")); break;
3725             }
3726
3727           if (e_flags & ~ EF_MSP430_MACH)
3728             strcat (buf, _(": unknown extra flag bits also present"));
3729         }
3730     }
3731
3732   return buf;
3733 }
3734
3735 static const char *
3736 get_osabi_name (Filedata * filedata, unsigned int osabi)
3737 {
3738   static char buff[32];
3739
3740   switch (osabi)
3741     {
3742     case ELFOSABI_NONE:         return "UNIX - System V";
3743     case ELFOSABI_HPUX:         return "UNIX - HP-UX";
3744     case ELFOSABI_NETBSD:       return "UNIX - NetBSD";
3745     case ELFOSABI_GNU:          return "UNIX - GNU";
3746     case ELFOSABI_SOLARIS:      return "UNIX - Solaris";
3747     case ELFOSABI_AIX:          return "UNIX - AIX";
3748     case ELFOSABI_IRIX:         return "UNIX - IRIX";
3749     case ELFOSABI_FREEBSD:      return "UNIX - FreeBSD";
3750     case ELFOSABI_TRU64:        return "UNIX - TRU64";
3751     case ELFOSABI_MODESTO:      return "Novell - Modesto";
3752     case ELFOSABI_OPENBSD:      return "UNIX - OpenBSD";
3753     case ELFOSABI_OPENVMS:      return "VMS - OpenVMS";
3754     case ELFOSABI_NSK:          return "HP - Non-Stop Kernel";
3755     case ELFOSABI_AROS:         return "AROS";
3756     case ELFOSABI_FENIXOS:      return "FenixOS";
3757     case ELFOSABI_CLOUDABI:     return "Nuxi CloudABI";
3758     case ELFOSABI_OPENVOS:      return "Stratus Technologies OpenVOS";
3759     default:
3760       if (osabi >= 64)
3761         switch (filedata->file_header.e_machine)
3762           {
3763           case EM_ARM:
3764             switch (osabi)
3765               {
3766               case ELFOSABI_ARM:        return "ARM";
3767               case ELFOSABI_ARM_FDPIC:  return "ARM FDPIC";
3768               default:
3769                 break;
3770               }
3771             break;
3772
3773           case EM_MSP430:
3774           case EM_MSP430_OLD:
3775           case EM_VISIUM:
3776             switch (osabi)
3777               {
3778               case ELFOSABI_STANDALONE: return _("Standalone App");
3779               default:
3780                 break;
3781               }
3782             break;
3783
3784           case EM_TI_C6000:
3785             switch (osabi)
3786               {
3787               case ELFOSABI_C6000_ELFABI:       return _("Bare-metal C6000");
3788               case ELFOSABI_C6000_LINUX:        return "Linux C6000";
3789               default:
3790                 break;
3791               }
3792             break;
3793
3794           default:
3795             break;
3796           }
3797       snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3798       return buff;
3799     }
3800 }
3801
3802 static const char *
3803 get_aarch64_segment_type (unsigned long type)
3804 {
3805   switch (type)
3806     {
3807     case PT_AARCH64_ARCHEXT:  return "AARCH64_ARCHEXT";
3808     default:                  return NULL;
3809     }
3810 }
3811
3812 static const char *
3813 get_arm_segment_type (unsigned long type)
3814 {
3815   switch (type)
3816     {
3817     case PT_ARM_EXIDX: return "EXIDX";
3818     default:           return NULL;
3819     }
3820 }
3821
3822 static const char *
3823 get_s390_segment_type (unsigned long type)
3824 {
3825   switch (type)
3826     {
3827     case PT_S390_PGSTE: return "S390_PGSTE";
3828     default:            return NULL;
3829     }
3830 }
3831
3832 static const char *
3833 get_mips_segment_type (unsigned long type)
3834 {
3835   switch (type)
3836     {
3837     case PT_MIPS_REGINFO:   return "REGINFO";
3838     case PT_MIPS_RTPROC:    return "RTPROC";
3839     case PT_MIPS_OPTIONS:   return "OPTIONS";
3840     case PT_MIPS_ABIFLAGS:  return "ABIFLAGS";
3841     default:                return NULL;
3842     }
3843 }
3844
3845 static const char *
3846 get_parisc_segment_type (unsigned long type)
3847 {
3848   switch (type)
3849     {
3850     case PT_HP_TLS:             return "HP_TLS";
3851     case PT_HP_CORE_NONE:       return "HP_CORE_NONE";
3852     case PT_HP_CORE_VERSION:    return "HP_CORE_VERSION";
3853     case PT_HP_CORE_KERNEL:     return "HP_CORE_KERNEL";
3854     case PT_HP_CORE_COMM:       return "HP_CORE_COMM";
3855     case PT_HP_CORE_PROC:       return "HP_CORE_PROC";
3856     case PT_HP_CORE_LOADABLE:   return "HP_CORE_LOADABLE";
3857     case PT_HP_CORE_STACK:      return "HP_CORE_STACK";
3858     case PT_HP_CORE_SHM:        return "HP_CORE_SHM";
3859     case PT_HP_CORE_MMF:        return "HP_CORE_MMF";
3860     case PT_HP_PARALLEL:        return "HP_PARALLEL";
3861     case PT_HP_FASTBIND:        return "HP_FASTBIND";
3862     case PT_HP_OPT_ANNOT:       return "HP_OPT_ANNOT";
3863     case PT_HP_HSL_ANNOT:       return "HP_HSL_ANNOT";
3864     case PT_HP_STACK:           return "HP_STACK";
3865     case PT_HP_CORE_UTSNAME:    return "HP_CORE_UTSNAME";
3866     case PT_PARISC_ARCHEXT:     return "PARISC_ARCHEXT";
3867     case PT_PARISC_UNWIND:      return "PARISC_UNWIND";
3868     case PT_PARISC_WEAKORDER:   return "PARISC_WEAKORDER";
3869     default:                    return NULL;
3870     }
3871 }
3872
3873 static const char *
3874 get_ia64_segment_type (unsigned long type)
3875 {
3876   switch (type)
3877     {
3878     case PT_IA_64_ARCHEXT:      return "IA_64_ARCHEXT";
3879     case PT_IA_64_UNWIND:       return "IA_64_UNWIND";
3880     case PT_HP_TLS:             return "HP_TLS";
3881     case PT_IA_64_HP_OPT_ANOT:  return "HP_OPT_ANNOT";
3882     case PT_IA_64_HP_HSL_ANOT:  return "HP_HSL_ANNOT";
3883     case PT_IA_64_HP_STACK:     return "HP_STACK";
3884     default:                    return NULL;
3885     }
3886 }
3887
3888 static const char *
3889 get_tic6x_segment_type (unsigned long type)
3890 {
3891   switch (type)
3892     {
3893     case PT_C6000_PHATTR:  return "C6000_PHATTR";
3894     default:               return NULL;
3895     }
3896 }
3897
3898 static const char *
3899 get_solaris_segment_type (unsigned long type)
3900 {
3901   switch (type)
3902     {
3903     case 0x6464e550: return "PT_SUNW_UNWIND";
3904     case 0x6474e550: return "PT_SUNW_EH_FRAME";
3905     case 0x6ffffff7: return "PT_LOSUNW";
3906     case 0x6ffffffa: return "PT_SUNWBSS";
3907     case 0x6ffffffb: return "PT_SUNWSTACK";
3908     case 0x6ffffffc: return "PT_SUNWDTRACE";
3909     case 0x6ffffffd: return "PT_SUNWCAP";
3910     case 0x6fffffff: return "PT_HISUNW";
3911     default:         return NULL;
3912     }
3913 }
3914
3915 static const char *
3916 get_segment_type (Filedata * filedata, unsigned long p_type)
3917 {
3918   static char buff[32];
3919
3920   switch (p_type)
3921     {
3922     case PT_NULL:       return "NULL";
3923     case PT_LOAD:       return "LOAD";
3924     case PT_DYNAMIC:    return "DYNAMIC";
3925     case PT_INTERP:     return "INTERP";
3926     case PT_NOTE:       return "NOTE";
3927     case PT_SHLIB:      return "SHLIB";
3928     case PT_PHDR:       return "PHDR";
3929     case PT_TLS:        return "TLS";
3930     case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3931     case PT_GNU_STACK:  return "GNU_STACK";
3932     case PT_GNU_RELRO:  return "GNU_RELRO";
3933
3934     default:
3935       if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3936         {
3937           sprintf (buff, "GNU_MBIND+%#lx",
3938                    p_type - PT_GNU_MBIND_LO);
3939         }
3940       else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3941         {
3942           const char * result;
3943
3944           switch (filedata->file_header.e_machine)
3945             {
3946             case EM_AARCH64:
3947               result = get_aarch64_segment_type (p_type);
3948               break;
3949             case EM_ARM:
3950               result = get_arm_segment_type (p_type);
3951               break;
3952             case EM_MIPS:
3953             case EM_MIPS_RS3_LE:
3954               result = get_mips_segment_type (p_type);
3955               break;
3956             case EM_PARISC:
3957               result = get_parisc_segment_type (p_type);
3958               break;
3959             case EM_IA_64:
3960               result = get_ia64_segment_type (p_type);
3961               break;
3962             case EM_TI_C6000:
3963               result = get_tic6x_segment_type (p_type);
3964               break;
3965             case EM_S390:
3966             case EM_S390_OLD:
3967               result = get_s390_segment_type (p_type);
3968               break;
3969             default:
3970               result = NULL;
3971               break;
3972             }
3973
3974           if (result != NULL)
3975             return result;
3976
3977           sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3978         }
3979       else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3980         {
3981           const char * result;
3982
3983           switch (filedata->file_header.e_machine)
3984             {
3985             case EM_PARISC:
3986               result = get_parisc_segment_type (p_type);
3987               break;
3988             case EM_IA_64:
3989               result = get_ia64_segment_type (p_type);
3990               break;
3991             default:
3992               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3993                 result = get_solaris_segment_type (p_type);
3994               else
3995                 result = NULL;
3996               break;
3997             }
3998
3999           if (result != NULL)
4000             return result;
4001
4002           sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4003         }
4004       else
4005         snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4006
4007       return buff;
4008     }
4009 }
4010
4011 static const char *
4012 get_arc_section_type_name (unsigned int sh_type)
4013 {
4014   switch (sh_type)
4015     {
4016     case SHT_ARC_ATTRIBUTES:      return "ARC_ATTRIBUTES";
4017     default:
4018       break;
4019     }
4020   return NULL;
4021 }
4022
4023 static const char *
4024 get_mips_section_type_name (unsigned int sh_type)
4025 {
4026   switch (sh_type)
4027     {
4028     case SHT_MIPS_LIBLIST:       return "MIPS_LIBLIST";
4029     case SHT_MIPS_MSYM:          return "MIPS_MSYM";
4030     case SHT_MIPS_CONFLICT:      return "MIPS_CONFLICT";
4031     case SHT_MIPS_GPTAB:         return "MIPS_GPTAB";
4032     case SHT_MIPS_UCODE:         return "MIPS_UCODE";
4033     case SHT_MIPS_DEBUG:         return "MIPS_DEBUG";
4034     case SHT_MIPS_REGINFO:       return "MIPS_REGINFO";
4035     case SHT_MIPS_PACKAGE:       return "MIPS_PACKAGE";
4036     case SHT_MIPS_PACKSYM:       return "MIPS_PACKSYM";
4037     case SHT_MIPS_RELD:          return "MIPS_RELD";
4038     case SHT_MIPS_IFACE:         return "MIPS_IFACE";
4039     case SHT_MIPS_CONTENT:       return "MIPS_CONTENT";
4040     case SHT_MIPS_OPTIONS:       return "MIPS_OPTIONS";
4041     case SHT_MIPS_SHDR:          return "MIPS_SHDR";
4042     case SHT_MIPS_FDESC:         return "MIPS_FDESC";
4043     case SHT_MIPS_EXTSYM:        return "MIPS_EXTSYM";
4044     case SHT_MIPS_DENSE:         return "MIPS_DENSE";
4045     case SHT_MIPS_PDESC:         return "MIPS_PDESC";
4046     case SHT_MIPS_LOCSYM:        return "MIPS_LOCSYM";
4047     case SHT_MIPS_AUXSYM:        return "MIPS_AUXSYM";
4048     case SHT_MIPS_OPTSYM:        return "MIPS_OPTSYM";
4049     case SHT_MIPS_LOCSTR:        return "MIPS_LOCSTR";
4050     case SHT_MIPS_LINE:          return "MIPS_LINE";
4051     case SHT_MIPS_RFDESC:        return "MIPS_RFDESC";
4052     case SHT_MIPS_DELTASYM:      return "MIPS_DELTASYM";
4053     case SHT_MIPS_DELTAINST:     return "MIPS_DELTAINST";
4054     case SHT_MIPS_DELTACLASS:    return "MIPS_DELTACLASS";
4055     case SHT_MIPS_DWARF:         return "MIPS_DWARF";
4056     case SHT_MIPS_DELTADECL:     return "MIPS_DELTADECL";
4057     case SHT_MIPS_SYMBOL_LIB:    return "MIPS_SYMBOL_LIB";
4058     case SHT_MIPS_EVENTS:        return "MIPS_EVENTS";
4059     case SHT_MIPS_TRANSLATE:     return "MIPS_TRANSLATE";
4060     case SHT_MIPS_PIXIE:         return "MIPS_PIXIE";
4061     case SHT_MIPS_XLATE:         return "MIPS_XLATE";
4062     case SHT_MIPS_XLATE_DEBUG:   return "MIPS_XLATE_DEBUG";
4063     case SHT_MIPS_WHIRL:         return "MIPS_WHIRL";
4064     case SHT_MIPS_EH_REGION:     return "MIPS_EH_REGION";
4065     case SHT_MIPS_XLATE_OLD:     return "MIPS_XLATE_OLD";
4066     case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4067     case SHT_MIPS_ABIFLAGS:      return "MIPS_ABIFLAGS";
4068     default:
4069       break;
4070     }
4071   return NULL;
4072 }
4073
4074 static const char *
4075 get_parisc_section_type_name (unsigned int sh_type)
4076 {
4077   switch (sh_type)
4078     {
4079     case SHT_PARISC_EXT:        return "PARISC_EXT";
4080     case SHT_PARISC_UNWIND:     return "PARISC_UNWIND";
4081     case SHT_PARISC_DOC:        return "PARISC_DOC";
4082     case SHT_PARISC_ANNOT:      return "PARISC_ANNOT";
4083     case SHT_PARISC_SYMEXTN:    return "PARISC_SYMEXTN";
4084     case SHT_PARISC_STUBS:      return "PARISC_STUBS";
4085     case SHT_PARISC_DLKM:       return "PARISC_DLKM";
4086     default:                    return NULL;
4087     }
4088 }
4089
4090 static const char *
4091 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4092 {
4093   /* If the top 8 bits are 0x78 the next 8 are the os/abi ID.  */
4094   if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4095     return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4096
4097   switch (sh_type)
4098     {
4099     case SHT_IA_64_EXT:                return "IA_64_EXT";
4100     case SHT_IA_64_UNWIND:             return "IA_64_UNWIND";
4101     case SHT_IA_64_PRIORITY_INIT:      return "IA_64_PRIORITY_INIT";
4102     case SHT_IA_64_VMS_TRACE:          return "VMS_TRACE";
4103     case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4104     case SHT_IA_64_VMS_DEBUG:          return "VMS_DEBUG";
4105     case SHT_IA_64_VMS_DEBUG_STR:      return "VMS_DEBUG_STR";
4106     case SHT_IA_64_VMS_LINKAGES:       return "VMS_LINKAGES";
4107     case SHT_IA_64_VMS_SYMBOL_VECTOR:  return "VMS_SYMBOL_VECTOR";
4108     case SHT_IA_64_VMS_FIXUP:          return "VMS_FIXUP";
4109     default:
4110       break;
4111     }
4112   return NULL;
4113 }
4114
4115 static const char *
4116 get_x86_64_section_type_name (unsigned int sh_type)
4117 {
4118   switch (sh_type)
4119     {
4120     case SHT_X86_64_UNWIND:     return "X86_64_UNWIND";
4121     default:                    return NULL;
4122     }
4123 }
4124
4125 static const char *
4126 get_aarch64_section_type_name (unsigned int sh_type)
4127 {
4128   switch (sh_type)
4129     {
4130     case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4131     default:                     return NULL;
4132     }
4133 }
4134
4135 static const char *
4136 get_arm_section_type_name (unsigned int sh_type)
4137 {
4138   switch (sh_type)
4139     {
4140     case SHT_ARM_EXIDX:           return "ARM_EXIDX";
4141     case SHT_ARM_PREEMPTMAP:      return "ARM_PREEMPTMAP";
4142     case SHT_ARM_ATTRIBUTES:      return "ARM_ATTRIBUTES";
4143     case SHT_ARM_DEBUGOVERLAY:    return "ARM_DEBUGOVERLAY";
4144     case SHT_ARM_OVERLAYSECTION:  return "ARM_OVERLAYSECTION";
4145     default:                      return NULL;
4146     }
4147 }
4148
4149 static const char *
4150 get_tic6x_section_type_name (unsigned int sh_type)
4151 {
4152   switch (sh_type)
4153     {
4154     case SHT_C6000_UNWIND:      return "C6000_UNWIND";
4155     case SHT_C6000_PREEMPTMAP:  return "C6000_PREEMPTMAP";
4156     case SHT_C6000_ATTRIBUTES:  return "C6000_ATTRIBUTES";
4157     case SHT_TI_ICODE:          return "TI_ICODE";
4158     case SHT_TI_XREF:           return "TI_XREF";
4159     case SHT_TI_HANDLER:        return "TI_HANDLER";
4160     case SHT_TI_INITINFO:       return "TI_INITINFO";
4161     case SHT_TI_PHATTRS:        return "TI_PHATTRS";
4162     default:                    return NULL;
4163     }
4164 }
4165
4166 static const char *
4167 get_msp430x_section_type_name (unsigned int sh_type)
4168 {
4169   switch (sh_type)
4170     {
4171     case SHT_MSP430_SEC_FLAGS:    return "MSP430_SEC_FLAGS";
4172     case SHT_MSP430_SYM_ALIASES:  return "MSP430_SYM_ALIASES";
4173     case SHT_MSP430_ATTRIBUTES:   return "MSP430_ATTRIBUTES";
4174     default:                      return NULL;
4175     }
4176 }
4177
4178 static const char *
4179 get_nfp_section_type_name (unsigned int sh_type)
4180 {
4181   switch (sh_type)
4182     {
4183     case SHT_NFP_MECONFIG:      return "NFP_MECONFIG";
4184     case SHT_NFP_INITREG:       return "NFP_INITREG";
4185     case SHT_NFP_UDEBUG:        return "NFP_UDEBUG";
4186     default:                    return NULL;
4187     }
4188 }
4189
4190 static const char *
4191 get_v850_section_type_name (unsigned int sh_type)
4192 {
4193   switch (sh_type)
4194     {
4195     case SHT_V850_SCOMMON:  return "V850 Small Common";
4196     case SHT_V850_TCOMMON:  return "V850 Tiny Common";
4197     case SHT_V850_ZCOMMON:  return "V850 Zero Common";
4198     case SHT_RENESAS_IOP:   return "RENESAS IOP";
4199     case SHT_RENESAS_INFO:  return "RENESAS INFO";
4200     default:                return NULL;
4201     }
4202 }
4203
4204 static const char *
4205 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4206 {
4207   static char buff[32];
4208   const char * result;
4209
4210   switch (sh_type)
4211     {
4212     case SHT_NULL:              return "NULL";
4213     case SHT_PROGBITS:          return "PROGBITS";
4214     case SHT_SYMTAB:            return "SYMTAB";
4215     case SHT_STRTAB:            return "STRTAB";
4216     case SHT_RELA:              return "RELA";
4217     case SHT_HASH:              return "HASH";
4218     case SHT_DYNAMIC:           return "DYNAMIC";
4219     case SHT_NOTE:              return "NOTE";
4220     case SHT_NOBITS:            return "NOBITS";
4221     case SHT_REL:               return "REL";
4222     case SHT_SHLIB:             return "SHLIB";
4223     case SHT_DYNSYM:            return "DYNSYM";
4224     case SHT_INIT_ARRAY:        return "INIT_ARRAY";
4225     case SHT_FINI_ARRAY:        return "FINI_ARRAY";
4226     case SHT_PREINIT_ARRAY:     return "PREINIT_ARRAY";
4227     case SHT_GNU_HASH:          return "GNU_HASH";
4228     case SHT_GROUP:             return "GROUP";
4229     case SHT_SYMTAB_SHNDX:      return "SYMTAB SECTION INDICES";
4230     case SHT_GNU_verdef:        return "VERDEF";
4231     case SHT_GNU_verneed:       return "VERNEED";
4232     case SHT_GNU_versym:        return "VERSYM";
4233     case 0x6ffffff0:            return "VERSYM";
4234     case 0x6ffffffc:            return "VERDEF";
4235     case 0x7ffffffd:            return "AUXILIARY";
4236     case 0x7fffffff:            return "FILTER";
4237     case SHT_GNU_LIBLIST:       return "GNU_LIBLIST";
4238
4239     default:
4240       if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4241         {
4242           switch (filedata->file_header.e_machine)
4243             {
4244             case EM_ARC:
4245             case EM_ARC_COMPACT:
4246             case EM_ARC_COMPACT2:
4247               result = get_arc_section_type_name (sh_type);
4248               break;
4249             case EM_MIPS:
4250             case EM_MIPS_RS3_LE:
4251               result = get_mips_section_type_name (sh_type);
4252               break;
4253             case EM_PARISC:
4254               result = get_parisc_section_type_name (sh_type);
4255               break;
4256             case EM_IA_64:
4257               result = get_ia64_section_type_name (filedata, sh_type);
4258               break;
4259             case EM_X86_64:
4260             case EM_L1OM:
4261             case EM_K1OM:
4262               result = get_x86_64_section_type_name (sh_type);
4263               break;
4264             case EM_AARCH64:
4265               result = get_aarch64_section_type_name (sh_type);
4266               break;
4267             case EM_ARM:
4268               result = get_arm_section_type_name (sh_type);
4269               break;
4270             case EM_TI_C6000:
4271               result = get_tic6x_section_type_name (sh_type);
4272               break;
4273             case EM_MSP430:
4274               result = get_msp430x_section_type_name (sh_type);
4275               break;
4276             case EM_NFP:
4277               result = get_nfp_section_type_name (sh_type);
4278               break;
4279             case EM_V800:
4280             case EM_V850:
4281             case EM_CYGNUS_V850:
4282               result = get_v850_section_type_name (sh_type);
4283               break;
4284             default:
4285               result = NULL;
4286               break;
4287             }
4288
4289           if (result != NULL)
4290             return result;
4291
4292           sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4293         }
4294       else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4295         {
4296           switch (filedata->file_header.e_machine)
4297             {
4298             case EM_IA_64:
4299               result = get_ia64_section_type_name (filedata, sh_type);
4300               break;
4301             default:
4302               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4303                 result = get_solaris_section_type (sh_type);
4304               else
4305                 {
4306                   switch (sh_type)
4307                     {
4308                     case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4309                     case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4310                     case SHT_GNU_HASH: result = "GNU_HASH"; break;
4311                     case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4312                     default:
4313                       result = NULL;
4314                       break;
4315                     }
4316                 }
4317               break;
4318             }
4319
4320           if (result != NULL)
4321             return result;
4322
4323           sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4324         }
4325       else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4326         {
4327           switch (filedata->file_header.e_machine)
4328             {
4329             case EM_V800:
4330             case EM_V850:
4331             case EM_CYGNUS_V850:
4332               result = get_v850_section_type_name (sh_type);
4333               break;
4334             default:
4335               result = NULL;
4336               break;
4337             }
4338
4339           if (result != NULL)
4340             return result;
4341
4342           sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4343         }
4344       else
4345         /* This message is probably going to be displayed in a 15
4346            character wide field, so put the hex value first.  */
4347         snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4348
4349       return buff;
4350     }
4351 }
4352
4353 #define OPTION_DEBUG_DUMP       512
4354 #define OPTION_DYN_SYMS         513
4355 #define OPTION_DWARF_DEPTH      514
4356 #define OPTION_DWARF_START      515
4357 #define OPTION_DWARF_CHECK      516
4358
4359 static struct option options[] =
4360 {
4361   {"all",              no_argument, 0, 'a'},
4362   {"file-header",      no_argument, 0, 'h'},
4363   {"program-headers",  no_argument, 0, 'l'},
4364   {"headers",          no_argument, 0, 'e'},
4365   {"histogram",        no_argument, 0, 'I'},
4366   {"segments",         no_argument, 0, 'l'},
4367   {"sections",         no_argument, 0, 'S'},
4368   {"section-headers",  no_argument, 0, 'S'},
4369   {"section-groups",   no_argument, 0, 'g'},
4370   {"section-details",  no_argument, 0, 't'},
4371   {"full-section-name",no_argument, 0, 'N'},
4372   {"symbols",          no_argument, 0, 's'},
4373   {"syms",             no_argument, 0, 's'},
4374   {"dyn-syms",         no_argument, 0, OPTION_DYN_SYMS},
4375   {"relocs",           no_argument, 0, 'r'},
4376   {"notes",            no_argument, 0, 'n'},
4377   {"dynamic",          no_argument, 0, 'd'},
4378   {"arch-specific",    no_argument, 0, 'A'},
4379   {"version-info",     no_argument, 0, 'V'},
4380   {"use-dynamic",      no_argument, 0, 'D'},
4381   {"unwind",           no_argument, 0, 'u'},
4382   {"archive-index",    no_argument, 0, 'c'},
4383   {"hex-dump",         required_argument, 0, 'x'},
4384   {"relocated-dump",   required_argument, 0, 'R'},
4385   {"string-dump",      required_argument, 0, 'p'},
4386   {"decompress",       no_argument, 0, 'z'},
4387 #ifdef SUPPORT_DISASSEMBLY
4388   {"instruction-dump", required_argument, 0, 'i'},
4389 #endif
4390   {"debug-dump",       optional_argument, 0, OPTION_DEBUG_DUMP},
4391
4392   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
4393   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
4394   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
4395
4396   {"version",          no_argument, 0, 'v'},
4397   {"wide",             no_argument, 0, 'W'},
4398   {"help",             no_argument, 0, 'H'},
4399   {0,                  no_argument, 0, 0}
4400 };
4401
4402 static void
4403 usage (FILE * stream)
4404 {
4405   fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4406   fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4407   fprintf (stream, _(" Options are:\n\
4408   -a --all               Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4409   -h --file-header       Display the ELF file header\n\
4410   -l --program-headers   Display the program headers\n\
4411      --segments          An alias for --program-headers\n\
4412   -S --section-headers   Display the sections' header\n\
4413      --sections          An alias for --section-headers\n\
4414   -g --section-groups    Display the section groups\n\
4415   -t --section-details   Display the section details\n\
4416   -e --headers           Equivalent to: -h -l -S\n\
4417   -s --syms              Display the symbol table\n\
4418      --symbols           An alias for --syms\n\
4419   --dyn-syms             Display the dynamic symbol table\n\
4420   -n --notes             Display the core notes (if present)\n\
4421   -r --relocs            Display the relocations (if present)\n\
4422   -u --unwind            Display the unwind info (if present)\n\
4423   -d --dynamic           Display the dynamic section (if present)\n\
4424   -V --version-info      Display the version sections (if present)\n\
4425   -A --arch-specific     Display architecture specific information (if any)\n\
4426   -c --archive-index     Display the symbol/file index in an archive\n\
4427   -D --use-dynamic       Use the dynamic section info when displaying symbols\n\
4428   -x --hex-dump=<number|name>\n\
4429                          Dump the contents of section <number|name> as bytes\n\
4430   -p --string-dump=<number|name>\n\
4431                          Dump the contents of section <number|name> as strings\n\
4432   -R --relocated-dump=<number|name>\n\
4433                          Dump the contents of section <number|name> as relocated bytes\n\
4434   -z --decompress        Decompress section before dumping it\n\
4435   -w[lLiaprmfFsoRtUuTgAckK] or\n\
4436   --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4437                =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4438                =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4439                =addr,=cu_index,=links,=follow-links]\n\
4440                          Display the contents of DWARF debug sections\n"));
4441   fprintf (stream, _("\
4442   --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
4443   --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
4444                          or deeper\n"));
4445 #ifdef SUPPORT_DISASSEMBLY
4446   fprintf (stream, _("\
4447   -i --instruction-dump=<number|name>\n\
4448                          Disassemble the contents of section <number|name>\n"));
4449 #endif
4450   fprintf (stream, _("\
4451   -I --histogram         Display histogram of bucket list lengths\n\
4452   -W --wide              Allow output width to exceed 80 characters\n\
4453   @<file>                Read options from <file>\n\
4454   -H --help              Display this information\n\
4455   -v --version           Display the version number of readelf\n"));
4456
4457   if (REPORT_BUGS_TO[0] && stream == stdout)
4458     fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4459
4460   exit (stream == stdout ? 0 : 1);
4461 }
4462
4463 /* Record the fact that the user wants the contents of section number
4464    SECTION to be displayed using the method(s) encoded as flags bits
4465    in TYPE.  Note, TYPE can be zero if we are creating the array for
4466    the first time.  */
4467
4468 static void
4469 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4470 {
4471   if (section >= filedata->num_dump_sects)
4472     {
4473       dump_type * new_dump_sects;
4474
4475       new_dump_sects = (dump_type *) calloc (section + 1,
4476                                              sizeof (* new_dump_sects));
4477
4478       if (new_dump_sects == NULL)
4479         error (_("Out of memory allocating dump request table.\n"));
4480       else
4481         {
4482           if (filedata->dump_sects)
4483             {
4484               /* Copy current flag settings.  */
4485               memcpy (new_dump_sects, filedata->dump_sects,
4486                       filedata->num_dump_sects * sizeof (* new_dump_sects));
4487
4488               free (filedata->dump_sects);
4489             }
4490
4491           filedata->dump_sects = new_dump_sects;
4492           filedata->num_dump_sects = section + 1;
4493         }
4494     }
4495
4496   if (filedata->dump_sects)
4497     filedata->dump_sects[section] |= type;
4498 }
4499
4500 /* Request a dump by section name.  */
4501
4502 static void
4503 request_dump_byname (const char * section, dump_type type)
4504 {
4505   struct dump_list_entry * new_request;
4506
4507   new_request = (struct dump_list_entry *)
4508       malloc (sizeof (struct dump_list_entry));
4509   if (!new_request)
4510     error (_("Out of memory allocating dump request table.\n"));
4511
4512   new_request->name = strdup (section);
4513   if (!new_request->name)
4514     error (_("Out of memory allocating dump request table.\n"));
4515
4516   new_request->type = type;
4517
4518   new_request->next = dump_sects_byname;
4519   dump_sects_byname = new_request;
4520 }
4521
4522 static inline void
4523 request_dump (Filedata * filedata, dump_type type)
4524 {
4525   int section;
4526   char * cp;
4527
4528   do_dump++;
4529   section = strtoul (optarg, & cp, 0);
4530
4531   if (! *cp && section >= 0)
4532     request_dump_bynumber (filedata, section, type);
4533   else
4534     request_dump_byname (optarg, type);
4535 }
4536
4537 static void
4538 parse_args (Filedata * filedata, int argc, char ** argv)
4539 {
4540   int c;
4541
4542   if (argc < 2)
4543     usage (stderr);
4544
4545   while ((c = getopt_long
4546           (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4547     {
4548       switch (c)
4549         {
4550         case 0:
4551           /* Long options.  */
4552           break;
4553         case 'H':
4554           usage (stdout);
4555           break;
4556
4557         case 'a':
4558           do_syms = TRUE;
4559           do_reloc = TRUE;
4560           do_unwind = TRUE;
4561           do_dynamic = TRUE;
4562           do_header = TRUE;
4563           do_sections = TRUE;
4564           do_section_groups = TRUE;
4565           do_segments = TRUE;
4566           do_version = TRUE;
4567           do_histogram = TRUE;
4568           do_arch = TRUE;
4569           do_notes = TRUE;
4570           break;
4571         case 'g':
4572           do_section_groups = TRUE;
4573           break;
4574         case 't':
4575         case 'N':
4576           do_sections = TRUE;
4577           do_section_details = TRUE;
4578           break;
4579         case 'e':
4580           do_header = TRUE;
4581           do_sections = TRUE;
4582           do_segments = TRUE;
4583           break;
4584         case 'A':
4585           do_arch = TRUE;
4586           break;
4587         case 'D':
4588           do_using_dynamic = TRUE;
4589           break;
4590         case 'r':
4591           do_reloc = TRUE;
4592           break;
4593         case 'u':
4594           do_unwind = TRUE;
4595           break;
4596         case 'h':
4597           do_header = TRUE;
4598           break;
4599         case 'l':
4600           do_segments = TRUE;
4601           break;
4602         case 's':
4603           do_syms = TRUE;
4604           break;
4605         case 'S':
4606           do_sections = TRUE;
4607           break;
4608         case 'd':
4609           do_dynamic = TRUE;
4610           break;
4611         case 'I':
4612           do_histogram = TRUE;
4613           break;
4614         case 'n':
4615           do_notes = TRUE;
4616           break;
4617         case 'c':
4618           do_archive_index = TRUE;
4619           break;
4620         case 'x':
4621           request_dump (filedata, HEX_DUMP);
4622           break;
4623         case 'p':
4624           request_dump (filedata, STRING_DUMP);
4625           break;
4626         case 'R':
4627           request_dump (filedata, RELOC_DUMP);
4628           break;
4629         case 'z':
4630           decompress_dumps = TRUE;
4631           break;
4632         case 'w':
4633           do_dump = TRUE;
4634           if (optarg == 0)
4635             {
4636               do_debugging = TRUE;
4637               dwarf_select_sections_all ();
4638             }
4639           else
4640             {
4641               do_debugging = FALSE;
4642               dwarf_select_sections_by_letters (optarg);
4643             }
4644           break;
4645         case OPTION_DEBUG_DUMP:
4646           do_dump = TRUE;
4647           if (optarg == 0)
4648             do_debugging = TRUE;
4649           else
4650             {
4651               do_debugging = FALSE;
4652               dwarf_select_sections_by_names (optarg);
4653             }
4654           break;
4655         case OPTION_DWARF_DEPTH:
4656           {
4657             char *cp;
4658
4659             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4660           }
4661           break;
4662         case OPTION_DWARF_START:
4663           {
4664             char *cp;
4665
4666             dwarf_start_die = strtoul (optarg, & cp, 0);
4667           }
4668           break;
4669         case OPTION_DWARF_CHECK:
4670           dwarf_check = TRUE;
4671           break;
4672         case OPTION_DYN_SYMS:
4673           do_dyn_syms = TRUE;
4674           break;
4675 #ifdef SUPPORT_DISASSEMBLY
4676         case 'i':
4677           request_dump (filedata, DISASS_DUMP);
4678           break;
4679 #endif
4680         case 'v':
4681           print_version (program_name);
4682           break;
4683         case 'V':
4684           do_version = TRUE;
4685           break;
4686         case 'W':
4687           do_wide = TRUE;
4688           break;
4689         default:
4690           /* xgettext:c-format */
4691           error (_("Invalid option '-%c'\n"), c);
4692           /* Fall through.  */
4693         case '?':
4694           usage (stderr);
4695         }
4696     }
4697
4698   if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4699       && !do_segments && !do_header && !do_dump && !do_version
4700       && !do_histogram && !do_debugging && !do_arch && !do_notes
4701       && !do_section_groups && !do_archive_index
4702       && !do_dyn_syms)
4703     usage (stderr);
4704 }
4705
4706 static const char *
4707 get_elf_class (unsigned int elf_class)
4708 {
4709   static char buff[32];
4710
4711   switch (elf_class)
4712     {
4713     case ELFCLASSNONE: return _("none");
4714     case ELFCLASS32:   return "ELF32";
4715     case ELFCLASS64:   return "ELF64";
4716     default:
4717       snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4718       return buff;
4719     }
4720 }
4721
4722 static const char *
4723 get_data_encoding (unsigned int encoding)
4724 {
4725   static char buff[32];
4726
4727   switch (encoding)
4728     {
4729     case ELFDATANONE: return _("none");
4730     case ELFDATA2LSB: return _("2's complement, little endian");
4731     case ELFDATA2MSB: return _("2's complement, big endian");
4732     default:
4733       snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4734       return buff;
4735     }
4736 }
4737
4738 /* Decode the data held in 'filedata->file_header'.  */
4739
4740 static bfd_boolean
4741 process_file_header (Filedata * filedata)
4742 {
4743   Elf_Internal_Ehdr * header = & filedata->file_header;
4744
4745   if (   header->e_ident[EI_MAG0] != ELFMAG0
4746       || header->e_ident[EI_MAG1] != ELFMAG1
4747       || header->e_ident[EI_MAG2] != ELFMAG2
4748       || header->e_ident[EI_MAG3] != ELFMAG3)
4749     {
4750       error
4751         (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4752       return FALSE;
4753     }
4754
4755   init_dwarf_regnames (header->e_machine);
4756
4757   if (do_header)
4758     {
4759       unsigned i;
4760
4761       printf (_("ELF Header:\n"));
4762       printf (_("  Magic:   "));
4763       for (i = 0; i < EI_NIDENT; i++)
4764         printf ("%2.2x ", header->e_ident[i]);
4765       printf ("\n");
4766       printf (_("  Class:                             %s\n"),
4767               get_elf_class (header->e_ident[EI_CLASS]));
4768       printf (_("  Data:                              %s\n"),
4769               get_data_encoding (header->e_ident[EI_DATA]));
4770       printf (_("  Version:                           %d%s\n"),
4771               header->e_ident[EI_VERSION],
4772               (header->e_ident[EI_VERSION] == EV_CURRENT
4773                ? _(" (current)")
4774                : (header->e_ident[EI_VERSION] != EV_NONE
4775                   ? _(" <unknown>")
4776                   : "")));
4777       printf (_("  OS/ABI:                            %s\n"),
4778               get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4779       printf (_("  ABI Version:                       %d\n"),
4780               header->e_ident[EI_ABIVERSION]);
4781       printf (_("  Type:                              %s\n"),
4782               get_file_type (header->e_type));
4783       printf (_("  Machine:                           %s\n"),
4784               get_machine_name (header->e_machine));
4785       printf (_("  Version:                           0x%lx\n"),
4786               header->e_version);
4787
4788       printf (_("  Entry point address:               "));
4789       print_vma (header->e_entry, PREFIX_HEX);
4790       printf (_("\n  Start of program headers:          "));
4791       print_vma (header->e_phoff, DEC);
4792       printf (_(" (bytes into file)\n  Start of section headers:          "));
4793       print_vma (header->e_shoff, DEC);
4794       printf (_(" (bytes into file)\n"));
4795
4796       printf (_("  Flags:                             0x%lx%s\n"),
4797               header->e_flags,
4798               get_machine_flags (filedata, header->e_flags, header->e_machine));
4799       printf (_("  Size of this header:               %u (bytes)\n"),
4800               header->e_ehsize);
4801       printf (_("  Size of program headers:           %u (bytes)\n"),
4802               header->e_phentsize);
4803       printf (_("  Number of program headers:         %u"),
4804               header->e_phnum);
4805       if (filedata->section_headers != NULL
4806           && header->e_phnum == PN_XNUM
4807           && filedata->section_headers[0].sh_info != 0)
4808         {
4809           header->e_phnum = filedata->section_headers[0].sh_info;
4810           printf (" (%u)", header->e_phnum);
4811         }
4812       putc ('\n', stdout);
4813       printf (_("  Size of section headers:           %u (bytes)\n"),
4814               header->e_shentsize);
4815       printf (_("  Number of section headers:         %u"),
4816               header->e_shnum);
4817       if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4818         {
4819           header->e_shnum = filedata->section_headers[0].sh_size;
4820           printf (" (%u)", header->e_shnum);
4821         }
4822       putc ('\n', stdout);
4823       printf (_("  Section header string table index: %u"),
4824               header->e_shstrndx);
4825       if (filedata->section_headers != NULL
4826           && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4827         {
4828           header->e_shstrndx = filedata->section_headers[0].sh_link;
4829           printf (" (%u)", header->e_shstrndx);
4830         }
4831       if (header->e_shstrndx != SHN_UNDEF
4832           && header->e_shstrndx >= header->e_shnum)
4833         {
4834           header->e_shstrndx = SHN_UNDEF;
4835           printf (_(" <corrupt: out of range>"));
4836         }
4837       putc ('\n', stdout);
4838     }
4839
4840   if (filedata->section_headers != NULL)
4841     {
4842       if (header->e_phnum == PN_XNUM
4843           && filedata->section_headers[0].sh_info != 0)
4844         header->e_phnum = filedata->section_headers[0].sh_info;
4845       if (header->e_shnum == SHN_UNDEF)
4846         header->e_shnum = filedata->section_headers[0].sh_size;
4847       if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4848         header->e_shstrndx = filedata->section_headers[0].sh_link;
4849       if (header->e_shstrndx >= header->e_shnum)
4850         header->e_shstrndx = SHN_UNDEF;
4851       free (filedata->section_headers);
4852       filedata->section_headers = NULL;
4853     }
4854
4855   return TRUE;
4856 }
4857
4858 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4859    Returns TRUE upon success, FALSE otherwise.  Loads 32-bit headers.  */
4860
4861 static bfd_boolean
4862 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4863 {
4864   Elf32_External_Phdr * phdrs;
4865   Elf32_External_Phdr * external;
4866   Elf_Internal_Phdr *   internal;
4867   unsigned int i;
4868   unsigned int size = filedata->file_header.e_phentsize;
4869   unsigned int num  = filedata->file_header.e_phnum;
4870
4871   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4872   if (size == 0 || num == 0)
4873     return FALSE;
4874   if (size < sizeof * phdrs)
4875     {
4876       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4877       return FALSE;
4878     }
4879   if (size > sizeof * phdrs)
4880     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4881
4882   phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4883                                             size, num, _("program headers"));
4884   if (phdrs == NULL)
4885     return FALSE;
4886
4887   for (i = 0, internal = pheaders, external = phdrs;
4888        i < filedata->file_header.e_phnum;
4889        i++, internal++, external++)
4890     {
4891       internal->p_type   = BYTE_GET (external->p_type);
4892       internal->p_offset = BYTE_GET (external->p_offset);
4893       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4894       internal->p_paddr  = BYTE_GET (external->p_paddr);
4895       internal->p_filesz = BYTE_GET (external->p_filesz);
4896       internal->p_memsz  = BYTE_GET (external->p_memsz);
4897       internal->p_flags  = BYTE_GET (external->p_flags);
4898       internal->p_align  = BYTE_GET (external->p_align);
4899     }
4900
4901   free (phdrs);
4902   return TRUE;
4903 }
4904
4905 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4906    Returns TRUE upon success, FALSE otherwise.  Loads 64-bit headers.  */
4907
4908 static bfd_boolean
4909 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4910 {
4911   Elf64_External_Phdr * phdrs;
4912   Elf64_External_Phdr * external;
4913   Elf_Internal_Phdr *   internal;
4914   unsigned int i;
4915   unsigned int size = filedata->file_header.e_phentsize;
4916   unsigned int num  = filedata->file_header.e_phnum;
4917
4918   /* PR binutils/17531: Cope with unexpected section header sizes.  */
4919   if (size == 0 || num == 0)
4920     return FALSE;
4921   if (size < sizeof * phdrs)
4922     {
4923       error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4924       return FALSE;
4925     }
4926   if (size > sizeof * phdrs)
4927     warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4928
4929   phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4930                                             size, num, _("program headers"));
4931   if (!phdrs)
4932     return FALSE;
4933
4934   for (i = 0, internal = pheaders, external = phdrs;
4935        i < filedata->file_header.e_phnum;
4936        i++, internal++, external++)
4937     {
4938       internal->p_type   = BYTE_GET (external->p_type);
4939       internal->p_flags  = BYTE_GET (external->p_flags);
4940       internal->p_offset = BYTE_GET (external->p_offset);
4941       internal->p_vaddr  = BYTE_GET (external->p_vaddr);
4942       internal->p_paddr  = BYTE_GET (external->p_paddr);
4943       internal->p_filesz = BYTE_GET (external->p_filesz);
4944       internal->p_memsz  = BYTE_GET (external->p_memsz);
4945       internal->p_align  = BYTE_GET (external->p_align);
4946     }
4947
4948   free (phdrs);
4949   return TRUE;
4950 }
4951
4952 /* Returns TRUE if the program headers were read into `program_headers'.  */
4953
4954 static bfd_boolean
4955 get_program_headers (Filedata * filedata)
4956 {
4957   Elf_Internal_Phdr * phdrs;
4958
4959   /* Check cache of prior read.  */
4960   if (filedata->program_headers != NULL)
4961     return TRUE;
4962
4963   /* Be kind to memory checkers by looking for
4964      e_phnum values which we know must be invalid.  */
4965   if (filedata->file_header.e_phnum
4966       * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4967       >= filedata->file_size)
4968     {
4969       error (_("Too many program headers - %#x - the file is not that big\n"),
4970              filedata->file_header.e_phnum);
4971       return FALSE;
4972     }
4973
4974   phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4975                                          sizeof (Elf_Internal_Phdr));
4976   if (phdrs == NULL)
4977     {
4978       error (_("Out of memory reading %u program headers\n"),
4979              filedata->file_header.e_phnum);
4980       return FALSE;
4981     }
4982
4983   if (is_32bit_elf
4984       ? get_32bit_program_headers (filedata, phdrs)
4985       : get_64bit_program_headers (filedata, phdrs))
4986     {
4987       filedata->program_headers = phdrs;
4988       return TRUE;
4989     }
4990
4991   free (phdrs);
4992   return FALSE;
4993 }
4994
4995 /* Returns TRUE if the program headers were loaded.  */
4996
4997 static bfd_boolean
4998 process_program_headers (Filedata * filedata)
4999 {
5000   Elf_Internal_Phdr * segment;
5001   unsigned int i;
5002   Elf_Internal_Phdr * previous_load = NULL;
5003
5004   if (filedata->file_header.e_phnum == 0)
5005     {
5006       /* PR binutils/12467.  */
5007       if (filedata->file_header.e_phoff != 0)
5008         {
5009           warn (_("possibly corrupt ELF header - it has a non-zero program"
5010                   " header offset, but no program headers\n"));
5011           return FALSE;
5012         }
5013       else if (do_segments)
5014         printf (_("\nThere are no program headers in this file.\n"));
5015       return TRUE;
5016     }
5017
5018   if (do_segments && !do_header)
5019     {
5020       printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5021       printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5022       printf (ngettext ("There is %d program header, starting at offset %s\n",
5023                         "There are %d program headers, starting at offset %s\n",
5024                         filedata->file_header.e_phnum),
5025               filedata->file_header.e_phnum,
5026               bfd_vmatoa ("u", filedata->file_header.e_phoff));
5027     }
5028
5029   if (! get_program_headers (filedata))
5030     return TRUE;
5031
5032   if (do_segments)
5033     {
5034       if (filedata->file_header.e_phnum > 1)
5035         printf (_("\nProgram Headers:\n"));
5036       else
5037         printf (_("\nProgram Headers:\n"));
5038
5039       if (is_32bit_elf)
5040         printf
5041           (_("  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n"));
5042       else if (do_wide)
5043         printf
5044           (_("  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align\n"));
5045       else
5046         {
5047           printf
5048             (_("  Type           Offset             VirtAddr           PhysAddr\n"));
5049           printf
5050             (_("                 FileSiz            MemSiz              Flags  Align\n"));
5051         }
5052     }
5053
5054   dynamic_addr = 0;
5055   dynamic_size = 0;
5056
5057   for (i = 0, segment = filedata->program_headers;
5058        i < filedata->file_header.e_phnum;
5059        i++, segment++)
5060     {
5061       if (do_segments)
5062         {
5063           printf ("  %-14.14s ", get_segment_type (filedata, segment->p_type));
5064
5065           if (is_32bit_elf)
5066             {
5067               printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5068               printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5069               printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5070               printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5071               printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5072               printf ("%c%c%c ",
5073                       (segment->p_flags & PF_R ? 'R' : ' '),
5074                       (segment->p_flags & PF_W ? 'W' : ' '),
5075                       (segment->p_flags & PF_X ? 'E' : ' '));
5076               printf ("%#lx", (unsigned long) segment->p_align);
5077             }
5078           else if (do_wide)
5079             {
5080               if ((unsigned long) segment->p_offset == segment->p_offset)
5081                 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5082               else
5083                 {
5084                   print_vma (segment->p_offset, FULL_HEX);
5085                   putchar (' ');
5086                 }
5087
5088               print_vma (segment->p_vaddr, FULL_HEX);
5089               putchar (' ');
5090               print_vma (segment->p_paddr, FULL_HEX);
5091               putchar (' ');
5092
5093               if ((unsigned long) segment->p_filesz == segment->p_filesz)
5094                 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5095               else
5096                 {
5097                   print_vma (segment->p_filesz, FULL_HEX);
5098                   putchar (' ');
5099                 }
5100
5101               if ((unsigned long) segment->p_memsz == segment->p_memsz)
5102                 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5103               else
5104                 {
5105                   print_vma (segment->p_memsz, FULL_HEX);
5106                 }
5107
5108               printf (" %c%c%c ",
5109                       (segment->p_flags & PF_R ? 'R' : ' '),
5110                       (segment->p_flags & PF_W ? 'W' : ' '),
5111                       (segment->p_flags & PF_X ? 'E' : ' '));
5112
5113               if ((unsigned long) segment->p_align == segment->p_align)
5114                 printf ("%#lx", (unsigned long) segment->p_align);
5115               else
5116                 {
5117                   print_vma (segment->p_align, PREFIX_HEX);
5118                 }
5119             }
5120           else
5121             {
5122               print_vma (segment->p_offset, FULL_HEX);
5123               putchar (' ');
5124               print_vma (segment->p_vaddr, FULL_HEX);
5125               putchar (' ');
5126               print_vma (segment->p_paddr, FULL_HEX);
5127               printf ("\n                 ");
5128               print_vma (segment->p_filesz, FULL_HEX);
5129               putchar (' ');
5130               print_vma (segment->p_memsz, FULL_HEX);
5131               printf ("  %c%c%c    ",
5132                       (segment->p_flags & PF_R ? 'R' : ' '),
5133                       (segment->p_flags & PF_W ? 'W' : ' '),
5134                       (segment->p_flags & PF_X ? 'E' : ' '));
5135               print_vma (segment->p_align, PREFIX_HEX);
5136             }
5137
5138           putc ('\n', stdout);
5139         }
5140
5141       switch (segment->p_type)
5142         {
5143         case PT_LOAD:
5144 #if 0 /* Do not warn about out of order PT_LOAD segments.  Although officially
5145          required by the ELF standard, several programs, including the Linux
5146          kernel, make use of non-ordered segments.  */
5147           if (previous_load
5148               && previous_load->p_vaddr > segment->p_vaddr)
5149             error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5150 #endif
5151           if (segment->p_memsz < segment->p_filesz)
5152             error (_("the segment's file size is larger than its memory size\n"));
5153           previous_load = segment;
5154           break;
5155
5156         case PT_PHDR:
5157           /* PR 20815 - Verify that the program header is loaded into memory.  */
5158           if (i > 0 && previous_load != NULL)
5159             error (_("the PHDR segment must occur before any LOAD segment\n"));
5160           if (filedata->file_header.e_machine != EM_PARISC)
5161             {
5162               unsigned int j;
5163
5164               for (j = 1; j < filedata->file_header.e_phnum; j++)
5165                 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5166                     && (filedata->program_headers[j].p_vaddr
5167                         + filedata->program_headers[j].p_memsz)
5168                     >= (segment->p_vaddr + segment->p_filesz))
5169                   break;
5170               if (j == filedata->file_header.e_phnum)
5171                 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5172             }
5173           break;
5174
5175         case PT_DYNAMIC:
5176           if (dynamic_addr)
5177             error (_("more than one dynamic segment\n"));
5178
5179           /* By default, assume that the .dynamic section is the first
5180              section in the DYNAMIC segment.  */
5181           dynamic_addr = segment->p_offset;
5182           dynamic_size = segment->p_filesz;
5183
5184           /* Try to locate the .dynamic section. If there is
5185              a section header table, we can easily locate it.  */
5186           if (filedata->section_headers != NULL)
5187             {
5188               Elf_Internal_Shdr * sec;
5189
5190               sec = find_section (filedata, ".dynamic");
5191               if (sec == NULL || sec->sh_size == 0)
5192                 {
5193                   /* A corresponding .dynamic section is expected, but on
5194                      IA-64/OpenVMS it is OK for it to be missing.  */
5195                   if (!is_ia64_vms (filedata))
5196                     error (_("no .dynamic section in the dynamic segment\n"));
5197                   break;
5198                 }
5199
5200               if (sec->sh_type == SHT_NOBITS)
5201                 {
5202                   dynamic_size = 0;
5203                   break;
5204                 }
5205
5206               dynamic_addr = sec->sh_offset;
5207               dynamic_size = sec->sh_size;
5208
5209               if (dynamic_addr < segment->p_offset
5210                   || dynamic_addr > segment->p_offset + segment->p_filesz)
5211                 warn (_("the .dynamic section is not contained"
5212                         " within the dynamic segment\n"));
5213               else if (dynamic_addr > segment->p_offset)
5214                 warn (_("the .dynamic section is not the first section"
5215                         " in the dynamic segment.\n"));
5216             }
5217
5218           /* PR binutils/17512: Avoid corrupt dynamic section info in the
5219              segment.  Check this after matching against the section headers
5220              so we don't warn on debuginfo file (which have NOBITS .dynamic
5221              sections).  */
5222           if (dynamic_addr + dynamic_size >= filedata->file_size)
5223             {
5224               error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5225               dynamic_addr = dynamic_size = 0;
5226             }
5227           break;
5228
5229         case PT_INTERP:
5230           if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5231                      SEEK_SET))
5232             error (_("Unable to find program interpreter name\n"));
5233           else
5234             {
5235               char fmt [32];
5236               int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5237
5238               if (ret >= (int) sizeof (fmt) || ret < 0)
5239                 error (_("Internal error: failed to create format string to display program interpreter\n"));
5240
5241               program_interpreter[0] = 0;
5242               if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5243                 error (_("Unable to read program interpreter name\n"));
5244
5245               if (do_segments)
5246                 printf (_("      [Requesting program interpreter: %s]\n"),
5247                     program_interpreter);
5248             }
5249           break;
5250         }
5251     }
5252
5253   if (do_segments
5254       && filedata->section_headers != NULL
5255       && filedata->string_table != NULL)
5256     {
5257       printf (_("\n Section to Segment mapping:\n"));
5258       printf (_("  Segment Sections...\n"));
5259
5260       for (i = 0; i < filedata->file_header.e_phnum; i++)
5261         {
5262           unsigned int j;
5263           Elf_Internal_Shdr * section;
5264
5265           segment = filedata->program_headers + i;
5266           section = filedata->section_headers + 1;
5267
5268           printf ("   %2.2d     ", i);
5269
5270           for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5271             {
5272               if (!ELF_TBSS_SPECIAL (section, segment)
5273                   && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5274                 printf ("%s ", printable_section_name (filedata, section));
5275             }
5276
5277           putc ('\n',stdout);
5278         }
5279     }
5280
5281   return TRUE;
5282 }
5283
5284
5285 /* Find the file offset corresponding to VMA by using the program headers.  */
5286
5287 static long
5288 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5289 {
5290   Elf_Internal_Phdr * seg;
5291
5292   if (! get_program_headers (filedata))
5293     {
5294       warn (_("Cannot interpret virtual addresses without program headers.\n"));
5295       return (long) vma;
5296     }
5297
5298   for (seg = filedata->program_headers;
5299        seg < filedata->program_headers + filedata->file_header.e_phnum;
5300        ++seg)
5301     {
5302       if (seg->p_type != PT_LOAD)
5303         continue;
5304
5305       if (vma >= (seg->p_vaddr & -seg->p_align)
5306           && vma + size <= seg->p_vaddr + seg->p_filesz)
5307         return vma - seg->p_vaddr + seg->p_offset;
5308     }
5309
5310   warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5311         (unsigned long) vma);
5312   return (long) vma;
5313 }
5314
5315
5316 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5317    If PROBE is true, this is just a probe and we do not generate any error
5318    messages if the load fails.  */
5319
5320 static bfd_boolean
5321 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5322 {
5323   Elf32_External_Shdr * shdrs;
5324   Elf_Internal_Shdr *   internal;
5325   unsigned int          i;
5326   unsigned int          size = filedata->file_header.e_shentsize;
5327   unsigned int          num = probe ? 1 : filedata->file_header.e_shnum;
5328
5329   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5330   if (size == 0 || num == 0)
5331     return FALSE;
5332   if (size < sizeof * shdrs)
5333     {
5334       if (! probe)
5335         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5336       return FALSE;
5337     }
5338   if (!probe && size > sizeof * shdrs)
5339     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5340
5341   shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5342                                             size, num,
5343                                             probe ? NULL : _("section headers"));
5344   if (shdrs == NULL)
5345     return FALSE;
5346
5347   free (filedata->section_headers);
5348   filedata->section_headers = (Elf_Internal_Shdr *)
5349     cmalloc (num, sizeof (Elf_Internal_Shdr));
5350   if (filedata->section_headers == NULL)
5351     {
5352       if (!probe)
5353         error (_("Out of memory reading %u section headers\n"), num);
5354       free (shdrs);
5355       return FALSE;
5356     }
5357
5358   for (i = 0, internal = filedata->section_headers;
5359        i < num;
5360        i++, internal++)
5361     {
5362       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5363       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5364       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5365       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5366       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5367       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5368       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5369       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5370       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5371       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5372       if (!probe && internal->sh_link > num)
5373         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5374       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5375         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5376     }
5377
5378   free (shdrs);
5379   return TRUE;
5380 }
5381
5382 /* Like get_32bit_section_headers, except that it fetches 64-bit headers.  */
5383
5384 static bfd_boolean
5385 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5386 {
5387   Elf64_External_Shdr *  shdrs;
5388   Elf_Internal_Shdr *    internal;
5389   unsigned int           i;
5390   unsigned int           size = filedata->file_header.e_shentsize;
5391   unsigned int           num = probe ? 1 : filedata->file_header.e_shnum;
5392
5393   /* PR binutils/17531: Cope with unexpected section header sizes.  */
5394   if (size == 0 || num == 0)
5395     return FALSE;
5396
5397   if (size < sizeof * shdrs)
5398     {
5399       if (! probe)
5400         error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5401       return FALSE;
5402     }
5403
5404   if (! probe && size > sizeof * shdrs)
5405     warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5406
5407   shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5408                                             filedata->file_header.e_shoff,
5409                                             size, num,
5410                                             probe ? NULL : _("section headers"));
5411   if (shdrs == NULL)
5412     return FALSE;
5413
5414   free (filedata->section_headers);
5415   filedata->section_headers = (Elf_Internal_Shdr *)
5416     cmalloc (num, sizeof (Elf_Internal_Shdr));
5417   if (filedata->section_headers == NULL)
5418     {
5419       if (! probe)
5420         error (_("Out of memory reading %u section headers\n"), num);
5421       free (shdrs);
5422       return FALSE;
5423     }
5424
5425   for (i = 0, internal = filedata->section_headers;
5426        i < num;
5427        i++, internal++)
5428     {
5429       internal->sh_name      = BYTE_GET (shdrs[i].sh_name);
5430       internal->sh_type      = BYTE_GET (shdrs[i].sh_type);
5431       internal->sh_flags     = BYTE_GET (shdrs[i].sh_flags);
5432       internal->sh_addr      = BYTE_GET (shdrs[i].sh_addr);
5433       internal->sh_size      = BYTE_GET (shdrs[i].sh_size);
5434       internal->sh_entsize   = BYTE_GET (shdrs[i].sh_entsize);
5435       internal->sh_link      = BYTE_GET (shdrs[i].sh_link);
5436       internal->sh_info      = BYTE_GET (shdrs[i].sh_info);
5437       internal->sh_offset    = BYTE_GET (shdrs[i].sh_offset);
5438       internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5439       if (!probe && internal->sh_link > num)
5440         warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5441       if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5442         warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5443     }
5444
5445   free (shdrs);
5446   return TRUE;
5447 }
5448
5449 static Elf_Internal_Sym *
5450 get_32bit_elf_symbols (Filedata *           filedata,
5451                        Elf_Internal_Shdr *  section,
5452                        unsigned long *      num_syms_return)
5453 {
5454   unsigned long number = 0;
5455   Elf32_External_Sym * esyms = NULL;
5456   Elf_External_Sym_Shndx * shndx = NULL;
5457   Elf_Internal_Sym * isyms = NULL;
5458   Elf_Internal_Sym * psym;
5459   unsigned int j;
5460   elf_section_list * entry;
5461
5462   if (section->sh_size == 0)
5463     {
5464       if (num_syms_return != NULL)
5465         * num_syms_return = 0;
5466       return NULL;
5467     }
5468
5469   /* Run some sanity checks first.  */
5470   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5471     {
5472       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5473              printable_section_name (filedata, section),
5474              (unsigned long) section->sh_entsize);
5475       goto exit_point;
5476     }
5477
5478   if (section->sh_size > filedata->file_size)
5479     {
5480       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5481              printable_section_name (filedata, section),
5482              (unsigned long) section->sh_size);
5483       goto exit_point;
5484     }
5485
5486   number = section->sh_size / section->sh_entsize;
5487
5488   if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5489     {
5490       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5491              (unsigned long) section->sh_size,
5492              printable_section_name (filedata, section),
5493              (unsigned long) section->sh_entsize);
5494       goto exit_point;
5495     }
5496
5497   esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5498                                            section->sh_size, _("symbols"));
5499   if (esyms == NULL)
5500     goto exit_point;
5501
5502   shndx = NULL;
5503   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5504     {
5505       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5506         continue;
5507
5508       if (shndx != NULL)
5509         {
5510           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5511           free (shndx);
5512         }
5513
5514       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5515                                                    entry->hdr->sh_offset,
5516                                                    1, entry->hdr->sh_size,
5517                                                    _("symbol table section indices"));
5518       if (shndx == NULL)
5519         goto exit_point;
5520
5521       /* PR17531: file: heap-buffer-overflow */
5522       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5523         {
5524           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5525                  printable_section_name (filedata, entry->hdr),
5526                  (unsigned long) entry->hdr->sh_size,
5527                  (unsigned long) section->sh_size);
5528           goto exit_point;
5529         }
5530     }
5531
5532   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5533
5534   if (isyms == NULL)
5535     {
5536       error (_("Out of memory reading %lu symbols\n"),
5537              (unsigned long) number);
5538       goto exit_point;
5539     }
5540
5541   for (j = 0, psym = isyms; j < number; j++, psym++)
5542     {
5543       psym->st_name  = BYTE_GET (esyms[j].st_name);
5544       psym->st_value = BYTE_GET (esyms[j].st_value);
5545       psym->st_size  = BYTE_GET (esyms[j].st_size);
5546       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5547       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5548         psym->st_shndx
5549           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5550       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5551         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5552       psym->st_info  = BYTE_GET (esyms[j].st_info);
5553       psym->st_other = BYTE_GET (esyms[j].st_other);
5554     }
5555
5556  exit_point:
5557   free (shndx);
5558   free (esyms);
5559
5560   if (num_syms_return != NULL)
5561     * num_syms_return = isyms == NULL ? 0 : number;
5562
5563   return isyms;
5564 }
5565
5566 static Elf_Internal_Sym *
5567 get_64bit_elf_symbols (Filedata *           filedata,
5568                        Elf_Internal_Shdr *  section,
5569                        unsigned long *      num_syms_return)
5570 {
5571   unsigned long number = 0;
5572   Elf64_External_Sym * esyms = NULL;
5573   Elf_External_Sym_Shndx * shndx = NULL;
5574   Elf_Internal_Sym * isyms = NULL;
5575   Elf_Internal_Sym * psym;
5576   unsigned int j;
5577   elf_section_list * entry;
5578
5579   if (section->sh_size == 0)
5580     {
5581       if (num_syms_return != NULL)
5582         * num_syms_return = 0;
5583       return NULL;
5584     }
5585
5586   /* Run some sanity checks first.  */
5587   if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5588     {
5589       error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5590              printable_section_name (filedata, section),
5591              (unsigned long) section->sh_entsize);
5592       goto exit_point;
5593     }
5594
5595   if (section->sh_size > filedata->file_size)
5596     {
5597       error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5598              printable_section_name (filedata, section),
5599              (unsigned long) section->sh_size);
5600       goto exit_point;
5601     }
5602
5603   number = section->sh_size / section->sh_entsize;
5604
5605   if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5606     {
5607       error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5608              (unsigned long) section->sh_size,
5609              printable_section_name (filedata, section),
5610              (unsigned long) section->sh_entsize);
5611       goto exit_point;
5612     }
5613
5614   esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5615                                            section->sh_size, _("symbols"));
5616   if (!esyms)
5617     goto exit_point;
5618
5619   shndx = NULL;
5620   for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5621     {
5622       if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5623         continue;
5624
5625       if (shndx != NULL)
5626         {
5627           error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5628           free (shndx);
5629         }
5630
5631       shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5632                                                    entry->hdr->sh_offset,
5633                                                    1, entry->hdr->sh_size,
5634                                                    _("symbol table section indices"));
5635       if (shndx == NULL)
5636         goto exit_point;
5637
5638       /* PR17531: file: heap-buffer-overflow */
5639       if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5640         {
5641           error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5642                  printable_section_name (filedata, entry->hdr),
5643                  (unsigned long) entry->hdr->sh_size,
5644                  (unsigned long) section->sh_size);
5645           goto exit_point;
5646         }
5647     }
5648
5649   isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5650
5651   if (isyms == NULL)
5652     {
5653       error (_("Out of memory reading %lu symbols\n"),
5654              (unsigned long) number);
5655       goto exit_point;
5656     }
5657
5658   for (j = 0, psym = isyms; j < number; j++, psym++)
5659     {
5660       psym->st_name  = BYTE_GET (esyms[j].st_name);
5661       psym->st_info  = BYTE_GET (esyms[j].st_info);
5662       psym->st_other = BYTE_GET (esyms[j].st_other);
5663       psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5664
5665       if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5666         psym->st_shndx
5667           = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5668       else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5669         psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5670
5671       psym->st_value = BYTE_GET (esyms[j].st_value);
5672       psym->st_size  = BYTE_GET (esyms[j].st_size);
5673     }
5674
5675  exit_point:
5676   free (shndx);
5677   free (esyms);
5678
5679   if (num_syms_return != NULL)
5680     * num_syms_return = isyms == NULL ? 0 : number;
5681
5682   return isyms;
5683 }
5684
5685 static const char *
5686 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5687 {
5688   static char buff[1024];
5689   char * p = buff;
5690   unsigned int field_size = is_32bit_elf ? 8 : 16;
5691   signed int sindex;
5692   unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5693   bfd_vma os_flags = 0;
5694   bfd_vma proc_flags = 0;
5695   bfd_vma unknown_flags = 0;
5696   static const struct
5697     {
5698       const char * str;
5699       unsigned int len;
5700     }
5701   flags [] =
5702     {
5703       /*  0 */ { STRING_COMMA_LEN ("WRITE") },
5704       /*  1 */ { STRING_COMMA_LEN ("ALLOC") },
5705       /*  2 */ { STRING_COMMA_LEN ("EXEC") },
5706       /*  3 */ { STRING_COMMA_LEN ("MERGE") },
5707       /*  4 */ { STRING_COMMA_LEN ("STRINGS") },
5708       /*  5 */ { STRING_COMMA_LEN ("INFO LINK") },
5709       /*  6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5710       /*  7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5711       /*  8 */ { STRING_COMMA_LEN ("GROUP") },
5712       /*  9 */ { STRING_COMMA_LEN ("TLS") },
5713       /* IA-64 specific.  */
5714       /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5715       /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5716       /* IA-64 OpenVMS specific.  */
5717       /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5718       /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5719       /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5720       /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5721       /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5722       /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5723       /* Generic.  */
5724       /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5725       /* SPARC specific.  */
5726       /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5727       /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5728       /* ARM specific.  */
5729       /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5730       /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5731       /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5732       /* GNU specific.  */
5733       /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5734       /* VLE specific.  */
5735       /* 25 */ { STRING_COMMA_LEN ("VLE") },
5736     };
5737
5738   if (do_section_details)
5739     {
5740       sprintf (buff, "[%*.*lx]: ",
5741                field_size, field_size, (unsigned long) sh_flags);
5742       p += field_size + 4;
5743     }
5744
5745   while (sh_flags)
5746     {
5747       bfd_vma flag;
5748
5749       flag = sh_flags & - sh_flags;
5750       sh_flags &= ~ flag;
5751
5752       if (do_section_details)
5753         {
5754           switch (flag)
5755             {
5756             case SHF_WRITE:             sindex = 0; break;
5757             case SHF_ALLOC:             sindex = 1; break;
5758             case SHF_EXECINSTR:         sindex = 2; break;
5759             case SHF_MERGE:             sindex = 3; break;
5760             case SHF_STRINGS:           sindex = 4; break;
5761             case SHF_INFO_LINK:         sindex = 5; break;
5762             case SHF_LINK_ORDER:        sindex = 6; break;
5763             case SHF_OS_NONCONFORMING:  sindex = 7; break;
5764             case SHF_GROUP:             sindex = 8; break;
5765             case SHF_TLS:               sindex = 9; break;
5766             case SHF_EXCLUDE:           sindex = 18; break;
5767             case SHF_COMPRESSED:        sindex = 20; break;
5768             case SHF_GNU_MBIND:         sindex = 24; break;
5769
5770             default:
5771               sindex = -1;
5772               switch (filedata->file_header.e_machine)
5773                 {
5774                 case EM_IA_64:
5775                   if (flag == SHF_IA_64_SHORT)
5776                     sindex = 10;
5777                   else if (flag == SHF_IA_64_NORECOV)
5778                     sindex = 11;
5779 #ifdef BFD64
5780                   else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5781                     switch (flag)
5782                       {
5783                       case SHF_IA_64_VMS_GLOBAL:      sindex = 12; break;
5784                       case SHF_IA_64_VMS_OVERLAID:    sindex = 13; break;
5785                       case SHF_IA_64_VMS_SHARED:      sindex = 14; break;
5786                       case SHF_IA_64_VMS_VECTOR:      sindex = 15; break;
5787                       case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5788                       case SHF_IA_64_VMS_PROTECTED:   sindex = 17; break;
5789                       default:                        break;
5790                       }
5791 #endif
5792                   break;
5793
5794                 case EM_386:
5795                 case EM_IAMCU:
5796                 case EM_X86_64:
5797                 case EM_L1OM:
5798                 case EM_K1OM:
5799                 case EM_OLD_SPARCV9:
5800                 case EM_SPARC32PLUS:
5801                 case EM_SPARCV9:
5802                 case EM_SPARC:
5803                   if (flag == SHF_ORDERED)
5804                     sindex = 19;
5805                   break;
5806
5807                 case EM_ARM:
5808                   switch (flag)
5809                     {
5810                     case SHF_ENTRYSECT: sindex = 21; break;
5811                     case SHF_ARM_PURECODE: sindex = 22; break;
5812                     case SHF_COMDEF: sindex = 23; break;
5813                     default: break;
5814                     }
5815                   break;
5816                 case EM_PPC:
5817                   if (flag == SHF_PPC_VLE)
5818                     sindex = 25;
5819                   break;
5820
5821                 default:
5822                   break;
5823                 }
5824             }
5825
5826           if (sindex != -1)
5827             {
5828               if (p != buff + field_size + 4)
5829                 {
5830                   if (size < (10 + 2))
5831                     {
5832                       warn (_("Internal error: not enough buffer room for section flag info"));
5833                       return _("<unknown>");
5834                     }
5835                   size -= 2;
5836                   *p++ = ',';
5837                   *p++ = ' ';
5838                 }
5839
5840               size -= flags [sindex].len;
5841               p = stpcpy (p, flags [sindex].str);
5842             }
5843           else if (flag & SHF_MASKOS)
5844             os_flags |= flag;
5845           else if (flag & SHF_MASKPROC)
5846             proc_flags |= flag;
5847           else
5848             unknown_flags |= flag;
5849         }
5850       else
5851         {
5852           switch (flag)
5853             {
5854             case SHF_WRITE:             *p = 'W'; break;
5855             case SHF_ALLOC:             *p = 'A'; break;
5856             case SHF_EXECINSTR:         *p = 'X'; break;
5857             case SHF_MERGE:             *p = 'M'; break;
5858             case SHF_STRINGS:           *p = 'S'; break;
5859             case SHF_INFO_LINK:         *p = 'I'; break;
5860             case SHF_LINK_ORDER:        *p = 'L'; break;
5861             case SHF_OS_NONCONFORMING:  *p = 'O'; break;
5862             case SHF_GROUP:             *p = 'G'; break;
5863             case SHF_TLS:               *p = 'T'; break;
5864             case SHF_EXCLUDE:           *p = 'E'; break;
5865             case SHF_COMPRESSED:        *p = 'C'; break;
5866             case SHF_GNU_MBIND:         *p = 'D'; break;
5867
5868             default:
5869               if ((filedata->file_header.e_machine == EM_X86_64
5870                    || filedata->file_header.e_machine == EM_L1OM
5871                    || filedata->file_header.e_machine == EM_K1OM)
5872                   && flag == SHF_X86_64_LARGE)
5873                 *p = 'l';
5874               else if (filedata->file_header.e_machine == EM_ARM
5875                        && flag == SHF_ARM_PURECODE)
5876                   *p = 'y';
5877               else if (filedata->file_header.e_machine == EM_PPC
5878                        && flag == SHF_PPC_VLE)
5879                   *p = 'v';
5880               else if (flag & SHF_MASKOS)
5881                 {
5882                   *p = 'o';
5883                   sh_flags &= ~ SHF_MASKOS;
5884                 }
5885               else if (flag & SHF_MASKPROC)
5886                 {
5887                   *p = 'p';
5888                   sh_flags &= ~ SHF_MASKPROC;
5889                 }
5890               else
5891                 *p = 'x';
5892               break;
5893             }
5894           p++;
5895         }
5896     }
5897
5898   if (do_section_details)
5899     {
5900       if (os_flags)
5901         {
5902           size -= 5 + field_size;
5903           if (p != buff + field_size + 4)
5904             {
5905               if (size < (2 + 1))
5906                 {
5907                   warn (_("Internal error: not enough buffer room for section flag info"));
5908                   return _("<unknown>");
5909                 }
5910               size -= 2;
5911               *p++ = ',';
5912               *p++ = ' ';
5913             }
5914           sprintf (p, "OS (%*.*lx)", field_size, field_size,
5915                    (unsigned long) os_flags);
5916           p += 5 + field_size;
5917         }
5918       if (proc_flags)
5919         {
5920           size -= 7 + field_size;
5921           if (p != buff + field_size + 4)
5922             {
5923               if (size < (2 + 1))
5924                 {
5925                   warn (_("Internal error: not enough buffer room for section flag info"));
5926                   return _("<unknown>");
5927                 }
5928               size -= 2;
5929               *p++ = ',';
5930               *p++ = ' ';
5931             }
5932           sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5933                    (unsigned long) proc_flags);
5934           p += 7 + field_size;
5935         }
5936       if (unknown_flags)
5937         {
5938           size -= 10 + field_size;
5939           if (p != buff + field_size + 4)
5940             {
5941               if (size < (2 + 1))
5942                 {
5943                   warn (_("Internal error: not enough buffer room for section flag info"));
5944                   return _("<unknown>");
5945                 }
5946               size -= 2;
5947               *p++ = ',';
5948               *p++ = ' ';
5949             }
5950           sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5951                    (unsigned long) unknown_flags);
5952           p += 10 + field_size;
5953         }
5954     }
5955
5956   *p = '\0';
5957   return buff;
5958 }
5959
5960 static unsigned int
5961 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5962 {
5963   if (is_32bit_elf)
5964     {
5965       Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5966
5967       if (size < sizeof (* echdr))
5968         {
5969           error (_("Compressed section is too small even for a compression header\n"));
5970           return 0;
5971         }
5972
5973       chdr->ch_type = BYTE_GET (echdr->ch_type);
5974       chdr->ch_size = BYTE_GET (echdr->ch_size);
5975       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5976       return sizeof (*echdr);
5977     }
5978   else
5979     {
5980       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5981
5982       if (size < sizeof (* echdr))
5983         {
5984           error (_("Compressed section is too small even for a compression header\n"));
5985           return 0;
5986         }
5987
5988       chdr->ch_type = BYTE_GET (echdr->ch_type);
5989       chdr->ch_size = BYTE_GET (echdr->ch_size);
5990       chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5991       return sizeof (*echdr);
5992     }
5993 }
5994
5995 static bfd_boolean
5996 process_section_headers (Filedata * filedata)
5997 {
5998   Elf_Internal_Shdr * section;
5999   unsigned int i;
6000
6001   filedata->section_headers = NULL;
6002
6003   if (filedata->file_header.e_shnum == 0)
6004     {
6005       /* PR binutils/12467.  */
6006       if (filedata->file_header.e_shoff != 0)
6007         {
6008           warn (_("possibly corrupt ELF file header - it has a non-zero"
6009                   " section header offset, but no section headers\n"));
6010           return FALSE;
6011         }
6012       else if (do_sections)
6013         printf (_("\nThere are no sections in this file.\n"));
6014
6015       return TRUE;
6016     }
6017
6018   if (do_sections && !do_header)
6019     printf (ngettext ("There is %d section header, "
6020                       "starting at offset 0x%lx:\n",
6021                       "There are %d section headers, "
6022                       "starting at offset 0x%lx:\n",
6023                       filedata->file_header.e_shnum),
6024             filedata->file_header.e_shnum,
6025             (unsigned long) filedata->file_header.e_shoff);
6026
6027   if (is_32bit_elf)
6028     {
6029       if (! get_32bit_section_headers (filedata, FALSE))
6030         return FALSE;
6031     }
6032   else
6033     {
6034       if (! get_64bit_section_headers (filedata, FALSE))
6035         return FALSE;
6036     }
6037
6038   /* Read in the string table, so that we have names to display.  */
6039   if (filedata->file_header.e_shstrndx != SHN_UNDEF
6040        && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6041     {
6042       section = filedata->section_headers + filedata->file_header.e_shstrndx;
6043
6044       if (section->sh_size != 0)
6045         {
6046           filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6047                                                       1, section->sh_size,
6048                                                       _("string table"));
6049
6050           filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6051         }
6052     }
6053
6054   /* Scan the sections for the dynamic symbol table
6055      and dynamic string table and debug sections.  */
6056   dynamic_symbols = NULL;
6057   dynamic_strings = NULL;
6058   dynamic_syminfo = NULL;
6059   symtab_shndx_list = NULL;
6060
6061   eh_addr_size = is_32bit_elf ? 4 : 8;
6062   switch (filedata->file_header.e_machine)
6063     {
6064     case EM_MIPS:
6065     case EM_MIPS_RS3_LE:
6066       /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6067          FDE addresses.  However, the ABI also has a semi-official ILP32
6068          variant for which the normal FDE address size rules apply.
6069
6070          GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6071          section, where XX is the size of longs in bits.  Unfortunately,
6072          earlier compilers provided no way of distinguishing ILP32 objects
6073          from LP64 objects, so if there's any doubt, we should assume that
6074          the official LP64 form is being used.  */
6075       if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6076           && find_section (filedata, ".gcc_compiled_long32") == NULL)
6077         eh_addr_size = 8;
6078       break;
6079
6080     case EM_H8_300:
6081     case EM_H8_300H:
6082       switch (filedata->file_header.e_flags & EF_H8_MACH)
6083         {
6084         case E_H8_MACH_H8300:
6085         case E_H8_MACH_H8300HN:
6086         case E_H8_MACH_H8300SN:
6087         case E_H8_MACH_H8300SXN:
6088           eh_addr_size = 2;
6089           break;
6090         case E_H8_MACH_H8300H:
6091         case E_H8_MACH_H8300S:
6092         case E_H8_MACH_H8300SX:
6093           eh_addr_size = 4;
6094           break;
6095         }
6096       break;
6097
6098     case EM_M32C_OLD:
6099     case EM_M32C:
6100       switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6101         {
6102         case EF_M32C_CPU_M16C:
6103           eh_addr_size = 2;
6104           break;
6105         }
6106       break;
6107     }
6108
6109 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64)                \
6110   do                                                                    \
6111     {                                                                   \
6112       bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64;  \
6113       if (section->sh_entsize != expected_entsize)                      \
6114         {                                                               \
6115           char buf[40];                                                 \
6116           sprintf_vma (buf, section->sh_entsize);                       \
6117           /* Note: coded this way so that there is a single string for  \
6118              translation.  */ \
6119           error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6120           error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6121                    (unsigned) expected_entsize);                        \
6122           section->sh_entsize = expected_entsize;                       \
6123         }                                                               \
6124     }                                                                   \
6125   while (0)
6126
6127 #define CHECK_ENTSIZE(section, i, type)                                 \
6128   CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type),         \
6129                         sizeof (Elf64_External_##type))
6130
6131   for (i = 0, section = filedata->section_headers;
6132        i < filedata->file_header.e_shnum;
6133        i++, section++)
6134     {
6135       char * name = SECTION_NAME (section);
6136
6137       if (section->sh_type == SHT_DYNSYM)
6138         {
6139           if (dynamic_symbols != NULL)
6140             {
6141               error (_("File contains multiple dynamic symbol tables\n"));
6142               continue;
6143             }
6144
6145           CHECK_ENTSIZE (section, i, Sym);
6146           dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6147         }
6148       else if (section->sh_type == SHT_STRTAB
6149                && streq (name, ".dynstr"))
6150         {
6151           if (dynamic_strings != NULL)
6152             {
6153               error (_("File contains multiple dynamic string tables\n"));
6154               continue;
6155             }
6156
6157           dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6158                                                1, section->sh_size,
6159                                                _("dynamic strings"));
6160           dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6161         }
6162       else if (section->sh_type == SHT_SYMTAB_SHNDX)
6163         {
6164           elf_section_list * entry = xmalloc (sizeof * entry);
6165
6166           entry->hdr = section;
6167           entry->next = symtab_shndx_list;
6168           symtab_shndx_list = entry;
6169         }
6170       else if (section->sh_type == SHT_SYMTAB)
6171         CHECK_ENTSIZE (section, i, Sym);
6172       else if (section->sh_type == SHT_GROUP)
6173         CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6174       else if (section->sh_type == SHT_REL)
6175         CHECK_ENTSIZE (section, i, Rel);
6176       else if (section->sh_type == SHT_RELA)
6177         CHECK_ENTSIZE (section, i, Rela);
6178       else if ((do_debugging || do_debug_info || do_debug_abbrevs
6179                 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6180                 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6181                 || do_debug_str || do_debug_loc || do_debug_ranges
6182                 || do_debug_addr || do_debug_cu_index || do_debug_links)
6183                && (const_strneq (name, ".debug_")
6184                    || const_strneq (name, ".zdebug_")))
6185         {
6186           if (name[1] == 'z')
6187             name += sizeof (".zdebug_") - 1;
6188           else
6189             name += sizeof (".debug_") - 1;
6190
6191           if (do_debugging
6192               || (do_debug_info     && const_strneq (name, "info"))
6193               || (do_debug_info     && const_strneq (name, "types"))
6194               || (do_debug_abbrevs  && const_strneq (name, "abbrev"))
6195               || (do_debug_lines    && strcmp (name, "line") == 0)
6196               || (do_debug_lines    && const_strneq (name, "line."))
6197               || (do_debug_pubnames && const_strneq (name, "pubnames"))
6198               || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6199               || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6200               || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6201               || (do_debug_aranges  && const_strneq (name, "aranges"))
6202               || (do_debug_ranges   && const_strneq (name, "ranges"))
6203               || (do_debug_ranges   && const_strneq (name, "rnglists"))
6204               || (do_debug_frames   && const_strneq (name, "frame"))
6205               || (do_debug_macinfo  && const_strneq (name, "macinfo"))
6206               || (do_debug_macinfo  && const_strneq (name, "macro"))
6207               || (do_debug_str      && const_strneq (name, "str"))
6208               || (do_debug_loc      && const_strneq (name, "loc"))
6209               || (do_debug_loc      && const_strneq (name, "loclists"))
6210               || (do_debug_addr     && const_strneq (name, "addr"))
6211               || (do_debug_cu_index && const_strneq (name, "cu_index"))
6212               || (do_debug_cu_index && const_strneq (name, "tu_index"))
6213               )
6214             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6215         }
6216       /* Linkonce section to be combined with .debug_info at link time.  */
6217       else if ((do_debugging || do_debug_info)
6218                && const_strneq (name, ".gnu.linkonce.wi."))
6219         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6220       else if (do_debug_frames && streq (name, ".eh_frame"))
6221         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6222       else if (do_gdb_index && (streq (name, ".gdb_index")
6223                                 || streq (name, ".debug_names")))
6224         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6225       /* Trace sections for Itanium VMS.  */
6226       else if ((do_debugging || do_trace_info || do_trace_abbrevs
6227                 || do_trace_aranges)
6228                && const_strneq (name, ".trace_"))
6229         {
6230           name += sizeof (".trace_") - 1;
6231
6232           if (do_debugging
6233               || (do_trace_info     && streq (name, "info"))
6234               || (do_trace_abbrevs  && streq (name, "abbrev"))
6235               || (do_trace_aranges  && streq (name, "aranges"))
6236               )
6237             request_dump_bynumber (filedata, i, DEBUG_DUMP);
6238         }
6239       else if ((do_debugging || do_debug_links)
6240                && (const_strneq (name, ".gnu_debuglink")
6241                    || const_strneq (name, ".gnu_debugaltlink")))
6242         request_dump_bynumber (filedata, i, DEBUG_DUMP);
6243     }
6244
6245   if (! do_sections)
6246     return TRUE;
6247
6248   if (filedata->file_header.e_shnum > 1)
6249     printf (_("\nSection Headers:\n"));
6250   else
6251     printf (_("\nSection Header:\n"));
6252
6253   if (is_32bit_elf)
6254     {
6255       if (do_section_details)
6256         {
6257           printf (_("  [Nr] Name\n"));
6258           printf (_("       Type            Addr     Off    Size   ES   Lk Inf Al\n"));
6259         }
6260       else
6261         printf
6262           (_("  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n"));
6263     }
6264   else if (do_wide)
6265     {
6266       if (do_section_details)
6267         {
6268           printf (_("  [Nr] Name\n"));
6269           printf (_("       Type            Address          Off    Size   ES   Lk Inf Al\n"));
6270         }
6271       else
6272         printf
6273           (_("  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n"));
6274     }
6275   else
6276     {
6277       if (do_section_details)
6278         {
6279           printf (_("  [Nr] Name\n"));
6280           printf (_("       Type              Address          Offset            Link\n"));
6281           printf (_("       Size              EntSize          Info              Align\n"));
6282         }
6283       else
6284         {
6285           printf (_("  [Nr] Name              Type             Address           Offset\n"));
6286           printf (_("       Size              EntSize          Flags  Link  Info  Align\n"));
6287         }
6288     }
6289
6290   if (do_section_details)
6291     printf (_("       Flags\n"));
6292
6293   for (i = 0, section = filedata->section_headers;
6294        i < filedata->file_header.e_shnum;
6295        i++, section++)
6296     {
6297       /* Run some sanity checks on the section header.  */
6298
6299       /* Check the sh_link field.  */
6300       switch (section->sh_type)
6301         {
6302         case SHT_SYMTAB_SHNDX:
6303         case SHT_GROUP:
6304         case SHT_HASH:
6305         case SHT_GNU_HASH:
6306         case SHT_GNU_versym:
6307         case SHT_REL:
6308         case SHT_RELA:
6309           if (section->sh_link < 1
6310               || section->sh_link >= filedata->file_header.e_shnum
6311               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6312                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6313             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6314                   i, section->sh_link);
6315           break;
6316
6317         case SHT_DYNAMIC:
6318         case SHT_SYMTAB:
6319         case SHT_DYNSYM:
6320         case SHT_GNU_verneed:
6321         case SHT_GNU_verdef:
6322         case SHT_GNU_LIBLIST:
6323           if (section->sh_link < 1
6324               || section->sh_link >= filedata->file_header.e_shnum
6325               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6326             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6327                   i, section->sh_link);
6328           break;
6329
6330         case SHT_INIT_ARRAY:
6331         case SHT_FINI_ARRAY:
6332         case SHT_PREINIT_ARRAY:
6333           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6334             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6335                   i, section->sh_link);
6336           break;
6337
6338         default:
6339           /* FIXME: Add support for target specific section types.  */
6340 #if 0     /* Currently we do not check other section types as there are too
6341              many special cases.  Stab sections for example have a type
6342              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6343              section.  */
6344           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6345             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6346                   i, section->sh_link);
6347 #endif
6348           break;
6349         }
6350
6351       /* Check the sh_info field.  */
6352       switch (section->sh_type)
6353         {
6354         case SHT_REL:
6355         case SHT_RELA:
6356           if (section->sh_info < 1
6357               || section->sh_info >= filedata->file_header.e_shnum
6358               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6359                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6360                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6361                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6362                   && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6363                   && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6364                   /* FIXME: Are other section types valid ?  */
6365                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6366             {
6367               if (section->sh_info == 0
6368                   && (filedata->file_header.e_type == ET_EXEC
6369                       || filedata->file_header.e_type == ET_DYN
6370                       /* These next two tests may be redundant, but
6371                          they have been left in for paranoia's sake.  */
6372                       || streq (SECTION_NAME (section), ".rel.dyn")
6373                       || streq (SECTION_NAME (section), ".rela.dyn")))
6374                 /* Dynamic relocations apply to segments, not sections, so
6375                    they do not need an sh_info value.  */
6376                 ;
6377               else
6378                 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6379                       i, section->sh_info);
6380             }
6381           break;
6382
6383         case SHT_DYNAMIC:
6384         case SHT_HASH:
6385         case SHT_SYMTAB_SHNDX:
6386         case SHT_INIT_ARRAY:
6387         case SHT_FINI_ARRAY:
6388         case SHT_PREINIT_ARRAY:
6389           if (section->sh_info != 0)
6390             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6391                   i, section->sh_info);
6392           break;
6393
6394         case SHT_GROUP:
6395         case SHT_SYMTAB:
6396         case SHT_DYNSYM:
6397           /* A symbol index - we assume that it is valid.  */
6398           break;
6399
6400         default:
6401           /* FIXME: Add support for target specific section types.  */
6402           if (section->sh_type == SHT_NOBITS)
6403             /* NOBITS section headers with non-zero sh_info fields can be
6404                created when a binary is stripped of everything but its debug
6405                information.  The stripped sections have their headers
6406                preserved but their types set to SHT_NOBITS.  So do not check
6407                this type of section.  */
6408             ;
6409           else if (section->sh_flags & SHF_INFO_LINK)
6410             {
6411               if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6412                 warn (_("[%2u]: Expected link to another section in info field"), i);
6413             }
6414           else if (section->sh_type < SHT_LOOS
6415                    && (section->sh_flags & SHF_GNU_MBIND) == 0
6416                    && section->sh_info != 0)
6417             warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6418                   i, section->sh_info);
6419           break;
6420         }
6421
6422       /* Check the sh_size field.  */
6423       if (section->sh_size > filedata->file_size
6424           && section->sh_type != SHT_NOBITS
6425           && section->sh_type != SHT_NULL
6426           && section->sh_type < SHT_LOOS)
6427         warn (_("Size of section %u is larger than the entire file!\n"), i);
6428
6429       printf ("  [%2u] ", i);
6430       if (do_section_details)
6431         printf ("%s\n      ", printable_section_name (filedata, section));
6432       else
6433         print_symbol (-17, SECTION_NAME (section));
6434
6435       printf (do_wide ? " %-15s " : " %-15.15s ",
6436               get_section_type_name (filedata, section->sh_type));
6437
6438       if (is_32bit_elf)
6439         {
6440           const char * link_too_big = NULL;
6441
6442           print_vma (section->sh_addr, LONG_HEX);
6443
6444           printf ( " %6.6lx %6.6lx %2.2lx",
6445                    (unsigned long) section->sh_offset,
6446                    (unsigned long) section->sh_size,
6447                    (unsigned long) section->sh_entsize);
6448
6449           if (do_section_details)
6450             fputs ("  ", stdout);
6451           else
6452             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6453
6454           if (section->sh_link >= filedata->file_header.e_shnum)
6455             {
6456               link_too_big = "";
6457               /* The sh_link value is out of range.  Normally this indicates
6458                  an error but it can have special values in Solaris binaries.  */
6459               switch (filedata->file_header.e_machine)
6460                 {
6461                 case EM_386:
6462                 case EM_IAMCU:
6463                 case EM_X86_64:
6464                 case EM_L1OM:
6465                 case EM_K1OM:
6466                 case EM_OLD_SPARCV9:
6467                 case EM_SPARC32PLUS:
6468                 case EM_SPARCV9:
6469                 case EM_SPARC:
6470                   if (section->sh_link == (SHN_BEFORE & 0xffff))
6471                     link_too_big = "BEFORE";
6472                   else if (section->sh_link == (SHN_AFTER & 0xffff))
6473                     link_too_big = "AFTER";
6474                   break;
6475                 default:
6476                   break;
6477                 }
6478             }
6479
6480           if (do_section_details)
6481             {
6482               if (link_too_big != NULL && * link_too_big)
6483                 printf ("<%s> ", link_too_big);
6484               else
6485                 printf ("%2u ", section->sh_link);
6486               printf ("%3u %2lu\n", section->sh_info,
6487                       (unsigned long) section->sh_addralign);
6488             }
6489           else
6490             printf ("%2u %3u %2lu\n",
6491                     section->sh_link,
6492                     section->sh_info,
6493                     (unsigned long) section->sh_addralign);
6494
6495           if (link_too_big && ! * link_too_big)
6496             warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6497                   i, section->sh_link);
6498         }
6499       else if (do_wide)
6500         {
6501           print_vma (section->sh_addr, LONG_HEX);
6502
6503           if ((long) section->sh_offset == section->sh_offset)
6504             printf (" %6.6lx", (unsigned long) section->sh_offset);
6505           else
6506             {
6507               putchar (' ');
6508               print_vma (section->sh_offset, LONG_HEX);
6509             }
6510
6511           if ((unsigned long) section->sh_size == section->sh_size)
6512             printf (" %6.6lx", (unsigned long) section->sh_size);
6513           else
6514             {
6515               putchar (' ');
6516               print_vma (section->sh_size, LONG_HEX);
6517             }
6518
6519           if ((unsigned long) section->sh_entsize == section->sh_entsize)
6520             printf (" %2.2lx", (unsigned long) section->sh_entsize);
6521           else
6522             {
6523               putchar (' ');
6524               print_vma (section->sh_entsize, LONG_HEX);
6525             }
6526
6527           if (do_section_details)
6528             fputs ("  ", stdout);
6529           else
6530             printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6531
6532           printf ("%2u %3u ", section->sh_link, section->sh_info);
6533
6534           if ((unsigned long) section->sh_addralign == section->sh_addralign)
6535             printf ("%2lu\n", (unsigned long) section->sh_addralign);
6536           else
6537             {
6538               print_vma (section->sh_addralign, DEC);
6539               putchar ('\n');
6540             }
6541         }
6542       else if (do_section_details)
6543         {
6544           putchar (' ');
6545           print_vma (section->sh_addr, LONG_HEX);
6546           if ((long) section->sh_offset == section->sh_offset)
6547             printf ("  %16.16lx", (unsigned long) section->sh_offset);
6548           else
6549             {
6550               printf ("  ");
6551               print_vma (section->sh_offset, LONG_HEX);
6552             }
6553           printf ("  %u\n       ", section->sh_link);
6554           print_vma (section->sh_size, LONG_HEX);
6555           putchar (' ');
6556           print_vma (section->sh_entsize, LONG_HEX);
6557
6558           printf ("  %-16u  %lu\n",
6559                   section->sh_info,
6560                   (unsigned long) section->sh_addralign);
6561         }
6562       else
6563         {
6564           putchar (' ');
6565           print_vma (section->sh_addr, LONG_HEX);
6566           if ((long) section->sh_offset == section->sh_offset)
6567             printf ("  %8.8lx", (unsigned long) section->sh_offset);
6568           else
6569             {
6570               printf ("  ");
6571               print_vma (section->sh_offset, LONG_HEX);
6572             }
6573           printf ("\n       ");
6574           print_vma (section->sh_size, LONG_HEX);
6575           printf ("  ");
6576           print_vma (section->sh_entsize, LONG_HEX);
6577
6578           printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6579
6580           printf ("     %2u   %3u     %lu\n",
6581                   section->sh_link,
6582                   section->sh_info,
6583                   (unsigned long) section->sh_addralign);
6584         }
6585
6586       if (do_section_details)
6587         {
6588           printf ("       %s\n", get_elf_section_flags (filedata, section->sh_flags));
6589           if ((section->sh_flags & SHF_COMPRESSED) != 0)
6590             {
6591               /* Minimum section size is 12 bytes for 32-bit compression
6592                  header + 12 bytes for compressed data header.  */
6593               unsigned char buf[24];
6594
6595               assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6596               if (get_data (&buf, filedata, section->sh_offset, 1,
6597                             sizeof (buf), _("compression header")))
6598                 {
6599                   Elf_Internal_Chdr chdr;
6600
6601                   (void) get_compression_header (&chdr, buf, sizeof (buf));
6602
6603                   if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6604                     printf ("       ZLIB, ");
6605                   else
6606                     printf (_("       [<unknown>: 0x%x], "),
6607                             chdr.ch_type);
6608                   print_vma (chdr.ch_size, LONG_HEX);
6609                   printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6610                 }
6611             }
6612         }
6613     }
6614
6615   if (!do_section_details)
6616     {
6617       /* The ordering of the letters shown here matches the ordering of the
6618          corresponding SHF_xxx values, and hence the order in which these
6619          letters will be displayed to the user.  */
6620       printf (_("Key to Flags:\n\
6621   W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6622   L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6623   C (compressed), x (unknown), o (OS specific), E (exclude),\n  "));
6624       if (filedata->file_header.e_machine == EM_X86_64
6625           || filedata->file_header.e_machine == EM_L1OM
6626           || filedata->file_header.e_machine == EM_K1OM)
6627         printf (_("l (large), "));
6628       else if (filedata->file_header.e_machine == EM_ARM)
6629         printf (_("y (purecode), "));
6630       else if (filedata->file_header.e_machine == EM_PPC)
6631         printf (_("v (VLE), "));
6632       printf ("p (processor specific)\n");
6633     }
6634
6635   return TRUE;
6636 }
6637
6638 static const char *
6639 get_group_flags (unsigned int flags)
6640 {
6641   static char buff[128];
6642
6643   if (flags == 0)
6644     return "";
6645   else if (flags == GRP_COMDAT)
6646     return "COMDAT ";
6647
6648   snprintf (buff, 14, _("[0x%x: "), flags);
6649
6650   flags &= ~ GRP_COMDAT;
6651   if (flags & GRP_MASKOS)
6652     {
6653       strcat (buff, "<OS specific>");
6654       flags &= ~ GRP_MASKOS;
6655     }
6656
6657   if (flags & GRP_MASKPROC)
6658     {
6659       strcat (buff, "<PROC specific>");
6660       flags &= ~ GRP_MASKPROC;
6661     }
6662
6663   if (flags)
6664     strcat (buff, "<unknown>");
6665
6666   strcat (buff, "]");
6667   return buff;
6668 }
6669
6670 static bfd_boolean
6671 process_section_groups (Filedata * filedata)
6672 {
6673   Elf_Internal_Shdr * section;
6674   unsigned int i;
6675   struct group * group;
6676   Elf_Internal_Shdr * symtab_sec;
6677   Elf_Internal_Shdr * strtab_sec;
6678   Elf_Internal_Sym * symtab;
6679   unsigned long num_syms;
6680   char * strtab;
6681   size_t strtab_size;
6682
6683   /* Don't process section groups unless needed.  */
6684   if (!do_unwind && !do_section_groups)
6685     return TRUE;
6686
6687   if (filedata->file_header.e_shnum == 0)
6688     {
6689       if (do_section_groups)
6690         printf (_("\nThere are no sections to group in this file.\n"));
6691
6692       return TRUE;
6693     }
6694
6695   if (filedata->section_headers == NULL)
6696     {
6697       error (_("Section headers are not available!\n"));
6698       /* PR 13622: This can happen with a corrupt ELF header.  */
6699       return FALSE;
6700     }
6701
6702   section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6703                                                      sizeof (struct group *));
6704
6705   if (section_headers_groups == NULL)
6706     {
6707       error (_("Out of memory reading %u section group headers\n"),
6708              filedata->file_header.e_shnum);
6709       return FALSE;
6710     }
6711
6712   /* Scan the sections for the group section.  */
6713   group_count = 0;
6714   for (i = 0, section = filedata->section_headers;
6715        i < filedata->file_header.e_shnum;
6716        i++, section++)
6717     if (section->sh_type == SHT_GROUP)
6718       group_count++;
6719
6720   if (group_count == 0)
6721     {
6722       if (do_section_groups)
6723         printf (_("\nThere are no section groups in this file.\n"));
6724
6725       return TRUE;
6726     }
6727
6728   section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6729
6730   if (section_groups == NULL)
6731     {
6732       error (_("Out of memory reading %lu groups\n"),
6733              (unsigned long) group_count);
6734       return FALSE;
6735     }
6736
6737   symtab_sec = NULL;
6738   strtab_sec = NULL;
6739   symtab = NULL;
6740   num_syms = 0;
6741   strtab = NULL;
6742   strtab_size = 0;
6743   for (i = 0, section = filedata->section_headers, group = section_groups;
6744        i < filedata->file_header.e_shnum;
6745        i++, section++)
6746     {
6747       if (section->sh_type == SHT_GROUP)
6748         {
6749           const char * name = printable_section_name (filedata, section);
6750           const char * group_name;
6751           unsigned char * start;
6752           unsigned char * indices;
6753           unsigned int entry, j, size;
6754           Elf_Internal_Shdr * sec;
6755           Elf_Internal_Sym * sym;
6756
6757           /* Get the symbol table.  */
6758           if (section->sh_link >= filedata->file_header.e_shnum
6759               || ((sec = filedata->section_headers + section->sh_link)->sh_type
6760                   != SHT_SYMTAB))
6761             {
6762               error (_("Bad sh_link in group section `%s'\n"), name);
6763               continue;
6764             }
6765
6766           if (symtab_sec != sec)
6767             {
6768               symtab_sec = sec;
6769               if (symtab)
6770                 free (symtab);
6771               symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6772             }
6773
6774           if (symtab == NULL)
6775             {
6776               error (_("Corrupt header in group section `%s'\n"), name);
6777               continue;
6778             }
6779
6780           if (section->sh_info >= num_syms)
6781             {
6782               error (_("Bad sh_info in group section `%s'\n"), name);
6783               continue;
6784             }
6785
6786           sym = symtab + section->sh_info;
6787
6788           if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6789             {
6790               if (sym->st_shndx == 0
6791                   || sym->st_shndx >= filedata->file_header.e_shnum)
6792                 {
6793                   error (_("Bad sh_info in group section `%s'\n"), name);
6794                   continue;
6795                 }
6796
6797               group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6798               strtab_sec = NULL;
6799               if (strtab)
6800                 free (strtab);
6801               strtab = NULL;
6802               strtab_size = 0;
6803             }
6804           else
6805             {
6806               /* Get the string table.  */
6807               if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6808                 {
6809                   strtab_sec = NULL;
6810                   if (strtab)
6811                     free (strtab);
6812                   strtab = NULL;
6813                   strtab_size = 0;
6814                 }
6815               else if (strtab_sec
6816                        != (sec = filedata->section_headers + symtab_sec->sh_link))
6817                 {
6818                   strtab_sec = sec;
6819                   if (strtab)
6820                     free (strtab);
6821
6822                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6823                                               1, strtab_sec->sh_size,
6824                                               _("string table"));
6825                   strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6826                 }
6827               group_name = sym->st_name < strtab_size
6828                 ? strtab + sym->st_name : _("<corrupt>");
6829             }
6830
6831           /* PR 17531: file: loop.  */
6832           if (section->sh_entsize > section->sh_size)
6833             {
6834               error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6835                      printable_section_name (filedata, section),
6836                      (unsigned long) section->sh_entsize,
6837                      (unsigned long) section->sh_size);
6838               break;
6839             }
6840
6841           start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6842                                               1, section->sh_size,
6843                                               _("section data"));
6844           if (start == NULL)
6845             continue;
6846
6847           indices = start;
6848           size = (section->sh_size / section->sh_entsize) - 1;
6849           entry = byte_get (indices, 4);
6850           indices += 4;
6851
6852           if (do_section_groups)
6853             {
6854               printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6855                       get_group_flags (entry), i, name, group_name, size);
6856
6857               printf (_("   [Index]    Name\n"));
6858             }
6859
6860           group->group_index = i;
6861
6862           for (j = 0; j < size; j++)
6863             {
6864               struct group_list * g;
6865
6866               entry = byte_get (indices, 4);
6867               indices += 4;
6868
6869               if (entry >= filedata->file_header.e_shnum)
6870                 {
6871                   static unsigned num_group_errors = 0;
6872
6873                   if (num_group_errors ++ < 10)
6874                     {
6875                       error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6876                              entry, i, filedata->file_header.e_shnum - 1);
6877                       if (num_group_errors == 10)
6878                         warn (_("Further error messages about overlarge group section indices suppressed\n"));
6879                     }
6880                   continue;
6881                 }
6882
6883               if (section_headers_groups [entry] != NULL)
6884                 {
6885                   if (entry)
6886                     {
6887                       static unsigned num_errs = 0;
6888
6889                       if (num_errs ++ < 10)
6890                         {
6891                           error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6892                                  entry, i,
6893                                  section_headers_groups [entry]->group_index);
6894                           if (num_errs == 10)
6895                             warn (_("Further error messages about already contained group sections suppressed\n"));
6896                         }
6897                       continue;
6898                     }
6899                   else
6900                     {
6901                       /* Intel C/C++ compiler may put section 0 in a
6902                          section group.  We just warn it the first time
6903                          and ignore it afterwards.  */
6904                       static bfd_boolean warned = FALSE;
6905                       if (!warned)
6906                         {
6907                           error (_("section 0 in group section [%5u]\n"),
6908                                  section_headers_groups [entry]->group_index);
6909                           warned = TRUE;
6910                         }
6911                     }
6912                 }
6913
6914               section_headers_groups [entry] = group;
6915
6916               if (do_section_groups)
6917                 {
6918                   sec = filedata->section_headers + entry;
6919                   printf ("   [%5u]   %s\n", entry, printable_section_name (filedata, sec));
6920                 }
6921
6922               g = (struct group_list *) xmalloc (sizeof (struct group_list));
6923               g->section_index = entry;
6924               g->next = group->root;
6925               group->root = g;
6926             }
6927
6928           if (start)
6929             free (start);
6930
6931           group++;
6932         }
6933     }
6934
6935   if (symtab)
6936     free (symtab);
6937   if (strtab)
6938     free (strtab);
6939   return TRUE;
6940 }
6941
6942 /* Data used to display dynamic fixups.  */
6943
6944 struct ia64_vms_dynfixup
6945 {
6946   bfd_vma needed_ident;         /* Library ident number.  */
6947   bfd_vma needed;               /* Index in the dstrtab of the library name.  */
6948   bfd_vma fixup_needed;         /* Index of the library.  */
6949   bfd_vma fixup_rela_cnt;       /* Number of fixups.  */
6950   bfd_vma fixup_rela_off;       /* Fixups offset in the dynamic segment.  */
6951 };
6952
6953 /* Data used to display dynamic relocations.  */
6954
6955 struct ia64_vms_dynimgrela
6956 {
6957   bfd_vma img_rela_cnt;         /* Number of relocations.  */
6958   bfd_vma img_rela_off;         /* Reloc offset in the dynamic segment.  */
6959 };
6960
6961 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6962    library).  */
6963
6964 static bfd_boolean
6965 dump_ia64_vms_dynamic_fixups (Filedata *                  filedata,
6966                               struct ia64_vms_dynfixup *  fixup,
6967                               const char *                strtab,
6968                               unsigned int                strtab_sz)
6969 {
6970   Elf64_External_VMS_IMAGE_FIXUP * imfs;
6971   long i;
6972   const char * lib_name;
6973
6974   imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6975                    1, fixup->fixup_rela_cnt * sizeof (*imfs),
6976                    _("dynamic section image fixups"));
6977   if (!imfs)
6978     return FALSE;
6979
6980   if (fixup->needed < strtab_sz)
6981     lib_name = strtab + fixup->needed;
6982   else
6983     {
6984       warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6985             (unsigned long) fixup->needed);
6986       lib_name = "???";
6987     }
6988   printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6989           (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6990   printf
6991     (_("Seg Offset           Type                             SymVec DataType\n"));
6992
6993   for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6994     {
6995       unsigned int type;
6996       const char *rtype;
6997
6998       printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6999       printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7000       type = BYTE_GET (imfs [i].type);
7001       rtype = elf_ia64_reloc_type (type);
7002       if (rtype == NULL)
7003         printf (" 0x%08x                       ", type);
7004       else
7005         printf (" %-32s ", rtype);
7006       printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7007       printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7008     }
7009
7010   free (imfs);
7011   return TRUE;
7012 }
7013
7014 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image).  */
7015
7016 static bfd_boolean
7017 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7018 {
7019   Elf64_External_VMS_IMAGE_RELA *imrs;
7020   long i;
7021
7022   imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7023                    1, imgrela->img_rela_cnt * sizeof (*imrs),
7024                    _("dynamic section image relocations"));
7025   if (!imrs)
7026     return FALSE;
7027
7028   printf (_("\nImage relocs\n"));
7029   printf
7030     (_("Seg Offset   Type                            Addend            Seg Sym Off\n"));
7031
7032   for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7033     {
7034       unsigned int type;
7035       const char *rtype;
7036
7037       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7038       printf ("%08" BFD_VMA_FMT "x ",
7039               (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7040       type = BYTE_GET (imrs [i].type);
7041       rtype = elf_ia64_reloc_type (type);
7042       if (rtype == NULL)
7043         printf ("0x%08x                      ", type);
7044       else
7045         printf ("%-31s ", rtype);
7046       print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7047       printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7048       printf ("%08" BFD_VMA_FMT "x\n",
7049               (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7050     }
7051
7052   free (imrs);
7053   return TRUE;
7054 }
7055
7056 /* Display IA-64 OpenVMS dynamic relocations and fixups.  */
7057
7058 static bfd_boolean
7059 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7060 {
7061   struct ia64_vms_dynfixup fixup;
7062   struct ia64_vms_dynimgrela imgrela;
7063   Elf_Internal_Dyn *entry;
7064   bfd_vma strtab_off = 0;
7065   bfd_vma strtab_sz = 0;
7066   char *strtab = NULL;
7067   bfd_boolean res = TRUE;
7068
7069   memset (&fixup, 0, sizeof (fixup));
7070   memset (&imgrela, 0, sizeof (imgrela));
7071
7072   /* Note: the order of the entries is specified by the OpenVMS specs.  */
7073   for (entry = dynamic_section;
7074        entry < dynamic_section + dynamic_nent;
7075        entry++)
7076     {
7077       switch (entry->d_tag)
7078         {
7079         case DT_IA_64_VMS_STRTAB_OFFSET:
7080           strtab_off = entry->d_un.d_val;
7081           break;
7082         case DT_STRSZ:
7083           strtab_sz = entry->d_un.d_val;
7084           if (strtab == NULL)
7085             strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7086                                1, strtab_sz, _("dynamic string section"));
7087           break;
7088
7089         case DT_IA_64_VMS_NEEDED_IDENT:
7090           fixup.needed_ident = entry->d_un.d_val;
7091           break;
7092         case DT_NEEDED:
7093           fixup.needed = entry->d_un.d_val;
7094           break;
7095         case DT_IA_64_VMS_FIXUP_NEEDED:
7096           fixup.fixup_needed = entry->d_un.d_val;
7097           break;
7098         case DT_IA_64_VMS_FIXUP_RELA_CNT:
7099           fixup.fixup_rela_cnt = entry->d_un.d_val;
7100           break;
7101         case DT_IA_64_VMS_FIXUP_RELA_OFF:
7102           fixup.fixup_rela_off = entry->d_un.d_val;
7103           if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7104             res = FALSE;
7105           break;
7106         case DT_IA_64_VMS_IMG_RELA_CNT:
7107           imgrela.img_rela_cnt = entry->d_un.d_val;
7108           break;
7109         case DT_IA_64_VMS_IMG_RELA_OFF:
7110           imgrela.img_rela_off = entry->d_un.d_val;
7111           if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7112             res = FALSE;
7113           break;
7114
7115         default:
7116           break;
7117         }
7118     }
7119
7120   if (strtab != NULL)
7121     free (strtab);
7122
7123   return res;
7124 }
7125
7126 static struct
7127 {
7128   const char * name;
7129   int reloc;
7130   int size;
7131   int rela;
7132 }
7133   dynamic_relocations [] =
7134 {
7135   { "REL", DT_REL, DT_RELSZ, FALSE },
7136   { "RELA", DT_RELA, DT_RELASZ, TRUE },
7137   { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7138 };
7139
7140 /* Process the reloc section.  */
7141
7142 static bfd_boolean
7143 process_relocs (Filedata * filedata)
7144 {
7145   unsigned long rel_size;
7146   unsigned long rel_offset;
7147
7148   if (!do_reloc)
7149     return TRUE;
7150
7151   if (do_using_dynamic)
7152     {
7153       int          is_rela;
7154       const char * name;
7155       bfd_boolean  has_dynamic_reloc;
7156       unsigned int i;
7157
7158       has_dynamic_reloc = FALSE;
7159
7160       for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7161         {
7162           is_rela = dynamic_relocations [i].rela;
7163           name = dynamic_relocations [i].name;
7164           rel_size = dynamic_info [dynamic_relocations [i].size];
7165           rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7166
7167           if (rel_size)
7168             has_dynamic_reloc = TRUE;
7169
7170           if (is_rela == UNKNOWN)
7171             {
7172               if (dynamic_relocations [i].reloc == DT_JMPREL)
7173                 switch (dynamic_info[DT_PLTREL])
7174                   {
7175                   case DT_REL:
7176                     is_rela = FALSE;
7177                     break;
7178                   case DT_RELA:
7179                     is_rela = TRUE;
7180                     break;
7181                   }
7182             }
7183
7184           if (rel_size)
7185             {
7186               printf
7187                 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7188                  name, rel_offset, rel_size);
7189
7190               dump_relocations (filedata,
7191                                 offset_from_vma (filedata, rel_offset, rel_size),
7192                                 rel_size,
7193                                 dynamic_symbols, num_dynamic_syms,
7194                                 dynamic_strings, dynamic_strings_length,
7195                                 is_rela, TRUE /* is_dynamic */);
7196             }
7197         }
7198
7199       if (is_ia64_vms (filedata))
7200         if (process_ia64_vms_dynamic_relocs (filedata))
7201           has_dynamic_reloc = TRUE;
7202
7203       if (! has_dynamic_reloc)
7204         printf (_("\nThere are no dynamic relocations in this file.\n"));
7205     }
7206   else
7207     {
7208       Elf_Internal_Shdr * section;
7209       unsigned long i;
7210       bfd_boolean found = FALSE;
7211
7212       for (i = 0, section = filedata->section_headers;
7213            i < filedata->file_header.e_shnum;
7214            i++, section++)
7215         {
7216           if (   section->sh_type != SHT_RELA
7217               && section->sh_type != SHT_REL)
7218             continue;
7219
7220           rel_offset = section->sh_offset;
7221           rel_size   = section->sh_size;
7222
7223           if (rel_size)
7224             {
7225               Elf_Internal_Shdr * strsec;
7226               int is_rela;
7227               unsigned long num_rela;
7228
7229               printf (_("\nRelocation section "));
7230
7231               if (filedata->string_table == NULL)
7232                 printf ("%d", section->sh_name);
7233               else
7234                 printf ("'%s'", printable_section_name (filedata, section));
7235
7236               num_rela = rel_size / section->sh_entsize;
7237               printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7238                                 " at offset 0x%lx contains %lu entries:\n",
7239                                 num_rela),
7240                       rel_offset, num_rela);
7241
7242               is_rela = section->sh_type == SHT_RELA;
7243
7244               if (section->sh_link != 0
7245                   && section->sh_link < filedata->file_header.e_shnum)
7246                 {
7247                   Elf_Internal_Shdr * symsec;
7248                   Elf_Internal_Sym *  symtab;
7249                   unsigned long nsyms;
7250                   unsigned long strtablen = 0;
7251                   char * strtab = NULL;
7252
7253                   symsec = filedata->section_headers + section->sh_link;
7254                   if (symsec->sh_type != SHT_SYMTAB
7255                       && symsec->sh_type != SHT_DYNSYM)
7256                     continue;
7257
7258                   symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7259
7260                   if (symtab == NULL)
7261                     continue;
7262
7263                   if (symsec->sh_link != 0
7264                       && symsec->sh_link < filedata->file_header.e_shnum)
7265                     {
7266                       strsec = filedata->section_headers + symsec->sh_link;
7267
7268                       strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7269                                                   1, strsec->sh_size,
7270                                                   _("string table"));
7271                       strtablen = strtab == NULL ? 0 : strsec->sh_size;
7272                     }
7273
7274                   dump_relocations (filedata, rel_offset, rel_size,
7275                                     symtab, nsyms, strtab, strtablen,
7276                                     is_rela,
7277                                     symsec->sh_type == SHT_DYNSYM);
7278                   if (strtab)
7279                     free (strtab);
7280                   free (symtab);
7281                 }
7282               else
7283                 dump_relocations (filedata, rel_offset, rel_size,
7284                                   NULL, 0, NULL, 0, is_rela,
7285                                   FALSE /* is_dynamic */);
7286
7287               found = TRUE;
7288             }
7289         }
7290
7291       if (! found)
7292         {
7293           /* Users sometimes forget the -D option, so try to be helpful.  */
7294           for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7295             {
7296               if (dynamic_info [dynamic_relocations [i].size])
7297                 {
7298                   printf (_("\nThere are no static relocations in this file."));
7299                   printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7300
7301                   break;
7302                 }
7303             }
7304           if (i == ARRAY_SIZE (dynamic_relocations))
7305             printf (_("\nThere are no relocations in this file.\n"));
7306         }
7307     }
7308
7309   return TRUE;
7310 }
7311
7312 /* An absolute address consists of a section and an offset.  If the
7313    section is NULL, the offset itself is the address, otherwise, the
7314    address equals to LOAD_ADDRESS(section) + offset.  */
7315
7316 struct absaddr
7317 {
7318   unsigned short section;
7319   bfd_vma offset;
7320 };
7321
7322 #define ABSADDR(a) \
7323   ((a).section \
7324    ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7325    : (a).offset)
7326
7327 /* Find the nearest symbol at or below ADDR.  Returns the symbol
7328    name, if found, and the offset from the symbol to ADDR.  */
7329
7330 static void
7331 find_symbol_for_address (Filedata *          filedata,
7332                          Elf_Internal_Sym *  symtab,
7333                          unsigned long       nsyms,
7334                          const char *        strtab,
7335                          unsigned long       strtab_size,
7336                          struct absaddr      addr,
7337                          const char **       symname,
7338                          bfd_vma *           offset)
7339 {
7340   bfd_vma dist = 0x100000;
7341   Elf_Internal_Sym * sym;
7342   Elf_Internal_Sym * beg;
7343   Elf_Internal_Sym * end;
7344   Elf_Internal_Sym * best = NULL;
7345
7346   REMOVE_ARCH_BITS (addr.offset);
7347   beg = symtab;
7348   end = symtab + nsyms;
7349
7350   while (beg < end)
7351     {
7352       bfd_vma value;
7353
7354       sym = beg + (end - beg) / 2;
7355
7356       value = sym->st_value;
7357       REMOVE_ARCH_BITS (value);
7358
7359       if (sym->st_name != 0
7360           && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7361           && addr.offset >= value
7362           && addr.offset - value < dist)
7363         {
7364           best = sym;
7365           dist = addr.offset - value;
7366           if (!dist)
7367             break;
7368         }
7369
7370       if (addr.offset < value)
7371         end = sym;
7372       else
7373         beg = sym + 1;
7374     }
7375
7376   if (best)
7377     {
7378       *symname = (best->st_name >= strtab_size
7379                   ? _("<corrupt>") : strtab + best->st_name);
7380       *offset = dist;
7381       return;
7382     }
7383
7384   *symname = NULL;
7385   *offset = addr.offset;
7386 }
7387
7388 static /* signed */ int
7389 symcmp (const void *p, const void *q)
7390 {
7391   Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7392   Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7393
7394   return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7395 }
7396
7397 /* Process the unwind section.  */
7398
7399 #include "unwind-ia64.h"
7400
7401 struct ia64_unw_table_entry
7402 {
7403   struct absaddr start;
7404   struct absaddr end;
7405   struct absaddr info;
7406 };
7407
7408 struct ia64_unw_aux_info
7409 {
7410   struct ia64_unw_table_entry * table;          /* Unwind table.  */
7411   unsigned long                 table_len;      /* Length of unwind table.  */
7412   unsigned char *               info;           /* Unwind info.  */
7413   unsigned long                 info_size;      /* Size of unwind info.  */
7414   bfd_vma                       info_addr;      /* Starting address of unwind info.  */
7415   bfd_vma                       seg_base;       /* Starting address of segment.  */
7416   Elf_Internal_Sym *            symtab;         /* The symbol table.  */
7417   unsigned long                 nsyms;          /* Number of symbols.  */
7418   Elf_Internal_Sym *            funtab;         /* Sorted table of STT_FUNC symbols.  */
7419   unsigned long                 nfuns;          /* Number of entries in funtab.  */
7420   char *                        strtab;         /* The string table.  */
7421   unsigned long                 strtab_size;    /* Size of string table.  */
7422 };
7423
7424 static bfd_boolean
7425 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7426 {
7427   struct ia64_unw_table_entry * tp;
7428   unsigned long j, nfuns;
7429   int in_body;
7430   bfd_boolean res = TRUE;
7431
7432   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7433   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7434     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7435       aux->funtab[nfuns++] = aux->symtab[j];
7436   aux->nfuns = nfuns;
7437   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7438
7439   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7440     {
7441       bfd_vma stamp;
7442       bfd_vma offset;
7443       const unsigned char * dp;
7444       const unsigned char * head;
7445       const unsigned char * end;
7446       const char * procname;
7447
7448       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7449                                aux->strtab_size, tp->start, &procname, &offset);
7450
7451       fputs ("\n<", stdout);
7452
7453       if (procname)
7454         {
7455           fputs (procname, stdout);
7456
7457           if (offset)
7458             printf ("+%lx", (unsigned long) offset);
7459         }
7460
7461       fputs (">: [", stdout);
7462       print_vma (tp->start.offset, PREFIX_HEX);
7463       fputc ('-', stdout);
7464       print_vma (tp->end.offset, PREFIX_HEX);
7465       printf ("], info at +0x%lx\n",
7466               (unsigned long) (tp->info.offset - aux->seg_base));
7467
7468       /* PR 17531: file: 86232b32.  */
7469       if (aux->info == NULL)
7470         continue;
7471
7472       /* PR 17531: file: 0997b4d1.  */
7473       if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7474         {
7475           warn (_("Invalid offset %lx in table entry %ld\n"),
7476                 (long) tp->info.offset, (long) (tp - aux->table));
7477           res = FALSE;
7478           continue;
7479         }
7480
7481       head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7482       stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7483
7484       printf ("  v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7485               (unsigned) UNW_VER (stamp),
7486               (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7487               UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7488               UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7489               (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7490
7491       if (UNW_VER (stamp) != 1)
7492         {
7493           printf (_("\tUnknown version.\n"));
7494           continue;
7495         }
7496
7497       in_body = 0;
7498       end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7499       /* PR 17531: file: 16ceda89.  */
7500       if (end > aux->info + aux->info_size)
7501         end = aux->info + aux->info_size;
7502       for (dp = head + 8; dp < end;)
7503         dp = unw_decode (dp, in_body, & in_body, end);
7504     }
7505
7506   free (aux->funtab);
7507
7508   return res;
7509 }
7510
7511 static bfd_boolean
7512 slurp_ia64_unwind_table (Filedata *                  filedata,
7513                          struct ia64_unw_aux_info *  aux,
7514                          Elf_Internal_Shdr *         sec)
7515 {
7516   unsigned long size, nrelas, i;
7517   Elf_Internal_Phdr * seg;
7518   struct ia64_unw_table_entry * tep;
7519   Elf_Internal_Shdr * relsec;
7520   Elf_Internal_Rela * rela;
7521   Elf_Internal_Rela * rp;
7522   unsigned char * table;
7523   unsigned char * tp;
7524   Elf_Internal_Sym * sym;
7525   const char * relname;
7526
7527   aux->table_len = 0;
7528
7529   /* First, find the starting address of the segment that includes
7530      this section: */
7531
7532   if (filedata->file_header.e_phnum)
7533     {
7534       if (! get_program_headers (filedata))
7535           return FALSE;
7536
7537       for (seg = filedata->program_headers;
7538            seg < filedata->program_headers + filedata->file_header.e_phnum;
7539            ++seg)
7540         {
7541           if (seg->p_type != PT_LOAD)
7542             continue;
7543
7544           if (sec->sh_addr >= seg->p_vaddr
7545               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7546             {
7547               aux->seg_base = seg->p_vaddr;
7548               break;
7549             }
7550         }
7551     }
7552
7553   /* Second, build the unwind table from the contents of the unwind section:  */
7554   size = sec->sh_size;
7555   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7556                                       _("unwind table"));
7557   if (!table)
7558     return FALSE;
7559
7560   aux->table_len = size / (3 * eh_addr_size);
7561   aux->table = (struct ia64_unw_table_entry *)
7562     xcmalloc (aux->table_len, sizeof (aux->table[0]));
7563   tep = aux->table;
7564
7565   for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7566     {
7567       tep->start.section = SHN_UNDEF;
7568       tep->end.section   = SHN_UNDEF;
7569       tep->info.section  = SHN_UNDEF;
7570       tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7571       tep->end.offset   = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7572       tep->info.offset  = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7573       tep->start.offset += aux->seg_base;
7574       tep->end.offset   += aux->seg_base;
7575       tep->info.offset  += aux->seg_base;
7576     }
7577   free (table);
7578
7579   /* Third, apply any relocations to the unwind table:  */
7580   for (relsec = filedata->section_headers;
7581        relsec < filedata->section_headers + filedata->file_header.e_shnum;
7582        ++relsec)
7583     {
7584       if (relsec->sh_type != SHT_RELA
7585           || relsec->sh_info >= filedata->file_header.e_shnum
7586           || filedata->section_headers + relsec->sh_info != sec)
7587         continue;
7588
7589       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7590                               & rela, & nrelas))
7591         {
7592           free (aux->table);
7593           aux->table = NULL;
7594           aux->table_len = 0;
7595           return FALSE;
7596         }
7597
7598       for (rp = rela; rp < rela + nrelas; ++rp)
7599         {
7600           relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7601           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7602
7603           /* PR 17531: file: 9fa67536.  */
7604           if (relname == NULL)
7605             {
7606               warn (_("Skipping unknown relocation type: %u\n"),
7607                     get_reloc_type (filedata, rp->r_info));
7608               continue;
7609             }
7610
7611           if (! const_strneq (relname, "R_IA64_SEGREL"))
7612             {
7613               warn (_("Skipping unexpected relocation type: %s\n"), relname);
7614               continue;
7615             }
7616
7617           i = rp->r_offset / (3 * eh_addr_size);
7618
7619           /* PR 17531: file: 5bc8d9bf.  */
7620           if (i >= aux->table_len)
7621             {
7622               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7623               continue;
7624             }
7625
7626           switch (rp->r_offset / eh_addr_size % 3)
7627             {
7628             case 0:
7629               aux->table[i].start.section = sym->st_shndx;
7630               aux->table[i].start.offset  = rp->r_addend + sym->st_value;
7631               break;
7632             case 1:
7633               aux->table[i].end.section   = sym->st_shndx;
7634               aux->table[i].end.offset    = rp->r_addend + sym->st_value;
7635               break;
7636             case 2:
7637               aux->table[i].info.section  = sym->st_shndx;
7638               aux->table[i].info.offset   = rp->r_addend + sym->st_value;
7639               break;
7640             default:
7641               break;
7642             }
7643         }
7644
7645       free (rela);
7646     }
7647
7648   return TRUE;
7649 }
7650
7651 static bfd_boolean
7652 ia64_process_unwind (Filedata * filedata)
7653 {
7654   Elf_Internal_Shdr * sec;
7655   Elf_Internal_Shdr * unwsec = NULL;
7656   Elf_Internal_Shdr * strsec;
7657   unsigned long i, unwcount = 0, unwstart = 0;
7658   struct ia64_unw_aux_info aux;
7659   bfd_boolean res = TRUE;
7660
7661   memset (& aux, 0, sizeof (aux));
7662
7663   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7664     {
7665       if (sec->sh_type == SHT_SYMTAB
7666           && sec->sh_link < filedata->file_header.e_shnum)
7667         {
7668           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7669
7670           strsec = filedata->section_headers + sec->sh_link;
7671           if (aux.strtab != NULL)
7672             {
7673               error (_("Multiple auxillary string tables encountered\n"));
7674               free (aux.strtab);
7675               res = FALSE;
7676             }
7677           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7678                                           1, strsec->sh_size,
7679                                           _("string table"));
7680           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7681         }
7682       else if (sec->sh_type == SHT_IA_64_UNWIND)
7683         unwcount++;
7684     }
7685
7686   if (!unwcount)
7687     printf (_("\nThere are no unwind sections in this file.\n"));
7688
7689   while (unwcount-- > 0)
7690     {
7691       char * suffix;
7692       size_t len, len2;
7693
7694       for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7695            i < filedata->file_header.e_shnum; ++i, ++sec)
7696         if (sec->sh_type == SHT_IA_64_UNWIND)
7697           {
7698             unwsec = sec;
7699             break;
7700           }
7701       /* We have already counted the number of SHT_IA64_UNWIND
7702          sections so the loop above should never fail.  */
7703       assert (unwsec != NULL);
7704
7705       unwstart = i + 1;
7706       len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7707
7708       if ((unwsec->sh_flags & SHF_GROUP) != 0)
7709         {
7710           /* We need to find which section group it is in.  */
7711           struct group_list * g;
7712
7713           if (section_headers_groups == NULL
7714               || section_headers_groups [i] == NULL)
7715             i = filedata->file_header.e_shnum;
7716           else
7717             {
7718               g = section_headers_groups [i]->root;
7719
7720               for (; g != NULL; g = g->next)
7721                 {
7722                   sec = filedata->section_headers + g->section_index;
7723
7724                   if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7725                     break;
7726                 }
7727
7728               if (g == NULL)
7729                 i = filedata->file_header.e_shnum;
7730             }
7731         }
7732       else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7733         {
7734           /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO.  */
7735           len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7736           suffix = SECTION_NAME (unwsec) + len;
7737           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7738                ++i, ++sec)
7739             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7740                 && streq (SECTION_NAME (sec) + len2, suffix))
7741               break;
7742         }
7743       else
7744         {
7745           /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7746              .IA_64.unwind or BAR -> .IA_64.unwind_info.  */
7747           len = sizeof (ELF_STRING_ia64_unwind) - 1;
7748           len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7749           suffix = "";
7750           if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7751             suffix = SECTION_NAME (unwsec) + len;
7752           for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7753                ++i, ++sec)
7754             if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7755                 && streq (SECTION_NAME (sec) + len2, suffix))
7756               break;
7757         }
7758
7759       if (i == filedata->file_header.e_shnum)
7760         {
7761           printf (_("\nCould not find unwind info section for "));
7762
7763           if (filedata->string_table == NULL)
7764             printf ("%d", unwsec->sh_name);
7765           else
7766             printf ("'%s'", printable_section_name (filedata, unwsec));
7767         }
7768       else
7769         {
7770           aux.info_addr = sec->sh_addr;
7771           aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7772                                                  sec->sh_size,
7773                                                  _("unwind info"));
7774           aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7775
7776           printf (_("\nUnwind section "));
7777
7778           if (filedata->string_table == NULL)
7779             printf ("%d", unwsec->sh_name);
7780           else
7781             printf ("'%s'", printable_section_name (filedata, unwsec));
7782
7783           printf (_(" at offset 0x%lx contains %lu entries:\n"),
7784                   (unsigned long) unwsec->sh_offset,
7785                   (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7786
7787           if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7788               && aux.table_len > 0)
7789             dump_ia64_unwind (filedata, & aux);
7790
7791           if (aux.table)
7792             free ((char *) aux.table);
7793           if (aux.info)
7794             free ((char *) aux.info);
7795           aux.table = NULL;
7796           aux.info = NULL;
7797         }
7798     }
7799
7800   if (aux.symtab)
7801     free (aux.symtab);
7802   if (aux.strtab)
7803     free ((char *) aux.strtab);
7804
7805   return res;
7806 }
7807
7808 struct hppa_unw_table_entry
7809 {
7810   struct absaddr start;
7811   struct absaddr end;
7812   unsigned int Cannot_unwind:1;                 /* 0 */
7813   unsigned int Millicode:1;                     /* 1 */
7814   unsigned int Millicode_save_sr0:1;            /* 2 */
7815   unsigned int Region_description:2;            /* 3..4 */
7816   unsigned int reserved1:1;                     /* 5 */
7817   unsigned int Entry_SR:1;                      /* 6 */
7818   unsigned int Entry_FR:4;     /* Number saved     7..10 */
7819   unsigned int Entry_GR:5;     /* Number saved     11..15 */
7820   unsigned int Args_stored:1;                   /* 16 */
7821   unsigned int Variable_Frame:1;                /* 17 */
7822   unsigned int Separate_Package_Body:1;         /* 18 */
7823   unsigned int Frame_Extension_Millicode:1;     /* 19 */
7824   unsigned int Stack_Overflow_Check:1;          /* 20 */
7825   unsigned int Two_Instruction_SP_Increment:1;  /* 21 */
7826   unsigned int Ada_Region:1;                    /* 22 */
7827   unsigned int cxx_info:1;                      /* 23 */
7828   unsigned int cxx_try_catch:1;                 /* 24 */
7829   unsigned int sched_entry_seq:1;               /* 25 */
7830   unsigned int reserved2:1;                     /* 26 */
7831   unsigned int Save_SP:1;                       /* 27 */
7832   unsigned int Save_RP:1;                       /* 28 */
7833   unsigned int Save_MRP_in_frame:1;             /* 29 */
7834   unsigned int extn_ptr_defined:1;              /* 30 */
7835   unsigned int Cleanup_defined:1;               /* 31 */
7836
7837   unsigned int MPE_XL_interrupt_marker:1;       /* 0 */
7838   unsigned int HP_UX_interrupt_marker:1;        /* 1 */
7839   unsigned int Large_frame:1;                   /* 2 */
7840   unsigned int Pseudo_SP_Set:1;                 /* 3 */
7841   unsigned int reserved4:1;                     /* 4 */
7842   unsigned int Total_frame_size:27;             /* 5..31 */
7843 };
7844
7845 struct hppa_unw_aux_info
7846 {
7847   struct hppa_unw_table_entry *  table;         /* Unwind table.  */
7848   unsigned long                  table_len;     /* Length of unwind table.  */
7849   bfd_vma                        seg_base;      /* Starting address of segment.  */
7850   Elf_Internal_Sym *             symtab;        /* The symbol table.  */
7851   unsigned long                  nsyms;         /* Number of symbols.  */
7852   Elf_Internal_Sym *             funtab;        /* Sorted table of STT_FUNC symbols.  */
7853   unsigned long                  nfuns;         /* Number of entries in funtab.  */
7854   char *                         strtab;        /* The string table.  */
7855   unsigned long                  strtab_size;   /* Size of string table.  */
7856 };
7857
7858 static bfd_boolean
7859 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7860 {
7861   struct hppa_unw_table_entry * tp;
7862   unsigned long j, nfuns;
7863   bfd_boolean res = TRUE;
7864
7865   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7866   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7867     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7868       aux->funtab[nfuns++] = aux->symtab[j];
7869   aux->nfuns = nfuns;
7870   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7871
7872   for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7873     {
7874       bfd_vma offset;
7875       const char * procname;
7876
7877       find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7878                                aux->strtab_size, tp->start, &procname,
7879                                &offset);
7880
7881       fputs ("\n<", stdout);
7882
7883       if (procname)
7884         {
7885           fputs (procname, stdout);
7886
7887           if (offset)
7888             printf ("+%lx", (unsigned long) offset);
7889         }
7890
7891       fputs (">: [", stdout);
7892       print_vma (tp->start.offset, PREFIX_HEX);
7893       fputc ('-', stdout);
7894       print_vma (tp->end.offset, PREFIX_HEX);
7895       printf ("]\n\t");
7896
7897 #define PF(_m) if (tp->_m) printf (#_m " ");
7898 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7899       PF(Cannot_unwind);
7900       PF(Millicode);
7901       PF(Millicode_save_sr0);
7902       /* PV(Region_description);  */
7903       PF(Entry_SR);
7904       PV(Entry_FR);
7905       PV(Entry_GR);
7906       PF(Args_stored);
7907       PF(Variable_Frame);
7908       PF(Separate_Package_Body);
7909       PF(Frame_Extension_Millicode);
7910       PF(Stack_Overflow_Check);
7911       PF(Two_Instruction_SP_Increment);
7912       PF(Ada_Region);
7913       PF(cxx_info);
7914       PF(cxx_try_catch);
7915       PF(sched_entry_seq);
7916       PF(Save_SP);
7917       PF(Save_RP);
7918       PF(Save_MRP_in_frame);
7919       PF(extn_ptr_defined);
7920       PF(Cleanup_defined);
7921       PF(MPE_XL_interrupt_marker);
7922       PF(HP_UX_interrupt_marker);
7923       PF(Large_frame);
7924       PF(Pseudo_SP_Set);
7925       PV(Total_frame_size);
7926 #undef PF
7927 #undef PV
7928     }
7929
7930   printf ("\n");
7931
7932   free (aux->funtab);
7933
7934   return res;
7935 }
7936
7937 static bfd_boolean
7938 slurp_hppa_unwind_table (Filedata *                  filedata,
7939                          struct hppa_unw_aux_info *  aux,
7940                          Elf_Internal_Shdr *         sec)
7941 {
7942   unsigned long size, unw_ent_size, nentries, nrelas, i;
7943   Elf_Internal_Phdr * seg;
7944   struct hppa_unw_table_entry * tep;
7945   Elf_Internal_Shdr * relsec;
7946   Elf_Internal_Rela * rela;
7947   Elf_Internal_Rela * rp;
7948   unsigned char * table;
7949   unsigned char * tp;
7950   Elf_Internal_Sym * sym;
7951   const char * relname;
7952
7953   /* First, find the starting address of the segment that includes
7954      this section.  */
7955   if (filedata->file_header.e_phnum)
7956     {
7957       if (! get_program_headers (filedata))
7958         return FALSE;
7959
7960       for (seg = filedata->program_headers;
7961            seg < filedata->program_headers + filedata->file_header.e_phnum;
7962            ++seg)
7963         {
7964           if (seg->p_type != PT_LOAD)
7965             continue;
7966
7967           if (sec->sh_addr >= seg->p_vaddr
7968               && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7969             {
7970               aux->seg_base = seg->p_vaddr;
7971               break;
7972             }
7973         }
7974     }
7975
7976   /* Second, build the unwind table from the contents of the unwind
7977      section.  */
7978   size = sec->sh_size;
7979   table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7980                                       _("unwind table"));
7981   if (!table)
7982     return FALSE;
7983
7984   unw_ent_size = 16;
7985   nentries = size / unw_ent_size;
7986   size = unw_ent_size * nentries;
7987
7988   tep = aux->table = (struct hppa_unw_table_entry *)
7989       xcmalloc (nentries, sizeof (aux->table[0]));
7990
7991   for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7992     {
7993       unsigned int tmp1, tmp2;
7994
7995       tep->start.section = SHN_UNDEF;
7996       tep->end.section   = SHN_UNDEF;
7997
7998       tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7999       tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8000       tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8001       tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8002
8003       tep->start.offset += aux->seg_base;
8004       tep->end.offset   += aux->seg_base;
8005
8006       tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8007       tep->Millicode = (tmp1 >> 30) & 0x1;
8008       tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8009       tep->Region_description = (tmp1 >> 27) & 0x3;
8010       tep->reserved1 = (tmp1 >> 26) & 0x1;
8011       tep->Entry_SR = (tmp1 >> 25) & 0x1;
8012       tep->Entry_FR = (tmp1 >> 21) & 0xf;
8013       tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8014       tep->Args_stored = (tmp1 >> 15) & 0x1;
8015       tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8016       tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8017       tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8018       tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8019       tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8020       tep->Ada_Region = (tmp1 >> 9) & 0x1;
8021       tep->cxx_info = (tmp1 >> 8) & 0x1;
8022       tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8023       tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8024       tep->reserved2 = (tmp1 >> 5) & 0x1;
8025       tep->Save_SP = (tmp1 >> 4) & 0x1;
8026       tep->Save_RP = (tmp1 >> 3) & 0x1;
8027       tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8028       tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8029       tep->Cleanup_defined = tmp1 & 0x1;
8030
8031       tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8032       tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8033       tep->Large_frame = (tmp2 >> 29) & 0x1;
8034       tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8035       tep->reserved4 = (tmp2 >> 27) & 0x1;
8036       tep->Total_frame_size = tmp2 & 0x7ffffff;
8037     }
8038   free (table);
8039
8040   /* Third, apply any relocations to the unwind table.  */
8041   for (relsec = filedata->section_headers;
8042        relsec < filedata->section_headers + filedata->file_header.e_shnum;
8043        ++relsec)
8044     {
8045       if (relsec->sh_type != SHT_RELA
8046           || relsec->sh_info >= filedata->file_header.e_shnum
8047           || filedata->section_headers + relsec->sh_info != sec)
8048         continue;
8049
8050       if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8051                               & rela, & nrelas))
8052         return FALSE;
8053
8054       for (rp = rela; rp < rela + nrelas; ++rp)
8055         {
8056           relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
8057           sym = aux->symtab + get_reloc_symindex (rp->r_info);
8058
8059           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
8060           if (! const_strneq (relname, "R_PARISC_SEGREL"))
8061             {
8062               warn (_("Skipping unexpected relocation type %s\n"), relname);
8063               continue;
8064             }
8065
8066           i = rp->r_offset / unw_ent_size;
8067
8068           switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
8069             {
8070             case 0:
8071               aux->table[i].start.section = sym->st_shndx;
8072               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
8073               break;
8074             case 1:
8075               aux->table[i].end.section   = sym->st_shndx;
8076               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
8077               break;
8078             default:
8079               break;
8080             }
8081         }
8082
8083       free (rela);
8084     }
8085
8086   aux->table_len = nentries;
8087
8088   return TRUE;
8089 }
8090
8091 static bfd_boolean
8092 hppa_process_unwind (Filedata * filedata)
8093 {
8094   struct hppa_unw_aux_info aux;
8095   Elf_Internal_Shdr * unwsec = NULL;
8096   Elf_Internal_Shdr * strsec;
8097   Elf_Internal_Shdr * sec;
8098   unsigned long i;
8099   bfd_boolean res = TRUE;
8100
8101   if (filedata->string_table == NULL)
8102     return FALSE;
8103
8104   memset (& aux, 0, sizeof (aux));
8105
8106   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8107     {
8108       if (sec->sh_type == SHT_SYMTAB
8109           && sec->sh_link < filedata->file_header.e_shnum)
8110         {
8111           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8112
8113           strsec = filedata->section_headers + sec->sh_link;
8114           if (aux.strtab != NULL)
8115             {
8116               error (_("Multiple auxillary string tables encountered\n"));
8117               free (aux.strtab);
8118               res = FALSE;
8119             }
8120           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8121                                           1, strsec->sh_size,
8122                                           _("string table"));
8123           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8124         }
8125       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8126         unwsec = sec;
8127     }
8128
8129   if (!unwsec)
8130     printf (_("\nThere are no unwind sections in this file.\n"));
8131
8132   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8133     {
8134       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8135         {
8136           unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8137
8138           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8139                             "contains %lu entry:\n",
8140                             "\nUnwind section '%s' at offset 0x%lx "
8141                             "contains %lu entries:\n",
8142                             num_unwind),
8143                   printable_section_name (filedata, sec),
8144                   (unsigned long) sec->sh_offset,
8145                   num_unwind);
8146
8147           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8148             res = FALSE;
8149
8150           if (res && aux.table_len > 0)
8151             {
8152               if (! dump_hppa_unwind (filedata, &aux))
8153                 res = FALSE;
8154             }
8155
8156           if (aux.table)
8157             free ((char *) aux.table);
8158           aux.table = NULL;
8159         }
8160     }
8161
8162   if (aux.symtab)
8163     free (aux.symtab);
8164   if (aux.strtab)
8165     free ((char *) aux.strtab);
8166
8167   return res;
8168 }
8169
8170 struct arm_section
8171 {
8172   unsigned char *      data;            /* The unwind data.  */
8173   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8174   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8175   unsigned long        nrelas;          /* The number of relocations.  */
8176   unsigned int         rel_type;        /* REL or RELA ?  */
8177   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8178 };
8179
8180 struct arm_unw_aux_info
8181 {
8182   Filedata *          filedata;         /* The file containing the unwind sections.  */
8183   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8184   unsigned long       nsyms;            /* Number of symbols.  */
8185   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8186   unsigned long       nfuns;            /* Number of these symbols.  */
8187   char *              strtab;           /* The file's string table.  */
8188   unsigned long       strtab_size;      /* Size of string table.  */
8189 };
8190
8191 static const char *
8192 arm_print_vma_and_name (Filedata *                 filedata,
8193                         struct arm_unw_aux_info *  aux,
8194                         bfd_vma                    fn,
8195                         struct absaddr             addr)
8196 {
8197   const char *procname;
8198   bfd_vma sym_offset;
8199
8200   if (addr.section == SHN_UNDEF)
8201     addr.offset = fn;
8202
8203   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8204                            aux->strtab_size, addr, &procname,
8205                            &sym_offset);
8206
8207   print_vma (fn, PREFIX_HEX);
8208
8209   if (procname)
8210     {
8211       fputs (" <", stdout);
8212       fputs (procname, stdout);
8213
8214       if (sym_offset)
8215         printf ("+0x%lx", (unsigned long) sym_offset);
8216       fputc ('>', stdout);
8217     }
8218
8219   return procname;
8220 }
8221
8222 static void
8223 arm_free_section (struct arm_section *arm_sec)
8224 {
8225   if (arm_sec->data != NULL)
8226     free (arm_sec->data);
8227
8228   if (arm_sec->rela != NULL)
8229     free (arm_sec->rela);
8230 }
8231
8232 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8233       cached section and install SEC instead.
8234    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8235       and return its valued in * WORDP, relocating if necessary.
8236    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8237       relocation's offset in ADDR.
8238    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8239       into the string table of the symbol associated with the reloc.  If no
8240       reloc was applied store -1 there.
8241    5) Return TRUE upon success, FALSE otherwise.  */
8242
8243 static bfd_boolean
8244 get_unwind_section_word (Filedata *                 filedata,
8245                          struct arm_unw_aux_info *  aux,
8246                          struct arm_section *       arm_sec,
8247                          Elf_Internal_Shdr *        sec,
8248                          bfd_vma                    word_offset,
8249                          unsigned int *             wordp,
8250                          struct absaddr *           addr,
8251                          bfd_vma *                  sym_name)
8252 {
8253   Elf_Internal_Rela *rp;
8254   Elf_Internal_Sym *sym;
8255   const char * relname;
8256   unsigned int word;
8257   bfd_boolean wrapped;
8258
8259   if (sec == NULL || arm_sec == NULL)
8260     return FALSE;
8261
8262   addr->section = SHN_UNDEF;
8263   addr->offset = 0;
8264
8265   if (sym_name != NULL)
8266     *sym_name = (bfd_vma) -1;
8267
8268   /* If necessary, update the section cache.  */
8269   if (sec != arm_sec->sec)
8270     {
8271       Elf_Internal_Shdr *relsec;
8272
8273       arm_free_section (arm_sec);
8274
8275       arm_sec->sec = sec;
8276       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8277                                 sec->sh_size, _("unwind data"));
8278       arm_sec->rela = NULL;
8279       arm_sec->nrelas = 0;
8280
8281       for (relsec = filedata->section_headers;
8282            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8283            ++relsec)
8284         {
8285           if (relsec->sh_info >= filedata->file_header.e_shnum
8286               || filedata->section_headers + relsec->sh_info != sec
8287               /* PR 15745: Check the section type as well.  */
8288               || (relsec->sh_type != SHT_REL
8289                   && relsec->sh_type != SHT_RELA))
8290             continue;
8291
8292           arm_sec->rel_type = relsec->sh_type;
8293           if (relsec->sh_type == SHT_REL)
8294             {
8295               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8296                                      relsec->sh_size,
8297                                      & arm_sec->rela, & arm_sec->nrelas))
8298                 return FALSE;
8299             }
8300           else /* relsec->sh_type == SHT_RELA */
8301             {
8302               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8303                                       relsec->sh_size,
8304                                       & arm_sec->rela, & arm_sec->nrelas))
8305                 return FALSE;
8306             }
8307           break;
8308         }
8309
8310       arm_sec->next_rela = arm_sec->rela;
8311     }
8312
8313   /* If there is no unwind data we can do nothing.  */
8314   if (arm_sec->data == NULL)
8315     return FALSE;
8316
8317   /* If the offset is invalid then fail.  */
8318   if (/* PR 21343 *//* PR 18879 */
8319       sec->sh_size < 4
8320       || word_offset > (sec->sh_size - 4)
8321       || ((bfd_signed_vma) word_offset) < 0)
8322     return FALSE;
8323
8324   /* Get the word at the required offset.  */
8325   word = byte_get (arm_sec->data + word_offset, 4);
8326
8327   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8328   if (arm_sec->rela == NULL)
8329     {
8330       * wordp = word;
8331       return TRUE;
8332     }
8333
8334   /* Look through the relocs to find the one that applies to the provided offset.  */
8335   wrapped = FALSE;
8336   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8337     {
8338       bfd_vma prelval, offset;
8339
8340       if (rp->r_offset > word_offset && !wrapped)
8341         {
8342           rp = arm_sec->rela;
8343           wrapped = TRUE;
8344         }
8345       if (rp->r_offset > word_offset)
8346         break;
8347
8348       if (rp->r_offset & 3)
8349         {
8350           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8351                 (unsigned long) rp->r_offset);
8352           continue;
8353         }
8354
8355       if (rp->r_offset < word_offset)
8356         continue;
8357
8358       /* PR 17531: file: 027-161405-0.004  */
8359       if (aux->symtab == NULL)
8360         continue;
8361
8362       if (arm_sec->rel_type == SHT_REL)
8363         {
8364           offset = word & 0x7fffffff;
8365           if (offset & 0x40000000)
8366             offset |= ~ (bfd_vma) 0x7fffffff;
8367         }
8368       else if (arm_sec->rel_type == SHT_RELA)
8369         offset = rp->r_addend;
8370       else
8371         {
8372           error (_("Unknown section relocation type %d encountered\n"),
8373                  arm_sec->rel_type);
8374           break;
8375         }
8376
8377       /* PR 17531 file: 027-1241568-0.004.  */
8378       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8379         {
8380           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8381                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8382           break;
8383         }
8384
8385       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8386       offset += sym->st_value;
8387       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8388
8389       /* Check that we are processing the expected reloc type.  */
8390       if (filedata->file_header.e_machine == EM_ARM)
8391         {
8392           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8393           if (relname == NULL)
8394             {
8395               warn (_("Skipping unknown ARM relocation type: %d\n"),
8396                     (int) ELF32_R_TYPE (rp->r_info));
8397               continue;
8398             }
8399
8400           if (streq (relname, "R_ARM_NONE"))
8401               continue;
8402
8403           if (! streq (relname, "R_ARM_PREL31"))
8404             {
8405               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8406               continue;
8407             }
8408         }
8409       else if (filedata->file_header.e_machine == EM_TI_C6000)
8410         {
8411           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8412           if (relname == NULL)
8413             {
8414               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8415                     (int) ELF32_R_TYPE (rp->r_info));
8416               continue;
8417             }
8418
8419           if (streq (relname, "R_C6000_NONE"))
8420             continue;
8421
8422           if (! streq (relname, "R_C6000_PREL31"))
8423             {
8424               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8425               continue;
8426             }
8427
8428           prelval >>= 1;
8429         }
8430       else
8431         {
8432           /* This function currently only supports ARM and TI unwinders.  */
8433           warn (_("Only TI and ARM unwinders are currently supported\n"));
8434           break;
8435         }
8436
8437       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8438       addr->section = sym->st_shndx;
8439       addr->offset = offset;
8440
8441       if (sym_name)
8442         * sym_name = sym->st_name;
8443       break;
8444     }
8445
8446   *wordp = word;
8447   arm_sec->next_rela = rp;
8448
8449   return TRUE;
8450 }
8451
8452 static const char *tic6x_unwind_regnames[16] =
8453 {
8454   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8455   "A14", "A13", "A12", "A11", "A10",
8456   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8457 };
8458
8459 static void
8460 decode_tic6x_unwind_regmask (unsigned int mask)
8461 {
8462   int i;
8463
8464   for (i = 12; mask; mask >>= 1, i--)
8465     {
8466       if (mask & 1)
8467         {
8468           fputs (tic6x_unwind_regnames[i], stdout);
8469           if (mask > 1)
8470             fputs (", ", stdout);
8471         }
8472     }
8473 }
8474
8475 #define ADVANCE                                                 \
8476   if (remaining == 0 && more_words)                             \
8477     {                                                           \
8478       data_offset += 4;                                         \
8479       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8480                                      data_offset, & word, & addr, NULL))        \
8481         return FALSE;                                           \
8482       remaining = 4;                                            \
8483       more_words--;                                             \
8484     }                                                           \
8485
8486 #define GET_OP(OP)                      \
8487   ADVANCE;                              \
8488   if (remaining)                        \
8489     {                                   \
8490       remaining--;                      \
8491       (OP) = word >> 24;                \
8492       word <<= 8;                       \
8493     }                                   \
8494   else                                  \
8495     {                                   \
8496       printf (_("[Truncated opcode]\n"));       \
8497       return FALSE;                     \
8498     }                                   \
8499   printf ("0x%02x ", OP)
8500
8501 static bfd_boolean
8502 decode_arm_unwind_bytecode (Filedata *                 filedata,
8503                             struct arm_unw_aux_info *  aux,
8504                             unsigned int               word,
8505                             unsigned int               remaining,
8506                             unsigned int               more_words,
8507                             bfd_vma                    data_offset,
8508                             Elf_Internal_Shdr *        data_sec,
8509                             struct arm_section *       data_arm_sec)
8510 {
8511   struct absaddr addr;
8512   bfd_boolean res = TRUE;
8513
8514   /* Decode the unwinding instructions.  */
8515   while (1)
8516     {
8517       unsigned int op, op2;
8518
8519       ADVANCE;
8520       if (remaining == 0)
8521         break;
8522       remaining--;
8523       op = word >> 24;
8524       word <<= 8;
8525
8526       printf ("  0x%02x ", op);
8527
8528       if ((op & 0xc0) == 0x00)
8529         {
8530           int offset = ((op & 0x3f) << 2) + 4;
8531
8532           printf ("     vsp = vsp + %d", offset);
8533         }
8534       else if ((op & 0xc0) == 0x40)
8535         {
8536           int offset = ((op & 0x3f) << 2) + 4;
8537
8538           printf ("     vsp = vsp - %d", offset);
8539         }
8540       else if ((op & 0xf0) == 0x80)
8541         {
8542           GET_OP (op2);
8543           if (op == 0x80 && op2 == 0)
8544             printf (_("Refuse to unwind"));
8545           else
8546             {
8547               unsigned int mask = ((op & 0x0f) << 8) | op2;
8548               bfd_boolean first = TRUE;
8549               int i;
8550
8551               printf ("pop {");
8552               for (i = 0; i < 12; i++)
8553                 if (mask & (1 << i))
8554                   {
8555                     if (first)
8556                       first = FALSE;
8557                     else
8558                       printf (", ");
8559                     printf ("r%d", 4 + i);
8560                   }
8561               printf ("}");
8562             }
8563         }
8564       else if ((op & 0xf0) == 0x90)
8565         {
8566           if (op == 0x9d || op == 0x9f)
8567             printf (_("     [Reserved]"));
8568           else
8569             printf ("     vsp = r%d", op & 0x0f);
8570         }
8571       else if ((op & 0xf0) == 0xa0)
8572         {
8573           int end = 4 + (op & 0x07);
8574           bfd_boolean first = TRUE;
8575           int i;
8576
8577           printf ("     pop {");
8578           for (i = 4; i <= end; i++)
8579             {
8580               if (first)
8581                 first = FALSE;
8582               else
8583                 printf (", ");
8584               printf ("r%d", i);
8585             }
8586           if (op & 0x08)
8587             {
8588               if (!first)
8589                 printf (", ");
8590               printf ("r14");
8591             }
8592           printf ("}");
8593         }
8594       else if (op == 0xb0)
8595         printf (_("     finish"));
8596       else if (op == 0xb1)
8597         {
8598           GET_OP (op2);
8599           if (op2 == 0 || (op2 & 0xf0) != 0)
8600             printf (_("[Spare]"));
8601           else
8602             {
8603               unsigned int mask = op2 & 0x0f;
8604               bfd_boolean first = TRUE;
8605               int i;
8606
8607               printf ("pop {");
8608               for (i = 0; i < 12; i++)
8609                 if (mask & (1 << i))
8610                   {
8611                     if (first)
8612                       first = FALSE;
8613                     else
8614                       printf (", ");
8615                     printf ("r%d", i);
8616                   }
8617               printf ("}");
8618             }
8619         }
8620       else if (op == 0xb2)
8621         {
8622           unsigned char buf[9];
8623           unsigned int i, len;
8624           unsigned long offset;
8625
8626           for (i = 0; i < sizeof (buf); i++)
8627             {
8628               GET_OP (buf[i]);
8629               if ((buf[i] & 0x80) == 0)
8630                 break;
8631             }
8632           if (i == sizeof (buf))
8633             {
8634               error (_("corrupt change to vsp"));
8635               res = FALSE;
8636             }
8637           else
8638             {
8639               offset = read_uleb128 (buf, &len, buf + i + 1);
8640               assert (len == i + 1);
8641               offset = offset * 4 + 0x204;
8642               printf ("vsp = vsp + %ld", offset);
8643             }
8644         }
8645       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8646         {
8647           unsigned int first, last;
8648
8649           GET_OP (op2);
8650           first = op2 >> 4;
8651           last = op2 & 0x0f;
8652           if (op == 0xc8)
8653             first = first + 16;
8654           printf ("pop {D%d", first);
8655           if (last)
8656             printf ("-D%d", first + last);
8657           printf ("}");
8658         }
8659       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8660         {
8661           unsigned int count = op & 0x07;
8662
8663           printf ("pop {D8");
8664           if (count)
8665             printf ("-D%d", 8 + count);
8666           printf ("}");
8667         }
8668       else if (op >= 0xc0 && op <= 0xc5)
8669         {
8670           unsigned int count = op & 0x07;
8671
8672           printf ("     pop {wR10");
8673           if (count)
8674             printf ("-wR%d", 10 + count);
8675           printf ("}");
8676         }
8677       else if (op == 0xc6)
8678         {
8679           unsigned int first, last;
8680
8681           GET_OP (op2);
8682           first = op2 >> 4;
8683           last = op2 & 0x0f;
8684           printf ("pop {wR%d", first);
8685           if (last)
8686             printf ("-wR%d", first + last);
8687           printf ("}");
8688         }
8689       else if (op == 0xc7)
8690         {
8691           GET_OP (op2);
8692           if (op2 == 0 || (op2 & 0xf0) != 0)
8693             printf (_("[Spare]"));
8694           else
8695             {
8696               unsigned int mask = op2 & 0x0f;
8697               bfd_boolean first = TRUE;
8698               int i;
8699
8700               printf ("pop {");
8701               for (i = 0; i < 4; i++)
8702                 if (mask & (1 << i))
8703                   {
8704                     if (first)
8705                       first = FALSE;
8706                     else
8707                       printf (", ");
8708                     printf ("wCGR%d", i);
8709                   }
8710               printf ("}");
8711             }
8712         }
8713       else
8714         {
8715           printf (_("     [unsupported opcode]"));
8716           res = FALSE;
8717         }
8718
8719       printf ("\n");
8720     }
8721
8722   return res;
8723 }
8724
8725 static bfd_boolean
8726 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8727                               struct arm_unw_aux_info *  aux,
8728                               unsigned int               word,
8729                               unsigned int               remaining,
8730                               unsigned int               more_words,
8731                               bfd_vma                    data_offset,
8732                               Elf_Internal_Shdr *        data_sec,
8733                               struct arm_section *       data_arm_sec)
8734 {
8735   struct absaddr addr;
8736
8737   /* Decode the unwinding instructions.  */
8738   while (1)
8739     {
8740       unsigned int op, op2;
8741
8742       ADVANCE;
8743       if (remaining == 0)
8744         break;
8745       remaining--;
8746       op = word >> 24;
8747       word <<= 8;
8748
8749       printf ("  0x%02x ", op);
8750
8751       if ((op & 0xc0) == 0x00)
8752         {
8753           int offset = ((op & 0x3f) << 3) + 8;
8754           printf ("     sp = sp + %d", offset);
8755         }
8756       else if ((op & 0xc0) == 0x80)
8757         {
8758           GET_OP (op2);
8759           if (op == 0x80 && op2 == 0)
8760             printf (_("Refuse to unwind"));
8761           else
8762             {
8763               unsigned int mask = ((op & 0x1f) << 8) | op2;
8764               if (op & 0x20)
8765                 printf ("pop compact {");
8766               else
8767                 printf ("pop {");
8768
8769               decode_tic6x_unwind_regmask (mask);
8770               printf("}");
8771             }
8772         }
8773       else if ((op & 0xf0) == 0xc0)
8774         {
8775           unsigned int reg;
8776           unsigned int nregs;
8777           unsigned int i;
8778           const char *name;
8779           struct
8780           {
8781             unsigned int offset;
8782             unsigned int reg;
8783           } regpos[16];
8784
8785           /* Scan entire instruction first so that GET_OP output is not
8786              interleaved with disassembly.  */
8787           nregs = 0;
8788           for (i = 0; nregs < (op & 0xf); i++)
8789             {
8790               GET_OP (op2);
8791               reg = op2 >> 4;
8792               if (reg != 0xf)
8793                 {
8794                   regpos[nregs].offset = i * 2;
8795                   regpos[nregs].reg = reg;
8796                   nregs++;
8797                 }
8798
8799               reg = op2 & 0xf;
8800               if (reg != 0xf)
8801                 {
8802                   regpos[nregs].offset = i * 2 + 1;
8803                   regpos[nregs].reg = reg;
8804                   nregs++;
8805                 }
8806             }
8807
8808           printf (_("pop frame {"));
8809           reg = nregs - 1;
8810           for (i = i * 2; i > 0; i--)
8811             {
8812               if (regpos[reg].offset == i - 1)
8813                 {
8814                   name = tic6x_unwind_regnames[regpos[reg].reg];
8815                   if (reg > 0)
8816                     reg--;
8817                 }
8818               else
8819                 name = _("[pad]");
8820
8821               fputs (name, stdout);
8822               if (i > 1)
8823                 printf (", ");
8824             }
8825
8826           printf ("}");
8827         }
8828       else if (op == 0xd0)
8829         printf ("     MOV FP, SP");
8830       else if (op == 0xd1)
8831         printf ("     __c6xabi_pop_rts");
8832       else if (op == 0xd2)
8833         {
8834           unsigned char buf[9];
8835           unsigned int i, len;
8836           unsigned long offset;
8837
8838           for (i = 0; i < sizeof (buf); i++)
8839             {
8840               GET_OP (buf[i]);
8841               if ((buf[i] & 0x80) == 0)
8842                 break;
8843             }
8844           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8845           if (i == sizeof (buf))
8846             {
8847               warn (_("Corrupt stack pointer adjustment detected\n"));
8848               return FALSE;
8849             }
8850
8851           offset = read_uleb128 (buf, &len, buf + i + 1);
8852           assert (len == i + 1);
8853           offset = offset * 8 + 0x408;
8854           printf (_("sp = sp + %ld"), offset);
8855         }
8856       else if ((op & 0xf0) == 0xe0)
8857         {
8858           if ((op & 0x0f) == 7)
8859             printf ("     RETURN");
8860           else
8861             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8862         }
8863       else
8864         {
8865           printf (_("     [unsupported opcode]"));
8866         }
8867       putchar ('\n');
8868     }
8869
8870   return TRUE;
8871 }
8872
8873 static bfd_vma
8874 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8875 {
8876   bfd_vma offset;
8877
8878   offset = word & 0x7fffffff;
8879   if (offset & 0x40000000)
8880     offset |= ~ (bfd_vma) 0x7fffffff;
8881
8882   if (filedata->file_header.e_machine == EM_TI_C6000)
8883     offset <<= 1;
8884
8885   return offset + where;
8886 }
8887
8888 static bfd_boolean
8889 decode_arm_unwind (Filedata *                 filedata,
8890                    struct arm_unw_aux_info *  aux,
8891                    unsigned int               word,
8892                    unsigned int               remaining,
8893                    bfd_vma                    data_offset,
8894                    Elf_Internal_Shdr *        data_sec,
8895                    struct arm_section *       data_arm_sec)
8896 {
8897   int per_index;
8898   unsigned int more_words = 0;
8899   struct absaddr addr;
8900   bfd_vma sym_name = (bfd_vma) -1;
8901   bfd_boolean res = TRUE;
8902
8903   if (remaining == 0)
8904     {
8905       /* Fetch the first word.
8906          Note - when decoding an object file the address extracted
8907          here will always be 0.  So we also pass in the sym_name
8908          parameter so that we can find the symbol associated with
8909          the personality routine.  */
8910       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8911                                      & word, & addr, & sym_name))
8912         return FALSE;
8913
8914       remaining = 4;
8915     }
8916
8917   if ((word & 0x80000000) == 0)
8918     {
8919       /* Expand prel31 for personality routine.  */
8920       bfd_vma fn;
8921       const char *procname;
8922
8923       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8924       printf (_("  Personality routine: "));
8925       if (fn == 0
8926           && addr.section == SHN_UNDEF && addr.offset == 0
8927           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8928         {
8929           procname = aux->strtab + sym_name;
8930           print_vma (fn, PREFIX_HEX);
8931           if (procname)
8932             {
8933               fputs (" <", stdout);
8934               fputs (procname, stdout);
8935               fputc ('>', stdout);
8936             }
8937         }
8938       else
8939         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8940       fputc ('\n', stdout);
8941
8942       /* The GCC personality routines use the standard compact
8943          encoding, starting with one byte giving the number of
8944          words.  */
8945       if (procname != NULL
8946           && (const_strneq (procname, "__gcc_personality_v0")
8947               || const_strneq (procname, "__gxx_personality_v0")
8948               || const_strneq (procname, "__gcj_personality_v0")
8949               || const_strneq (procname, "__gnu_objc_personality_v0")))
8950         {
8951           remaining = 0;
8952           more_words = 1;
8953           ADVANCE;
8954           if (!remaining)
8955             {
8956               printf (_("  [Truncated data]\n"));
8957               return FALSE;
8958             }
8959           more_words = word >> 24;
8960           word <<= 8;
8961           remaining--;
8962           per_index = -1;
8963         }
8964       else
8965         return TRUE;
8966     }
8967   else
8968     {
8969       /* ARM EHABI Section 6.3:
8970
8971          An exception-handling table entry for the compact model looks like:
8972
8973            31 30-28 27-24 23-0
8974            -- ----- ----- ----
8975             1   0   index Data for personalityRoutine[index]    */
8976
8977       if (filedata->file_header.e_machine == EM_ARM
8978           && (word & 0x70000000))
8979         {
8980           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8981           res = FALSE;
8982         }
8983
8984       per_index = (word >> 24) & 0x7f;
8985       printf (_("  Compact model index: %d\n"), per_index);
8986       if (per_index == 0)
8987         {
8988           more_words = 0;
8989           word <<= 8;
8990           remaining--;
8991         }
8992       else if (per_index < 3)
8993         {
8994           more_words = (word >> 16) & 0xff;
8995           word <<= 16;
8996           remaining -= 2;
8997         }
8998     }
8999
9000   switch (filedata->file_header.e_machine)
9001     {
9002     case EM_ARM:
9003       if (per_index < 3)
9004         {
9005           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9006                                             data_offset, data_sec, data_arm_sec))
9007             res = FALSE;
9008         }
9009       else
9010         {
9011           warn (_("Unknown ARM compact model index encountered\n"));
9012           printf (_("  [reserved]\n"));
9013           res = FALSE;
9014         }
9015       break;
9016
9017     case EM_TI_C6000:
9018       if (per_index < 3)
9019         {
9020           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9021                                               data_offset, data_sec, data_arm_sec))
9022             res = FALSE;
9023         }
9024       else if (per_index < 5)
9025         {
9026           if (((word >> 17) & 0x7f) == 0x7f)
9027             printf (_("  Restore stack from frame pointer\n"));
9028           else
9029             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
9030           printf (_("  Registers restored: "));
9031           if (per_index == 4)
9032             printf (" (compact) ");
9033           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9034           putchar ('\n');
9035           printf (_("  Return register: %s\n"),
9036                   tic6x_unwind_regnames[word & 0xf]);
9037         }
9038       else
9039         printf (_("  [reserved (%d)]\n"), per_index);
9040       break;
9041
9042     default:
9043       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9044              filedata->file_header.e_machine);
9045       res = FALSE;
9046     }
9047
9048   /* Decode the descriptors.  Not implemented.  */
9049
9050   return res;
9051 }
9052
9053 static bfd_boolean
9054 dump_arm_unwind (Filedata *                 filedata,
9055                  struct arm_unw_aux_info *  aux,
9056                  Elf_Internal_Shdr *        exidx_sec)
9057 {
9058   struct arm_section exidx_arm_sec, extab_arm_sec;
9059   unsigned int i, exidx_len;
9060   unsigned long j, nfuns;
9061   bfd_boolean res = TRUE;
9062
9063   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9064   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9065   exidx_len = exidx_sec->sh_size / 8;
9066
9067   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9068   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9069     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9070       aux->funtab[nfuns++] = aux->symtab[j];
9071   aux->nfuns = nfuns;
9072   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9073
9074   for (i = 0; i < exidx_len; i++)
9075     {
9076       unsigned int exidx_fn, exidx_entry;
9077       struct absaddr fn_addr, entry_addr;
9078       bfd_vma fn;
9079
9080       fputc ('\n', stdout);
9081
9082       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9083                                      8 * i, & exidx_fn, & fn_addr, NULL)
9084           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9085                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9086         {
9087           free (aux->funtab);
9088           arm_free_section (& exidx_arm_sec);
9089           arm_free_section (& extab_arm_sec);
9090           return FALSE;
9091         }
9092
9093       /* ARM EHABI, Section 5:
9094          An index table entry consists of 2 words.
9095          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9096       if (exidx_fn & 0x80000000)
9097         {
9098           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9099           res = FALSE;
9100         }
9101
9102       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9103
9104       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9105       fputs (": ", stdout);
9106
9107       if (exidx_entry == 1)
9108         {
9109           print_vma (exidx_entry, PREFIX_HEX);
9110           fputs (" [cantunwind]\n", stdout);
9111         }
9112       else if (exidx_entry & 0x80000000)
9113         {
9114           print_vma (exidx_entry, PREFIX_HEX);
9115           fputc ('\n', stdout);
9116           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9117         }
9118       else
9119         {
9120           bfd_vma table, table_offset = 0;
9121           Elf_Internal_Shdr *table_sec;
9122
9123           fputs ("@", stdout);
9124           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9125           print_vma (table, PREFIX_HEX);
9126           printf ("\n");
9127
9128           /* Locate the matching .ARM.extab.  */
9129           if (entry_addr.section != SHN_UNDEF
9130               && entry_addr.section < filedata->file_header.e_shnum)
9131             {
9132               table_sec = filedata->section_headers + entry_addr.section;
9133               table_offset = entry_addr.offset;
9134               /* PR 18879 */
9135               if (table_offset > table_sec->sh_size
9136                   || ((bfd_signed_vma) table_offset) < 0)
9137                 {
9138                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9139                         (unsigned long) table_offset,
9140                         printable_section_name (filedata, table_sec));
9141                   res = FALSE;
9142                   continue;
9143                 }
9144             }
9145           else
9146             {
9147               table_sec = find_section_by_address (filedata, table);
9148               if (table_sec != NULL)
9149                 table_offset = table - table_sec->sh_addr;
9150             }
9151
9152           if (table_sec == NULL)
9153             {
9154               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9155                     (unsigned long) table);
9156               res = FALSE;
9157               continue;
9158             }
9159
9160           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9161                                    &extab_arm_sec))
9162             res = FALSE;
9163         }
9164     }
9165
9166   printf ("\n");
9167
9168   free (aux->funtab);
9169   arm_free_section (&exidx_arm_sec);
9170   arm_free_section (&extab_arm_sec);
9171
9172   return res;
9173 }
9174
9175 /* Used for both ARM and C6X unwinding tables.  */
9176
9177 static bfd_boolean
9178 arm_process_unwind (Filedata * filedata)
9179 {
9180   struct arm_unw_aux_info aux;
9181   Elf_Internal_Shdr *unwsec = NULL;
9182   Elf_Internal_Shdr *strsec;
9183   Elf_Internal_Shdr *sec;
9184   unsigned long i;
9185   unsigned int sec_type;
9186   bfd_boolean res = TRUE;
9187
9188   switch (filedata->file_header.e_machine)
9189     {
9190     case EM_ARM:
9191       sec_type = SHT_ARM_EXIDX;
9192       break;
9193
9194     case EM_TI_C6000:
9195       sec_type = SHT_C6000_UNWIND;
9196       break;
9197
9198     default:
9199       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9200              filedata->file_header.e_machine);
9201       return FALSE;
9202     }
9203
9204   if (filedata->string_table == NULL)
9205     return FALSE;
9206
9207   memset (& aux, 0, sizeof (aux));
9208   aux.filedata = filedata;
9209
9210   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9211     {
9212       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9213         {
9214           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9215
9216           strsec = filedata->section_headers + sec->sh_link;
9217
9218           /* PR binutils/17531 file: 011-12666-0.004.  */
9219           if (aux.strtab != NULL)
9220             {
9221               error (_("Multiple string tables found in file.\n"));
9222               free (aux.strtab);
9223               res = FALSE;
9224             }
9225           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9226                                  1, strsec->sh_size, _("string table"));
9227           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9228         }
9229       else if (sec->sh_type == sec_type)
9230         unwsec = sec;
9231     }
9232
9233   if (unwsec == NULL)
9234     printf (_("\nThere are no unwind sections in this file.\n"));
9235   else
9236     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9237       {
9238         if (sec->sh_type == sec_type)
9239           {
9240             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9241             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9242                               "contains %lu entry:\n",
9243                               "\nUnwind section '%s' at offset 0x%lx "
9244                               "contains %lu entries:\n",
9245                               num_unwind),
9246                     printable_section_name (filedata, sec),
9247                     (unsigned long) sec->sh_offset,
9248                     num_unwind);
9249
9250             if (! dump_arm_unwind (filedata, &aux, sec))
9251               res = FALSE;
9252           }
9253       }
9254
9255   if (aux.symtab)
9256     free (aux.symtab);
9257   if (aux.strtab)
9258     free ((char *) aux.strtab);
9259
9260   return res;
9261 }
9262
9263 static bfd_boolean
9264 process_unwind (Filedata * filedata)
9265 {
9266   struct unwind_handler
9267   {
9268     unsigned int machtype;
9269     bfd_boolean (* handler)(Filedata *);
9270   } handlers[] =
9271   {
9272     { EM_ARM, arm_process_unwind },
9273     { EM_IA_64, ia64_process_unwind },
9274     { EM_PARISC, hppa_process_unwind },
9275     { EM_TI_C6000, arm_process_unwind },
9276     { 0, NULL }
9277   };
9278   int i;
9279
9280   if (!do_unwind)
9281     return TRUE;
9282
9283   for (i = 0; handlers[i].handler != NULL; i++)
9284     if (filedata->file_header.e_machine == handlers[i].machtype)
9285       return handlers[i].handler (filedata);
9286
9287   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9288           get_machine_name (filedata->file_header.e_machine));
9289   return TRUE;
9290 }
9291
9292 static void
9293 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9294 {
9295   switch (entry->d_tag)
9296     {
9297     case DT_MIPS_FLAGS:
9298       if (entry->d_un.d_val == 0)
9299         printf (_("NONE"));
9300       else
9301         {
9302           static const char * opts[] =
9303           {
9304             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9305             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9306             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9307             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9308             "RLD_ORDER_SAFE"
9309           };
9310           unsigned int cnt;
9311           bfd_boolean first = TRUE;
9312
9313           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9314             if (entry->d_un.d_val & (1 << cnt))
9315               {
9316                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9317                 first = FALSE;
9318               }
9319         }
9320       break;
9321
9322     case DT_MIPS_IVERSION:
9323       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9324         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9325       else
9326         {
9327           char buf[40];
9328           sprintf_vma (buf, entry->d_un.d_ptr);
9329           /* Note: coded this way so that there is a single string for translation.  */
9330           printf (_("<corrupt: %s>"), buf);
9331         }
9332       break;
9333
9334     case DT_MIPS_TIME_STAMP:
9335       {
9336         char timebuf[128];
9337         struct tm * tmp;
9338         time_t atime = entry->d_un.d_val;
9339
9340         tmp = gmtime (&atime);
9341         /* PR 17531: file: 6accc532.  */
9342         if (tmp == NULL)
9343           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9344         else
9345           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9346                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9347                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9348         printf (_("Time Stamp: %s"), timebuf);
9349       }
9350       break;
9351
9352     case DT_MIPS_RLD_VERSION:
9353     case DT_MIPS_LOCAL_GOTNO:
9354     case DT_MIPS_CONFLICTNO:
9355     case DT_MIPS_LIBLISTNO:
9356     case DT_MIPS_SYMTABNO:
9357     case DT_MIPS_UNREFEXTNO:
9358     case DT_MIPS_HIPAGENO:
9359     case DT_MIPS_DELTA_CLASS_NO:
9360     case DT_MIPS_DELTA_INSTANCE_NO:
9361     case DT_MIPS_DELTA_RELOC_NO:
9362     case DT_MIPS_DELTA_SYM_NO:
9363     case DT_MIPS_DELTA_CLASSSYM_NO:
9364     case DT_MIPS_COMPACT_SIZE:
9365       print_vma (entry->d_un.d_val, DEC);
9366       break;
9367
9368     default:
9369       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9370     }
9371     putchar ('\n');
9372 }
9373
9374 static void
9375 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9376 {
9377   switch (entry->d_tag)
9378     {
9379     case DT_HP_DLD_FLAGS:
9380       {
9381         static struct
9382         {
9383           long int bit;
9384           const char * str;
9385         }
9386         flags[] =
9387         {
9388           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9389           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9390           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9391           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9392           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9393           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9394           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9395           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9396           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9397           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9398           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9399           { DT_HP_GST, "HP_GST" },
9400           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9401           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9402           { DT_HP_NODELETE, "HP_NODELETE" },
9403           { DT_HP_GROUP, "HP_GROUP" },
9404           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9405         };
9406         bfd_boolean first = TRUE;
9407         size_t cnt;
9408         bfd_vma val = entry->d_un.d_val;
9409
9410         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9411           if (val & flags[cnt].bit)
9412             {
9413               if (! first)
9414                 putchar (' ');
9415               fputs (flags[cnt].str, stdout);
9416               first = FALSE;
9417               val ^= flags[cnt].bit;
9418             }
9419
9420         if (val != 0 || first)
9421           {
9422             if (! first)
9423               putchar (' ');
9424             print_vma (val, HEX);
9425           }
9426       }
9427       break;
9428
9429     default:
9430       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9431       break;
9432     }
9433   putchar ('\n');
9434 }
9435
9436 #ifdef BFD64
9437
9438 /* VMS vs Unix time offset and factor.  */
9439
9440 #define VMS_EPOCH_OFFSET 35067168000000000LL
9441 #define VMS_GRANULARITY_FACTOR 10000000
9442
9443 /* Display a VMS time in a human readable format.  */
9444
9445 static void
9446 print_vms_time (bfd_int64_t vmstime)
9447 {
9448   struct tm *tm;
9449   time_t unxtime;
9450
9451   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9452   tm = gmtime (&unxtime);
9453   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9454           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9455           tm->tm_hour, tm->tm_min, tm->tm_sec);
9456 }
9457 #endif /* BFD64 */
9458
9459 static void
9460 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9461 {
9462   switch (entry->d_tag)
9463     {
9464     case DT_IA_64_PLT_RESERVE:
9465       /* First 3 slots reserved.  */
9466       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9467       printf (" -- ");
9468       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9469       break;
9470
9471     case DT_IA_64_VMS_LINKTIME:
9472 #ifdef BFD64
9473       print_vms_time (entry->d_un.d_val);
9474 #endif
9475       break;
9476
9477     case DT_IA_64_VMS_LNKFLAGS:
9478       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9479       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9480         printf (" CALL_DEBUG");
9481       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9482         printf (" NOP0BUFS");
9483       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9484         printf (" P0IMAGE");
9485       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9486         printf (" MKTHREADS");
9487       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9488         printf (" UPCALLS");
9489       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9490         printf (" IMGSTA");
9491       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9492         printf (" INITIALIZE");
9493       if (entry->d_un.d_val & VMS_LF_MAIN)
9494         printf (" MAIN");
9495       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9496         printf (" EXE_INIT");
9497       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9498         printf (" TBK_IN_IMG");
9499       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9500         printf (" DBG_IN_IMG");
9501       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9502         printf (" TBK_IN_DSF");
9503       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9504         printf (" DBG_IN_DSF");
9505       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9506         printf (" SIGNATURES");
9507       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9508         printf (" REL_SEG_OFF");
9509       break;
9510
9511     default:
9512       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9513       break;
9514     }
9515   putchar ('\n');
9516 }
9517
9518 static bfd_boolean
9519 get_32bit_dynamic_section (Filedata * filedata)
9520 {
9521   Elf32_External_Dyn * edyn;
9522   Elf32_External_Dyn * ext;
9523   Elf_Internal_Dyn * entry;
9524
9525   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9526                                           dynamic_size, _("dynamic section"));
9527   if (!edyn)
9528     return FALSE;
9529
9530   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9531      might not have the luxury of section headers.  Look for the DT_NULL
9532      terminator to determine the number of entries.  */
9533   for (ext = edyn, dynamic_nent = 0;
9534        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9535        ext++)
9536     {
9537       dynamic_nent++;
9538       if (BYTE_GET (ext->d_tag) == DT_NULL)
9539         break;
9540     }
9541
9542   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9543                                                   sizeof (* entry));
9544   if (dynamic_section == NULL)
9545     {
9546       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9547              (unsigned long) dynamic_nent);
9548       free (edyn);
9549       return FALSE;
9550     }
9551
9552   for (ext = edyn, entry = dynamic_section;
9553        entry < dynamic_section + dynamic_nent;
9554        ext++, entry++)
9555     {
9556       entry->d_tag      = BYTE_GET (ext->d_tag);
9557       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9558     }
9559
9560   free (edyn);
9561
9562   return TRUE;
9563 }
9564
9565 static bfd_boolean
9566 get_64bit_dynamic_section (Filedata * filedata)
9567 {
9568   Elf64_External_Dyn * edyn;
9569   Elf64_External_Dyn * ext;
9570   Elf_Internal_Dyn * entry;
9571
9572   /* Read in the data.  */
9573   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9574                                           dynamic_size, _("dynamic section"));
9575   if (!edyn)
9576     return FALSE;
9577
9578   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9579      might not have the luxury of section headers.  Look for the DT_NULL
9580      terminator to determine the number of entries.  */
9581   for (ext = edyn, dynamic_nent = 0;
9582        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9583        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9584        ext++)
9585     {
9586       dynamic_nent++;
9587       if (BYTE_GET (ext->d_tag) == DT_NULL)
9588         break;
9589     }
9590
9591   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9592                                                   sizeof (* entry));
9593   if (dynamic_section == NULL)
9594     {
9595       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9596              (unsigned long) dynamic_nent);
9597       free (edyn);
9598       return FALSE;
9599     }
9600
9601   /* Convert from external to internal formats.  */
9602   for (ext = edyn, entry = dynamic_section;
9603        entry < dynamic_section + dynamic_nent;
9604        ext++, entry++)
9605     {
9606       entry->d_tag      = BYTE_GET (ext->d_tag);
9607       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9608     }
9609
9610   free (edyn);
9611
9612   return TRUE;
9613 }
9614
9615 static void
9616 print_dynamic_flags (bfd_vma flags)
9617 {
9618   bfd_boolean first = TRUE;
9619
9620   while (flags)
9621     {
9622       bfd_vma flag;
9623
9624       flag = flags & - flags;
9625       flags &= ~ flag;
9626
9627       if (first)
9628         first = FALSE;
9629       else
9630         putc (' ', stdout);
9631
9632       switch (flag)
9633         {
9634         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9635         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9636         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9637         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9638         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9639         default:                fputs (_("unknown"), stdout); break;
9640         }
9641     }
9642   puts ("");
9643 }
9644
9645 /* Parse and display the contents of the dynamic section.  */
9646
9647 static bfd_boolean
9648 process_dynamic_section (Filedata * filedata)
9649 {
9650   Elf_Internal_Dyn * entry;
9651
9652   if (dynamic_size == 0)
9653     {
9654       if (do_dynamic)
9655         printf (_("\nThere is no dynamic section in this file.\n"));
9656
9657       return TRUE;
9658     }
9659
9660   if (is_32bit_elf)
9661     {
9662       if (! get_32bit_dynamic_section (filedata))
9663         return FALSE;
9664     }
9665   else
9666     {
9667       if (! get_64bit_dynamic_section (filedata))
9668         return FALSE;
9669     }
9670
9671   /* Find the appropriate symbol table.  */
9672   if (dynamic_symbols == NULL)
9673     {
9674       for (entry = dynamic_section;
9675            entry < dynamic_section + dynamic_nent;
9676            ++entry)
9677         {
9678           Elf_Internal_Shdr section;
9679
9680           if (entry->d_tag != DT_SYMTAB)
9681             continue;
9682
9683           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9684
9685           /* Since we do not know how big the symbol table is,
9686              we default to reading in the entire file (!) and
9687              processing that.  This is overkill, I know, but it
9688              should work.  */
9689           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9690           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9691             {
9692               /* See PR 21379 for a reproducer.  */
9693               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9694               return FALSE;
9695             }
9696
9697           if (archive_file_offset != 0)
9698             section.sh_size = archive_file_size - section.sh_offset;
9699           else
9700             section.sh_size = filedata->file_size - section.sh_offset;
9701
9702           if (is_32bit_elf)
9703             section.sh_entsize = sizeof (Elf32_External_Sym);
9704           else
9705             section.sh_entsize = sizeof (Elf64_External_Sym);
9706           section.sh_name = filedata->string_table_length;
9707
9708           if (dynamic_symbols != NULL)
9709             {
9710               error (_("Multiple dynamic symbol table sections found\n"));
9711               free (dynamic_symbols);
9712             }
9713           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9714           if (num_dynamic_syms < 1)
9715             {
9716               error (_("Unable to determine the number of symbols to load\n"));
9717               continue;
9718             }
9719         }
9720     }
9721
9722   /* Similarly find a string table.  */
9723   if (dynamic_strings == NULL)
9724     {
9725       for (entry = dynamic_section;
9726            entry < dynamic_section + dynamic_nent;
9727            ++entry)
9728         {
9729           unsigned long offset;
9730           long str_tab_len;
9731
9732           if (entry->d_tag != DT_STRTAB)
9733             continue;
9734
9735           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9736
9737           /* Since we do not know how big the string table is,
9738              we default to reading in the entire file (!) and
9739              processing that.  This is overkill, I know, but it
9740              should work.  */
9741
9742           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9743
9744           if (archive_file_offset != 0)
9745             str_tab_len = archive_file_size - offset;
9746           else
9747             str_tab_len = filedata->file_size - offset;
9748
9749           if (str_tab_len < 1)
9750             {
9751               error
9752                 (_("Unable to determine the length of the dynamic string table\n"));
9753               continue;
9754             }
9755
9756           if (dynamic_strings != NULL)
9757             {
9758               error (_("Multiple dynamic string tables found\n"));
9759               free (dynamic_strings);
9760             }
9761
9762           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9763                                                str_tab_len,
9764                                                _("dynamic string table"));
9765           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9766         }
9767     }
9768
9769   /* And find the syminfo section if available.  */
9770   if (dynamic_syminfo == NULL)
9771     {
9772       unsigned long syminsz = 0;
9773
9774       for (entry = dynamic_section;
9775            entry < dynamic_section + dynamic_nent;
9776            ++entry)
9777         {
9778           if (entry->d_tag == DT_SYMINENT)
9779             {
9780               /* Note: these braces are necessary to avoid a syntax
9781                  error from the SunOS4 C compiler.  */
9782               /* PR binutils/17531: A corrupt file can trigger this test.
9783                  So do not use an assert, instead generate an error message.  */
9784               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9785                 error (_("Bad value (%d) for SYMINENT entry\n"),
9786                        (int) entry->d_un.d_val);
9787             }
9788           else if (entry->d_tag == DT_SYMINSZ)
9789             syminsz = entry->d_un.d_val;
9790           else if (entry->d_tag == DT_SYMINFO)
9791             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9792                                                       syminsz);
9793         }
9794
9795       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9796         {
9797           Elf_External_Syminfo * extsyminfo;
9798           Elf_External_Syminfo * extsym;
9799           Elf_Internal_Syminfo * syminfo;
9800
9801           /* There is a syminfo section.  Read the data.  */
9802           extsyminfo = (Elf_External_Syminfo *)
9803               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9804                         _("symbol information"));
9805           if (!extsyminfo)
9806             return FALSE;
9807
9808           if (dynamic_syminfo != NULL)
9809             {
9810               error (_("Multiple dynamic symbol information sections found\n"));
9811               free (dynamic_syminfo);
9812             }
9813           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9814           if (dynamic_syminfo == NULL)
9815             {
9816               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9817                      (unsigned long) syminsz);
9818               return FALSE;
9819             }
9820
9821           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9822           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9823                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9824                ++syminfo, ++extsym)
9825             {
9826               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9827               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9828             }
9829
9830           free (extsyminfo);
9831         }
9832     }
9833
9834   if (do_dynamic && dynamic_addr)
9835     printf (ngettext ("\nDynamic section at offset 0x%lx "
9836                       "contains %lu entry:\n",
9837                       "\nDynamic section at offset 0x%lx "
9838                       "contains %lu entries:\n",
9839                       dynamic_nent),
9840             dynamic_addr, (unsigned long) dynamic_nent);
9841   if (do_dynamic)
9842     printf (_("  Tag        Type                         Name/Value\n"));
9843
9844   for (entry = dynamic_section;
9845        entry < dynamic_section + dynamic_nent;
9846        entry++)
9847     {
9848       if (do_dynamic)
9849         {
9850           const char * dtype;
9851
9852           putchar (' ');
9853           print_vma (entry->d_tag, FULL_HEX);
9854           dtype = get_dynamic_type (filedata, entry->d_tag);
9855           printf (" (%s)%*s", dtype,
9856                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9857         }
9858
9859       switch (entry->d_tag)
9860         {
9861         case DT_FLAGS:
9862           if (do_dynamic)
9863             print_dynamic_flags (entry->d_un.d_val);
9864           break;
9865
9866         case DT_AUXILIARY:
9867         case DT_FILTER:
9868         case DT_CONFIG:
9869         case DT_DEPAUDIT:
9870         case DT_AUDIT:
9871           if (do_dynamic)
9872             {
9873               switch (entry->d_tag)
9874                 {
9875                 case DT_AUXILIARY:
9876                   printf (_("Auxiliary library"));
9877                   break;
9878
9879                 case DT_FILTER:
9880                   printf (_("Filter library"));
9881                   break;
9882
9883                 case DT_CONFIG:
9884                   printf (_("Configuration file"));
9885                   break;
9886
9887                 case DT_DEPAUDIT:
9888                   printf (_("Dependency audit library"));
9889                   break;
9890
9891                 case DT_AUDIT:
9892                   printf (_("Audit library"));
9893                   break;
9894                 }
9895
9896               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9897                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9898               else
9899                 {
9900                   printf (": ");
9901                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9902                   putchar ('\n');
9903                 }
9904             }
9905           break;
9906
9907         case DT_FEATURE:
9908           if (do_dynamic)
9909             {
9910               printf (_("Flags:"));
9911
9912               if (entry->d_un.d_val == 0)
9913                 printf (_(" None\n"));
9914               else
9915                 {
9916                   unsigned long int val = entry->d_un.d_val;
9917
9918                   if (val & DTF_1_PARINIT)
9919                     {
9920                       printf (" PARINIT");
9921                       val ^= DTF_1_PARINIT;
9922                     }
9923                   if (val & DTF_1_CONFEXP)
9924                     {
9925                       printf (" CONFEXP");
9926                       val ^= DTF_1_CONFEXP;
9927                     }
9928                   if (val != 0)
9929                     printf (" %lx", val);
9930                   puts ("");
9931                 }
9932             }
9933           break;
9934
9935         case DT_POSFLAG_1:
9936           if (do_dynamic)
9937             {
9938               printf (_("Flags:"));
9939
9940               if (entry->d_un.d_val == 0)
9941                 printf (_(" None\n"));
9942               else
9943                 {
9944                   unsigned long int val = entry->d_un.d_val;
9945
9946                   if (val & DF_P1_LAZYLOAD)
9947                     {
9948                       printf (" LAZYLOAD");
9949                       val ^= DF_P1_LAZYLOAD;
9950                     }
9951                   if (val & DF_P1_GROUPPERM)
9952                     {
9953                       printf (" GROUPPERM");
9954                       val ^= DF_P1_GROUPPERM;
9955                     }
9956                   if (val != 0)
9957                     printf (" %lx", val);
9958                   puts ("");
9959                 }
9960             }
9961           break;
9962
9963         case DT_FLAGS_1:
9964           if (do_dynamic)
9965             {
9966               printf (_("Flags:"));
9967               if (entry->d_un.d_val == 0)
9968                 printf (_(" None\n"));
9969               else
9970                 {
9971                   unsigned long int val = entry->d_un.d_val;
9972
9973                   if (val & DF_1_NOW)
9974                     {
9975                       printf (" NOW");
9976                       val ^= DF_1_NOW;
9977                     }
9978                   if (val & DF_1_GLOBAL)
9979                     {
9980                       printf (" GLOBAL");
9981                       val ^= DF_1_GLOBAL;
9982                     }
9983                   if (val & DF_1_GROUP)
9984                     {
9985                       printf (" GROUP");
9986                       val ^= DF_1_GROUP;
9987                     }
9988                   if (val & DF_1_NODELETE)
9989                     {
9990                       printf (" NODELETE");
9991                       val ^= DF_1_NODELETE;
9992                     }
9993                   if (val & DF_1_LOADFLTR)
9994                     {
9995                       printf (" LOADFLTR");
9996                       val ^= DF_1_LOADFLTR;
9997                     }
9998                   if (val & DF_1_INITFIRST)
9999                     {
10000                       printf (" INITFIRST");
10001                       val ^= DF_1_INITFIRST;
10002                     }
10003                   if (val & DF_1_NOOPEN)
10004                     {
10005                       printf (" NOOPEN");
10006                       val ^= DF_1_NOOPEN;
10007                     }
10008                   if (val & DF_1_ORIGIN)
10009                     {
10010                       printf (" ORIGIN");
10011                       val ^= DF_1_ORIGIN;
10012                     }
10013                   if (val & DF_1_DIRECT)
10014                     {
10015                       printf (" DIRECT");
10016                       val ^= DF_1_DIRECT;
10017                     }
10018                   if (val & DF_1_TRANS)
10019                     {
10020                       printf (" TRANS");
10021                       val ^= DF_1_TRANS;
10022                     }
10023                   if (val & DF_1_INTERPOSE)
10024                     {
10025                       printf (" INTERPOSE");
10026                       val ^= DF_1_INTERPOSE;
10027                     }
10028                   if (val & DF_1_NODEFLIB)
10029                     {
10030                       printf (" NODEFLIB");
10031                       val ^= DF_1_NODEFLIB;
10032                     }
10033                   if (val & DF_1_NODUMP)
10034                     {
10035                       printf (" NODUMP");
10036                       val ^= DF_1_NODUMP;
10037                     }
10038                   if (val & DF_1_CONFALT)
10039                     {
10040                       printf (" CONFALT");
10041                       val ^= DF_1_CONFALT;
10042                     }
10043                   if (val & DF_1_ENDFILTEE)
10044                     {
10045                       printf (" ENDFILTEE");
10046                       val ^= DF_1_ENDFILTEE;
10047                     }
10048                   if (val & DF_1_DISPRELDNE)
10049                     {
10050                       printf (" DISPRELDNE");
10051                       val ^= DF_1_DISPRELDNE;
10052                     }
10053                   if (val & DF_1_DISPRELPND)
10054                     {
10055                       printf (" DISPRELPND");
10056                       val ^= DF_1_DISPRELPND;
10057                     }
10058                   if (val & DF_1_NODIRECT)
10059                     {
10060                       printf (" NODIRECT");
10061                       val ^= DF_1_NODIRECT;
10062                     }
10063                   if (val & DF_1_IGNMULDEF)
10064                     {
10065                       printf (" IGNMULDEF");
10066                       val ^= DF_1_IGNMULDEF;
10067                     }
10068                   if (val & DF_1_NOKSYMS)
10069                     {
10070                       printf (" NOKSYMS");
10071                       val ^= DF_1_NOKSYMS;
10072                     }
10073                   if (val & DF_1_NOHDR)
10074                     {
10075                       printf (" NOHDR");
10076                       val ^= DF_1_NOHDR;
10077                     }
10078                   if (val & DF_1_EDITED)
10079                     {
10080                       printf (" EDITED");
10081                       val ^= DF_1_EDITED;
10082                     }
10083                   if (val & DF_1_NORELOC)
10084                     {
10085                       printf (" NORELOC");
10086                       val ^= DF_1_NORELOC;
10087                     }
10088                   if (val & DF_1_SYMINTPOSE)
10089                     {
10090                       printf (" SYMINTPOSE");
10091                       val ^= DF_1_SYMINTPOSE;
10092                     }
10093                   if (val & DF_1_GLOBAUDIT)
10094                     {
10095                       printf (" GLOBAUDIT");
10096                       val ^= DF_1_GLOBAUDIT;
10097                     }
10098                   if (val & DF_1_SINGLETON)
10099                     {
10100                       printf (" SINGLETON");
10101                       val ^= DF_1_SINGLETON;
10102                     }
10103                   if (val & DF_1_STUB)
10104                     {
10105                       printf (" STUB");
10106                       val ^= DF_1_STUB;
10107                     }
10108                   if (val & DF_1_PIE)
10109                     {
10110                       printf (" PIE");
10111                       val ^= DF_1_PIE;
10112                     }
10113                   if (val & DF_1_KMOD)
10114                     {
10115                       printf (" KMOD");
10116                       val ^= DF_1_KMOD;
10117                     }
10118                   if (val & DF_1_WEAKFILTER)
10119                     {
10120                       printf (" WEAKFILTER");
10121                       val ^= DF_1_WEAKFILTER;
10122                     }
10123                   if (val & DF_1_NOCOMMON)
10124                     {
10125                       printf (" NOCOMMON");
10126                       val ^= DF_1_NOCOMMON;
10127                     }
10128                   if (val != 0)
10129                     printf (" %lx", val);
10130                   puts ("");
10131                 }
10132             }
10133           break;
10134
10135         case DT_PLTREL:
10136           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10137           if (do_dynamic)
10138             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10139           break;
10140
10141         case DT_NULL    :
10142         case DT_NEEDED  :
10143         case DT_PLTGOT  :
10144         case DT_HASH    :
10145         case DT_STRTAB  :
10146         case DT_SYMTAB  :
10147         case DT_RELA    :
10148         case DT_INIT    :
10149         case DT_FINI    :
10150         case DT_SONAME  :
10151         case DT_RPATH   :
10152         case DT_SYMBOLIC:
10153         case DT_REL     :
10154         case DT_DEBUG   :
10155         case DT_TEXTREL :
10156         case DT_JMPREL  :
10157         case DT_RUNPATH :
10158           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10159
10160           if (do_dynamic)
10161             {
10162               char * name;
10163
10164               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10165                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10166               else
10167                 name = NULL;
10168
10169               if (name)
10170                 {
10171                   switch (entry->d_tag)
10172                     {
10173                     case DT_NEEDED:
10174                       printf (_("Shared library: [%s]"), name);
10175
10176                       if (streq (name, program_interpreter))
10177                         printf (_(" program interpreter"));
10178                       break;
10179
10180                     case DT_SONAME:
10181                       printf (_("Library soname: [%s]"), name);
10182                       break;
10183
10184                     case DT_RPATH:
10185                       printf (_("Library rpath: [%s]"), name);
10186                       break;
10187
10188                     case DT_RUNPATH:
10189                       printf (_("Library runpath: [%s]"), name);
10190                       break;
10191
10192                     default:
10193                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10194                       break;
10195                     }
10196                 }
10197               else
10198                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10199
10200               putchar ('\n');
10201             }
10202           break;
10203
10204         case DT_PLTRELSZ:
10205         case DT_RELASZ  :
10206         case DT_STRSZ   :
10207         case DT_RELSZ   :
10208         case DT_RELAENT :
10209         case DT_SYMENT  :
10210         case DT_RELENT  :
10211           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10212           /* Fall through.  */
10213         case DT_PLTPADSZ:
10214         case DT_MOVEENT :
10215         case DT_MOVESZ  :
10216         case DT_INIT_ARRAYSZ:
10217         case DT_FINI_ARRAYSZ:
10218         case DT_GNU_CONFLICTSZ:
10219         case DT_GNU_LIBLISTSZ:
10220           if (do_dynamic)
10221             {
10222               print_vma (entry->d_un.d_val, UNSIGNED);
10223               printf (_(" (bytes)\n"));
10224             }
10225           break;
10226
10227         case DT_VERDEFNUM:
10228         case DT_VERNEEDNUM:
10229         case DT_RELACOUNT:
10230         case DT_RELCOUNT:
10231           if (do_dynamic)
10232             {
10233               print_vma (entry->d_un.d_val, UNSIGNED);
10234               putchar ('\n');
10235             }
10236           break;
10237
10238         case DT_SYMINSZ:
10239         case DT_SYMINENT:
10240         case DT_SYMINFO:
10241         case DT_USED:
10242         case DT_INIT_ARRAY:
10243         case DT_FINI_ARRAY:
10244           if (do_dynamic)
10245             {
10246               if (entry->d_tag == DT_USED
10247                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10248                 {
10249                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10250
10251                   if (*name)
10252                     {
10253                       printf (_("Not needed object: [%s]\n"), name);
10254                       break;
10255                     }
10256                 }
10257
10258               print_vma (entry->d_un.d_val, PREFIX_HEX);
10259               putchar ('\n');
10260             }
10261           break;
10262
10263         case DT_BIND_NOW:
10264           /* The value of this entry is ignored.  */
10265           if (do_dynamic)
10266             putchar ('\n');
10267           break;
10268
10269         case DT_GNU_PRELINKED:
10270           if (do_dynamic)
10271             {
10272               struct tm * tmp;
10273               time_t atime = entry->d_un.d_val;
10274
10275               tmp = gmtime (&atime);
10276               /* PR 17533 file: 041-1244816-0.004.  */
10277               if (tmp == NULL)
10278                 printf (_("<corrupt time val: %lx"),
10279                         (unsigned long) atime);
10280               else
10281                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10282                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10283                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10284
10285             }
10286           break;
10287
10288         case DT_GNU_HASH:
10289           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10290           if (do_dynamic)
10291             {
10292               print_vma (entry->d_un.d_val, PREFIX_HEX);
10293               putchar ('\n');
10294             }
10295           break;
10296
10297         default:
10298           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10299             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10300               entry->d_un.d_val;
10301
10302           if (do_dynamic)
10303             {
10304               switch (filedata->file_header.e_machine)
10305                 {
10306                 case EM_MIPS:
10307                 case EM_MIPS_RS3_LE:
10308                   dynamic_section_mips_val (entry);
10309                   break;
10310                 case EM_PARISC:
10311                   dynamic_section_parisc_val (entry);
10312                   break;
10313                 case EM_IA_64:
10314                   dynamic_section_ia64_val (entry);
10315                   break;
10316                 default:
10317                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10318                   putchar ('\n');
10319                 }
10320             }
10321           break;
10322         }
10323     }
10324
10325   return TRUE;
10326 }
10327
10328 static char *
10329 get_ver_flags (unsigned int flags)
10330 {
10331   static char buff[128];
10332
10333   buff[0] = 0;
10334
10335   if (flags == 0)
10336     return _("none");
10337
10338   if (flags & VER_FLG_BASE)
10339     strcat (buff, "BASE");
10340
10341   if (flags & VER_FLG_WEAK)
10342     {
10343       if (flags & VER_FLG_BASE)
10344         strcat (buff, " | ");
10345
10346       strcat (buff, "WEAK");
10347     }
10348
10349   if (flags & VER_FLG_INFO)
10350     {
10351       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10352         strcat (buff, " | ");
10353
10354       strcat (buff, "INFO");
10355     }
10356
10357   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10358     {
10359       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10360         strcat (buff, " | ");
10361
10362       strcat (buff, _("<unknown>"));
10363     }
10364
10365   return buff;
10366 }
10367
10368 /* Display the contents of the version sections.  */
10369
10370 static bfd_boolean
10371 process_version_sections (Filedata * filedata)
10372 {
10373   Elf_Internal_Shdr * section;
10374   unsigned i;
10375   bfd_boolean found = FALSE;
10376
10377   if (! do_version)
10378     return TRUE;
10379
10380   for (i = 0, section = filedata->section_headers;
10381        i < filedata->file_header.e_shnum;
10382        i++, section++)
10383     {
10384       switch (section->sh_type)
10385         {
10386         case SHT_GNU_verdef:
10387           {
10388             Elf_External_Verdef * edefs;
10389             unsigned long idx;
10390             unsigned long cnt;
10391             char * endbuf;
10392
10393             found = TRUE;
10394
10395             printf (ngettext ("\nVersion definition section '%s' "
10396                               "contains %u entry:\n",
10397                               "\nVersion definition section '%s' "
10398                               "contains %u entries:\n",
10399                               section->sh_info),
10400                     printable_section_name (filedata, section),
10401                     section->sh_info);
10402
10403             printf (_("  Addr: 0x"));
10404             printf_vma (section->sh_addr);
10405             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10406                     (unsigned long) section->sh_offset, section->sh_link,
10407                     printable_section_name_from_index (filedata, section->sh_link));
10408
10409             edefs = (Elf_External_Verdef *)
10410                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10411                           _("version definition section"));
10412             if (!edefs)
10413               break;
10414             endbuf = (char *) edefs + section->sh_size;
10415
10416             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10417               {
10418                 char * vstart;
10419                 Elf_External_Verdef * edef;
10420                 Elf_Internal_Verdef ent;
10421                 Elf_External_Verdaux * eaux;
10422                 Elf_Internal_Verdaux aux;
10423                 unsigned long isum;
10424                 int j;
10425
10426                 vstart = ((char *) edefs) + idx;
10427                 if (vstart + sizeof (*edef) > endbuf)
10428                   break;
10429
10430                 edef = (Elf_External_Verdef *) vstart;
10431
10432                 ent.vd_version = BYTE_GET (edef->vd_version);
10433                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10434                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10435                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10436                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10437                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10438                 ent.vd_next    = BYTE_GET (edef->vd_next);
10439
10440                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10441                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10442
10443                 printf (_("  Index: %d  Cnt: %d  "),
10444                         ent.vd_ndx, ent.vd_cnt);
10445
10446                 /* Check for overflow.  */
10447                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10448                   break;
10449
10450                 vstart += ent.vd_aux;
10451
10452                 if (vstart + sizeof (*eaux) > endbuf)
10453                   break;
10454                 eaux = (Elf_External_Verdaux *) vstart;
10455
10456                 aux.vda_name = BYTE_GET (eaux->vda_name);
10457                 aux.vda_next = BYTE_GET (eaux->vda_next);
10458
10459                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10460                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10461                 else
10462                   printf (_("Name index: %ld\n"), aux.vda_name);
10463
10464                 isum = idx + ent.vd_aux;
10465
10466                 for (j = 1; j < ent.vd_cnt; j++)
10467                   {
10468                     if (aux.vda_next < sizeof (*eaux)
10469                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10470                       {
10471                         warn (_("Invalid vda_next field of %lx\n"),
10472                               aux.vda_next);
10473                         j = ent.vd_cnt;
10474                         break;
10475                       }
10476                     /* Check for overflow.  */
10477                     if (aux.vda_next > (size_t) (endbuf - vstart))
10478                       break;
10479
10480                     isum   += aux.vda_next;
10481                     vstart += aux.vda_next;
10482
10483                     if (vstart + sizeof (*eaux) > endbuf)
10484                       break;
10485                     eaux = (Elf_External_Verdaux *) vstart;
10486
10487                     aux.vda_name = BYTE_GET (eaux->vda_name);
10488                     aux.vda_next = BYTE_GET (eaux->vda_next);
10489
10490                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10491                       printf (_("  %#06lx: Parent %d: %s\n"),
10492                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10493                     else
10494                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10495                               isum, j, aux.vda_name);
10496                   }
10497
10498                 if (j < ent.vd_cnt)
10499                   printf (_("  Version def aux past end of section\n"));
10500
10501                 /* PR 17531:
10502                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10503                 if (ent.vd_next < sizeof (*edef)
10504                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10505                   {
10506                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10507                     cnt = section->sh_info;
10508                     break;
10509                   }
10510                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10511                   break;
10512
10513                 idx += ent.vd_next;
10514               }
10515
10516             if (cnt < section->sh_info)
10517               printf (_("  Version definition past end of section\n"));
10518
10519             free (edefs);
10520           }
10521           break;
10522
10523         case SHT_GNU_verneed:
10524           {
10525             Elf_External_Verneed * eneed;
10526             unsigned long idx;
10527             unsigned long cnt;
10528             char * endbuf;
10529
10530             found = TRUE;
10531
10532             printf (ngettext ("\nVersion needs section '%s' "
10533                               "contains %u entry:\n",
10534                               "\nVersion needs section '%s' "
10535                               "contains %u entries:\n",
10536                               section->sh_info),
10537                     printable_section_name (filedata, section), section->sh_info);
10538
10539             printf (_(" Addr: 0x"));
10540             printf_vma (section->sh_addr);
10541             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10542                     (unsigned long) section->sh_offset, section->sh_link,
10543                     printable_section_name_from_index (filedata, section->sh_link));
10544
10545             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10546                                                        section->sh_offset, 1,
10547                                                        section->sh_size,
10548                                                        _("Version Needs section"));
10549             if (!eneed)
10550               break;
10551             endbuf = (char *) eneed + section->sh_size;
10552
10553             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10554               {
10555                 Elf_External_Verneed * entry;
10556                 Elf_Internal_Verneed ent;
10557                 unsigned long isum;
10558                 int j;
10559                 char * vstart;
10560
10561                 vstart = ((char *) eneed) + idx;
10562                 if (vstart + sizeof (*entry) > endbuf)
10563                   break;
10564
10565                 entry = (Elf_External_Verneed *) vstart;
10566
10567                 ent.vn_version = BYTE_GET (entry->vn_version);
10568                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10569                 ent.vn_file    = BYTE_GET (entry->vn_file);
10570                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10571                 ent.vn_next    = BYTE_GET (entry->vn_next);
10572
10573                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10574
10575                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10576                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10577                 else
10578                   printf (_("  File: %lx"), ent.vn_file);
10579
10580                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10581
10582                 /* Check for overflow.  */
10583                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10584                   break;
10585                 vstart += ent.vn_aux;
10586
10587                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10588                   {
10589                     Elf_External_Vernaux * eaux;
10590                     Elf_Internal_Vernaux aux;
10591
10592                     if (vstart + sizeof (*eaux) > endbuf)
10593                       break;
10594                     eaux = (Elf_External_Vernaux *) vstart;
10595
10596                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10597                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10598                     aux.vna_other = BYTE_GET (eaux->vna_other);
10599                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10600                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10601
10602                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10603                       printf (_("  %#06lx:   Name: %s"),
10604                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10605                     else
10606                       printf (_("  %#06lx:   Name index: %lx"),
10607                               isum, aux.vna_name);
10608
10609                     printf (_("  Flags: %s  Version: %d\n"),
10610                             get_ver_flags (aux.vna_flags), aux.vna_other);
10611
10612                     if (aux.vna_next < sizeof (*eaux)
10613                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10614                       {
10615                         warn (_("Invalid vna_next field of %lx\n"),
10616                               aux.vna_next);
10617                         j = ent.vn_cnt;
10618                         break;
10619                       }
10620                     /* Check for overflow.  */
10621                     if (aux.vna_next > (size_t) (endbuf - vstart))
10622                       break;
10623                     isum   += aux.vna_next;
10624                     vstart += aux.vna_next;
10625                   }
10626
10627                 if (j < ent.vn_cnt)
10628                   warn (_("Missing Version Needs auxillary information\n"));
10629
10630                 if (ent.vn_next < sizeof (*entry)
10631                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10632                   {
10633                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10634                     cnt = section->sh_info;
10635                     break;
10636                   }
10637                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10638                   break;
10639                 idx += ent.vn_next;
10640               }
10641
10642             if (cnt < section->sh_info)
10643               warn (_("Missing Version Needs information\n"));
10644
10645             free (eneed);
10646           }
10647           break;
10648
10649         case SHT_GNU_versym:
10650           {
10651             Elf_Internal_Shdr * link_section;
10652             size_t total;
10653             unsigned int cnt;
10654             unsigned char * edata;
10655             unsigned short * data;
10656             char * strtab;
10657             Elf_Internal_Sym * symbols;
10658             Elf_Internal_Shdr * string_sec;
10659             unsigned long num_syms;
10660             long off;
10661
10662             if (section->sh_link >= filedata->file_header.e_shnum)
10663               break;
10664
10665             link_section = filedata->section_headers + section->sh_link;
10666             total = section->sh_size / sizeof (Elf_External_Versym);
10667
10668             if (link_section->sh_link >= filedata->file_header.e_shnum)
10669               break;
10670
10671             found = TRUE;
10672
10673             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10674             if (symbols == NULL)
10675               break;
10676
10677             string_sec = filedata->section_headers + link_section->sh_link;
10678
10679             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10680                                         string_sec->sh_size,
10681                                         _("version string table"));
10682             if (!strtab)
10683               {
10684                 free (symbols);
10685                 break;
10686               }
10687
10688             printf (ngettext ("\nVersion symbols section '%s' "
10689                               "contains %lu entry:\n",
10690                               "\nVersion symbols section '%s' "
10691                               "contains %lu entries:\n",
10692                               total),
10693                     printable_section_name (filedata, section), (unsigned long) total);
10694
10695             printf (_(" Addr: "));
10696             printf_vma (section->sh_addr);
10697             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10698                     (unsigned long) section->sh_offset, section->sh_link,
10699                     printable_section_name (filedata, link_section));
10700
10701             off = offset_from_vma (filedata,
10702                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10703                                    total * sizeof (short));
10704             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10705                                                 sizeof (short),
10706                                                 _("version symbol data"));
10707             if (!edata)
10708               {
10709                 free (strtab);
10710                 free (symbols);
10711                 break;
10712               }
10713
10714             data = (short unsigned int *) cmalloc (total, sizeof (short));
10715
10716             for (cnt = total; cnt --;)
10717               data[cnt] = byte_get (edata + cnt * sizeof (short),
10718                                     sizeof (short));
10719
10720             free (edata);
10721
10722             for (cnt = 0; cnt < total; cnt += 4)
10723               {
10724                 int j, nn;
10725                 char *name;
10726                 char *invalid = _("*invalid*");
10727
10728                 printf ("  %03x:", cnt);
10729
10730                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10731                   switch (data[cnt + j])
10732                     {
10733                     case 0:
10734                       fputs (_("   0 (*local*)    "), stdout);
10735                       break;
10736
10737                     case 1:
10738                       fputs (_("   1 (*global*)   "), stdout);
10739                       break;
10740
10741                     default:
10742                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10743                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10744
10745                       /* If this index value is greater than the size of the symbols
10746                          array, break to avoid an out-of-bounds read.  */
10747                       if ((unsigned long)(cnt + j) >= num_syms)
10748                         {
10749                           warn (_("invalid index into symbol array\n"));
10750                           break;
10751                         }
10752
10753                       name = NULL;
10754                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10755                         {
10756                           Elf_Internal_Verneed ivn;
10757                           unsigned long offset;
10758
10759                           offset = offset_from_vma
10760                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10761                              sizeof (Elf_External_Verneed));
10762
10763                           do
10764                             {
10765                               Elf_Internal_Vernaux ivna;
10766                               Elf_External_Verneed evn;
10767                               Elf_External_Vernaux evna;
10768                               unsigned long a_off;
10769
10770                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10771                                             _("version need")) == NULL)
10772                                 break;
10773
10774                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10775                               ivn.vn_next = BYTE_GET (evn.vn_next);
10776
10777                               a_off = offset + ivn.vn_aux;
10778
10779                               do
10780                                 {
10781                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10782                                                 1, _("version need aux (2)")) == NULL)
10783                                     {
10784                                       ivna.vna_next  = 0;
10785                                       ivna.vna_other = 0;
10786                                     }
10787                                   else
10788                                     {
10789                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10790                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10791                                     }
10792
10793                                   a_off += ivna.vna_next;
10794                                 }
10795                               while (ivna.vna_other != data[cnt + j]
10796                                      && ivna.vna_next != 0);
10797
10798                               if (ivna.vna_other == data[cnt + j])
10799                                 {
10800                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10801
10802                                   if (ivna.vna_name >= string_sec->sh_size)
10803                                     name = invalid;
10804                                   else
10805                                     name = strtab + ivna.vna_name;
10806                                   break;
10807                                 }
10808
10809                               offset += ivn.vn_next;
10810                             }
10811                           while (ivn.vn_next);
10812                         }
10813
10814                       if (data[cnt + j] != 0x8001
10815                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10816                         {
10817                           Elf_Internal_Verdef ivd;
10818                           Elf_External_Verdef evd;
10819                           unsigned long offset;
10820
10821                           offset = offset_from_vma
10822                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10823                              sizeof evd);
10824
10825                           do
10826                             {
10827                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10828                                             _("version def")) == NULL)
10829                                 {
10830                                   ivd.vd_next = 0;
10831                                   /* PR 17531: file: 046-1082287-0.004.  */
10832                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10833                                   break;
10834                                 }
10835                               else
10836                                 {
10837                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10838                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10839                                 }
10840
10841                               offset += ivd.vd_next;
10842                             }
10843                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10844                                  && ivd.vd_next != 0);
10845
10846                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10847                             {
10848                               Elf_External_Verdaux evda;
10849                               Elf_Internal_Verdaux ivda;
10850
10851                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10852
10853                               if (get_data (&evda, filedata,
10854                                             offset - ivd.vd_next + ivd.vd_aux,
10855                                             sizeof (evda), 1,
10856                                             _("version def aux")) == NULL)
10857                                 break;
10858
10859                               ivda.vda_name = BYTE_GET (evda.vda_name);
10860
10861                               if (ivda.vda_name >= string_sec->sh_size)
10862                                 name = invalid;
10863                               else if (name != NULL && name != invalid)
10864                                 name = _("*both*");
10865                               else
10866                                 name = strtab + ivda.vda_name;
10867                             }
10868                         }
10869                       if (name != NULL)
10870                         nn += printf ("(%s%-*s",
10871                                       name,
10872                                       12 - (int) strlen (name),
10873                                       ")");
10874
10875                       if (nn < 18)
10876                         printf ("%*c", 18 - nn, ' ');
10877                     }
10878
10879                 putchar ('\n');
10880               }
10881
10882             free (data);
10883             free (strtab);
10884             free (symbols);
10885           }
10886           break;
10887
10888         default:
10889           break;
10890         }
10891     }
10892
10893   if (! found)
10894     printf (_("\nNo version information found in this file.\n"));
10895
10896   return TRUE;
10897 }
10898
10899 static const char *
10900 get_symbol_binding (Filedata * filedata, unsigned int binding)
10901 {
10902   static char buff[32];
10903
10904   switch (binding)
10905     {
10906     case STB_LOCAL:     return "LOCAL";
10907     case STB_GLOBAL:    return "GLOBAL";
10908     case STB_WEAK:      return "WEAK";
10909     default:
10910       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10911         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10912                   binding);
10913       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10914         {
10915           if (binding == STB_GNU_UNIQUE
10916               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10917                   /* GNU is still using the default value 0.  */
10918                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10919             return "UNIQUE";
10920           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10921         }
10922       else
10923         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10924       return buff;
10925     }
10926 }
10927
10928 static const char *
10929 get_symbol_type (Filedata * filedata, unsigned int type)
10930 {
10931   static char buff[32];
10932
10933   switch (type)
10934     {
10935     case STT_NOTYPE:    return "NOTYPE";
10936     case STT_OBJECT:    return "OBJECT";
10937     case STT_FUNC:      return "FUNC";
10938     case STT_SECTION:   return "SECTION";
10939     case STT_FILE:      return "FILE";
10940     case STT_COMMON:    return "COMMON";
10941     case STT_TLS:       return "TLS";
10942     case STT_RELC:      return "RELC";
10943     case STT_SRELC:     return "SRELC";
10944     default:
10945       if (type >= STT_LOPROC && type <= STT_HIPROC)
10946         {
10947           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10948             return "THUMB_FUNC";
10949
10950           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10951             return "REGISTER";
10952
10953           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10954             return "PARISC_MILLI";
10955
10956           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10957         }
10958       else if (type >= STT_LOOS && type <= STT_HIOS)
10959         {
10960           if (filedata->file_header.e_machine == EM_PARISC)
10961             {
10962               if (type == STT_HP_OPAQUE)
10963                 return "HP_OPAQUE";
10964               if (type == STT_HP_STUB)
10965                 return "HP_STUB";
10966             }
10967
10968           if (type == STT_GNU_IFUNC
10969               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10970                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10971                   /* GNU is still using the default value 0.  */
10972                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10973             return "IFUNC";
10974
10975           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10976         }
10977       else
10978         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10979       return buff;
10980     }
10981 }
10982
10983 static const char *
10984 get_symbol_visibility (unsigned int visibility)
10985 {
10986   switch (visibility)
10987     {
10988     case STV_DEFAULT:   return "DEFAULT";
10989     case STV_INTERNAL:  return "INTERNAL";
10990     case STV_HIDDEN:    return "HIDDEN";
10991     case STV_PROTECTED: return "PROTECTED";
10992     default:
10993       error (_("Unrecognized visibility value: %u"), visibility);
10994       return _("<unknown>");
10995     }
10996 }
10997
10998 static const char *
10999 get_solaris_symbol_visibility (unsigned int visibility)
11000 {
11001   switch (visibility)
11002     {
11003     case 4: return "EXPORTED";
11004     case 5: return "SINGLETON";
11005     case 6: return "ELIMINATE";
11006     default: return get_symbol_visibility (visibility);
11007     }
11008 }
11009
11010 static const char *
11011 get_mips_symbol_other (unsigned int other)
11012 {
11013   switch (other)
11014     {
11015     case STO_OPTIONAL:      return "OPTIONAL";
11016     case STO_MIPS_PLT:      return "MIPS PLT";
11017     case STO_MIPS_PIC:      return "MIPS PIC";
11018     case STO_MICROMIPS:     return "MICROMIPS";
11019     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
11020     case STO_MIPS16:        return "MIPS16";
11021     default:                return NULL;
11022     }
11023 }
11024
11025 static const char *
11026 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11027 {
11028   if (is_ia64_vms (filedata))
11029     {
11030       static char res[32];
11031
11032       res[0] = 0;
11033
11034       /* Function types is for images and .STB files only.  */
11035       switch (filedata->file_header.e_type)
11036         {
11037         case ET_DYN:
11038         case ET_EXEC:
11039           switch (VMS_ST_FUNC_TYPE (other))
11040             {
11041             case VMS_SFT_CODE_ADDR:
11042               strcat (res, " CA");
11043               break;
11044             case VMS_SFT_SYMV_IDX:
11045               strcat (res, " VEC");
11046               break;
11047             case VMS_SFT_FD:
11048               strcat (res, " FD");
11049               break;
11050             case VMS_SFT_RESERVE:
11051               strcat (res, " RSV");
11052               break;
11053             default:
11054               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11055                     VMS_ST_FUNC_TYPE (other));
11056               strcat (res, " <unknown>");
11057               break;
11058             }
11059           break;
11060         default:
11061           break;
11062         }
11063       switch (VMS_ST_LINKAGE (other))
11064         {
11065         case VMS_STL_IGNORE:
11066           strcat (res, " IGN");
11067           break;
11068         case VMS_STL_RESERVE:
11069           strcat (res, " RSV");
11070           break;
11071         case VMS_STL_STD:
11072           strcat (res, " STD");
11073           break;
11074         case VMS_STL_LNK:
11075           strcat (res, " LNK");
11076           break;
11077         default:
11078           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11079                 VMS_ST_LINKAGE (other));
11080           strcat (res, " <unknown>");
11081           break;
11082         }
11083
11084       if (res[0] != 0)
11085         return res + 1;
11086       else
11087         return res;
11088     }
11089   return NULL;
11090 }
11091
11092 static const char *
11093 get_ppc64_symbol_other (unsigned int other)
11094 {
11095   if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11096     return NULL;
11097
11098   other >>= STO_PPC64_LOCAL_BIT;
11099   if (other <= 6)
11100     {
11101       static char buf[32];
11102       if (other >= 2)
11103         other = ppc64_decode_local_entry (other);
11104       snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11105       return buf;
11106     }
11107   return NULL;
11108 }
11109
11110 static const char *
11111 get_symbol_other (Filedata * filedata, unsigned int other)
11112 {
11113   const char * result = NULL;
11114   static char buff [32];
11115
11116   if (other == 0)
11117     return "";
11118
11119   switch (filedata->file_header.e_machine)
11120     {
11121     case EM_MIPS:
11122       result = get_mips_symbol_other (other);
11123       break;
11124     case EM_IA_64:
11125       result = get_ia64_symbol_other (filedata, other);
11126       break;
11127     case EM_PPC64:
11128       result = get_ppc64_symbol_other (other);
11129       break;
11130     default:
11131       result = NULL;
11132       break;
11133     }
11134
11135   if (result)
11136     return result;
11137
11138   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11139   return buff;
11140 }
11141
11142 static const char *
11143 get_symbol_index_type (Filedata * filedata, unsigned int type)
11144 {
11145   static char buff[32];
11146
11147   switch (type)
11148     {
11149     case SHN_UNDEF:     return "UND";
11150     case SHN_ABS:       return "ABS";
11151     case SHN_COMMON:    return "COM";
11152     default:
11153       if (type == SHN_IA_64_ANSI_COMMON
11154           && filedata->file_header.e_machine == EM_IA_64
11155           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11156         return "ANSI_COM";
11157       else if ((filedata->file_header.e_machine == EM_X86_64
11158                 || filedata->file_header.e_machine == EM_L1OM
11159                 || filedata->file_header.e_machine == EM_K1OM)
11160                && type == SHN_X86_64_LCOMMON)
11161         return "LARGE_COM";
11162       else if ((type == SHN_MIPS_SCOMMON
11163                 && filedata->file_header.e_machine == EM_MIPS)
11164                || (type == SHN_TIC6X_SCOMMON
11165                    && filedata->file_header.e_machine == EM_TI_C6000))
11166         return "SCOM";
11167       else if (type == SHN_MIPS_SUNDEFINED
11168                && filedata->file_header.e_machine == EM_MIPS)
11169         return "SUND";
11170       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11171         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11172       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11173         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11174       else if (type >= SHN_LORESERVE)
11175         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11176       else if (type >= filedata->file_header.e_shnum)
11177         sprintf (buff, _("bad section index[%3d]"), type);
11178       else
11179         sprintf (buff, "%3d", type);
11180       break;
11181     }
11182
11183   return buff;
11184 }
11185
11186 static bfd_vma *
11187 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11188 {
11189   unsigned char * e_data;
11190   bfd_vma * i_data;
11191
11192   /* If the size_t type is smaller than the bfd_size_type, eg because
11193      you are building a 32-bit tool on a 64-bit host, then make sure
11194      that when (number) is cast to (size_t) no information is lost.  */
11195   if (sizeof (size_t) < sizeof (bfd_size_type)
11196       && (bfd_size_type) ((size_t) number) != number)
11197     {
11198       error (_("Size truncation prevents reading %s elements of size %u\n"),
11199              bfd_vmatoa ("u", number), ent_size);
11200       return NULL;
11201     }
11202
11203   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11204      attempting to allocate memory when the read is bound to fail.  */
11205   if (ent_size * number > filedata->file_size)
11206     {
11207       error (_("Invalid number of dynamic entries: %s\n"),
11208              bfd_vmatoa ("u", number));
11209       return NULL;
11210     }
11211
11212   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11213   if (e_data == NULL)
11214     {
11215       error (_("Out of memory reading %s dynamic entries\n"),
11216              bfd_vmatoa ("u", number));
11217       return NULL;
11218     }
11219
11220   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11221     {
11222       error (_("Unable to read in %s bytes of dynamic data\n"),
11223              bfd_vmatoa ("u", number * ent_size));
11224       free (e_data);
11225       return NULL;
11226     }
11227
11228   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11229   if (i_data == NULL)
11230     {
11231       error (_("Out of memory allocating space for %s dynamic entries\n"),
11232              bfd_vmatoa ("u", number));
11233       free (e_data);
11234       return NULL;
11235     }
11236
11237   while (number--)
11238     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11239
11240   free (e_data);
11241
11242   return i_data;
11243 }
11244
11245 static void
11246 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11247 {
11248   Elf_Internal_Sym * psym;
11249   int n;
11250
11251   n = print_vma (si, DEC_5);
11252   if (n < 5)
11253     fputs (&"     "[n], stdout);
11254   printf (" %3lu: ", hn);
11255
11256   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11257     {
11258       printf (_("<No info available for dynamic symbol number %lu>\n"),
11259               (unsigned long) si);
11260       return;
11261     }
11262
11263   psym = dynamic_symbols + si;
11264   print_vma (psym->st_value, LONG_HEX);
11265   putchar (' ');
11266   print_vma (psym->st_size, DEC_5);
11267
11268   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11269   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11270
11271   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11272     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11273   else
11274     {
11275       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11276
11277       printf (" %-7s",  get_symbol_visibility (vis));
11278       /* Check to see if any other bits in the st_other field are set.
11279          Note - displaying this information disrupts the layout of the
11280          table being generated, but for the moment this case is very
11281          rare.  */
11282       if (psym->st_other ^ vis)
11283         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11284     }
11285
11286   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11287   if (VALID_DYNAMIC_NAME (psym->st_name))
11288     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11289   else
11290     printf (_(" <corrupt: %14ld>"), psym->st_name);
11291   putchar ('\n');
11292 }
11293
11294 static const char *
11295 get_symbol_version_string (Filedata *                   filedata,
11296                            bfd_boolean                  is_dynsym,
11297                            const char *                 strtab,
11298                            unsigned long int            strtab_size,
11299                            unsigned int                 si,
11300                            Elf_Internal_Sym *           psym,
11301                            enum versioned_symbol_info * sym_info,
11302                            unsigned short *             vna_other)
11303 {
11304   unsigned char data[2];
11305   unsigned short vers_data;
11306   unsigned long offset;
11307   unsigned short max_vd_ndx;
11308
11309   if (!is_dynsym
11310       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11311     return NULL;
11312
11313   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11314                             sizeof data + si * sizeof (vers_data));
11315
11316   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11317                 sizeof (data), 1, _("version data")) == NULL)
11318     return NULL;
11319
11320   vers_data = byte_get (data, 2);
11321
11322   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11323     return NULL;
11324
11325   max_vd_ndx = 0;
11326
11327   /* Usually we'd only see verdef for defined symbols, and verneed for
11328      undefined symbols.  However, symbols defined by the linker in
11329      .dynbss for variables copied from a shared library in order to
11330      avoid text relocations are defined yet have verneed.  We could
11331      use a heuristic to detect the special case, for example, check
11332      for verneed first on symbols defined in SHT_NOBITS sections, but
11333      it is simpler and more reliable to just look for both verdef and
11334      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11335
11336   if (psym->st_shndx != SHN_UNDEF
11337       && vers_data != 0x8001
11338       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11339     {
11340       Elf_Internal_Verdef ivd;
11341       Elf_Internal_Verdaux ivda;
11342       Elf_External_Verdaux evda;
11343       unsigned long off;
11344
11345       off = offset_from_vma (filedata,
11346                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11347                              sizeof (Elf_External_Verdef));
11348
11349       do
11350         {
11351           Elf_External_Verdef evd;
11352
11353           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11354                         _("version def")) == NULL)
11355             {
11356               ivd.vd_ndx = 0;
11357               ivd.vd_aux = 0;
11358               ivd.vd_next = 0;
11359               ivd.vd_flags = 0;
11360             }
11361           else
11362             {
11363               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11364               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11365               ivd.vd_next = BYTE_GET (evd.vd_next);
11366               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11367             }
11368
11369           if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11370             max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11371
11372           off += ivd.vd_next;
11373         }
11374       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11375
11376       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11377         {
11378           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11379             return NULL;
11380
11381           off -= ivd.vd_next;
11382           off += ivd.vd_aux;
11383
11384           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11385                         _("version def aux")) != NULL)
11386             {
11387               ivda.vda_name = BYTE_GET (evda.vda_name);
11388
11389               if (psym->st_name != ivda.vda_name)
11390                 {
11391                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11392                                ? symbol_hidden : symbol_public);
11393                   return (ivda.vda_name < strtab_size
11394                           ? strtab + ivda.vda_name : _("<corrupt>"));
11395                 }
11396             }
11397         }
11398     }
11399
11400   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11401     {
11402       Elf_External_Verneed evn;
11403       Elf_Internal_Verneed ivn;
11404       Elf_Internal_Vernaux ivna;
11405
11406       offset = offset_from_vma (filedata,
11407                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11408                                 sizeof evn);
11409       do
11410         {
11411           unsigned long vna_off;
11412
11413           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11414                         _("version need")) == NULL)
11415             {
11416               ivna.vna_next = 0;
11417               ivna.vna_other = 0;
11418               ivna.vna_name = 0;
11419               break;
11420             }
11421
11422           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11423           ivn.vn_next = BYTE_GET (evn.vn_next);
11424
11425           vna_off = offset + ivn.vn_aux;
11426
11427           do
11428             {
11429               Elf_External_Vernaux evna;
11430
11431               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11432                             _("version need aux (3)")) == NULL)
11433                 {
11434                   ivna.vna_next = 0;
11435                   ivna.vna_other = 0;
11436                   ivna.vna_name = 0;
11437                 }
11438               else
11439                 {
11440                   ivna.vna_other = BYTE_GET (evna.vna_other);
11441                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11442                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11443                 }
11444
11445               vna_off += ivna.vna_next;
11446             }
11447           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11448
11449           if (ivna.vna_other == vers_data)
11450             break;
11451
11452           offset += ivn.vn_next;
11453         }
11454       while (ivn.vn_next != 0);
11455
11456       if (ivna.vna_other == vers_data)
11457         {
11458           *sym_info = symbol_undefined;
11459           *vna_other = ivna.vna_other;
11460           return (ivna.vna_name < strtab_size
11461                   ? strtab + ivna.vna_name : _("<corrupt>"));
11462         }
11463       else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11464                && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11465         return _("<corrupt>");
11466     }
11467   return NULL;
11468 }
11469
11470 /* Dump the symbol table.  */
11471 static bfd_boolean
11472 process_symbol_table (Filedata * filedata)
11473 {
11474   Elf_Internal_Shdr * section;
11475   bfd_size_type nbuckets = 0;
11476   bfd_size_type nchains = 0;
11477   bfd_vma * buckets = NULL;
11478   bfd_vma * chains = NULL;
11479   bfd_vma ngnubuckets = 0;
11480   bfd_vma * gnubuckets = NULL;
11481   bfd_vma * gnuchains = NULL;
11482   bfd_vma gnusymidx = 0;
11483   bfd_size_type ngnuchains = 0;
11484
11485   if (!do_syms && !do_dyn_syms && !do_histogram)
11486     return TRUE;
11487
11488   if (dynamic_info[DT_HASH]
11489       && (do_histogram
11490           || (do_using_dynamic
11491               && !do_dyn_syms
11492               && dynamic_strings != NULL)))
11493     {
11494       unsigned char nb[8];
11495       unsigned char nc[8];
11496       unsigned int hash_ent_size = 4;
11497
11498       if ((filedata->file_header.e_machine == EM_ALPHA
11499            || filedata->file_header.e_machine == EM_S390
11500            || filedata->file_header.e_machine == EM_S390_OLD)
11501           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11502         hash_ent_size = 8;
11503
11504       if (fseek (filedata->handle,
11505                  (archive_file_offset
11506                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11507                                      sizeof nb + sizeof nc)),
11508                  SEEK_SET))
11509         {
11510           error (_("Unable to seek to start of dynamic information\n"));
11511           goto no_hash;
11512         }
11513
11514       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11515         {
11516           error (_("Failed to read in number of buckets\n"));
11517           goto no_hash;
11518         }
11519
11520       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11521         {
11522           error (_("Failed to read in number of chains\n"));
11523           goto no_hash;
11524         }
11525
11526       nbuckets = byte_get (nb, hash_ent_size);
11527       nchains  = byte_get (nc, hash_ent_size);
11528
11529       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11530       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11531
11532     no_hash:
11533       if (buckets == NULL || chains == NULL)
11534         {
11535           if (do_using_dynamic)
11536             return FALSE;
11537           free (buckets);
11538           free (chains);
11539           buckets = NULL;
11540           chains = NULL;
11541           nbuckets = 0;
11542           nchains = 0;
11543         }
11544     }
11545
11546   if (dynamic_info_DT_GNU_HASH
11547       && (do_histogram
11548           || (do_using_dynamic
11549               && !do_dyn_syms
11550               && dynamic_strings != NULL)))
11551     {
11552       unsigned char nb[16];
11553       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11554       bfd_vma buckets_vma;
11555
11556       if (fseek (filedata->handle,
11557                  (archive_file_offset
11558                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11559                                      sizeof nb)),
11560                  SEEK_SET))
11561         {
11562           error (_("Unable to seek to start of dynamic information\n"));
11563           goto no_gnu_hash;
11564         }
11565
11566       if (fread (nb, 16, 1, filedata->handle) != 1)
11567         {
11568           error (_("Failed to read in number of buckets\n"));
11569           goto no_gnu_hash;
11570         }
11571
11572       ngnubuckets = byte_get (nb, 4);
11573       gnusymidx = byte_get (nb + 4, 4);
11574       bitmaskwords = byte_get (nb + 8, 4);
11575       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11576       if (is_32bit_elf)
11577         buckets_vma += bitmaskwords * 4;
11578       else
11579         buckets_vma += bitmaskwords * 8;
11580
11581       if (fseek (filedata->handle,
11582                  (archive_file_offset
11583                   + offset_from_vma (filedata, buckets_vma, 4)),
11584                  SEEK_SET))
11585         {
11586           error (_("Unable to seek to start of dynamic information\n"));
11587           goto no_gnu_hash;
11588         }
11589
11590       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11591
11592       if (gnubuckets == NULL)
11593         goto no_gnu_hash;
11594
11595       for (i = 0; i < ngnubuckets; i++)
11596         if (gnubuckets[i] != 0)
11597           {
11598             if (gnubuckets[i] < gnusymidx)
11599               return FALSE;
11600
11601             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11602               maxchain = gnubuckets[i];
11603           }
11604
11605       if (maxchain == 0xffffffff)
11606         goto no_gnu_hash;
11607
11608       maxchain -= gnusymidx;
11609
11610       if (fseek (filedata->handle,
11611                  (archive_file_offset
11612                   + offset_from_vma (filedata, buckets_vma
11613                                            + 4 * (ngnubuckets + maxchain), 4)),
11614                  SEEK_SET))
11615         {
11616           error (_("Unable to seek to start of dynamic information\n"));
11617           goto no_gnu_hash;
11618         }
11619
11620       do
11621         {
11622           if (fread (nb, 4, 1, filedata->handle) != 1)
11623             {
11624               error (_("Failed to determine last chain length\n"));
11625               goto no_gnu_hash;
11626             }
11627
11628           if (maxchain + 1 == 0)
11629             goto no_gnu_hash;
11630
11631           ++maxchain;
11632         }
11633       while ((byte_get (nb, 4) & 1) == 0);
11634
11635       if (fseek (filedata->handle,
11636                  (archive_file_offset
11637                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11638                  SEEK_SET))
11639         {
11640           error (_("Unable to seek to start of dynamic information\n"));
11641           goto no_gnu_hash;
11642         }
11643
11644       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11645       ngnuchains = maxchain;
11646
11647     no_gnu_hash:
11648       if (gnuchains == NULL)
11649         {
11650           free (gnubuckets);
11651           gnubuckets = NULL;
11652           ngnubuckets = 0;
11653           if (do_using_dynamic)
11654             return FALSE;
11655         }
11656     }
11657
11658   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11659       && do_syms
11660       && do_using_dynamic
11661       && dynamic_strings != NULL
11662       && dynamic_symbols != NULL)
11663     {
11664       unsigned long hn;
11665
11666       if (dynamic_info[DT_HASH])
11667         {
11668           bfd_vma si;
11669           char *visited;
11670
11671           printf (_("\nSymbol table for image:\n"));
11672           if (is_32bit_elf)
11673             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11674           else
11675             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11676
11677           visited = xcmalloc (nchains, 1);
11678           memset (visited, 0, nchains);
11679           for (hn = 0; hn < nbuckets; hn++)
11680             {
11681               for (si = buckets[hn]; si > 0; si = chains[si])
11682                 {
11683                   print_dynamic_symbol (filedata, si, hn);
11684                   if (si >= nchains || visited[si])
11685                     {
11686                       error (_("histogram chain is corrupt\n"));
11687                       break;
11688                     }
11689                   visited[si] = 1;
11690                 }
11691             }
11692           free (visited);
11693         }
11694
11695       if (dynamic_info_DT_GNU_HASH)
11696         {
11697           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11698           if (is_32bit_elf)
11699             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11700           else
11701             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11702
11703           for (hn = 0; hn < ngnubuckets; ++hn)
11704             if (gnubuckets[hn] != 0)
11705               {
11706                 bfd_vma si = gnubuckets[hn];
11707                 bfd_vma off = si - gnusymidx;
11708
11709                 do
11710                   {
11711                     print_dynamic_symbol (filedata, si, hn);
11712                     si++;
11713                   }
11714                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11715               }
11716         }
11717     }
11718   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11719            && filedata->section_headers != NULL)
11720     {
11721       unsigned int i;
11722
11723       for (i = 0, section = filedata->section_headers;
11724            i < filedata->file_header.e_shnum;
11725            i++, section++)
11726         {
11727           unsigned int si;
11728           char * strtab = NULL;
11729           unsigned long int strtab_size = 0;
11730           Elf_Internal_Sym * symtab;
11731           Elf_Internal_Sym * psym;
11732           unsigned long num_syms;
11733
11734           if ((section->sh_type != SHT_SYMTAB
11735                && section->sh_type != SHT_DYNSYM)
11736               || (!do_syms
11737                   && section->sh_type == SHT_SYMTAB))
11738             continue;
11739
11740           if (section->sh_entsize == 0)
11741             {
11742               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11743                       printable_section_name (filedata, section));
11744               continue;
11745             }
11746
11747           num_syms = section->sh_size / section->sh_entsize;
11748           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11749                             "\nSymbol table '%s' contains %lu entries:\n",
11750                             num_syms),
11751                   printable_section_name (filedata, section),
11752                   num_syms);
11753
11754           if (is_32bit_elf)
11755             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11756           else
11757             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11758
11759           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11760           if (symtab == NULL)
11761             continue;
11762
11763           if (section->sh_link == filedata->file_header.e_shstrndx)
11764             {
11765               strtab = filedata->string_table;
11766               strtab_size = filedata->string_table_length;
11767             }
11768           else if (section->sh_link < filedata->file_header.e_shnum)
11769             {
11770               Elf_Internal_Shdr * string_sec;
11771
11772               string_sec = filedata->section_headers + section->sh_link;
11773
11774               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11775                                           1, string_sec->sh_size,
11776                                           _("string table"));
11777               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11778             }
11779
11780           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11781             {
11782               const char *version_string;
11783               enum versioned_symbol_info sym_info;
11784               unsigned short vna_other;
11785
11786               printf ("%6d: ", si);
11787               print_vma (psym->st_value, LONG_HEX);
11788               putchar (' ');
11789               print_vma (psym->st_size, DEC_5);
11790               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11791               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11792               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11793                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11794               else
11795                 {
11796                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11797
11798                   printf (" %-7s", get_symbol_visibility (vis));
11799                   /* Check to see if any other bits in the st_other field are set.
11800                      Note - displaying this information disrupts the layout of the
11801                      table being generated, but for the moment this case is very rare.  */
11802                   if (psym->st_other ^ vis)
11803                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11804                 }
11805               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11806               print_symbol (25, psym->st_name < strtab_size
11807                             ? strtab + psym->st_name : _("<corrupt>"));
11808
11809               version_string
11810                 = get_symbol_version_string (filedata,
11811                                              section->sh_type == SHT_DYNSYM,
11812                                              strtab, strtab_size, si,
11813                                              psym, &sym_info, &vna_other);
11814               if (version_string)
11815                 {
11816                   if (sym_info == symbol_undefined)
11817                     printf ("@%s (%d)", version_string, vna_other);
11818                   else
11819                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11820                             version_string);
11821                 }
11822
11823               putchar ('\n');
11824
11825               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11826                   && si >= section->sh_info
11827                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11828                   && filedata->file_header.e_machine != EM_MIPS
11829                   /* Solaris binaries have been found to violate this requirement as
11830                      well.  Not sure if this is a bug or an ABI requirement.  */
11831                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11832                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11833                       si, printable_section_name (filedata, section), section->sh_info);
11834             }
11835
11836           free (symtab);
11837           if (strtab != filedata->string_table)
11838             free (strtab);
11839         }
11840     }
11841   else if (do_syms)
11842     printf
11843       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11844
11845   if (do_histogram && buckets != NULL)
11846     {
11847       unsigned long * lengths;
11848       unsigned long * counts;
11849       unsigned long hn;
11850       bfd_vma si;
11851       unsigned long maxlength = 0;
11852       unsigned long nzero_counts = 0;
11853       unsigned long nsyms = 0;
11854       char *visited;
11855
11856       printf (ngettext ("\nHistogram for bucket list length "
11857                         "(total of %lu bucket):\n",
11858                         "\nHistogram for bucket list length "
11859                         "(total of %lu buckets):\n",
11860                         (unsigned long) nbuckets),
11861               (unsigned long) nbuckets);
11862
11863       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11864       if (lengths == NULL)
11865         {
11866           error (_("Out of memory allocating space for histogram buckets\n"));
11867           return FALSE;
11868         }
11869       visited = xcmalloc (nchains, 1);
11870       memset (visited, 0, nchains);
11871
11872       printf (_(" Length  Number     %% of total  Coverage\n"));
11873       for (hn = 0; hn < nbuckets; ++hn)
11874         {
11875           for (si = buckets[hn]; si > 0; si = chains[si])
11876             {
11877               ++nsyms;
11878               if (maxlength < ++lengths[hn])
11879                 ++maxlength;
11880               if (si >= nchains || visited[si])
11881                 {
11882                   error (_("histogram chain is corrupt\n"));
11883                   break;
11884                 }
11885               visited[si] = 1;
11886             }
11887         }
11888       free (visited);
11889
11890       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11891       if (counts == NULL)
11892         {
11893           free (lengths);
11894           error (_("Out of memory allocating space for histogram counts\n"));
11895           return FALSE;
11896         }
11897
11898       for (hn = 0; hn < nbuckets; ++hn)
11899         ++counts[lengths[hn]];
11900
11901       if (nbuckets > 0)
11902         {
11903           unsigned long i;
11904           printf ("      0  %-10lu (%5.1f%%)\n",
11905                   counts[0], (counts[0] * 100.0) / nbuckets);
11906           for (i = 1; i <= maxlength; ++i)
11907             {
11908               nzero_counts += counts[i] * i;
11909               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11910                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11911                       (nzero_counts * 100.0) / nsyms);
11912             }
11913         }
11914
11915       free (counts);
11916       free (lengths);
11917     }
11918
11919   if (buckets != NULL)
11920     {
11921       free (buckets);
11922       free (chains);
11923     }
11924
11925   if (do_histogram && gnubuckets != NULL)
11926     {
11927       unsigned long * lengths;
11928       unsigned long * counts;
11929       unsigned long hn;
11930       unsigned long maxlength = 0;
11931       unsigned long nzero_counts = 0;
11932       unsigned long nsyms = 0;
11933
11934       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11935                         "(total of %lu bucket):\n",
11936                         "\nHistogram for `.gnu.hash' bucket list length "
11937                         "(total of %lu buckets):\n",
11938                         (unsigned long) ngnubuckets),
11939               (unsigned long) ngnubuckets);
11940
11941       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11942       if (lengths == NULL)
11943         {
11944           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11945           return FALSE;
11946         }
11947
11948       printf (_(" Length  Number     %% of total  Coverage\n"));
11949
11950       for (hn = 0; hn < ngnubuckets; ++hn)
11951         if (gnubuckets[hn] != 0)
11952           {
11953             bfd_vma off, length = 1;
11954
11955             for (off = gnubuckets[hn] - gnusymidx;
11956                  /* PR 17531 file: 010-77222-0.004.  */
11957                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11958                  ++off)
11959               ++length;
11960             lengths[hn] = length;
11961             if (length > maxlength)
11962               maxlength = length;
11963             nsyms += length;
11964           }
11965
11966       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11967       if (counts == NULL)
11968         {
11969           free (lengths);
11970           error (_("Out of memory allocating space for gnu histogram counts\n"));
11971           return FALSE;
11972         }
11973
11974       for (hn = 0; hn < ngnubuckets; ++hn)
11975         ++counts[lengths[hn]];
11976
11977       if (ngnubuckets > 0)
11978         {
11979           unsigned long j;
11980           printf ("      0  %-10lu (%5.1f%%)\n",
11981                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11982           for (j = 1; j <= maxlength; ++j)
11983             {
11984               nzero_counts += counts[j] * j;
11985               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11986                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11987                       (nzero_counts * 100.0) / nsyms);
11988             }
11989         }
11990
11991       free (counts);
11992       free (lengths);
11993       free (gnubuckets);
11994       free (gnuchains);
11995     }
11996
11997   return TRUE;
11998 }
11999
12000 static bfd_boolean
12001 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12002 {
12003   unsigned int i;
12004
12005   if (dynamic_syminfo == NULL
12006       || !do_dynamic)
12007     /* No syminfo, this is ok.  */
12008     return TRUE;
12009
12010   /* There better should be a dynamic symbol section.  */
12011   if (dynamic_symbols == NULL || dynamic_strings == NULL)
12012     return FALSE;
12013
12014   if (dynamic_addr)
12015     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12016                       "contains %d entry:\n",
12017                       "\nDynamic info segment at offset 0x%lx "
12018                       "contains %d entries:\n",
12019                       dynamic_syminfo_nent),
12020             dynamic_syminfo_offset, dynamic_syminfo_nent);
12021
12022   printf (_(" Num: Name                           BoundTo     Flags\n"));
12023   for (i = 0; i < dynamic_syminfo_nent; ++i)
12024     {
12025       unsigned short int flags = dynamic_syminfo[i].si_flags;
12026
12027       printf ("%4d: ", i);
12028       if (i >= num_dynamic_syms)
12029         printf (_("<corrupt index>"));
12030       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12031         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12032       else
12033         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12034       putchar (' ');
12035
12036       switch (dynamic_syminfo[i].si_boundto)
12037         {
12038         case SYMINFO_BT_SELF:
12039           fputs ("SELF       ", stdout);
12040           break;
12041         case SYMINFO_BT_PARENT:
12042           fputs ("PARENT     ", stdout);
12043           break;
12044         default:
12045           if (dynamic_syminfo[i].si_boundto > 0
12046               && dynamic_syminfo[i].si_boundto < dynamic_nent
12047               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12048             {
12049               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12050               putchar (' ' );
12051             }
12052           else
12053             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12054           break;
12055         }
12056
12057       if (flags & SYMINFO_FLG_DIRECT)
12058         printf (" DIRECT");
12059       if (flags & SYMINFO_FLG_PASSTHRU)
12060         printf (" PASSTHRU");
12061       if (flags & SYMINFO_FLG_COPY)
12062         printf (" COPY");
12063       if (flags & SYMINFO_FLG_LAZYLOAD)
12064         printf (" LAZYLOAD");
12065
12066       puts ("");
12067     }
12068
12069   return TRUE;
12070 }
12071
12072 #define IN_RANGE(START,END,ADDR,OFF)            \
12073   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12074
12075 /* Check to see if the given reloc needs to be handled in a target specific
12076    manner.  If so then process the reloc and return TRUE otherwise return
12077    FALSE.
12078
12079    If called with reloc == NULL, then this is a signal that reloc processing
12080    for the current section has finished, and any saved state should be
12081    discarded.  */
12082
12083 static bfd_boolean
12084 target_specific_reloc_handling (Filedata *           filedata,
12085                                 Elf_Internal_Rela *  reloc,
12086                                 unsigned char *      start,
12087                                 unsigned char *      end,
12088                                 Elf_Internal_Sym *   symtab,
12089                                 unsigned long        num_syms)
12090 {
12091   unsigned int reloc_type = 0;
12092   unsigned long sym_index = 0;
12093
12094   if (reloc)
12095     {
12096       reloc_type = get_reloc_type (filedata, reloc->r_info);
12097       sym_index = get_reloc_symindex (reloc->r_info);
12098     }
12099
12100   switch (filedata->file_header.e_machine)
12101     {
12102     case EM_MSP430:
12103     case EM_MSP430_OLD:
12104       {
12105         static Elf_Internal_Sym * saved_sym = NULL;
12106
12107         if (reloc == NULL)
12108           {
12109             saved_sym = NULL;
12110             return TRUE;
12111           }
12112
12113         switch (reloc_type)
12114           {
12115           case 10: /* R_MSP430_SYM_DIFF */
12116             if (uses_msp430x_relocs (filedata))
12117               break;
12118             /* Fall through.  */
12119           case 21: /* R_MSP430X_SYM_DIFF */
12120             /* PR 21139.  */
12121             if (sym_index >= num_syms)
12122               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12123                      sym_index);
12124             else
12125               saved_sym = symtab + sym_index;
12126             return TRUE;
12127
12128           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12129           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12130             goto handle_sym_diff;
12131
12132           case 5: /* R_MSP430_16_BYTE */
12133           case 9: /* R_MSP430_8 */
12134             if (uses_msp430x_relocs (filedata))
12135               break;
12136             goto handle_sym_diff;
12137
12138           case 2: /* R_MSP430_ABS16 */
12139           case 15: /* R_MSP430X_ABS16 */
12140             if (! uses_msp430x_relocs (filedata))
12141               break;
12142             goto handle_sym_diff;
12143
12144           handle_sym_diff:
12145             if (saved_sym != NULL)
12146               {
12147                 int reloc_size = reloc_type == 1 ? 4 : 2;
12148                 bfd_vma value;
12149
12150                 if (sym_index >= num_syms)
12151                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12152                          sym_index);
12153                 else
12154                   {
12155                     value = reloc->r_addend + (symtab[sym_index].st_value
12156                                                - saved_sym->st_value);
12157
12158                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12159                       byte_put (start + reloc->r_offset, value, reloc_size);
12160                     else
12161                       /* PR 21137 */
12162                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12163                              (long) reloc->r_offset);
12164                   }
12165
12166                 saved_sym = NULL;
12167                 return TRUE;
12168               }
12169             break;
12170
12171           default:
12172             if (saved_sym != NULL)
12173               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12174             break;
12175           }
12176         break;
12177       }
12178
12179     case EM_MN10300:
12180     case EM_CYGNUS_MN10300:
12181       {
12182         static Elf_Internal_Sym * saved_sym = NULL;
12183
12184         if (reloc == NULL)
12185           {
12186             saved_sym = NULL;
12187             return TRUE;
12188           }
12189
12190         switch (reloc_type)
12191           {
12192           case 34: /* R_MN10300_ALIGN */
12193             return TRUE;
12194           case 33: /* R_MN10300_SYM_DIFF */
12195             if (sym_index >= num_syms)
12196               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12197                      sym_index);
12198             else
12199               saved_sym = symtab + sym_index;
12200             return TRUE;
12201
12202           case 1: /* R_MN10300_32 */
12203           case 2: /* R_MN10300_16 */
12204             if (saved_sym != NULL)
12205               {
12206                 int reloc_size = reloc_type == 1 ? 4 : 2;
12207                 bfd_vma value;
12208
12209                 if (sym_index >= num_syms)
12210                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12211                          sym_index);
12212                 else
12213                   {
12214                     value = reloc->r_addend + (symtab[sym_index].st_value
12215                                                - saved_sym->st_value);
12216
12217                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12218                       byte_put (start + reloc->r_offset, value, reloc_size);
12219                     else
12220                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12221                              (long) reloc->r_offset);
12222                   }
12223
12224                 saved_sym = NULL;
12225                 return TRUE;
12226               }
12227             break;
12228           default:
12229             if (saved_sym != NULL)
12230               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12231             break;
12232           }
12233         break;
12234       }
12235
12236     case EM_RL78:
12237       {
12238         static bfd_vma saved_sym1 = 0;
12239         static bfd_vma saved_sym2 = 0;
12240         static bfd_vma value;
12241
12242         if (reloc == NULL)
12243           {
12244             saved_sym1 = saved_sym2 = 0;
12245             return TRUE;
12246           }
12247
12248         switch (reloc_type)
12249           {
12250           case 0x80: /* R_RL78_SYM.  */
12251             saved_sym1 = saved_sym2;
12252             if (sym_index >= num_syms)
12253               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12254                      sym_index);
12255             else
12256               {
12257                 saved_sym2 = symtab[sym_index].st_value;
12258                 saved_sym2 += reloc->r_addend;
12259               }
12260             return TRUE;
12261
12262           case 0x83: /* R_RL78_OPsub.  */
12263             value = saved_sym1 - saved_sym2;
12264             saved_sym2 = saved_sym1 = 0;
12265             return TRUE;
12266             break;
12267
12268           case 0x41: /* R_RL78_ABS32.  */
12269             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12270               byte_put (start + reloc->r_offset, value, 4);
12271             else
12272               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12273                      (long) reloc->r_offset);
12274             value = 0;
12275             return TRUE;
12276
12277           case 0x43: /* R_RL78_ABS16.  */
12278             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12279               byte_put (start + reloc->r_offset, value, 2);
12280             else
12281               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12282                      (long) reloc->r_offset);
12283             value = 0;
12284             return TRUE;
12285
12286           default:
12287             break;
12288           }
12289         break;
12290       }
12291     }
12292
12293   return FALSE;
12294 }
12295
12296 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12297    DWARF debug sections.  This is a target specific test.  Note - we do not
12298    go through the whole including-target-headers-multiple-times route, (as
12299    we have already done with <elf/h8.h>) because this would become very
12300    messy and even then this function would have to contain target specific
12301    information (the names of the relocs instead of their numeric values).
12302    FIXME: This is not the correct way to solve this problem.  The proper way
12303    is to have target specific reloc sizing and typing functions created by
12304    the reloc-macros.h header, in the same way that it already creates the
12305    reloc naming functions.  */
12306
12307 static bfd_boolean
12308 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12309 {
12310   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12311   switch (filedata->file_header.e_machine)
12312     {
12313     case EM_386:
12314     case EM_IAMCU:
12315       return reloc_type == 1; /* R_386_32.  */
12316     case EM_68K:
12317       return reloc_type == 1; /* R_68K_32.  */
12318     case EM_860:
12319       return reloc_type == 1; /* R_860_32.  */
12320     case EM_960:
12321       return reloc_type == 2; /* R_960_32.  */
12322     case EM_AARCH64:
12323       return (reloc_type == 258
12324               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12325     case EM_ADAPTEVA_EPIPHANY:
12326       return reloc_type == 3;
12327     case EM_ALPHA:
12328       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12329     case EM_ARC:
12330       return reloc_type == 1; /* R_ARC_32.  */
12331     case EM_ARC_COMPACT:
12332     case EM_ARC_COMPACT2:
12333       return reloc_type == 4; /* R_ARC_32.  */
12334     case EM_ARM:
12335       return reloc_type == 2; /* R_ARM_ABS32 */
12336     case EM_AVR_OLD:
12337     case EM_AVR:
12338       return reloc_type == 1;
12339     case EM_BLACKFIN:
12340       return reloc_type == 0x12; /* R_byte4_data.  */
12341     case EM_CRIS:
12342       return reloc_type == 3; /* R_CRIS_32.  */
12343     case EM_CR16:
12344       return reloc_type == 3; /* R_CR16_NUM32.  */
12345     case EM_CRX:
12346       return reloc_type == 15; /* R_CRX_NUM32.  */
12347     case EM_CSKY:
12348       return reloc_type == 1; /* R_CKCORE_ADDR32.  */
12349     case EM_CYGNUS_FRV:
12350       return reloc_type == 1;
12351     case EM_CYGNUS_D10V:
12352     case EM_D10V:
12353       return reloc_type == 6; /* R_D10V_32.  */
12354     case EM_CYGNUS_D30V:
12355     case EM_D30V:
12356       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12357     case EM_DLX:
12358       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12359     case EM_CYGNUS_FR30:
12360     case EM_FR30:
12361       return reloc_type == 3; /* R_FR30_32.  */
12362     case EM_FT32:
12363       return reloc_type == 1; /* R_FT32_32.  */
12364     case EM_H8S:
12365     case EM_H8_300:
12366     case EM_H8_300H:
12367       return reloc_type == 1; /* R_H8_DIR32.  */
12368     case EM_IA_64:
12369       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12370               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12371               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12372               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12373     case EM_IP2K_OLD:
12374     case EM_IP2K:
12375       return reloc_type == 2; /* R_IP2K_32.  */
12376     case EM_IQ2000:
12377       return reloc_type == 2; /* R_IQ2000_32.  */
12378     case EM_LATTICEMICO32:
12379       return reloc_type == 3; /* R_LM32_32.  */
12380     case EM_M32C_OLD:
12381     case EM_M32C:
12382       return reloc_type == 3; /* R_M32C_32.  */
12383     case EM_M32R:
12384       return reloc_type == 34; /* R_M32R_32_RELA.  */
12385     case EM_68HC11:
12386     case EM_68HC12:
12387       return reloc_type == 6; /* R_M68HC11_32.  */
12388     case EM_S12Z:
12389       return reloc_type == 6; /* R_S12Z_EXT32.  */
12390     case EM_MCORE:
12391       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12392     case EM_CYGNUS_MEP:
12393       return reloc_type == 4; /* R_MEP_32.  */
12394     case EM_METAG:
12395       return reloc_type == 2; /* R_METAG_ADDR32.  */
12396     case EM_MICROBLAZE:
12397       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12398     case EM_MIPS:
12399       return reloc_type == 2; /* R_MIPS_32.  */
12400     case EM_MMIX:
12401       return reloc_type == 4; /* R_MMIX_32.  */
12402     case EM_CYGNUS_MN10200:
12403     case EM_MN10200:
12404       return reloc_type == 1; /* R_MN10200_32.  */
12405     case EM_CYGNUS_MN10300:
12406     case EM_MN10300:
12407       return reloc_type == 1; /* R_MN10300_32.  */
12408     case EM_MOXIE:
12409       return reloc_type == 1; /* R_MOXIE_32.  */
12410     case EM_MSP430_OLD:
12411     case EM_MSP430:
12412       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12413     case EM_MT:
12414       return reloc_type == 2; /* R_MT_32.  */
12415     case EM_NDS32:
12416       return reloc_type == 20; /* R_NDS32_RELA.  */
12417     case EM_ALTERA_NIOS2:
12418       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12419     case EM_NIOS32:
12420       return reloc_type == 1; /* R_NIOS_32.  */
12421     case EM_OR1K:
12422       return reloc_type == 1; /* R_OR1K_32.  */
12423     case EM_PARISC:
12424       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12425               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12426               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12427     case EM_PJ:
12428     case EM_PJ_OLD:
12429       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12430     case EM_PPC64:
12431       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12432     case EM_PPC:
12433       return reloc_type == 1; /* R_PPC_ADDR32.  */
12434     case EM_TI_PRU:
12435       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12436     case EM_RISCV:
12437       return reloc_type == 1; /* R_RISCV_32.  */
12438     case EM_RL78:
12439       return reloc_type == 1; /* R_RL78_DIR32.  */
12440     case EM_RX:
12441       return reloc_type == 1; /* R_RX_DIR32.  */
12442     case EM_S370:
12443       return reloc_type == 1; /* R_I370_ADDR31.  */
12444     case EM_S390_OLD:
12445     case EM_S390:
12446       return reloc_type == 4; /* R_S390_32.  */
12447     case EM_SCORE:
12448       return reloc_type == 8; /* R_SCORE_ABS32.  */
12449     case EM_SH:
12450       return reloc_type == 1; /* R_SH_DIR32.  */
12451     case EM_SPARC32PLUS:
12452     case EM_SPARCV9:
12453     case EM_SPARC:
12454       return reloc_type == 3 /* R_SPARC_32.  */
12455         || reloc_type == 23; /* R_SPARC_UA32.  */
12456     case EM_SPU:
12457       return reloc_type == 6; /* R_SPU_ADDR32 */
12458     case EM_TI_C6000:
12459       return reloc_type == 1; /* R_C6000_ABS32.  */
12460     case EM_TILEGX:
12461       return reloc_type == 2; /* R_TILEGX_32.  */
12462     case EM_TILEPRO:
12463       return reloc_type == 1; /* R_TILEPRO_32.  */
12464     case EM_CYGNUS_V850:
12465     case EM_V850:
12466       return reloc_type == 6; /* R_V850_ABS32.  */
12467     case EM_V800:
12468       return reloc_type == 0x33; /* R_V810_WORD.  */
12469     case EM_VAX:
12470       return reloc_type == 1; /* R_VAX_32.  */
12471     case EM_VISIUM:
12472       return reloc_type == 3;  /* R_VISIUM_32. */
12473     case EM_WEBASSEMBLY:
12474       return reloc_type == 1;  /* R_WASM32_32.  */
12475     case EM_X86_64:
12476     case EM_L1OM:
12477     case EM_K1OM:
12478       return reloc_type == 10; /* R_X86_64_32.  */
12479     case EM_XC16X:
12480     case EM_C166:
12481       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12482     case EM_XGATE:
12483       return reloc_type == 4; /* R_XGATE_32.  */
12484     case EM_XSTORMY16:
12485       return reloc_type == 1; /* R_XSTROMY16_32.  */
12486     case EM_XTENSA_OLD:
12487     case EM_XTENSA:
12488       return reloc_type == 1; /* R_XTENSA_32.  */
12489     default:
12490       {
12491         static unsigned int prev_warn = 0;
12492
12493         /* Avoid repeating the same warning multiple times.  */
12494         if (prev_warn != filedata->file_header.e_machine)
12495           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12496                  filedata->file_header.e_machine);
12497         prev_warn = filedata->file_header.e_machine;
12498         return FALSE;
12499       }
12500     }
12501 }
12502
12503 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12504    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12505
12506 static bfd_boolean
12507 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12508 {
12509   switch (filedata->file_header.e_machine)
12510   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12511     {
12512     case EM_386:
12513     case EM_IAMCU:
12514       return reloc_type == 2;  /* R_386_PC32.  */
12515     case EM_68K:
12516       return reloc_type == 4;  /* R_68K_PC32.  */
12517     case EM_AARCH64:
12518       return reloc_type == 261; /* R_AARCH64_PREL32 */
12519     case EM_ADAPTEVA_EPIPHANY:
12520       return reloc_type == 6;
12521     case EM_ALPHA:
12522       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12523     case EM_ARC_COMPACT:
12524     case EM_ARC_COMPACT2:
12525       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12526     case EM_ARM:
12527       return reloc_type == 3;  /* R_ARM_REL32 */
12528     case EM_AVR_OLD:
12529     case EM_AVR:
12530       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12531     case EM_MICROBLAZE:
12532       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12533     case EM_OR1K:
12534       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12535     case EM_PARISC:
12536       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12537     case EM_PPC:
12538       return reloc_type == 26; /* R_PPC_REL32.  */
12539     case EM_PPC64:
12540       return reloc_type == 26; /* R_PPC64_REL32.  */
12541     case EM_S390_OLD:
12542     case EM_S390:
12543       return reloc_type == 5;  /* R_390_PC32.  */
12544     case EM_SH:
12545       return reloc_type == 2;  /* R_SH_REL32.  */
12546     case EM_SPARC32PLUS:
12547     case EM_SPARCV9:
12548     case EM_SPARC:
12549       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12550     case EM_SPU:
12551       return reloc_type == 13; /* R_SPU_REL32.  */
12552     case EM_TILEGX:
12553       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12554     case EM_TILEPRO:
12555       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12556     case EM_VISIUM:
12557       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12558     case EM_X86_64:
12559     case EM_L1OM:
12560     case EM_K1OM:
12561       return reloc_type == 2;  /* R_X86_64_PC32.  */
12562     case EM_XTENSA_OLD:
12563     case EM_XTENSA:
12564       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12565     default:
12566       /* Do not abort or issue an error message here.  Not all targets use
12567          pc-relative 32-bit relocs in their DWARF debug information and we
12568          have already tested for target coverage in is_32bit_abs_reloc.  A
12569          more helpful warning message will be generated by apply_relocations
12570          anyway, so just return.  */
12571       return FALSE;
12572     }
12573 }
12574
12575 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12576    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12577
12578 static bfd_boolean
12579 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12580 {
12581   switch (filedata->file_header.e_machine)
12582     {
12583     case EM_AARCH64:
12584       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12585     case EM_ALPHA:
12586       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12587     case EM_IA_64:
12588       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12589               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12590     case EM_PARISC:
12591       return reloc_type == 80; /* R_PARISC_DIR64.  */
12592     case EM_PPC64:
12593       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12594     case EM_RISCV:
12595       return reloc_type == 2; /* R_RISCV_64.  */
12596     case EM_SPARC32PLUS:
12597     case EM_SPARCV9:
12598     case EM_SPARC:
12599       return reloc_type == 32 /* R_SPARC_64.  */
12600         || reloc_type == 54; /* R_SPARC_UA64.  */
12601     case EM_X86_64:
12602     case EM_L1OM:
12603     case EM_K1OM:
12604       return reloc_type == 1; /* R_X86_64_64.  */
12605     case EM_S390_OLD:
12606     case EM_S390:
12607       return reloc_type == 22;  /* R_S390_64.  */
12608     case EM_TILEGX:
12609       return reloc_type == 1; /* R_TILEGX_64.  */
12610     case EM_MIPS:
12611       return reloc_type == 18;  /* R_MIPS_64.  */
12612     default:
12613       return FALSE;
12614     }
12615 }
12616
12617 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12618    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12619
12620 static bfd_boolean
12621 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12622 {
12623   switch (filedata->file_header.e_machine)
12624     {
12625     case EM_AARCH64:
12626       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12627     case EM_ALPHA:
12628       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12629     case EM_IA_64:
12630       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12631               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12632     case EM_PARISC:
12633       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12634     case EM_PPC64:
12635       return reloc_type == 44; /* R_PPC64_REL64.  */
12636     case EM_SPARC32PLUS:
12637     case EM_SPARCV9:
12638     case EM_SPARC:
12639       return reloc_type == 46; /* R_SPARC_DISP64.  */
12640     case EM_X86_64:
12641     case EM_L1OM:
12642     case EM_K1OM:
12643       return reloc_type == 24; /* R_X86_64_PC64.  */
12644     case EM_S390_OLD:
12645     case EM_S390:
12646       return reloc_type == 23;  /* R_S390_PC64.  */
12647     case EM_TILEGX:
12648       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12649     default:
12650       return FALSE;
12651     }
12652 }
12653
12654 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12655    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12656
12657 static bfd_boolean
12658 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12659 {
12660   switch (filedata->file_header.e_machine)
12661     {
12662     case EM_CYGNUS_MN10200:
12663     case EM_MN10200:
12664       return reloc_type == 4; /* R_MN10200_24.  */
12665     case EM_FT32:
12666       return reloc_type == 5; /* R_FT32_20.  */
12667     default:
12668       return FALSE;
12669     }
12670 }
12671
12672 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12673    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12674
12675 static bfd_boolean
12676 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12677 {
12678   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12679   switch (filedata->file_header.e_machine)
12680     {
12681     case EM_ARC:
12682     case EM_ARC_COMPACT:
12683     case EM_ARC_COMPACT2:
12684       return reloc_type == 2; /* R_ARC_16.  */
12685     case EM_ADAPTEVA_EPIPHANY:
12686       return reloc_type == 5;
12687     case EM_AVR_OLD:
12688     case EM_AVR:
12689       return reloc_type == 4; /* R_AVR_16.  */
12690     case EM_CYGNUS_D10V:
12691     case EM_D10V:
12692       return reloc_type == 3; /* R_D10V_16.  */
12693     case EM_FT32:
12694       return reloc_type == 2; /* R_FT32_16.  */
12695     case EM_H8S:
12696     case EM_H8_300:
12697     case EM_H8_300H:
12698       return reloc_type == R_H8_DIR16;
12699     case EM_IP2K_OLD:
12700     case EM_IP2K:
12701       return reloc_type == 1; /* R_IP2K_16.  */
12702     case EM_M32C_OLD:
12703     case EM_M32C:
12704       return reloc_type == 1; /* R_M32C_16 */
12705     case EM_CYGNUS_MN10200:
12706     case EM_MN10200:
12707       return reloc_type == 2; /* R_MN10200_16.  */
12708     case EM_CYGNUS_MN10300:
12709     case EM_MN10300:
12710       return reloc_type == 2; /* R_MN10300_16.  */
12711     case EM_MSP430:
12712       if (uses_msp430x_relocs (filedata))
12713         return reloc_type == 2; /* R_MSP430_ABS16.  */
12714       /* Fall through.  */
12715     case EM_MSP430_OLD:
12716       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12717     case EM_NDS32:
12718       return reloc_type == 19; /* R_NDS32_RELA.  */
12719     case EM_ALTERA_NIOS2:
12720       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12721     case EM_NIOS32:
12722       return reloc_type == 9; /* R_NIOS_16.  */
12723     case EM_OR1K:
12724       return reloc_type == 2; /* R_OR1K_16.  */
12725     case EM_RISCV:
12726       return reloc_type == 55; /* R_RISCV_SET16.  */
12727     case EM_TI_PRU:
12728       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12729     case EM_TI_C6000:
12730       return reloc_type == 2; /* R_C6000_ABS16.  */
12731     case EM_VISIUM:
12732       return reloc_type == 2; /* R_VISIUM_16. */
12733     case EM_XC16X:
12734     case EM_C166:
12735       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12736     case EM_XGATE:
12737       return reloc_type == 3; /* R_XGATE_16.  */
12738     default:
12739       return FALSE;
12740     }
12741 }
12742
12743 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12744    a 8-bit absolute RELA relocation used in DWARF debug sections.  */
12745
12746 static bfd_boolean
12747 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12748 {
12749   switch (filedata->file_header.e_machine)
12750     {
12751     case EM_RISCV:
12752       return reloc_type == 54; /* R_RISCV_SET8.  */
12753     default:
12754       return FALSE;
12755     }
12756 }
12757
12758 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12759    a 6-bit absolute RELA relocation used in DWARF debug sections.  */
12760
12761 static bfd_boolean
12762 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12763 {
12764   switch (filedata->file_header.e_machine)
12765     {
12766     case EM_RISCV:
12767       return reloc_type == 53; /* R_RISCV_SET6.  */
12768     default:
12769       return FALSE;
12770     }
12771 }
12772
12773 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12774    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12775
12776 static bfd_boolean
12777 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12778 {
12779   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12780   switch (filedata->file_header.e_machine)
12781     {
12782     case EM_RISCV:
12783       return reloc_type == 35; /* R_RISCV_ADD32.  */
12784     default:
12785       return FALSE;
12786     }
12787 }
12788
12789 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12790    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12791
12792 static bfd_boolean
12793 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12794 {
12795   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12796   switch (filedata->file_header.e_machine)
12797     {
12798     case EM_RISCV:
12799       return reloc_type == 39; /* R_RISCV_SUB32.  */
12800     default:
12801       return FALSE;
12802     }
12803 }
12804
12805 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12806    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12807
12808 static bfd_boolean
12809 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12810 {
12811   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12812   switch (filedata->file_header.e_machine)
12813     {
12814     case EM_RISCV:
12815       return reloc_type == 36; /* R_RISCV_ADD64.  */
12816     default:
12817       return FALSE;
12818     }
12819 }
12820
12821 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12822    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12823
12824 static bfd_boolean
12825 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12826 {
12827   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12828   switch (filedata->file_header.e_machine)
12829     {
12830     case EM_RISCV:
12831       return reloc_type == 40; /* R_RISCV_SUB64.  */
12832     default:
12833       return FALSE;
12834     }
12835 }
12836
12837 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12838    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12839
12840 static bfd_boolean
12841 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12842 {
12843   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12844   switch (filedata->file_header.e_machine)
12845     {
12846     case EM_RISCV:
12847       return reloc_type == 34; /* R_RISCV_ADD16.  */
12848     default:
12849       return FALSE;
12850     }
12851 }
12852
12853 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12854    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12855
12856 static bfd_boolean
12857 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12858 {
12859   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12860   switch (filedata->file_header.e_machine)
12861     {
12862     case EM_RISCV:
12863       return reloc_type == 38; /* R_RISCV_SUB16.  */
12864     default:
12865       return FALSE;
12866     }
12867 }
12868
12869 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12870    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12871
12872 static bfd_boolean
12873 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12874 {
12875   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12876   switch (filedata->file_header.e_machine)
12877     {
12878     case EM_RISCV:
12879       return reloc_type == 33; /* R_RISCV_ADD8.  */
12880     default:
12881       return FALSE;
12882     }
12883 }
12884
12885 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12886    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12887
12888 static bfd_boolean
12889 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12890 {
12891   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12892   switch (filedata->file_header.e_machine)
12893     {
12894     case EM_RISCV:
12895       return reloc_type == 37; /* R_RISCV_SUB8.  */
12896     default:
12897       return FALSE;
12898     }
12899 }
12900
12901 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12902    a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
12903
12904 static bfd_boolean
12905 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12906 {
12907   switch (filedata->file_header.e_machine)
12908     {
12909     case EM_RISCV:
12910       return reloc_type == 52; /* R_RISCV_SUB6.  */
12911     default:
12912       return FALSE;
12913     }
12914 }
12915
12916 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12917    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12918
12919 static bfd_boolean
12920 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12921 {
12922   switch (filedata->file_header.e_machine)
12923     {
12924     case EM_386:     /* R_386_NONE.  */
12925     case EM_68K:     /* R_68K_NONE.  */
12926     case EM_ADAPTEVA_EPIPHANY:
12927     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12928     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12929     case EM_ARC:     /* R_ARC_NONE.  */
12930     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12931     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12932     case EM_ARM:     /* R_ARM_NONE.  */
12933     case EM_C166:    /* R_XC16X_NONE.  */
12934     case EM_CRIS:    /* R_CRIS_NONE.  */
12935     case EM_FT32:    /* R_FT32_NONE.  */
12936     case EM_IA_64:   /* R_IA64_NONE.  */
12937     case EM_K1OM:    /* R_X86_64_NONE.  */
12938     case EM_L1OM:    /* R_X86_64_NONE.  */
12939     case EM_M32R:    /* R_M32R_NONE.  */
12940     case EM_MIPS:    /* R_MIPS_NONE.  */
12941     case EM_MN10300: /* R_MN10300_NONE.  */
12942     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12943     case EM_NIOS32:  /* R_NIOS_NONE.  */
12944     case EM_OR1K:    /* R_OR1K_NONE. */
12945     case EM_PARISC:  /* R_PARISC_NONE.  */
12946     case EM_PPC64:   /* R_PPC64_NONE.  */
12947     case EM_PPC:     /* R_PPC_NONE.  */
12948     case EM_RISCV:   /* R_RISCV_NONE.  */
12949     case EM_S390:    /* R_390_NONE.  */
12950     case EM_S390_OLD:
12951     case EM_SH:      /* R_SH_NONE.  */
12952     case EM_SPARC32PLUS:
12953     case EM_SPARC:   /* R_SPARC_NONE.  */
12954     case EM_SPARCV9:
12955     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12956     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12957     case EM_TI_C6000:/* R_C6000_NONE.  */
12958     case EM_X86_64:  /* R_X86_64_NONE.  */
12959     case EM_XC16X:
12960     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12961       return reloc_type == 0;
12962
12963     case EM_AARCH64:
12964       return reloc_type == 0 || reloc_type == 256;
12965     case EM_AVR_OLD:
12966     case EM_AVR:
12967       return (reloc_type == 0 /* R_AVR_NONE.  */
12968               || reloc_type == 30 /* R_AVR_DIFF8.  */
12969               || reloc_type == 31 /* R_AVR_DIFF16.  */
12970               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12971     case EM_METAG:
12972       return reloc_type == 3; /* R_METAG_NONE.  */
12973     case EM_NDS32:
12974       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12975               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12976               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12977               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12978               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12979     case EM_TI_PRU:
12980       return (reloc_type == 0       /* R_PRU_NONE.  */
12981               || reloc_type == 65   /* R_PRU_DIFF8.  */
12982               || reloc_type == 66   /* R_PRU_DIFF16.  */
12983               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12984     case EM_XTENSA_OLD:
12985     case EM_XTENSA:
12986       return (reloc_type == 0      /* R_XTENSA_NONE.  */
12987               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
12988               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
12989               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
12990     }
12991   return FALSE;
12992 }
12993
12994 /* Returns TRUE if there is a relocation against
12995    section NAME at OFFSET bytes.  */
12996
12997 bfd_boolean
12998 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12999 {
13000   Elf_Internal_Rela * relocs;
13001   Elf_Internal_Rela * rp;
13002
13003   if (dsec == NULL || dsec->reloc_info == NULL)
13004     return FALSE;
13005
13006   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13007
13008   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13009     if (rp->r_offset == offset)
13010       return TRUE;
13011
13012    return FALSE;
13013 }
13014
13015 /* Apply relocations to a section.
13016    Returns TRUE upon success, FALSE otherwise.
13017    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13018    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
13019    will be set to the number of relocs loaded.
13020
13021    Note: So far support has been added only for those relocations
13022    which can be found in debug sections. FIXME: Add support for
13023    more relocations ?  */
13024
13025 static bfd_boolean
13026 apply_relocations (Filedata *                 filedata,
13027                    const Elf_Internal_Shdr *  section,
13028                    unsigned char *            start,
13029                    bfd_size_type              size,
13030                    void **                    relocs_return,
13031                    unsigned long *            num_relocs_return)
13032 {
13033   Elf_Internal_Shdr * relsec;
13034   unsigned char * end = start + size;
13035   bfd_boolean res = TRUE;
13036
13037   if (relocs_return != NULL)
13038     {
13039       * (Elf_Internal_Rela **) relocs_return = NULL;
13040       * num_relocs_return = 0;
13041     }
13042
13043   if (filedata->file_header.e_type != ET_REL)
13044     /* No relocs to apply.  */
13045     return TRUE;
13046
13047   /* Find the reloc section associated with the section.  */
13048   for (relsec = filedata->section_headers;
13049        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13050        ++relsec)
13051     {
13052       bfd_boolean is_rela;
13053       unsigned long num_relocs;
13054       Elf_Internal_Rela * relocs;
13055       Elf_Internal_Rela * rp;
13056       Elf_Internal_Shdr * symsec;
13057       Elf_Internal_Sym * symtab;
13058       unsigned long num_syms;
13059       Elf_Internal_Sym * sym;
13060
13061       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13062           || relsec->sh_info >= filedata->file_header.e_shnum
13063           || filedata->section_headers + relsec->sh_info != section
13064           || relsec->sh_size == 0
13065           || relsec->sh_link >= filedata->file_header.e_shnum)
13066         continue;
13067
13068       is_rela = relsec->sh_type == SHT_RELA;
13069
13070       if (is_rela)
13071         {
13072           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13073                                   relsec->sh_size, & relocs, & num_relocs))
13074             return FALSE;
13075         }
13076       else
13077         {
13078           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13079                                  relsec->sh_size, & relocs, & num_relocs))
13080             return FALSE;
13081         }
13082
13083       /* SH uses RELA but uses in place value instead of the addend field.  */
13084       if (filedata->file_header.e_machine == EM_SH)
13085         is_rela = FALSE;
13086
13087       symsec = filedata->section_headers + relsec->sh_link;
13088       if (symsec->sh_type != SHT_SYMTAB
13089           && symsec->sh_type != SHT_DYNSYM)
13090         return FALSE;
13091       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13092
13093       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13094         {
13095           bfd_vma         addend;
13096           unsigned int    reloc_type;
13097           unsigned int    reloc_size;
13098           bfd_boolean     reloc_inplace = FALSE;
13099           bfd_boolean     reloc_subtract = FALSE;
13100           unsigned char * rloc;
13101           unsigned long   sym_index;
13102
13103           reloc_type = get_reloc_type (filedata, rp->r_info);
13104
13105           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13106             continue;
13107           else if (is_none_reloc (filedata, reloc_type))
13108             continue;
13109           else if (is_32bit_abs_reloc (filedata, reloc_type)
13110                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13111             reloc_size = 4;
13112           else if (is_64bit_abs_reloc (filedata, reloc_type)
13113                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13114             reloc_size = 8;
13115           else if (is_24bit_abs_reloc (filedata, reloc_type))
13116             reloc_size = 3;
13117           else if (is_16bit_abs_reloc (filedata, reloc_type))
13118             reloc_size = 2;
13119           else if (is_8bit_abs_reloc (filedata, reloc_type)
13120                    || is_6bit_abs_reloc (filedata, reloc_type))
13121             reloc_size = 1;
13122           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13123                                                                  reloc_type))
13124                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13125             {
13126               reloc_size = 4;
13127               reloc_inplace = TRUE;
13128             }
13129           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13130                                                                  reloc_type))
13131                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13132             {
13133               reloc_size = 8;
13134               reloc_inplace = TRUE;
13135             }
13136           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13137                                                                  reloc_type))
13138                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13139             {
13140               reloc_size = 2;
13141               reloc_inplace = TRUE;
13142             }
13143           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13144                                                                 reloc_type))
13145                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13146             {
13147               reloc_size = 1;
13148               reloc_inplace = TRUE;
13149             }
13150           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13151                                                                 reloc_type)))
13152             {
13153               reloc_size = 1;
13154               reloc_inplace = TRUE;
13155             }
13156           else
13157             {
13158               static unsigned int prev_reloc = 0;
13159
13160               if (reloc_type != prev_reloc)
13161                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13162                       reloc_type, printable_section_name (filedata, section));
13163               prev_reloc = reloc_type;
13164               res = FALSE;
13165               continue;
13166             }
13167
13168           rloc = start + rp->r_offset;
13169           if ((rloc + reloc_size) > end || (rloc < start))
13170             {
13171               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13172                     (unsigned long) rp->r_offset,
13173                     printable_section_name (filedata, section));
13174               res = FALSE;
13175               continue;
13176             }
13177
13178           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13179           if (sym_index >= num_syms)
13180             {
13181               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13182                     sym_index, printable_section_name (filedata, section));
13183               res = FALSE;
13184               continue;
13185             }
13186           sym = symtab + sym_index;
13187
13188           /* If the reloc has a symbol associated with it,
13189              make sure that it is of an appropriate type.
13190
13191              Relocations against symbols without type can happen.
13192              Gcc -feliminate-dwarf2-dups may generate symbols
13193              without type for debug info.
13194
13195              Icc generates relocations against function symbols
13196              instead of local labels.
13197
13198              Relocations against object symbols can happen, eg when
13199              referencing a global array.  For an example of this see
13200              the _clz.o binary in libgcc.a.  */
13201           if (sym != symtab
13202               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13203               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13204             {
13205               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13206                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13207                     printable_section_name (filedata, relsec),
13208                     (long int)(rp - relocs));
13209               res = FALSE;
13210               continue;
13211             }
13212
13213           addend = 0;
13214           if (is_rela)
13215             addend += rp->r_addend;
13216           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13217              partial_inplace.  */
13218           if (!is_rela
13219               || (filedata->file_header.e_machine == EM_XTENSA
13220                   && reloc_type == 1)
13221               || ((filedata->file_header.e_machine == EM_PJ
13222                    || filedata->file_header.e_machine == EM_PJ_OLD)
13223                   && reloc_type == 1)
13224               || ((filedata->file_header.e_machine == EM_D30V
13225                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13226                   && reloc_type == 12)
13227               || reloc_inplace)
13228             {
13229               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13230                 addend += byte_get (rloc, reloc_size) & 0x3f;
13231               else
13232                 addend += byte_get (rloc, reloc_size);
13233             }
13234
13235           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13236               || is_64bit_pcrel_reloc (filedata, reloc_type))
13237             {
13238               /* On HPPA, all pc-relative relocations are biased by 8.  */
13239               if (filedata->file_header.e_machine == EM_PARISC)
13240                 addend -= 8;
13241               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13242                         reloc_size);
13243             }
13244           else if (is_6bit_abs_reloc (filedata, reloc_type)
13245                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13246             {
13247               if (reloc_subtract)
13248                 addend -= sym->st_value;
13249               else
13250                 addend += sym->st_value;
13251               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13252               byte_put (rloc, addend, reloc_size);
13253             }
13254           else if (reloc_subtract)
13255             byte_put (rloc, addend - sym->st_value, reloc_size);
13256           else
13257             byte_put (rloc, addend + sym->st_value, reloc_size);
13258         }
13259
13260       free (symtab);
13261       /* Let the target specific reloc processing code know that
13262          we have finished with these relocs.  */
13263       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13264
13265       if (relocs_return)
13266         {
13267           * (Elf_Internal_Rela **) relocs_return = relocs;
13268           * num_relocs_return = num_relocs;
13269         }
13270       else
13271         free (relocs);
13272
13273       break;
13274     }
13275
13276   return res;
13277 }
13278
13279 #ifdef SUPPORT_DISASSEMBLY
13280 static bfd_boolean
13281 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13282 {
13283   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13284
13285   /* FIXME: XXX -- to be done --- XXX */
13286
13287   return TRUE;
13288 }
13289 #endif
13290
13291 /* Reads in the contents of SECTION from FILE, returning a pointer
13292    to a malloc'ed buffer or NULL if something went wrong.  */
13293
13294 static char *
13295 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13296 {
13297   bfd_size_type num_bytes = section->sh_size;
13298
13299   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13300     {
13301       printf (_("Section '%s' has no data to dump.\n"),
13302               printable_section_name (filedata, section));
13303       return NULL;
13304     }
13305
13306   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13307                              _("section contents"));
13308 }
13309
13310 /* Uncompresses a section that was compressed using zlib, in place.  */
13311
13312 static bfd_boolean
13313 uncompress_section_contents (unsigned char **   buffer,
13314                              dwarf_size_type    uncompressed_size,
13315                              dwarf_size_type *  size)
13316 {
13317   dwarf_size_type compressed_size = *size;
13318   unsigned char * compressed_buffer = *buffer;
13319   unsigned char * uncompressed_buffer;
13320   z_stream strm;
13321   int rc;
13322
13323   /* It is possible the section consists of several compressed
13324      buffers concatenated together, so we uncompress in a loop.  */
13325   /* PR 18313: The state field in the z_stream structure is supposed
13326      to be invisible to the user (ie us), but some compilers will
13327      still complain about it being used without initialisation.  So
13328      we first zero the entire z_stream structure and then set the fields
13329      that we need.  */
13330   memset (& strm, 0, sizeof strm);
13331   strm.avail_in = compressed_size;
13332   strm.next_in = (Bytef *) compressed_buffer;
13333   strm.avail_out = uncompressed_size;
13334   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13335
13336   rc = inflateInit (& strm);
13337   while (strm.avail_in > 0)
13338     {
13339       if (rc != Z_OK)
13340         goto fail;
13341       strm.next_out = ((Bytef *) uncompressed_buffer
13342                        + (uncompressed_size - strm.avail_out));
13343       rc = inflate (&strm, Z_FINISH);
13344       if (rc != Z_STREAM_END)
13345         goto fail;
13346       rc = inflateReset (& strm);
13347     }
13348   rc = inflateEnd (& strm);
13349   if (rc != Z_OK
13350       || strm.avail_out != 0)
13351     goto fail;
13352
13353   *buffer = uncompressed_buffer;
13354   *size = uncompressed_size;
13355   return TRUE;
13356
13357  fail:
13358   free (uncompressed_buffer);
13359   /* Indicate decompression failure.  */
13360   *buffer = NULL;
13361   return FALSE;
13362 }
13363
13364 static bfd_boolean
13365 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13366 {
13367   Elf_Internal_Shdr *  relsec;
13368   bfd_size_type        num_bytes;
13369   unsigned char *      data;
13370   unsigned char *      end;
13371   unsigned char *      real_start;
13372   unsigned char *      start;
13373   bfd_boolean          some_strings_shown;
13374
13375   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13376   if (start == NULL)
13377     /* PR 21820: Do not fail if the section was empty.  */
13378     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13379
13380   num_bytes = section->sh_size;
13381
13382   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13383
13384   if (decompress_dumps)
13385     {
13386       dwarf_size_type new_size = num_bytes;
13387       dwarf_size_type uncompressed_size = 0;
13388
13389       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13390         {
13391           Elf_Internal_Chdr chdr;
13392           unsigned int compression_header_size
13393             = get_compression_header (& chdr, (unsigned char *) start,
13394                                       num_bytes);
13395
13396           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13397             {
13398               warn (_("section '%s' has unsupported compress type: %d\n"),
13399                     printable_section_name (filedata, section), chdr.ch_type);
13400               return FALSE;
13401             }
13402           else if (chdr.ch_addralign != section->sh_addralign)
13403             {
13404               warn (_("compressed section '%s' is corrupted\n"),
13405                     printable_section_name (filedata, section));
13406               return FALSE;
13407             }
13408           uncompressed_size = chdr.ch_size;
13409           start += compression_header_size;
13410           new_size -= compression_header_size;
13411         }
13412       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13413         {
13414           /* Read the zlib header.  In this case, it should be "ZLIB"
13415              followed by the uncompressed section size, 8 bytes in
13416              big-endian order.  */
13417           uncompressed_size = start[4]; uncompressed_size <<= 8;
13418           uncompressed_size += start[5]; uncompressed_size <<= 8;
13419           uncompressed_size += start[6]; uncompressed_size <<= 8;
13420           uncompressed_size += start[7]; uncompressed_size <<= 8;
13421           uncompressed_size += start[8]; uncompressed_size <<= 8;
13422           uncompressed_size += start[9]; uncompressed_size <<= 8;
13423           uncompressed_size += start[10]; uncompressed_size <<= 8;
13424           uncompressed_size += start[11];
13425           start += 12;
13426           new_size -= 12;
13427         }
13428
13429       if (uncompressed_size)
13430         {
13431           if (uncompress_section_contents (& start,
13432                                            uncompressed_size, & new_size))
13433             num_bytes = new_size;
13434           else
13435             {
13436               error (_("Unable to decompress section %s\n"),
13437                      printable_section_name (filedata, section));
13438               return FALSE;
13439             }
13440         }
13441       else
13442         start = real_start;
13443     }
13444
13445   /* If the section being dumped has relocations against it the user might
13446      be expecting these relocations to have been applied.  Check for this
13447      case and issue a warning message in order to avoid confusion.
13448      FIXME: Maybe we ought to have an option that dumps a section with
13449      relocs applied ?  */
13450   for (relsec = filedata->section_headers;
13451        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13452        ++relsec)
13453     {
13454       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13455           || relsec->sh_info >= filedata->file_header.e_shnum
13456           || filedata->section_headers + relsec->sh_info != section
13457           || relsec->sh_size == 0
13458           || relsec->sh_link >= filedata->file_header.e_shnum)
13459         continue;
13460
13461       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13462       break;
13463     }
13464
13465   data = start;
13466   end  = start + num_bytes;
13467   some_strings_shown = FALSE;
13468
13469   while (data < end)
13470     {
13471       while (!ISPRINT (* data))
13472         if (++ data >= end)
13473           break;
13474
13475       if (data < end)
13476         {
13477           size_t maxlen = end - data;
13478
13479 #ifndef __MSVCRT__
13480           /* PR 11128: Use two separate invocations in order to work
13481              around bugs in the Solaris 8 implementation of printf.  */
13482           printf ("  [%6tx]  ", data - start);
13483 #else
13484           printf ("  [%6Ix]  ", (size_t) (data - start));
13485 #endif
13486           if (maxlen > 0)
13487             {
13488               print_symbol ((int) maxlen, (const char *) data);
13489               putchar ('\n');
13490               data += strnlen ((const char *) data, maxlen);
13491             }
13492           else
13493             {
13494               printf (_("<corrupt>\n"));
13495               data = end;
13496             }
13497           some_strings_shown = TRUE;
13498         }
13499     }
13500
13501   if (! some_strings_shown)
13502     printf (_("  No strings found in this section."));
13503
13504   free (real_start);
13505
13506   putchar ('\n');
13507   return TRUE;
13508 }
13509
13510 static bfd_boolean
13511 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13512                        Filedata *           filedata,
13513                        bfd_boolean          relocate)
13514 {
13515   Elf_Internal_Shdr * relsec;
13516   bfd_size_type       bytes;
13517   bfd_size_type       section_size;
13518   bfd_vma             addr;
13519   unsigned char *     data;
13520   unsigned char *     real_start;
13521   unsigned char *     start;
13522
13523   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13524   if (start == NULL)
13525     /* PR 21820: Do not fail if the section was empty.  */
13526     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13527
13528   section_size = section->sh_size;
13529
13530   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13531
13532   if (decompress_dumps)
13533     {
13534       dwarf_size_type new_size = section_size;
13535       dwarf_size_type uncompressed_size = 0;
13536
13537       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13538         {
13539           Elf_Internal_Chdr chdr;
13540           unsigned int compression_header_size
13541             = get_compression_header (& chdr, start, section_size);
13542
13543           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13544             {
13545               warn (_("section '%s' has unsupported compress type: %d\n"),
13546                     printable_section_name (filedata, section), chdr.ch_type);
13547               return FALSE;
13548             }
13549           else if (chdr.ch_addralign != section->sh_addralign)
13550             {
13551               warn (_("compressed section '%s' is corrupted\n"),
13552                     printable_section_name (filedata, section));
13553               return FALSE;
13554             }
13555           uncompressed_size = chdr.ch_size;
13556           start += compression_header_size;
13557           new_size -= compression_header_size;
13558         }
13559       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13560         {
13561           /* Read the zlib header.  In this case, it should be "ZLIB"
13562              followed by the uncompressed section size, 8 bytes in
13563              big-endian order.  */
13564           uncompressed_size = start[4]; uncompressed_size <<= 8;
13565           uncompressed_size += start[5]; uncompressed_size <<= 8;
13566           uncompressed_size += start[6]; uncompressed_size <<= 8;
13567           uncompressed_size += start[7]; uncompressed_size <<= 8;
13568           uncompressed_size += start[8]; uncompressed_size <<= 8;
13569           uncompressed_size += start[9]; uncompressed_size <<= 8;
13570           uncompressed_size += start[10]; uncompressed_size <<= 8;
13571           uncompressed_size += start[11];
13572           start += 12;
13573           new_size -= 12;
13574         }
13575
13576       if (uncompressed_size)
13577         {
13578           if (uncompress_section_contents (& start, uncompressed_size,
13579                                            & new_size))
13580             {
13581               section_size = new_size;
13582             }
13583           else
13584             {
13585               error (_("Unable to decompress section %s\n"),
13586                      printable_section_name (filedata, section));
13587               /* FIXME: Print the section anyway ?  */
13588               return FALSE;
13589             }
13590         }
13591       else
13592         start = real_start;
13593     }
13594
13595   if (relocate)
13596     {
13597       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13598         return FALSE;
13599     }
13600   else
13601     {
13602       /* If the section being dumped has relocations against it the user might
13603          be expecting these relocations to have been applied.  Check for this
13604          case and issue a warning message in order to avoid confusion.
13605          FIXME: Maybe we ought to have an option that dumps a section with
13606          relocs applied ?  */
13607       for (relsec = filedata->section_headers;
13608            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13609            ++relsec)
13610         {
13611           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13612               || relsec->sh_info >= filedata->file_header.e_shnum
13613               || filedata->section_headers + relsec->sh_info != section
13614               || relsec->sh_size == 0
13615               || relsec->sh_link >= filedata->file_header.e_shnum)
13616             continue;
13617
13618           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13619           break;
13620         }
13621     }
13622
13623   addr = section->sh_addr;
13624   bytes = section_size;
13625   data = start;
13626
13627   while (bytes)
13628     {
13629       int j;
13630       int k;
13631       int lbytes;
13632
13633       lbytes = (bytes > 16 ? 16 : bytes);
13634
13635       printf ("  0x%8.8lx ", (unsigned long) addr);
13636
13637       for (j = 0; j < 16; j++)
13638         {
13639           if (j < lbytes)
13640             printf ("%2.2x", data[j]);
13641           else
13642             printf ("  ");
13643
13644           if ((j & 3) == 3)
13645             printf (" ");
13646         }
13647
13648       for (j = 0; j < lbytes; j++)
13649         {
13650           k = data[j];
13651           if (k >= ' ' && k < 0x7f)
13652             printf ("%c", k);
13653           else
13654             printf (".");
13655         }
13656
13657       putchar ('\n');
13658
13659       data  += lbytes;
13660       addr  += lbytes;
13661       bytes -= lbytes;
13662     }
13663
13664   free (real_start);
13665
13666   putchar ('\n');
13667   return TRUE;
13668 }
13669
13670 static bfd_boolean
13671 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13672                              const Elf_Internal_Shdr *        sec,
13673                              void *                           data)
13674 {
13675   struct dwarf_section * section = &debug_displays [debug].section;
13676   char buf [64];
13677   Filedata * filedata = (Filedata *) data;
13678
13679   if (section->start != NULL)
13680     {
13681       /* If it is already loaded, do nothing.  */
13682       if (streq (section->filename, filedata->file_name))
13683         return TRUE;
13684       free (section->start);
13685     }
13686
13687   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13688   section->address = sec->sh_addr;
13689   section->user_data = NULL;
13690   section->filename = filedata->file_name;
13691   section->start = (unsigned char *) get_data (NULL, filedata,
13692                                                sec->sh_offset, 1,
13693                                                sec->sh_size, buf);
13694   if (section->start == NULL)
13695     section->size = 0;
13696   else
13697     {
13698       unsigned char *start = section->start;
13699       dwarf_size_type size = sec->sh_size;
13700       dwarf_size_type uncompressed_size = 0;
13701
13702       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13703         {
13704           Elf_Internal_Chdr chdr;
13705           unsigned int compression_header_size;
13706
13707           if (size < (is_32bit_elf
13708                       ? sizeof (Elf32_External_Chdr)
13709                       : sizeof (Elf64_External_Chdr)))
13710             {
13711               warn (_("compressed section %s is too small to contain a compression header"),
13712                     section->name);
13713               return FALSE;
13714             }
13715
13716           compression_header_size = get_compression_header (&chdr, start, size);
13717
13718           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13719             {
13720               warn (_("section '%s' has unsupported compress type: %d\n"),
13721                     section->name, chdr.ch_type);
13722               return FALSE;
13723             }
13724           else if (chdr.ch_addralign != sec->sh_addralign)
13725             {
13726               warn (_("compressed section '%s' is corrupted\n"),
13727                     section->name);
13728               return FALSE;
13729             }
13730           uncompressed_size = chdr.ch_size;
13731           start += compression_header_size;
13732           size -= compression_header_size;
13733         }
13734       else if (size > 12 && streq ((char *) start, "ZLIB"))
13735         {
13736           /* Read the zlib header.  In this case, it should be "ZLIB"
13737              followed by the uncompressed section size, 8 bytes in
13738              big-endian order.  */
13739           uncompressed_size = start[4]; uncompressed_size <<= 8;
13740           uncompressed_size += start[5]; uncompressed_size <<= 8;
13741           uncompressed_size += start[6]; uncompressed_size <<= 8;
13742           uncompressed_size += start[7]; uncompressed_size <<= 8;
13743           uncompressed_size += start[8]; uncompressed_size <<= 8;
13744           uncompressed_size += start[9]; uncompressed_size <<= 8;
13745           uncompressed_size += start[10]; uncompressed_size <<= 8;
13746           uncompressed_size += start[11];
13747           start += 12;
13748           size -= 12;
13749         }
13750
13751       if (uncompressed_size)
13752         {
13753           if (uncompress_section_contents (&start, uncompressed_size,
13754                                            &size))
13755             {
13756               /* Free the compressed buffer, update the section buffer
13757                  and the section size if uncompress is successful.  */
13758               free (section->start);
13759               section->start = start;
13760             }
13761           else
13762             {
13763               error (_("Unable to decompress section %s\n"),
13764                      printable_section_name (filedata, sec));
13765               return FALSE;
13766             }
13767         }
13768
13769       section->size = size;
13770     }
13771
13772   if (section->start == NULL)
13773     return FALSE;
13774
13775   if (debug_displays [debug].relocate)
13776     {
13777       if (! apply_relocations (filedata, sec, section->start, section->size,
13778                                & section->reloc_info, & section->num_relocs))
13779         return FALSE;
13780     }
13781   else
13782     {
13783       section->reloc_info = NULL;
13784       section->num_relocs = 0;
13785     }
13786
13787   return TRUE;
13788 }
13789
13790 /* If this is not NULL, load_debug_section will only look for sections
13791    within the list of sections given here.  */
13792 static unsigned int * section_subset = NULL;
13793
13794 bfd_boolean
13795 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13796 {
13797   struct dwarf_section * section = &debug_displays [debug].section;
13798   Elf_Internal_Shdr * sec;
13799   Filedata * filedata = (Filedata *) data;
13800
13801   /* Without section headers we cannot find any sections.  */
13802   if (filedata->section_headers == NULL)
13803     return FALSE;
13804
13805   if (filedata->string_table == NULL
13806       && filedata->file_header.e_shstrndx != SHN_UNDEF
13807       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13808     {
13809       Elf_Internal_Shdr * strs;
13810
13811       /* Read in the string table, so that we have section names to scan.  */
13812       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13813
13814       if (strs != NULL && strs->sh_size != 0)
13815         {
13816           filedata->string_table
13817             = (char *) get_data (NULL, filedata, strs->sh_offset,
13818                                  1, strs->sh_size, _("string table"));
13819
13820           filedata->string_table_length
13821             = filedata->string_table != NULL ? strs->sh_size : 0;
13822         }
13823     }
13824
13825   /* Locate the debug section.  */
13826   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13827   if (sec != NULL)
13828     section->name = section->uncompressed_name;
13829   else
13830     {
13831       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13832       if (sec != NULL)
13833         section->name = section->compressed_name;
13834     }
13835   if (sec == NULL)
13836     return FALSE;
13837
13838   /* If we're loading from a subset of sections, and we've loaded
13839      a section matching this name before, it's likely that it's a
13840      different one.  */
13841   if (section_subset != NULL)
13842     free_debug_section (debug);
13843
13844   return load_specific_debug_section (debug, sec, data);
13845 }
13846
13847 void
13848 free_debug_section (enum dwarf_section_display_enum debug)
13849 {
13850   struct dwarf_section * section = &debug_displays [debug].section;
13851
13852   if (section->start == NULL)
13853     return;
13854
13855   free ((char *) section->start);
13856   section->start = NULL;
13857   section->address = 0;
13858   section->size = 0;
13859 }
13860
13861 static bfd_boolean
13862 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13863 {
13864   char * name = SECTION_NAME (section);
13865   const char * print_name = printable_section_name (filedata, section);
13866   bfd_size_type length;
13867   bfd_boolean result = TRUE;
13868   int i;
13869
13870   length = section->sh_size;
13871   if (length == 0)
13872     {
13873       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13874       return TRUE;
13875     }
13876   if (section->sh_type == SHT_NOBITS)
13877     {
13878       /* There is no point in dumping the contents of a debugging section
13879          which has the NOBITS type - the bits in the file will be random.
13880          This can happen when a file containing a .eh_frame section is
13881          stripped with the --only-keep-debug command line option.  */
13882       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13883               print_name);
13884       return FALSE;
13885     }
13886
13887   if (const_strneq (name, ".gnu.linkonce.wi."))
13888     name = ".debug_info";
13889
13890   /* See if we know how to display the contents of this section.  */
13891   for (i = 0; i < max; i++)
13892     {
13893       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13894       struct dwarf_section_display *   display = debug_displays + i;
13895       struct dwarf_section *           sec = & display->section;
13896
13897       if (streq (sec->uncompressed_name, name)
13898           || (id == line && const_strneq (name, ".debug_line."))
13899           || streq (sec->compressed_name, name))
13900         {
13901           bfd_boolean secondary = (section != find_section (filedata, name));
13902
13903           if (secondary)
13904             free_debug_section (id);
13905
13906           if (i == line && const_strneq (name, ".debug_line."))
13907             sec->name = name;
13908           else if (streq (sec->uncompressed_name, name))
13909             sec->name = sec->uncompressed_name;
13910           else
13911             sec->name = sec->compressed_name;
13912
13913           if (load_specific_debug_section (id, section, filedata))
13914             {
13915               /* If this debug section is part of a CU/TU set in a .dwp file,
13916                  restrict load_debug_section to the sections in that set.  */
13917               section_subset = find_cu_tu_set (filedata, shndx);
13918
13919               result &= display->display (sec, filedata);
13920
13921               section_subset = NULL;
13922
13923               if (secondary || (id != info && id != abbrev))
13924                 free_debug_section (id);
13925             }
13926           break;
13927         }
13928     }
13929
13930   if (i == max)
13931     {
13932       printf (_("Unrecognized debug section: %s\n"), print_name);
13933       result = FALSE;
13934     }
13935
13936   return result;
13937 }
13938
13939 /* Set DUMP_SECTS for all sections where dumps were requested
13940    based on section name.  */
13941
13942 static void
13943 initialise_dumps_byname (Filedata * filedata)
13944 {
13945   struct dump_list_entry * cur;
13946
13947   for (cur = dump_sects_byname; cur; cur = cur->next)
13948     {
13949       unsigned int i;
13950       bfd_boolean any = FALSE;
13951
13952       for (i = 0; i < filedata->file_header.e_shnum; i++)
13953         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13954           {
13955             request_dump_bynumber (filedata, i, cur->type);
13956             any = TRUE;
13957           }
13958
13959       if (!any)
13960         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13961               cur->name);
13962     }
13963 }
13964
13965 static bfd_boolean
13966 process_section_contents (Filedata * filedata)
13967 {
13968   Elf_Internal_Shdr * section;
13969   unsigned int i;
13970   bfd_boolean res = TRUE;
13971
13972   if (! do_dump)
13973     return TRUE;
13974
13975   initialise_dumps_byname (filedata);
13976
13977   for (i = 0, section = filedata->section_headers;
13978        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13979        i++, section++)
13980     {
13981       dump_type dump = filedata->dump_sects[i];
13982
13983 #ifdef SUPPORT_DISASSEMBLY
13984       if (dump & DISASS_DUMP)
13985         {
13986           if (! disassemble_section (section, filedata))
13987             res = FALSE;
13988         }
13989 #endif
13990       if (dump & HEX_DUMP)
13991         {
13992           if (! dump_section_as_bytes (section, filedata, FALSE))
13993             res = FALSE;
13994         }
13995
13996       if (dump & RELOC_DUMP)
13997         {
13998           if (! dump_section_as_bytes (section, filedata, TRUE))
13999             res = FALSE;
14000         }
14001
14002       if (dump & STRING_DUMP)
14003         {
14004           if (! dump_section_as_strings (section, filedata))
14005             res = FALSE;
14006         }
14007
14008       if (dump & DEBUG_DUMP)
14009         {
14010           if (! display_debug_section (i, section, filedata))
14011             res = FALSE;
14012         }
14013     }
14014
14015   /* Check to see if the user requested a
14016      dump of a section that does not exist.  */
14017   while (i < filedata->num_dump_sects)
14018     {
14019       if (filedata->dump_sects[i])
14020         {
14021           warn (_("Section %d was not dumped because it does not exist!\n"), i);
14022           res = FALSE;
14023         }
14024       i++;
14025     }
14026
14027   return res;
14028 }
14029
14030 static void
14031 process_mips_fpe_exception (int mask)
14032 {
14033   if (mask)
14034     {
14035       bfd_boolean first = TRUE;
14036
14037       if (mask & OEX_FPU_INEX)
14038         fputs ("INEX", stdout), first = FALSE;
14039       if (mask & OEX_FPU_UFLO)
14040         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14041       if (mask & OEX_FPU_OFLO)
14042         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14043       if (mask & OEX_FPU_DIV0)
14044         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14045       if (mask & OEX_FPU_INVAL)
14046         printf ("%sINVAL", first ? "" : "|");
14047     }
14048   else
14049     fputs ("0", stdout);
14050 }
14051
14052 /* Display's the value of TAG at location P.  If TAG is
14053    greater than 0 it is assumed to be an unknown tag, and
14054    a message is printed to this effect.  Otherwise it is
14055    assumed that a message has already been printed.
14056
14057    If the bottom bit of TAG is set it assumed to have a
14058    string value, otherwise it is assumed to have an integer
14059    value.
14060
14061    Returns an updated P pointing to the first unread byte
14062    beyond the end of TAG's value.
14063
14064    Reads at or beyond END will not be made.  */
14065
14066 static unsigned char *
14067 display_tag_value (signed int tag,
14068                    unsigned char * p,
14069                    const unsigned char * const end)
14070 {
14071   unsigned long val;
14072
14073   if (tag > 0)
14074     printf ("  Tag_unknown_%d: ", tag);
14075
14076   if (p >= end)
14077     {
14078       warn (_("<corrupt tag>\n"));
14079     }
14080   else if (tag & 1)
14081     {
14082       /* PR 17531 file: 027-19978-0.004.  */
14083       size_t maxlen = (end - p) - 1;
14084
14085       putchar ('"');
14086       if (maxlen > 0)
14087         {
14088           print_symbol ((int) maxlen, (const char *) p);
14089           p += strnlen ((char *) p, maxlen) + 1;
14090         }
14091       else
14092         {
14093           printf (_("<corrupt string tag>"));
14094           p = (unsigned char *) end;
14095         }
14096       printf ("\"\n");
14097     }
14098   else
14099     {
14100       unsigned int len;
14101
14102       val = read_uleb128 (p, &len, end);
14103       p += len;
14104       printf ("%ld (0x%lx)\n", val, val);
14105     }
14106
14107   assert (p <= end);
14108   return p;
14109 }
14110
14111 /* ARC ABI attributes section.  */
14112
14113 static unsigned char *
14114 display_arc_attribute (unsigned char * p,
14115                        const unsigned char * const end)
14116 {
14117   unsigned int tag;
14118   unsigned int len;
14119   unsigned int val;
14120
14121   tag = read_uleb128 (p, &len, end);
14122   p += len;
14123
14124   switch (tag)
14125     {
14126     case Tag_ARC_PCS_config:
14127       val = read_uleb128 (p, &len, end);
14128       p += len;
14129       printf ("  Tag_ARC_PCS_config: ");
14130       switch (val)
14131         {
14132         case 0:
14133           printf (_("Absent/Non standard\n"));
14134           break;
14135         case 1:
14136           printf (_("Bare metal/mwdt\n"));
14137           break;
14138         case 2:
14139           printf (_("Bare metal/newlib\n"));
14140           break;
14141         case 3:
14142           printf (_("Linux/uclibc\n"));
14143           break;
14144         case 4:
14145           printf (_("Linux/glibc\n"));
14146           break;
14147         default:
14148           printf (_("Unknown\n"));
14149           break;
14150         }
14151       break;
14152
14153     case Tag_ARC_CPU_base:
14154       val = read_uleb128 (p, &len, end);
14155       p += len;
14156       printf ("  Tag_ARC_CPU_base: ");
14157       switch (val)
14158         {
14159         default:
14160         case TAG_CPU_NONE:
14161           printf (_("Absent\n"));
14162           break;
14163         case TAG_CPU_ARC6xx:
14164           printf ("ARC6xx\n");
14165           break;
14166         case TAG_CPU_ARC7xx:
14167           printf ("ARC7xx\n");
14168           break;
14169         case TAG_CPU_ARCEM:
14170           printf ("ARCEM\n");
14171           break;
14172         case TAG_CPU_ARCHS:
14173           printf ("ARCHS\n");
14174           break;
14175         }
14176       break;
14177
14178     case Tag_ARC_CPU_variation:
14179       val = read_uleb128 (p, &len, end);
14180       p += len;
14181       printf ("  Tag_ARC_CPU_variation: ");
14182       switch (val)
14183         {
14184         default:
14185           if (val > 0 && val < 16)
14186               printf ("Core%d\n", val);
14187           else
14188               printf ("Unknown\n");
14189           break;
14190
14191         case 0:
14192           printf (_("Absent\n"));
14193           break;
14194         }
14195       break;
14196
14197     case Tag_ARC_CPU_name:
14198       printf ("  Tag_ARC_CPU_name: ");
14199       p = display_tag_value (-1, p, end);
14200       break;
14201
14202     case Tag_ARC_ABI_rf16:
14203       val = read_uleb128 (p, &len, end);
14204       p += len;
14205       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14206       break;
14207
14208     case Tag_ARC_ABI_osver:
14209       val = read_uleb128 (p, &len, end);
14210       p += len;
14211       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14212       break;
14213
14214     case Tag_ARC_ABI_pic:
14215     case Tag_ARC_ABI_sda:
14216       val = read_uleb128 (p, &len, end);
14217       p += len;
14218       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14219               : "  Tag_ARC_ABI_pic: ");
14220       switch (val)
14221         {
14222         case 0:
14223           printf (_("Absent\n"));
14224           break;
14225         case 1:
14226           printf ("MWDT\n");
14227           break;
14228         case 2:
14229           printf ("GNU\n");
14230           break;
14231         default:
14232           printf (_("Unknown\n"));
14233           break;
14234         }
14235       break;
14236
14237     case Tag_ARC_ABI_tls:
14238       val = read_uleb128 (p, &len, end);
14239       p += len;
14240       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14241       break;
14242
14243     case Tag_ARC_ABI_enumsize:
14244       val = read_uleb128 (p, &len, end);
14245       p += len;
14246       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14247               _("smallest"));
14248       break;
14249
14250     case Tag_ARC_ABI_exceptions:
14251       val = read_uleb128 (p, &len, end);
14252       p += len;
14253       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14254               : _("default"));
14255       break;
14256
14257     case Tag_ARC_ABI_double_size:
14258       val = read_uleb128 (p, &len, end);
14259       p += len;
14260       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14261       break;
14262
14263     case Tag_ARC_ISA_config:
14264       printf ("  Tag_ARC_ISA_config: ");
14265       p = display_tag_value (-1, p, end);
14266       break;
14267
14268     case Tag_ARC_ISA_apex:
14269       printf ("  Tag_ARC_ISA_apex: ");
14270       p = display_tag_value (-1, p, end);
14271       break;
14272
14273     case Tag_ARC_ISA_mpy_option:
14274       val = read_uleb128 (p, &len, end);
14275       p += len;
14276       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14277       break;
14278
14279     case Tag_ARC_ATR_version:
14280       val = read_uleb128 (p, &len, end);
14281       p += len;
14282       printf ("  Tag_ARC_ATR_version: %d\n", val);
14283       break;
14284
14285     default:
14286       return display_tag_value (tag & 1, p, end);
14287     }
14288
14289   return p;
14290 }
14291
14292 /* ARM EABI attributes section.  */
14293 typedef struct
14294 {
14295   unsigned int tag;
14296   const char * name;
14297   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14298   unsigned int type;
14299   const char ** table;
14300 } arm_attr_public_tag;
14301
14302 static const char * arm_attr_tag_CPU_arch[] =
14303   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14304    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14305    "v8-M.mainline"};
14306 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14307 static const char * arm_attr_tag_THUMB_ISA_use[] =
14308   {"No", "Thumb-1", "Thumb-2", "Yes"};
14309 static const char * arm_attr_tag_FP_arch[] =
14310   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14311    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14312 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14313 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14314   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14315    "NEON for ARMv8.1"};
14316 static const char * arm_attr_tag_PCS_config[] =
14317   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14318    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14319 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14320   {"V6", "SB", "TLS", "Unused"};
14321 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14322   {"Absolute", "PC-relative", "SB-relative", "None"};
14323 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14324   {"Absolute", "PC-relative", "None"};
14325 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14326   {"None", "direct", "GOT-indirect"};
14327 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14328   {"None", "??? 1", "2", "??? 3", "4"};
14329 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14330 static const char * arm_attr_tag_ABI_FP_denormal[] =
14331   {"Unused", "Needed", "Sign only"};
14332 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14333 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14334 static const char * arm_attr_tag_ABI_FP_number_model[] =
14335   {"Unused", "Finite", "RTABI", "IEEE 754"};
14336 static const char * arm_attr_tag_ABI_enum_size[] =
14337   {"Unused", "small", "int", "forced to int"};
14338 static const char * arm_attr_tag_ABI_HardFP_use[] =
14339   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14340 static const char * arm_attr_tag_ABI_VFP_args[] =
14341   {"AAPCS", "VFP registers", "custom", "compatible"};
14342 static const char * arm_attr_tag_ABI_WMMX_args[] =
14343   {"AAPCS", "WMMX registers", "custom"};
14344 static const char * arm_attr_tag_ABI_optimization_goals[] =
14345   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14346     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14347 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14348   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14349     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14350 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14351 static const char * arm_attr_tag_FP_HP_extension[] =
14352   {"Not Allowed", "Allowed"};
14353 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14354   {"None", "IEEE 754", "Alternative Format"};
14355 static const char * arm_attr_tag_DSP_extension[] =
14356   {"Follow architecture", "Allowed"};
14357 static const char * arm_attr_tag_MPextension_use[] =
14358   {"Not Allowed", "Allowed"};
14359 static const char * arm_attr_tag_DIV_use[] =
14360   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14361     "Allowed in v7-A with integer division extension"};
14362 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14363 static const char * arm_attr_tag_Virtualization_use[] =
14364   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14365     "TrustZone and Virtualization Extensions"};
14366 static const char * arm_attr_tag_MPextension_use_legacy[] =
14367   {"Not Allowed", "Allowed"};
14368
14369 #define LOOKUP(id, name) \
14370   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14371 static arm_attr_public_tag arm_attr_public_tags[] =
14372 {
14373   {4, "CPU_raw_name", 1, NULL},
14374   {5, "CPU_name", 1, NULL},
14375   LOOKUP(6, CPU_arch),
14376   {7, "CPU_arch_profile", 0, NULL},
14377   LOOKUP(8, ARM_ISA_use),
14378   LOOKUP(9, THUMB_ISA_use),
14379   LOOKUP(10, FP_arch),
14380   LOOKUP(11, WMMX_arch),
14381   LOOKUP(12, Advanced_SIMD_arch),
14382   LOOKUP(13, PCS_config),
14383   LOOKUP(14, ABI_PCS_R9_use),
14384   LOOKUP(15, ABI_PCS_RW_data),
14385   LOOKUP(16, ABI_PCS_RO_data),
14386   LOOKUP(17, ABI_PCS_GOT_use),
14387   LOOKUP(18, ABI_PCS_wchar_t),
14388   LOOKUP(19, ABI_FP_rounding),
14389   LOOKUP(20, ABI_FP_denormal),
14390   LOOKUP(21, ABI_FP_exceptions),
14391   LOOKUP(22, ABI_FP_user_exceptions),
14392   LOOKUP(23, ABI_FP_number_model),
14393   {24, "ABI_align_needed", 0, NULL},
14394   {25, "ABI_align_preserved", 0, NULL},
14395   LOOKUP(26, ABI_enum_size),
14396   LOOKUP(27, ABI_HardFP_use),
14397   LOOKUP(28, ABI_VFP_args),
14398   LOOKUP(29, ABI_WMMX_args),
14399   LOOKUP(30, ABI_optimization_goals),
14400   LOOKUP(31, ABI_FP_optimization_goals),
14401   {32, "compatibility", 0, NULL},
14402   LOOKUP(34, CPU_unaligned_access),
14403   LOOKUP(36, FP_HP_extension),
14404   LOOKUP(38, ABI_FP_16bit_format),
14405   LOOKUP(42, MPextension_use),
14406   LOOKUP(44, DIV_use),
14407   LOOKUP(46, DSP_extension),
14408   {64, "nodefaults", 0, NULL},
14409   {65, "also_compatible_with", 0, NULL},
14410   LOOKUP(66, T2EE_use),
14411   {67, "conformance", 1, NULL},
14412   LOOKUP(68, Virtualization_use),
14413   LOOKUP(70, MPextension_use_legacy)
14414 };
14415 #undef LOOKUP
14416
14417 static unsigned char *
14418 display_arm_attribute (unsigned char * p,
14419                        const unsigned char * const end)
14420 {
14421   unsigned int tag;
14422   unsigned int len;
14423   unsigned int val;
14424   arm_attr_public_tag * attr;
14425   unsigned i;
14426   unsigned int type;
14427
14428   tag = read_uleb128 (p, &len, end);
14429   p += len;
14430   attr = NULL;
14431   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14432     {
14433       if (arm_attr_public_tags[i].tag == tag)
14434         {
14435           attr = &arm_attr_public_tags[i];
14436           break;
14437         }
14438     }
14439
14440   if (attr)
14441     {
14442       printf ("  Tag_%s: ", attr->name);
14443       switch (attr->type)
14444         {
14445         case 0:
14446           switch (tag)
14447             {
14448             case 7: /* Tag_CPU_arch_profile.  */
14449               val = read_uleb128 (p, &len, end);
14450               p += len;
14451               switch (val)
14452                 {
14453                 case 0: printf (_("None\n")); break;
14454                 case 'A': printf (_("Application\n")); break;
14455                 case 'R': printf (_("Realtime\n")); break;
14456                 case 'M': printf (_("Microcontroller\n")); break;
14457                 case 'S': printf (_("Application or Realtime\n")); break;
14458                 default: printf ("??? (%d)\n", val); break;
14459                 }
14460               break;
14461
14462             case 24: /* Tag_align_needed.  */
14463               val = read_uleb128 (p, &len, end);
14464               p += len;
14465               switch (val)
14466                 {
14467                 case 0: printf (_("None\n")); break;
14468                 case 1: printf (_("8-byte\n")); break;
14469                 case 2: printf (_("4-byte\n")); break;
14470                 case 3: printf ("??? 3\n"); break;
14471                 default:
14472                   if (val <= 12)
14473                     printf (_("8-byte and up to %d-byte extended\n"),
14474                             1 << val);
14475                   else
14476                     printf ("??? (%d)\n", val);
14477                   break;
14478                 }
14479               break;
14480
14481             case 25: /* Tag_align_preserved.  */
14482               val = read_uleb128 (p, &len, end);
14483               p += len;
14484               switch (val)
14485                 {
14486                 case 0: printf (_("None\n")); break;
14487                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14488                 case 2: printf (_("8-byte\n")); break;
14489                 case 3: printf ("??? 3\n"); break;
14490                 default:
14491                   if (val <= 12)
14492                     printf (_("8-byte and up to %d-byte extended\n"),
14493                             1 << val);
14494                   else
14495                     printf ("??? (%d)\n", val);
14496                   break;
14497                 }
14498               break;
14499
14500             case 32: /* Tag_compatibility.  */
14501               {
14502                 val = read_uleb128 (p, &len, end);
14503                 p += len;
14504                 printf (_("flag = %d, vendor = "), val);
14505                 if (p < end - 1)
14506                   {
14507                     size_t maxlen = (end - p) - 1;
14508
14509                     print_symbol ((int) maxlen, (const char *) p);
14510                     p += strnlen ((char *) p, maxlen) + 1;
14511                   }
14512                 else
14513                   {
14514                     printf (_("<corrupt>"));
14515                     p = (unsigned char *) end;
14516                   }
14517                 putchar ('\n');
14518               }
14519               break;
14520
14521             case 64: /* Tag_nodefaults.  */
14522               /* PR 17531: file: 001-505008-0.01.  */
14523               if (p < end)
14524                 p++;
14525               printf (_("True\n"));
14526               break;
14527
14528             case 65: /* Tag_also_compatible_with.  */
14529               val = read_uleb128 (p, &len, end);
14530               p += len;
14531               if (val == 6 /* Tag_CPU_arch.  */)
14532                 {
14533                   val = read_uleb128 (p, &len, end);
14534                   p += len;
14535                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14536                     printf ("??? (%d)\n", val);
14537                   else
14538                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14539                 }
14540               else
14541                 printf ("???\n");
14542               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14543                 ;
14544               break;
14545
14546             default:
14547               printf (_("<unknown: %d>\n"), tag);
14548               break;
14549             }
14550           return p;
14551
14552         case 1:
14553           return display_tag_value (-1, p, end);
14554         case 2:
14555           return display_tag_value (0, p, end);
14556
14557         default:
14558           assert (attr->type & 0x80);
14559           val = read_uleb128 (p, &len, end);
14560           p += len;
14561           type = attr->type & 0x7f;
14562           if (val >= type)
14563             printf ("??? (%d)\n", val);
14564           else
14565             printf ("%s\n", attr->table[val]);
14566           return p;
14567         }
14568     }
14569
14570   return display_tag_value (tag, p, end);
14571 }
14572
14573 static unsigned char *
14574 display_gnu_attribute (unsigned char * p,
14575                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14576                        const unsigned char * const end)
14577 {
14578   int tag;
14579   unsigned int len;
14580   unsigned int val;
14581
14582   tag = read_uleb128 (p, &len, end);
14583   p += len;
14584
14585   /* Tag_compatibility is the only generic GNU attribute defined at
14586      present.  */
14587   if (tag == 32)
14588     {
14589       val = read_uleb128 (p, &len, end);
14590       p += len;
14591
14592       printf (_("flag = %d, vendor = "), val);
14593       if (p == end)
14594         {
14595           printf (_("<corrupt>\n"));
14596           warn (_("corrupt vendor attribute\n"));
14597         }
14598       else
14599         {
14600           if (p < end - 1)
14601             {
14602               size_t maxlen = (end - p) - 1;
14603
14604               print_symbol ((int) maxlen, (const char *) p);
14605               p += strnlen ((char *) p, maxlen) + 1;
14606             }
14607           else
14608             {
14609               printf (_("<corrupt>"));
14610               p = (unsigned char *) end;
14611             }
14612           putchar ('\n');
14613         }
14614       return p;
14615     }
14616
14617   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14618     return display_proc_gnu_attribute (p, tag, end);
14619
14620   return display_tag_value (tag, p, end);
14621 }
14622
14623 static unsigned char *
14624 display_power_gnu_attribute (unsigned char * p,
14625                              unsigned int tag,
14626                              const unsigned char * const end)
14627 {
14628   unsigned int len;
14629   unsigned int val;
14630
14631   if (tag == Tag_GNU_Power_ABI_FP)
14632     {
14633       val = read_uleb128 (p, &len, end);
14634       p += len;
14635       printf ("  Tag_GNU_Power_ABI_FP: ");
14636       if (len == 0)
14637         {
14638           printf (_("<corrupt>\n"));
14639           return p;
14640         }
14641
14642       if (val > 15)
14643         printf ("(%#x), ", val);
14644
14645       switch (val & 3)
14646         {
14647         case 0:
14648           printf (_("unspecified hard/soft float, "));
14649           break;
14650         case 1:
14651           printf (_("hard float, "));
14652           break;
14653         case 2:
14654           printf (_("soft float, "));
14655           break;
14656         case 3:
14657           printf (_("single-precision hard float, "));
14658           break;
14659         }
14660
14661       switch (val & 0xC)
14662         {
14663         case 0:
14664           printf (_("unspecified long double\n"));
14665           break;
14666         case 4:
14667           printf (_("128-bit IBM long double\n"));
14668           break;
14669         case 8:
14670           printf (_("64-bit long double\n"));
14671           break;
14672         case 12:
14673           printf (_("128-bit IEEE long double\n"));
14674           break;
14675         }
14676       return p;
14677     }
14678
14679   if (tag == Tag_GNU_Power_ABI_Vector)
14680     {
14681       val = read_uleb128 (p, &len, end);
14682       p += len;
14683       printf ("  Tag_GNU_Power_ABI_Vector: ");
14684       if (len == 0)
14685         {
14686           printf (_("<corrupt>\n"));
14687           return p;
14688         }
14689
14690       if (val > 3)
14691         printf ("(%#x), ", val);
14692
14693       switch (val & 3)
14694         {
14695         case 0:
14696           printf (_("unspecified\n"));
14697           break;
14698         case 1:
14699           printf (_("generic\n"));
14700           break;
14701         case 2:
14702           printf ("AltiVec\n");
14703           break;
14704         case 3:
14705           printf ("SPE\n");
14706           break;
14707         }
14708       return p;
14709     }
14710
14711   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14712     {
14713       val = read_uleb128 (p, &len, end);
14714       p += len;
14715       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14716       if (len == 0)
14717         {
14718           printf (_("<corrupt>\n"));
14719           return p;
14720         }
14721
14722       if (val > 2)
14723         printf ("(%#x), ", val);
14724
14725       switch (val & 3)
14726         {
14727         case 0:
14728           printf (_("unspecified\n"));
14729           break;
14730         case 1:
14731           printf ("r3/r4\n");
14732           break;
14733         case 2:
14734           printf (_("memory\n"));
14735           break;
14736         case 3:
14737           printf ("???\n");
14738           break;
14739         }
14740       return p;
14741     }
14742
14743   return display_tag_value (tag & 1, p, end);
14744 }
14745
14746 static unsigned char *
14747 display_s390_gnu_attribute (unsigned char * p,
14748                             unsigned int tag,
14749                             const unsigned char * const end)
14750 {
14751   unsigned int len;
14752   int val;
14753
14754   if (tag == Tag_GNU_S390_ABI_Vector)
14755     {
14756       val = read_uleb128 (p, &len, end);
14757       p += len;
14758       printf ("  Tag_GNU_S390_ABI_Vector: ");
14759
14760       switch (val)
14761         {
14762         case 0:
14763           printf (_("any\n"));
14764           break;
14765         case 1:
14766           printf (_("software\n"));
14767           break;
14768         case 2:
14769           printf (_("hardware\n"));
14770           break;
14771         default:
14772           printf ("??? (%d)\n", val);
14773           break;
14774         }
14775       return p;
14776    }
14777
14778   return display_tag_value (tag & 1, p, end);
14779 }
14780
14781 static void
14782 display_sparc_hwcaps (unsigned int mask)
14783 {
14784   if (mask)
14785     {
14786       bfd_boolean first = TRUE;
14787
14788       if (mask & ELF_SPARC_HWCAP_MUL32)
14789         fputs ("mul32", stdout), first = FALSE;
14790       if (mask & ELF_SPARC_HWCAP_DIV32)
14791         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14792       if (mask & ELF_SPARC_HWCAP_FSMULD)
14793         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14794       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14795         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14796       if (mask & ELF_SPARC_HWCAP_POPC)
14797         printf ("%spopc", first ? "" : "|"), first = FALSE;
14798       if (mask & ELF_SPARC_HWCAP_VIS)
14799         printf ("%svis", first ? "" : "|"), first = FALSE;
14800       if (mask & ELF_SPARC_HWCAP_VIS2)
14801         printf ("%svis2", first ? "" : "|"), first = FALSE;
14802       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14803         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14804       if (mask & ELF_SPARC_HWCAP_FMAF)
14805         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14806       if (mask & ELF_SPARC_HWCAP_VIS3)
14807         printf ("%svis3", first ? "" : "|"), first = FALSE;
14808       if (mask & ELF_SPARC_HWCAP_HPC)
14809         printf ("%shpc", first ? "" : "|"), first = FALSE;
14810       if (mask & ELF_SPARC_HWCAP_RANDOM)
14811         printf ("%srandom", first ? "" : "|"), first = FALSE;
14812       if (mask & ELF_SPARC_HWCAP_TRANS)
14813         printf ("%strans", first ? "" : "|"), first = FALSE;
14814       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14815         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14816       if (mask & ELF_SPARC_HWCAP_IMA)
14817         printf ("%sima", first ? "" : "|"), first = FALSE;
14818       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14819         printf ("%scspare", first ? "" : "|"), first = FALSE;
14820     }
14821   else
14822     fputc ('0', stdout);
14823   fputc ('\n', stdout);
14824 }
14825
14826 static void
14827 display_sparc_hwcaps2 (unsigned int mask)
14828 {
14829   if (mask)
14830     {
14831       bfd_boolean first = TRUE;
14832
14833       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14834         fputs ("fjathplus", stdout), first = FALSE;
14835       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14836         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14837       if (mask & ELF_SPARC_HWCAP2_ADP)
14838         printf ("%sadp", first ? "" : "|"), first = FALSE;
14839       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14840         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14841       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14842         printf ("%smwait", first ? "" : "|"), first = FALSE;
14843       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14844         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14845       if (mask & ELF_SPARC_HWCAP2_XMONT)
14846         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14847       if (mask & ELF_SPARC_HWCAP2_NSEC)
14848         printf ("%snsec", first ? "" : "|"), first = FALSE;
14849       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14850         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14851       if (mask & ELF_SPARC_HWCAP2_FJDES)
14852         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14853       if (mask & ELF_SPARC_HWCAP2_FJAES)
14854         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14855     }
14856   else
14857     fputc ('0', stdout);
14858   fputc ('\n', stdout);
14859 }
14860
14861 static unsigned char *
14862 display_sparc_gnu_attribute (unsigned char * p,
14863                              unsigned int tag,
14864                              const unsigned char * const end)
14865 {
14866   unsigned int len;
14867   int val;
14868
14869   if (tag == Tag_GNU_Sparc_HWCAPS)
14870     {
14871       val = read_uleb128 (p, &len, end);
14872       p += len;
14873       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14874       display_sparc_hwcaps (val);
14875       return p;
14876     }
14877   if (tag == Tag_GNU_Sparc_HWCAPS2)
14878     {
14879       val = read_uleb128 (p, &len, end);
14880       p += len;
14881       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14882       display_sparc_hwcaps2 (val);
14883       return p;
14884     }
14885
14886   return display_tag_value (tag, p, end);
14887 }
14888
14889 static void
14890 print_mips_fp_abi_value (unsigned int val)
14891 {
14892   switch (val)
14893     {
14894     case Val_GNU_MIPS_ABI_FP_ANY:
14895       printf (_("Hard or soft float\n"));
14896       break;
14897     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14898       printf (_("Hard float (double precision)\n"));
14899       break;
14900     case Val_GNU_MIPS_ABI_FP_SINGLE:
14901       printf (_("Hard float (single precision)\n"));
14902       break;
14903     case Val_GNU_MIPS_ABI_FP_SOFT:
14904       printf (_("Soft float\n"));
14905       break;
14906     case Val_GNU_MIPS_ABI_FP_OLD_64:
14907       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14908       break;
14909     case Val_GNU_MIPS_ABI_FP_XX:
14910       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14911       break;
14912     case Val_GNU_MIPS_ABI_FP_64:
14913       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14914       break;
14915     case Val_GNU_MIPS_ABI_FP_64A:
14916       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14917       break;
14918     case Val_GNU_MIPS_ABI_FP_NAN2008:
14919       printf (_("NaN 2008 compatibility\n"));
14920       break;
14921     default:
14922       printf ("??? (%d)\n", val);
14923       break;
14924     }
14925 }
14926
14927 static unsigned char *
14928 display_mips_gnu_attribute (unsigned char * p,
14929                             unsigned int tag,
14930                             const unsigned char * const end)
14931 {
14932   if (tag == Tag_GNU_MIPS_ABI_FP)
14933     {
14934       unsigned int len;
14935       unsigned int val;
14936
14937       val = read_uleb128 (p, &len, end);
14938       p += len;
14939       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14940
14941       print_mips_fp_abi_value (val);
14942
14943       return p;
14944    }
14945
14946   if (tag == Tag_GNU_MIPS_ABI_MSA)
14947     {
14948       unsigned int len;
14949       unsigned int val;
14950
14951       val = read_uleb128 (p, &len, end);
14952       p += len;
14953       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14954
14955       switch (val)
14956         {
14957         case Val_GNU_MIPS_ABI_MSA_ANY:
14958           printf (_("Any MSA or not\n"));
14959           break;
14960         case Val_GNU_MIPS_ABI_MSA_128:
14961           printf (_("128-bit MSA\n"));
14962           break;
14963         default:
14964           printf ("??? (%d)\n", val);
14965           break;
14966         }
14967       return p;
14968     }
14969
14970   return display_tag_value (tag & 1, p, end);
14971 }
14972
14973 static unsigned char *
14974 display_tic6x_attribute (unsigned char * p,
14975                          const unsigned char * const end)
14976 {
14977   unsigned int tag;
14978   unsigned int len;
14979   int val;
14980
14981   tag = read_uleb128 (p, &len, end);
14982   p += len;
14983
14984   switch (tag)
14985     {
14986     case Tag_ISA:
14987       val = read_uleb128 (p, &len, end);
14988       p += len;
14989       printf ("  Tag_ISA: ");
14990
14991       switch (val)
14992         {
14993         case C6XABI_Tag_ISA_none:
14994           printf (_("None\n"));
14995           break;
14996         case C6XABI_Tag_ISA_C62X:
14997           printf ("C62x\n");
14998           break;
14999         case C6XABI_Tag_ISA_C67X:
15000           printf ("C67x\n");
15001           break;
15002         case C6XABI_Tag_ISA_C67XP:
15003           printf ("C67x+\n");
15004           break;
15005         case C6XABI_Tag_ISA_C64X:
15006           printf ("C64x\n");
15007           break;
15008         case C6XABI_Tag_ISA_C64XP:
15009           printf ("C64x+\n");
15010           break;
15011         case C6XABI_Tag_ISA_C674X:
15012           printf ("C674x\n");
15013           break;
15014         default:
15015           printf ("??? (%d)\n", val);
15016           break;
15017         }
15018       return p;
15019
15020     case Tag_ABI_wchar_t:
15021       val = read_uleb128 (p, &len, end);
15022       p += len;
15023       printf ("  Tag_ABI_wchar_t: ");
15024       switch (val)
15025         {
15026         case 0:
15027           printf (_("Not used\n"));
15028           break;
15029         case 1:
15030           printf (_("2 bytes\n"));
15031           break;
15032         case 2:
15033           printf (_("4 bytes\n"));
15034           break;
15035         default:
15036           printf ("??? (%d)\n", val);
15037           break;
15038         }
15039       return p;
15040
15041     case Tag_ABI_stack_align_needed:
15042       val = read_uleb128 (p, &len, end);
15043       p += len;
15044       printf ("  Tag_ABI_stack_align_needed: ");
15045       switch (val)
15046         {
15047         case 0:
15048           printf (_("8-byte\n"));
15049           break;
15050         case 1:
15051           printf (_("16-byte\n"));
15052           break;
15053         default:
15054           printf ("??? (%d)\n", val);
15055           break;
15056         }
15057       return p;
15058
15059     case Tag_ABI_stack_align_preserved:
15060       val = read_uleb128 (p, &len, end);
15061       p += len;
15062       printf ("  Tag_ABI_stack_align_preserved: ");
15063       switch (val)
15064         {
15065         case 0:
15066           printf (_("8-byte\n"));
15067           break;
15068         case 1:
15069           printf (_("16-byte\n"));
15070           break;
15071         default:
15072           printf ("??? (%d)\n", val);
15073           break;
15074         }
15075       return p;
15076
15077     case Tag_ABI_DSBT:
15078       val = read_uleb128 (p, &len, end);
15079       p += len;
15080       printf ("  Tag_ABI_DSBT: ");
15081       switch (val)
15082         {
15083         case 0:
15084           printf (_("DSBT addressing not used\n"));
15085           break;
15086         case 1:
15087           printf (_("DSBT addressing used\n"));
15088           break;
15089         default:
15090           printf ("??? (%d)\n", val);
15091           break;
15092         }
15093       return p;
15094
15095     case Tag_ABI_PID:
15096       val = read_uleb128 (p, &len, end);
15097       p += len;
15098       printf ("  Tag_ABI_PID: ");
15099       switch (val)
15100         {
15101         case 0:
15102           printf (_("Data addressing position-dependent\n"));
15103           break;
15104         case 1:
15105           printf (_("Data addressing position-independent, GOT near DP\n"));
15106           break;
15107         case 2:
15108           printf (_("Data addressing position-independent, GOT far from DP\n"));
15109           break;
15110         default:
15111           printf ("??? (%d)\n", val);
15112           break;
15113         }
15114       return p;
15115
15116     case Tag_ABI_PIC:
15117       val = read_uleb128 (p, &len, end);
15118       p += len;
15119       printf ("  Tag_ABI_PIC: ");
15120       switch (val)
15121         {
15122         case 0:
15123           printf (_("Code addressing position-dependent\n"));
15124           break;
15125         case 1:
15126           printf (_("Code addressing position-independent\n"));
15127           break;
15128         default:
15129           printf ("??? (%d)\n", val);
15130           break;
15131         }
15132       return p;
15133
15134     case Tag_ABI_array_object_alignment:
15135       val = read_uleb128 (p, &len, end);
15136       p += len;
15137       printf ("  Tag_ABI_array_object_alignment: ");
15138       switch (val)
15139         {
15140         case 0:
15141           printf (_("8-byte\n"));
15142           break;
15143         case 1:
15144           printf (_("4-byte\n"));
15145           break;
15146         case 2:
15147           printf (_("16-byte\n"));
15148           break;
15149         default:
15150           printf ("??? (%d)\n", val);
15151           break;
15152         }
15153       return p;
15154
15155     case Tag_ABI_array_object_align_expected:
15156       val = read_uleb128 (p, &len, end);
15157       p += len;
15158       printf ("  Tag_ABI_array_object_align_expected: ");
15159       switch (val)
15160         {
15161         case 0:
15162           printf (_("8-byte\n"));
15163           break;
15164         case 1:
15165           printf (_("4-byte\n"));
15166           break;
15167         case 2:
15168           printf (_("16-byte\n"));
15169           break;
15170         default:
15171           printf ("??? (%d)\n", val);
15172           break;
15173         }
15174       return p;
15175
15176     case Tag_ABI_compatibility:
15177       {
15178         val = read_uleb128 (p, &len, end);
15179         p += len;
15180         printf ("  Tag_ABI_compatibility: ");
15181         printf (_("flag = %d, vendor = "), val);
15182         if (p < end - 1)
15183           {
15184             size_t maxlen = (end - p) - 1;
15185
15186             print_symbol ((int) maxlen, (const char *) p);
15187             p += strnlen ((char *) p, maxlen) + 1;
15188           }
15189         else
15190           {
15191             printf (_("<corrupt>"));
15192             p = (unsigned char *) end;
15193           }
15194         putchar ('\n');
15195         return p;
15196       }
15197
15198     case Tag_ABI_conformance:
15199       {
15200         printf ("  Tag_ABI_conformance: \"");
15201         if (p < end - 1)
15202           {
15203             size_t maxlen = (end - p) - 1;
15204
15205             print_symbol ((int) maxlen, (const char *) p);
15206             p += strnlen ((char *) p, maxlen) + 1;
15207           }
15208         else
15209           {
15210             printf (_("<corrupt>"));
15211             p = (unsigned char *) end;
15212           }
15213         printf ("\"\n");
15214         return p;
15215       }
15216     }
15217
15218   return display_tag_value (tag, p, end);
15219 }
15220
15221 static void
15222 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15223 {
15224   unsigned long addr = 0;
15225   size_t bytes = end - p;
15226
15227   assert (end > p);
15228   while (bytes)
15229     {
15230       int j;
15231       int k;
15232       int lbytes = (bytes > 16 ? 16 : bytes);
15233
15234       printf ("  0x%8.8lx ", addr);
15235
15236       for (j = 0; j < 16; j++)
15237         {
15238           if (j < lbytes)
15239             printf ("%2.2x", p[j]);
15240           else
15241             printf ("  ");
15242
15243           if ((j & 3) == 3)
15244             printf (" ");
15245         }
15246
15247       for (j = 0; j < lbytes; j++)
15248         {
15249           k = p[j];
15250           if (k >= ' ' && k < 0x7f)
15251             printf ("%c", k);
15252           else
15253             printf (".");
15254         }
15255
15256       putchar ('\n');
15257
15258       p  += lbytes;
15259       bytes -= lbytes;
15260       addr += lbytes;
15261     }
15262
15263   putchar ('\n');
15264 }
15265
15266 static unsigned char *
15267 display_msp430x_attribute (unsigned char * p,
15268                            const unsigned char * const end)
15269 {
15270   unsigned int len;
15271   unsigned int val;
15272   unsigned int tag;
15273
15274   tag = read_uleb128 (p, & len, end);
15275   p += len;
15276
15277   switch (tag)
15278     {
15279     case OFBA_MSPABI_Tag_ISA:
15280       val = read_uleb128 (p, &len, end);
15281       p += len;
15282       printf ("  Tag_ISA: ");
15283       switch (val)
15284         {
15285         case 0: printf (_("None\n")); break;
15286         case 1: printf (_("MSP430\n")); break;
15287         case 2: printf (_("MSP430X\n")); break;
15288         default: printf ("??? (%d)\n", val); break;
15289         }
15290       break;
15291
15292     case OFBA_MSPABI_Tag_Code_Model:
15293       val = read_uleb128 (p, &len, end);
15294       p += len;
15295       printf ("  Tag_Code_Model: ");
15296       switch (val)
15297         {
15298         case 0: printf (_("None\n")); break;
15299         case 1: printf (_("Small\n")); break;
15300         case 2: printf (_("Large\n")); break;
15301         default: printf ("??? (%d)\n", val); break;
15302         }
15303       break;
15304
15305     case OFBA_MSPABI_Tag_Data_Model:
15306       val = read_uleb128 (p, &len, end);
15307       p += len;
15308       printf ("  Tag_Data_Model: ");
15309       switch (val)
15310         {
15311         case 0: printf (_("None\n")); break;
15312         case 1: printf (_("Small\n")); break;
15313         case 2: printf (_("Large\n")); break;
15314         case 3: printf (_("Restricted Large\n")); break;
15315         default: printf ("??? (%d)\n", val); break;
15316         }
15317       break;
15318
15319     default:
15320       printf (_("  <unknown tag %d>: "), tag);
15321
15322       if (tag & 1)
15323         {
15324           putchar ('"');
15325           if (p < end - 1)
15326             {
15327               size_t maxlen = (end - p) - 1;
15328
15329               print_symbol ((int) maxlen, (const char *) p);
15330               p += strnlen ((char *) p, maxlen) + 1;
15331             }
15332           else
15333             {
15334               printf (_("<corrupt>"));
15335               p = (unsigned char *) end;
15336             }
15337           printf ("\"\n");
15338         }
15339       else
15340         {
15341           val = read_uleb128 (p, &len, end);
15342           p += len;
15343           printf ("%d (0x%x)\n", val, val);
15344         }
15345       break;
15346    }
15347
15348   assert (p <= end);
15349   return p;
15350 }
15351
15352 static bfd_boolean
15353 process_attributes (Filedata * filedata,
15354                     const char * public_name,
15355                     unsigned int proc_type,
15356                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15357                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15358 {
15359   Elf_Internal_Shdr * sect;
15360   unsigned i;
15361   bfd_boolean res = TRUE;
15362
15363   /* Find the section header so that we get the size.  */
15364   for (i = 0, sect = filedata->section_headers;
15365        i < filedata->file_header.e_shnum;
15366        i++, sect++)
15367     {
15368       unsigned char * contents;
15369       unsigned char * p;
15370
15371       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15372         continue;
15373
15374       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15375                                              sect->sh_size, _("attributes"));
15376       if (contents == NULL)
15377         {
15378           res = FALSE;
15379           continue;
15380         }
15381
15382       p = contents;
15383       /* The first character is the version of the attributes.
15384          Currently only version 1, (aka 'A') is recognised here.  */
15385       if (*p != 'A')
15386         {
15387           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15388           res = FALSE;
15389         }
15390       else
15391         {
15392           bfd_vma section_len;
15393
15394           section_len = sect->sh_size - 1;
15395           p++;
15396
15397           while (section_len > 0)
15398             {
15399               bfd_vma attr_len;
15400               unsigned int namelen;
15401               bfd_boolean public_section;
15402               bfd_boolean gnu_section;
15403
15404               if (section_len <= 4)
15405                 {
15406                   error (_("Tag section ends prematurely\n"));
15407                   res = FALSE;
15408                   break;
15409                 }
15410               attr_len = byte_get (p, 4);
15411               p += 4;
15412
15413               if (attr_len > section_len)
15414                 {
15415                   error (_("Bad attribute length (%u > %u)\n"),
15416                           (unsigned) attr_len, (unsigned) section_len);
15417                   attr_len = section_len;
15418                   res = FALSE;
15419                 }
15420               /* PR 17531: file: 001-101425-0.004  */
15421               else if (attr_len < 5)
15422                 {
15423                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15424                   res = FALSE;
15425                   break;
15426                 }
15427
15428               section_len -= attr_len;
15429               attr_len -= 4;
15430
15431               namelen = strnlen ((char *) p, attr_len) + 1;
15432               if (namelen == 0 || namelen >= attr_len)
15433                 {
15434                   error (_("Corrupt attribute section name\n"));
15435                   res = FALSE;
15436                   break;
15437                 }
15438
15439               printf (_("Attribute Section: "));
15440               print_symbol (INT_MAX, (const char *) p);
15441               putchar ('\n');
15442
15443               if (public_name && streq ((char *) p, public_name))
15444                 public_section = TRUE;
15445               else
15446                 public_section = FALSE;
15447
15448               if (streq ((char *) p, "gnu"))
15449                 gnu_section = TRUE;
15450               else
15451                 gnu_section = FALSE;
15452
15453               p += namelen;
15454               attr_len -= namelen;
15455
15456               while (attr_len > 0 && p < contents + sect->sh_size)
15457                 {
15458                   int tag;
15459                   int val;
15460                   bfd_vma size;
15461                   unsigned char * end;
15462
15463                   /* PR binutils/17531: Safe handling of corrupt files.  */
15464                   if (attr_len < 6)
15465                     {
15466                       error (_("Unused bytes at end of section\n"));
15467                       res = FALSE;
15468                       section_len = 0;
15469                       break;
15470                     }
15471
15472                   tag = *(p++);
15473                   size = byte_get (p, 4);
15474                   if (size > attr_len)
15475                     {
15476                       error (_("Bad subsection length (%u > %u)\n"),
15477                               (unsigned) size, (unsigned) attr_len);
15478                       res = FALSE;
15479                       size = attr_len;
15480                     }
15481                   /* PR binutils/17531: Safe handling of corrupt files.  */
15482                   if (size < 6)
15483                     {
15484                       error (_("Bad subsection length (%u < 6)\n"),
15485                               (unsigned) size);
15486                       res = FALSE;
15487                       section_len = 0;
15488                       break;
15489                     }
15490
15491                   attr_len -= size;
15492                   end = p + size - 1;
15493                   assert (end <= contents + sect->sh_size);
15494                   p += 4;
15495
15496                   switch (tag)
15497                     {
15498                     case 1:
15499                       printf (_("File Attributes\n"));
15500                       break;
15501                     case 2:
15502                       printf (_("Section Attributes:"));
15503                       goto do_numlist;
15504                     case 3:
15505                       printf (_("Symbol Attributes:"));
15506                       /* Fall through.  */
15507                     do_numlist:
15508                       for (;;)
15509                         {
15510                           unsigned int j;
15511
15512                           val = read_uleb128 (p, &j, end);
15513                           p += j;
15514                           if (val == 0)
15515                             break;
15516                           printf (" %d", val);
15517                         }
15518                       printf ("\n");
15519                       break;
15520                     default:
15521                       printf (_("Unknown tag: %d\n"), tag);
15522                       public_section = FALSE;
15523                       break;
15524                     }
15525
15526                   if (public_section && display_pub_attribute != NULL)
15527                     {
15528                       while (p < end)
15529                         p = display_pub_attribute (p, end);
15530                       assert (p == end);
15531                     }
15532                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15533                     {
15534                       while (p < end)
15535                         p = display_gnu_attribute (p,
15536                                                    display_proc_gnu_attribute,
15537                                                    end);
15538                       assert (p == end);
15539                     }
15540                   else if (p < end)
15541                     {
15542                       printf (_("  Unknown attribute:\n"));
15543                       display_raw_attribute (p, end);
15544                       p = end;
15545                     }
15546                   else
15547                     attr_len = 0;
15548                 }
15549             }
15550         }
15551
15552       free (contents);
15553     }
15554
15555   return res;
15556 }
15557
15558 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15559    Print the Address, Access and Initial fields of an entry at VMA ADDR
15560    and return the VMA of the next entry, or -1 if there was a problem.
15561    Does not read from DATA_END or beyond.  */
15562
15563 static bfd_vma
15564 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15565                       unsigned char * data_end)
15566 {
15567   printf ("  ");
15568   print_vma (addr, LONG_HEX);
15569   printf (" ");
15570   if (addr < pltgot + 0xfff0)
15571     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15572   else
15573     printf ("%10s", "");
15574   printf (" ");
15575   if (data == NULL)
15576     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15577   else
15578     {
15579       bfd_vma entry;
15580       unsigned char * from = data + addr - pltgot;
15581
15582       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15583         {
15584           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15585           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15586           return (bfd_vma) -1;
15587         }
15588       else
15589         {
15590           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15591           print_vma (entry, LONG_HEX);
15592         }
15593     }
15594   return addr + (is_32bit_elf ? 4 : 8);
15595 }
15596
15597 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15598    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15599    ADDR and return the VMA of the next entry.  */
15600
15601 static bfd_vma
15602 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15603 {
15604   printf ("  ");
15605   print_vma (addr, LONG_HEX);
15606   printf (" ");
15607   if (data == NULL)
15608     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15609   else
15610     {
15611       bfd_vma entry;
15612
15613       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15614       print_vma (entry, LONG_HEX);
15615     }
15616   return addr + (is_32bit_elf ? 4 : 8);
15617 }
15618
15619 static void
15620 print_mips_ases (unsigned int mask)
15621 {
15622   if (mask & AFL_ASE_DSP)
15623     fputs ("\n\tDSP ASE", stdout);
15624   if (mask & AFL_ASE_DSPR2)
15625     fputs ("\n\tDSP R2 ASE", stdout);
15626   if (mask & AFL_ASE_DSPR3)
15627     fputs ("\n\tDSP R3 ASE", stdout);
15628   if (mask & AFL_ASE_EVA)
15629     fputs ("\n\tEnhanced VA Scheme", stdout);
15630   if (mask & AFL_ASE_MCU)
15631     fputs ("\n\tMCU (MicroController) ASE", stdout);
15632   if (mask & AFL_ASE_MDMX)
15633     fputs ("\n\tMDMX ASE", stdout);
15634   if (mask & AFL_ASE_MIPS3D)
15635     fputs ("\n\tMIPS-3D ASE", stdout);
15636   if (mask & AFL_ASE_MT)
15637     fputs ("\n\tMT ASE", stdout);
15638   if (mask & AFL_ASE_SMARTMIPS)
15639     fputs ("\n\tSmartMIPS ASE", stdout);
15640   if (mask & AFL_ASE_VIRT)
15641     fputs ("\n\tVZ ASE", stdout);
15642   if (mask & AFL_ASE_MSA)
15643     fputs ("\n\tMSA ASE", stdout);
15644   if (mask & AFL_ASE_MIPS16)
15645     fputs ("\n\tMIPS16 ASE", stdout);
15646   if (mask & AFL_ASE_MICROMIPS)
15647     fputs ("\n\tMICROMIPS ASE", stdout);
15648   if (mask & AFL_ASE_XPA)
15649     fputs ("\n\tXPA ASE", stdout);
15650   if (mask & AFL_ASE_MIPS16E2)
15651     fputs ("\n\tMIPS16e2 ASE", stdout);
15652   if (mask & AFL_ASE_CRC)
15653     fputs ("\n\tCRC ASE", stdout);
15654   if (mask & AFL_ASE_GINV)
15655     fputs ("\n\tGINV ASE", stdout);
15656   if (mask & AFL_ASE_LOONGSON_MMI)
15657     fputs ("\n\tLoongson MMI ASE", stdout);
15658   if (mask & AFL_ASE_LOONGSON_CAM)
15659     fputs ("\n\tLoongson CAM ASE", stdout);
15660   if (mask & AFL_ASE_LOONGSON_EXT)
15661     fputs ("\n\tLoongson EXT ASE", stdout);
15662   if (mask & AFL_ASE_LOONGSON_EXT2)
15663     fputs ("\n\tLoongson EXT2 ASE", stdout);
15664   if (mask == 0)
15665     fprintf (stdout, "\n\t%s", _("None"));
15666   else if ((mask & ~AFL_ASE_MASK) != 0)
15667     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15668 }
15669
15670 static void
15671 print_mips_isa_ext (unsigned int isa_ext)
15672 {
15673   switch (isa_ext)
15674     {
15675     case 0:
15676       fputs (_("None"), stdout);
15677       break;
15678     case AFL_EXT_XLR:
15679       fputs ("RMI XLR", stdout);
15680       break;
15681     case AFL_EXT_OCTEON3:
15682       fputs ("Cavium Networks Octeon3", stdout);
15683       break;
15684     case AFL_EXT_OCTEON2:
15685       fputs ("Cavium Networks Octeon2", stdout);
15686       break;
15687     case AFL_EXT_OCTEONP:
15688       fputs ("Cavium Networks OcteonP", stdout);
15689       break;
15690     case AFL_EXT_OCTEON:
15691       fputs ("Cavium Networks Octeon", stdout);
15692       break;
15693     case AFL_EXT_5900:
15694       fputs ("Toshiba R5900", stdout);
15695       break;
15696     case AFL_EXT_4650:
15697       fputs ("MIPS R4650", stdout);
15698       break;
15699     case AFL_EXT_4010:
15700       fputs ("LSI R4010", stdout);
15701       break;
15702     case AFL_EXT_4100:
15703       fputs ("NEC VR4100", stdout);
15704       break;
15705     case AFL_EXT_3900:
15706       fputs ("Toshiba R3900", stdout);
15707       break;
15708     case AFL_EXT_10000:
15709       fputs ("MIPS R10000", stdout);
15710       break;
15711     case AFL_EXT_SB1:
15712       fputs ("Broadcom SB-1", stdout);
15713       break;
15714     case AFL_EXT_4111:
15715       fputs ("NEC VR4111/VR4181", stdout);
15716       break;
15717     case AFL_EXT_4120:
15718       fputs ("NEC VR4120", stdout);
15719       break;
15720     case AFL_EXT_5400:
15721       fputs ("NEC VR5400", stdout);
15722       break;
15723     case AFL_EXT_5500:
15724       fputs ("NEC VR5500", stdout);
15725       break;
15726     case AFL_EXT_LOONGSON_2E:
15727       fputs ("ST Microelectronics Loongson 2E", stdout);
15728       break;
15729     case AFL_EXT_LOONGSON_2F:
15730       fputs ("ST Microelectronics Loongson 2F", stdout);
15731       break;
15732     case AFL_EXT_INTERAPTIV_MR2:
15733       fputs ("Imagination interAptiv MR2", stdout);
15734       break;
15735     default:
15736       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15737     }
15738 }
15739
15740 static signed int
15741 get_mips_reg_size (int reg_size)
15742 {
15743   return (reg_size == AFL_REG_NONE) ? 0
15744          : (reg_size == AFL_REG_32) ? 32
15745          : (reg_size == AFL_REG_64) ? 64
15746          : (reg_size == AFL_REG_128) ? 128
15747          : -1;
15748 }
15749
15750 static bfd_boolean
15751 process_mips_specific (Filedata * filedata)
15752 {
15753   Elf_Internal_Dyn * entry;
15754   Elf_Internal_Shdr *sect = NULL;
15755   size_t liblist_offset = 0;
15756   size_t liblistno = 0;
15757   size_t conflictsno = 0;
15758   size_t options_offset = 0;
15759   size_t conflicts_offset = 0;
15760   size_t pltrelsz = 0;
15761   size_t pltrel = 0;
15762   bfd_vma pltgot = 0;
15763   bfd_vma mips_pltgot = 0;
15764   bfd_vma jmprel = 0;
15765   bfd_vma local_gotno = 0;
15766   bfd_vma gotsym = 0;
15767   bfd_vma symtabno = 0;
15768   bfd_boolean res = TRUE;
15769
15770   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15771                             display_mips_gnu_attribute))
15772     res = FALSE;
15773
15774   sect = find_section (filedata, ".MIPS.abiflags");
15775
15776   if (sect != NULL)
15777     {
15778       Elf_External_ABIFlags_v0 *abiflags_ext;
15779       Elf_Internal_ABIFlags_v0 abiflags_in;
15780
15781       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15782         {
15783           error (_("Corrupt MIPS ABI Flags section.\n"));
15784           res = FALSE;
15785         }
15786       else
15787         {
15788           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15789                                    sect->sh_size, _("MIPS ABI Flags section"));
15790           if (abiflags_ext)
15791             {
15792               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15793               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15794               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15795               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15796               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15797               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15798               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15799               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15800               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15801               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15802               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15803
15804               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15805               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15806               if (abiflags_in.isa_rev > 1)
15807                 printf ("r%d", abiflags_in.isa_rev);
15808               printf ("\nGPR size: %d",
15809                       get_mips_reg_size (abiflags_in.gpr_size));
15810               printf ("\nCPR1 size: %d",
15811                       get_mips_reg_size (abiflags_in.cpr1_size));
15812               printf ("\nCPR2 size: %d",
15813                       get_mips_reg_size (abiflags_in.cpr2_size));
15814               fputs ("\nFP ABI: ", stdout);
15815               print_mips_fp_abi_value (abiflags_in.fp_abi);
15816               fputs ("ISA Extension: ", stdout);
15817               print_mips_isa_ext (abiflags_in.isa_ext);
15818               fputs ("\nASEs:", stdout);
15819               print_mips_ases (abiflags_in.ases);
15820               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15821               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15822               fputc ('\n', stdout);
15823               free (abiflags_ext);
15824             }
15825         }
15826     }
15827
15828   /* We have a lot of special sections.  Thanks SGI!  */
15829   if (dynamic_section == NULL)
15830     {
15831       /* No dynamic information available.  See if there is static GOT.  */
15832       sect = find_section (filedata, ".got");
15833       if (sect != NULL)
15834         {
15835           unsigned char *data_end;
15836           unsigned char *data;
15837           bfd_vma ent, end;
15838           int addr_size;
15839
15840           pltgot = sect->sh_addr;
15841
15842           ent = pltgot;
15843           addr_size = (is_32bit_elf ? 4 : 8);
15844           end = pltgot + sect->sh_size;
15845
15846           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15847                                              end - pltgot, 1,
15848                                              _("Global Offset Table data"));
15849           /* PR 12855: Null data is handled gracefully throughout.  */
15850           data_end = data + (end - pltgot);
15851
15852           printf (_("\nStatic GOT:\n"));
15853           printf (_(" Canonical gp value: "));
15854           print_vma (ent + 0x7ff0, LONG_HEX);
15855           printf ("\n\n");
15856
15857           /* In a dynamic binary GOT[0] is reserved for the dynamic
15858              loader to store the lazy resolver pointer, however in
15859              a static binary it may well have been omitted and GOT
15860              reduced to a table of addresses.
15861              PR 21344: Check for the entry being fully available
15862              before fetching it.  */
15863           if (data
15864               && data + ent - pltgot + addr_size <= data_end
15865               && byte_get (data + ent - pltgot, addr_size) == 0)
15866             {
15867               printf (_(" Reserved entries:\n"));
15868               printf (_("  %*s %10s %*s\n"),
15869                       addr_size * 2, _("Address"), _("Access"),
15870                       addr_size * 2, _("Value"));
15871               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15872               printf ("\n");
15873               if (ent == (bfd_vma) -1)
15874                 goto sgot_print_fail;
15875
15876               /* Check for the MSB of GOT[1] being set, identifying a
15877                  GNU object.  This entry will be used by some runtime
15878                  loaders, to store the module pointer.  Otherwise this
15879                  is an ordinary local entry.
15880                  PR 21344: Check for the entry being fully available
15881                  before fetching it.  */
15882               if (data
15883                   && data + ent - pltgot + addr_size <= data_end
15884                   && (byte_get (data + ent - pltgot, addr_size)
15885                       >> (addr_size * 8 - 1)) != 0)
15886                 {
15887                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15888                   printf ("\n");
15889                   if (ent == (bfd_vma) -1)
15890                     goto sgot_print_fail;
15891                 }
15892               printf ("\n");
15893             }
15894
15895           if (data != NULL && ent < end)
15896             {
15897               printf (_(" Local entries:\n"));
15898               printf ("  %*s %10s %*s\n",
15899                       addr_size * 2, _("Address"), _("Access"),
15900                       addr_size * 2, _("Value"));
15901               while (ent < end)
15902                 {
15903                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15904                   printf ("\n");
15905                   if (ent == (bfd_vma) -1)
15906                     goto sgot_print_fail;
15907                 }
15908               printf ("\n");
15909             }
15910
15911         sgot_print_fail:
15912           if (data)
15913             free (data);
15914         }
15915       return res;
15916     }
15917
15918   for (entry = dynamic_section;
15919        /* PR 17531 file: 012-50589-0.004.  */
15920        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15921        ++entry)
15922     switch (entry->d_tag)
15923       {
15924       case DT_MIPS_LIBLIST:
15925         liblist_offset
15926           = offset_from_vma (filedata, entry->d_un.d_val,
15927                              liblistno * sizeof (Elf32_External_Lib));
15928         break;
15929       case DT_MIPS_LIBLISTNO:
15930         liblistno = entry->d_un.d_val;
15931         break;
15932       case DT_MIPS_OPTIONS:
15933         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15934         break;
15935       case DT_MIPS_CONFLICT:
15936         conflicts_offset
15937           = offset_from_vma (filedata, entry->d_un.d_val,
15938                              conflictsno * sizeof (Elf32_External_Conflict));
15939         break;
15940       case DT_MIPS_CONFLICTNO:
15941         conflictsno = entry->d_un.d_val;
15942         break;
15943       case DT_PLTGOT:
15944         pltgot = entry->d_un.d_ptr;
15945         break;
15946       case DT_MIPS_LOCAL_GOTNO:
15947         local_gotno = entry->d_un.d_val;
15948         break;
15949       case DT_MIPS_GOTSYM:
15950         gotsym = entry->d_un.d_val;
15951         break;
15952       case DT_MIPS_SYMTABNO:
15953         symtabno = entry->d_un.d_val;
15954         break;
15955       case DT_MIPS_PLTGOT:
15956         mips_pltgot = entry->d_un.d_ptr;
15957         break;
15958       case DT_PLTREL:
15959         pltrel = entry->d_un.d_val;
15960         break;
15961       case DT_PLTRELSZ:
15962         pltrelsz = entry->d_un.d_val;
15963         break;
15964       case DT_JMPREL:
15965         jmprel = entry->d_un.d_ptr;
15966         break;
15967       default:
15968         break;
15969       }
15970
15971   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15972     {
15973       Elf32_External_Lib * elib;
15974       size_t cnt;
15975
15976       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15977                                               liblistno,
15978                                               sizeof (Elf32_External_Lib),
15979                                               _("liblist section data"));
15980       if (elib)
15981         {
15982           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15983                             "\nSection '.liblist' contains %lu entries:\n",
15984                             (unsigned long) liblistno),
15985                   (unsigned long) liblistno);
15986           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15987                  stdout);
15988
15989           for (cnt = 0; cnt < liblistno; ++cnt)
15990             {
15991               Elf32_Lib liblist;
15992               time_t atime;
15993               char timebuf[128];
15994               struct tm * tmp;
15995
15996               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15997               atime = BYTE_GET (elib[cnt].l_time_stamp);
15998               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15999               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16000               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16001
16002               tmp = gmtime (&atime);
16003               snprintf (timebuf, sizeof (timebuf),
16004                         "%04u-%02u-%02uT%02u:%02u:%02u",
16005                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16006                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16007
16008               printf ("%3lu: ", (unsigned long) cnt);
16009               if (VALID_DYNAMIC_NAME (liblist.l_name))
16010                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16011               else
16012                 printf (_("<corrupt: %9ld>"), liblist.l_name);
16013               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16014                       liblist.l_version);
16015
16016               if (liblist.l_flags == 0)
16017                 puts (_(" NONE"));
16018               else
16019                 {
16020                   static const struct
16021                   {
16022                     const char * name;
16023                     int bit;
16024                   }
16025                   l_flags_vals[] =
16026                   {
16027                     { " EXACT_MATCH", LL_EXACT_MATCH },
16028                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16029                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16030                     { " EXPORTS", LL_EXPORTS },
16031                     { " DELAY_LOAD", LL_DELAY_LOAD },
16032                     { " DELTA", LL_DELTA }
16033                   };
16034                   int flags = liblist.l_flags;
16035                   size_t fcnt;
16036
16037                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16038                     if ((flags & l_flags_vals[fcnt].bit) != 0)
16039                       {
16040                         fputs (l_flags_vals[fcnt].name, stdout);
16041                         flags ^= l_flags_vals[fcnt].bit;
16042                       }
16043                   if (flags != 0)
16044                     printf (" %#x", (unsigned int) flags);
16045
16046                   puts ("");
16047                 }
16048             }
16049
16050           free (elib);
16051         }
16052       else
16053         res = FALSE;
16054     }
16055
16056   if (options_offset != 0)
16057     {
16058       Elf_External_Options * eopt;
16059       Elf_Internal_Options * iopt;
16060       Elf_Internal_Options * option;
16061       size_t offset;
16062       int cnt;
16063       sect = filedata->section_headers;
16064
16065       /* Find the section header so that we get the size.  */
16066       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16067       /* PR 17533 file: 012-277276-0.004.  */
16068       if (sect == NULL)
16069         {
16070           error (_("No MIPS_OPTIONS header found\n"));
16071           return FALSE;
16072         }
16073
16074       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16075                                                 sect->sh_size, _("options"));
16076       if (eopt)
16077         {
16078           iopt = (Elf_Internal_Options *)
16079               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16080           if (iopt == NULL)
16081             {
16082               error (_("Out of memory allocating space for MIPS options\n"));
16083               return FALSE;
16084             }
16085
16086           offset = cnt = 0;
16087           option = iopt;
16088
16089           while (offset <= sect->sh_size - sizeof (* eopt))
16090             {
16091               Elf_External_Options * eoption;
16092
16093               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16094
16095               option->kind = BYTE_GET (eoption->kind);
16096               option->size = BYTE_GET (eoption->size);
16097               option->section = BYTE_GET (eoption->section);
16098               option->info = BYTE_GET (eoption->info);
16099
16100               /* PR 17531: file: ffa0fa3b.  */
16101               if (option->size < sizeof (* eopt)
16102                   || offset + option->size > sect->sh_size)
16103                 {
16104                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
16105                   return FALSE;
16106                 }
16107               offset += option->size;
16108
16109               ++option;
16110               ++cnt;
16111             }
16112
16113           printf (ngettext ("\nSection '%s' contains %d entry:\n",
16114                             "\nSection '%s' contains %d entries:\n",
16115                             cnt),
16116                   printable_section_name (filedata, sect), cnt);
16117
16118           option = iopt;
16119           offset = 0;
16120
16121           while (cnt-- > 0)
16122             {
16123               size_t len;
16124
16125               switch (option->kind)
16126                 {
16127                 case ODK_NULL:
16128                   /* This shouldn't happen.  */
16129                   printf (" NULL       %d %lx", option->section, option->info);
16130                   break;
16131                 case ODK_REGINFO:
16132                   printf (" REGINFO    ");
16133                   if (filedata->file_header.e_machine == EM_MIPS)
16134                     {
16135                       /* 32bit form.  */
16136                       Elf32_External_RegInfo * ereg;
16137                       Elf32_RegInfo reginfo;
16138
16139                       ereg = (Elf32_External_RegInfo *) (option + 1);
16140                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16141                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16142                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16143                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16144                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16145                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16146
16147                       printf ("GPR %08lx  GP 0x%lx\n",
16148                               reginfo.ri_gprmask,
16149                               (unsigned long) reginfo.ri_gp_value);
16150                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16151                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16152                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16153                     }
16154                   else
16155                     {
16156                       /* 64 bit form.  */
16157                       Elf64_External_RegInfo * ereg;
16158                       Elf64_Internal_RegInfo reginfo;
16159
16160                       ereg = (Elf64_External_RegInfo *) (option + 1);
16161                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
16162                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16163                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16164                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16165                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16166                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16167
16168                       printf ("GPR %08lx  GP 0x",
16169                               reginfo.ri_gprmask);
16170                       printf_vma (reginfo.ri_gp_value);
16171                       printf ("\n");
16172
16173                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16174                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16175                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16176                     }
16177                   ++option;
16178                   continue;
16179                 case ODK_EXCEPTIONS:
16180                   fputs (" EXCEPTIONS fpe_min(", stdout);
16181                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16182                   fputs (") fpe_max(", stdout);
16183                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16184                   fputs (")", stdout);
16185
16186                   if (option->info & OEX_PAGE0)
16187                     fputs (" PAGE0", stdout);
16188                   if (option->info & OEX_SMM)
16189                     fputs (" SMM", stdout);
16190                   if (option->info & OEX_FPDBUG)
16191                     fputs (" FPDBUG", stdout);
16192                   if (option->info & OEX_DISMISS)
16193                     fputs (" DISMISS", stdout);
16194                   break;
16195                 case ODK_PAD:
16196                   fputs (" PAD       ", stdout);
16197                   if (option->info & OPAD_PREFIX)
16198                     fputs (" PREFIX", stdout);
16199                   if (option->info & OPAD_POSTFIX)
16200                     fputs (" POSTFIX", stdout);
16201                   if (option->info & OPAD_SYMBOL)
16202                     fputs (" SYMBOL", stdout);
16203                   break;
16204                 case ODK_HWPATCH:
16205                   fputs (" HWPATCH   ", stdout);
16206                   if (option->info & OHW_R4KEOP)
16207                     fputs (" R4KEOP", stdout);
16208                   if (option->info & OHW_R8KPFETCH)
16209                     fputs (" R8KPFETCH", stdout);
16210                   if (option->info & OHW_R5KEOP)
16211                     fputs (" R5KEOP", stdout);
16212                   if (option->info & OHW_R5KCVTL)
16213                     fputs (" R5KCVTL", stdout);
16214                   break;
16215                 case ODK_FILL:
16216                   fputs (" FILL       ", stdout);
16217                   /* XXX Print content of info word?  */
16218                   break;
16219                 case ODK_TAGS:
16220                   fputs (" TAGS       ", stdout);
16221                   /* XXX Print content of info word?  */
16222                   break;
16223                 case ODK_HWAND:
16224                   fputs (" HWAND     ", stdout);
16225                   if (option->info & OHWA0_R4KEOP_CHECKED)
16226                     fputs (" R4KEOP_CHECKED", stdout);
16227                   if (option->info & OHWA0_R4KEOP_CLEAN)
16228                     fputs (" R4KEOP_CLEAN", stdout);
16229                   break;
16230                 case ODK_HWOR:
16231                   fputs (" HWOR      ", stdout);
16232                   if (option->info & OHWA0_R4KEOP_CHECKED)
16233                     fputs (" R4KEOP_CHECKED", stdout);
16234                   if (option->info & OHWA0_R4KEOP_CLEAN)
16235                     fputs (" R4KEOP_CLEAN", stdout);
16236                   break;
16237                 case ODK_GP_GROUP:
16238                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16239                           option->info & OGP_GROUP,
16240                           (option->info & OGP_SELF) >> 16);
16241                   break;
16242                 case ODK_IDENT:
16243                   printf (" IDENT     %#06lx  self-contained %#06lx",
16244                           option->info & OGP_GROUP,
16245                           (option->info & OGP_SELF) >> 16);
16246                   break;
16247                 default:
16248                   /* This shouldn't happen.  */
16249                   printf (" %3d ???     %d %lx",
16250                           option->kind, option->section, option->info);
16251                   break;
16252                 }
16253
16254               len = sizeof (* eopt);
16255               while (len < option->size)
16256                 {
16257                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16258
16259                   if (ISPRINT (datum))
16260                     printf ("%c", datum);
16261                   else
16262                     printf ("\\%03o", datum);
16263                   len ++;
16264                 }
16265               fputs ("\n", stdout);
16266
16267               offset += option->size;
16268               ++option;
16269             }
16270
16271           free (eopt);
16272         }
16273       else
16274         res = FALSE;
16275     }
16276
16277   if (conflicts_offset != 0 && conflictsno != 0)
16278     {
16279       Elf32_Conflict * iconf;
16280       size_t cnt;
16281
16282       if (dynamic_symbols == NULL)
16283         {
16284           error (_("conflict list found without a dynamic symbol table\n"));
16285           return FALSE;
16286         }
16287
16288       /* PR 21345 - print a slightly more helpful error message
16289          if we are sure that the cmalloc will fail.  */
16290       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16291         {
16292           error (_("Overlarge number of conflicts detected: %lx\n"),
16293                  (long) conflictsno);
16294           return FALSE;
16295         }
16296
16297       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16298       if (iconf == NULL)
16299         {
16300           error (_("Out of memory allocating space for dynamic conflicts\n"));
16301           return FALSE;
16302         }
16303
16304       if (is_32bit_elf)
16305         {
16306           Elf32_External_Conflict * econf32;
16307
16308           econf32 = (Elf32_External_Conflict *)
16309               get_data (NULL, filedata, conflicts_offset, conflictsno,
16310                         sizeof (* econf32), _("conflict"));
16311           if (!econf32)
16312             return FALSE;
16313
16314           for (cnt = 0; cnt < conflictsno; ++cnt)
16315             iconf[cnt] = BYTE_GET (econf32[cnt]);
16316
16317           free (econf32);
16318         }
16319       else
16320         {
16321           Elf64_External_Conflict * econf64;
16322
16323           econf64 = (Elf64_External_Conflict *)
16324               get_data (NULL, filedata, conflicts_offset, conflictsno,
16325                         sizeof (* econf64), _("conflict"));
16326           if (!econf64)
16327             return FALSE;
16328
16329           for (cnt = 0; cnt < conflictsno; ++cnt)
16330             iconf[cnt] = BYTE_GET (econf64[cnt]);
16331
16332           free (econf64);
16333         }
16334
16335       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16336                         "\nSection '.conflict' contains %lu entries:\n",
16337                         (unsigned long) conflictsno),
16338               (unsigned long) conflictsno);
16339       puts (_("  Num:    Index       Value  Name"));
16340
16341       for (cnt = 0; cnt < conflictsno; ++cnt)
16342         {
16343           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16344
16345           if (iconf[cnt] >= num_dynamic_syms)
16346             printf (_("<corrupt symbol index>"));
16347           else
16348             {
16349               Elf_Internal_Sym * psym;
16350
16351               psym = & dynamic_symbols[iconf[cnt]];
16352               print_vma (psym->st_value, FULL_HEX);
16353               putchar (' ');
16354               if (VALID_DYNAMIC_NAME (psym->st_name))
16355                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16356               else
16357                 printf (_("<corrupt: %14ld>"), psym->st_name);
16358             }
16359           putchar ('\n');
16360         }
16361
16362       free (iconf);
16363     }
16364
16365   if (pltgot != 0 && local_gotno != 0)
16366     {
16367       bfd_vma ent, local_end, global_end;
16368       size_t i, offset;
16369       unsigned char * data;
16370       unsigned char * data_end;
16371       int addr_size;
16372
16373       ent = pltgot;
16374       addr_size = (is_32bit_elf ? 4 : 8);
16375       local_end = pltgot + local_gotno * addr_size;
16376
16377       /* PR binutils/17533 file: 012-111227-0.004  */
16378       if (symtabno < gotsym)
16379         {
16380           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16381                  (unsigned long) gotsym, (unsigned long) symtabno);
16382           return FALSE;
16383         }
16384
16385       global_end = local_end + (symtabno - gotsym) * addr_size;
16386       /* PR 17531: file: 54c91a34.  */
16387       if (global_end < local_end)
16388         {
16389           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16390           return FALSE;
16391         }
16392
16393       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16394       data = (unsigned char *) get_data (NULL, filedata, offset,
16395                                          global_end - pltgot, 1,
16396                                          _("Global Offset Table data"));
16397       /* PR 12855: Null data is handled gracefully throughout.  */
16398       data_end = data + (global_end - pltgot);
16399
16400       printf (_("\nPrimary GOT:\n"));
16401       printf (_(" Canonical gp value: "));
16402       print_vma (pltgot + 0x7ff0, LONG_HEX);
16403       printf ("\n\n");
16404
16405       printf (_(" Reserved entries:\n"));
16406       printf (_("  %*s %10s %*s Purpose\n"),
16407               addr_size * 2, _("Address"), _("Access"),
16408               addr_size * 2, _("Initial"));
16409       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16410       printf (_(" Lazy resolver\n"));
16411       if (ent == (bfd_vma) -1)
16412         goto got_print_fail;
16413
16414       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16415          This entry will be used by some runtime loaders, to store the
16416          module pointer.  Otherwise this is an ordinary local entry.
16417          PR 21344: Check for the entry being fully available before
16418          fetching it.  */
16419       if (data
16420           && data + ent - pltgot + addr_size <= data_end
16421           && (byte_get (data + ent - pltgot, addr_size)
16422               >> (addr_size * 8 - 1)) != 0)
16423         {
16424           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16425           printf (_(" Module pointer (GNU extension)\n"));
16426           if (ent == (bfd_vma) -1)
16427             goto got_print_fail;
16428         }
16429       printf ("\n");
16430
16431       if (data != NULL && ent < local_end)
16432         {
16433           printf (_(" Local entries:\n"));
16434           printf ("  %*s %10s %*s\n",
16435                   addr_size * 2, _("Address"), _("Access"),
16436                   addr_size * 2, _("Initial"));
16437           while (ent < local_end)
16438             {
16439               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16440               printf ("\n");
16441               if (ent == (bfd_vma) -1)
16442                 goto got_print_fail;
16443             }
16444           printf ("\n");
16445         }
16446
16447       if (data != NULL && gotsym < symtabno)
16448         {
16449           int sym_width;
16450
16451           printf (_(" Global entries:\n"));
16452           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16453                   addr_size * 2, _("Address"),
16454                   _("Access"),
16455                   addr_size * 2, _("Initial"),
16456                   addr_size * 2, _("Sym.Val."),
16457                   _("Type"),
16458                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16459                   _("Ndx"), _("Name"));
16460
16461           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16462
16463           for (i = gotsym; i < symtabno; i++)
16464             {
16465               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16466               printf (" ");
16467
16468               if (dynamic_symbols == NULL)
16469                 printf (_("<no dynamic symbols>"));
16470               else if (i < num_dynamic_syms)
16471                 {
16472                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16473
16474                   print_vma (psym->st_value, LONG_HEX);
16475                   printf (" %-7s %3s ",
16476                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16477                           get_symbol_index_type (filedata, psym->st_shndx));
16478
16479                   if (VALID_DYNAMIC_NAME (psym->st_name))
16480                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16481                   else
16482                     printf (_("<corrupt: %14ld>"), psym->st_name);
16483                 }
16484               else
16485                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16486                         (unsigned long) i);
16487
16488               printf ("\n");
16489               if (ent == (bfd_vma) -1)
16490                 break;
16491             }
16492           printf ("\n");
16493         }
16494
16495     got_print_fail:
16496       if (data)
16497         free (data);
16498     }
16499
16500   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16501     {
16502       bfd_vma ent, end;
16503       size_t offset, rel_offset;
16504       unsigned long count, i;
16505       unsigned char * data;
16506       int addr_size, sym_width;
16507       Elf_Internal_Rela * rels;
16508
16509       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16510       if (pltrel == DT_RELA)
16511         {
16512           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16513             return FALSE;
16514         }
16515       else
16516         {
16517           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16518             return FALSE;
16519         }
16520
16521       ent = mips_pltgot;
16522       addr_size = (is_32bit_elf ? 4 : 8);
16523       end = mips_pltgot + (2 + count) * addr_size;
16524
16525       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16526       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16527                                          1, _("Procedure Linkage Table data"));
16528       if (data == NULL)
16529         return FALSE;
16530
16531       printf ("\nPLT GOT:\n\n");
16532       printf (_(" Reserved entries:\n"));
16533       printf (_("  %*s %*s Purpose\n"),
16534               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16535       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16536       printf (_(" PLT lazy resolver\n"));
16537       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16538       printf (_(" Module pointer\n"));
16539       printf ("\n");
16540
16541       printf (_(" Entries:\n"));
16542       printf ("  %*s %*s %*s %-7s %3s %s\n",
16543               addr_size * 2, _("Address"),
16544               addr_size * 2, _("Initial"),
16545               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16546       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16547       for (i = 0; i < count; i++)
16548         {
16549           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16550
16551           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16552           printf (" ");
16553
16554           if (idx >= num_dynamic_syms)
16555             printf (_("<corrupt symbol index: %lu>"), idx);
16556           else
16557             {
16558               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16559
16560               print_vma (psym->st_value, LONG_HEX);
16561               printf (" %-7s %3s ",
16562                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16563                       get_symbol_index_type (filedata, psym->st_shndx));
16564               if (VALID_DYNAMIC_NAME (psym->st_name))
16565                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16566               else
16567                 printf (_("<corrupt: %14ld>"), psym->st_name);
16568             }
16569           printf ("\n");
16570         }
16571       printf ("\n");
16572
16573       if (data)
16574         free (data);
16575       free (rels);
16576     }
16577
16578   return res;
16579 }
16580
16581 static bfd_boolean
16582 process_nds32_specific (Filedata * filedata)
16583 {
16584   Elf_Internal_Shdr *sect = NULL;
16585
16586   sect = find_section (filedata, ".nds32_e_flags");
16587   if (sect != NULL)
16588     {
16589       unsigned int *flag;
16590
16591       printf ("\nNDS32 elf flags section:\n");
16592       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16593                        sect->sh_size, _("NDS32 elf flags section"));
16594
16595       if (! flag)
16596         return FALSE;
16597
16598       switch ((*flag) & 0x3)
16599         {
16600         case 0:
16601           printf ("(VEC_SIZE):\tNo entry.\n");
16602           break;
16603         case 1:
16604           printf ("(VEC_SIZE):\t4 bytes\n");
16605           break;
16606         case 2:
16607           printf ("(VEC_SIZE):\t16 bytes\n");
16608           break;
16609         case 3:
16610           printf ("(VEC_SIZE):\treserved\n");
16611           break;
16612         }
16613     }
16614
16615   return TRUE;
16616 }
16617
16618 static bfd_boolean
16619 process_gnu_liblist (Filedata * filedata)
16620 {
16621   Elf_Internal_Shdr * section;
16622   Elf_Internal_Shdr * string_sec;
16623   Elf32_External_Lib * elib;
16624   char * strtab;
16625   size_t strtab_size;
16626   size_t cnt;
16627   unsigned long num_liblist;
16628   unsigned i;
16629   bfd_boolean res = TRUE;
16630
16631   if (! do_arch)
16632     return TRUE;
16633
16634   for (i = 0, section = filedata->section_headers;
16635        i < filedata->file_header.e_shnum;
16636        i++, section++)
16637     {
16638       switch (section->sh_type)
16639         {
16640         case SHT_GNU_LIBLIST:
16641           if (section->sh_link >= filedata->file_header.e_shnum)
16642             break;
16643
16644           elib = (Elf32_External_Lib *)
16645               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16646                         _("liblist section data"));
16647
16648           if (elib == NULL)
16649             {
16650               res = FALSE;
16651               break;
16652             }
16653
16654           string_sec = filedata->section_headers + section->sh_link;
16655           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16656                                       string_sec->sh_size,
16657                                       _("liblist string table"));
16658           if (strtab == NULL
16659               || section->sh_entsize != sizeof (Elf32_External_Lib))
16660             {
16661               free (elib);
16662               free (strtab);
16663               res = FALSE;
16664               break;
16665             }
16666           strtab_size = string_sec->sh_size;
16667
16668           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16669           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16670                             "\nLibrary list section '%s' contains %lu entries:\n",
16671                             num_liblist),
16672                   printable_section_name (filedata, section),
16673                   num_liblist);
16674
16675           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16676
16677           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16678                ++cnt)
16679             {
16680               Elf32_Lib liblist;
16681               time_t atime;
16682               char timebuf[128];
16683               struct tm * tmp;
16684
16685               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16686               atime = BYTE_GET (elib[cnt].l_time_stamp);
16687               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16688               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16689               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16690
16691               tmp = gmtime (&atime);
16692               snprintf (timebuf, sizeof (timebuf),
16693                         "%04u-%02u-%02uT%02u:%02u:%02u",
16694                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16695                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16696
16697               printf ("%3lu: ", (unsigned long) cnt);
16698               if (do_wide)
16699                 printf ("%-20s", liblist.l_name < strtab_size
16700                         ? strtab + liblist.l_name : _("<corrupt>"));
16701               else
16702                 printf ("%-20.20s", liblist.l_name < strtab_size
16703                         ? strtab + liblist.l_name : _("<corrupt>"));
16704               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16705                       liblist.l_version, liblist.l_flags);
16706             }
16707
16708           free (elib);
16709           free (strtab);
16710         }
16711     }
16712
16713   return res;
16714 }
16715
16716 static const char *
16717 get_note_type (Filedata * filedata, unsigned e_type)
16718 {
16719   static char buff[64];
16720
16721   if (filedata->file_header.e_type == ET_CORE)
16722     switch (e_type)
16723       {
16724       case NT_AUXV:
16725         return _("NT_AUXV (auxiliary vector)");
16726       case NT_PRSTATUS:
16727         return _("NT_PRSTATUS (prstatus structure)");
16728       case NT_FPREGSET:
16729         return _("NT_FPREGSET (floating point registers)");
16730       case NT_PRPSINFO:
16731         return _("NT_PRPSINFO (prpsinfo structure)");
16732       case NT_TASKSTRUCT:
16733         return _("NT_TASKSTRUCT (task structure)");
16734       case NT_PRXFPREG:
16735         return _("NT_PRXFPREG (user_xfpregs structure)");
16736       case NT_PPC_VMX:
16737         return _("NT_PPC_VMX (ppc Altivec registers)");
16738       case NT_PPC_VSX:
16739         return _("NT_PPC_VSX (ppc VSX registers)");
16740       case NT_PPC_TAR:
16741         return _("NT_PPC_TAR (ppc TAR register)");
16742       case NT_PPC_PPR:
16743         return _("NT_PPC_PPR (ppc PPR register)");
16744       case NT_PPC_DSCR:
16745         return _("NT_PPC_DSCR (ppc DSCR register)");
16746       case NT_PPC_EBB:
16747         return _("NT_PPC_EBB (ppc EBB registers)");
16748       case NT_PPC_PMU:
16749         return _("NT_PPC_PMU (ppc PMU registers)");
16750       case NT_PPC_TM_CGPR:
16751         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16752       case NT_PPC_TM_CFPR:
16753         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16754       case NT_PPC_TM_CVMX:
16755         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16756       case NT_PPC_TM_CVSX:
16757         return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16758       case NT_PPC_TM_SPR:
16759         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16760       case NT_PPC_TM_CTAR:
16761         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16762       case NT_PPC_TM_CPPR:
16763         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16764       case NT_PPC_TM_CDSCR:
16765         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16766       case NT_386_TLS:
16767         return _("NT_386_TLS (x86 TLS information)");
16768       case NT_386_IOPERM:
16769         return _("NT_386_IOPERM (x86 I/O permissions)");
16770       case NT_X86_XSTATE:
16771         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16772       case NT_S390_HIGH_GPRS:
16773         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16774       case NT_S390_TIMER:
16775         return _("NT_S390_TIMER (s390 timer register)");
16776       case NT_S390_TODCMP:
16777         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16778       case NT_S390_TODPREG:
16779         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16780       case NT_S390_CTRS:
16781         return _("NT_S390_CTRS (s390 control registers)");
16782       case NT_S390_PREFIX:
16783         return _("NT_S390_PREFIX (s390 prefix register)");
16784       case NT_S390_LAST_BREAK:
16785         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16786       case NT_S390_SYSTEM_CALL:
16787         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16788       case NT_S390_TDB:
16789         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16790       case NT_S390_VXRS_LOW:
16791         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16792       case NT_S390_VXRS_HIGH:
16793         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16794       case NT_S390_GS_CB:
16795         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16796       case NT_S390_GS_BC:
16797         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16798       case NT_ARM_VFP:
16799         return _("NT_ARM_VFP (arm VFP registers)");
16800       case NT_ARM_TLS:
16801         return _("NT_ARM_TLS (AArch TLS registers)");
16802       case NT_ARM_HW_BREAK:
16803         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16804       case NT_ARM_HW_WATCH:
16805         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16806       case NT_PSTATUS:
16807         return _("NT_PSTATUS (pstatus structure)");
16808       case NT_FPREGS:
16809         return _("NT_FPREGS (floating point registers)");
16810       case NT_PSINFO:
16811         return _("NT_PSINFO (psinfo structure)");
16812       case NT_LWPSTATUS:
16813         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16814       case NT_LWPSINFO:
16815         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16816       case NT_WIN32PSTATUS:
16817         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16818       case NT_SIGINFO:
16819         return _("NT_SIGINFO (siginfo_t data)");
16820       case NT_FILE:
16821         return _("NT_FILE (mapped files)");
16822       default:
16823         break;
16824       }
16825   else
16826     switch (e_type)
16827       {
16828       case NT_VERSION:
16829         return _("NT_VERSION (version)");
16830       case NT_ARCH:
16831         return _("NT_ARCH (architecture)");
16832       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16833         return _("OPEN");
16834       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16835         return _("func");
16836       default:
16837         break;
16838       }
16839
16840   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16841   return buff;
16842 }
16843
16844 static bfd_boolean
16845 print_core_note (Elf_Internal_Note *pnote)
16846 {
16847   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16848   bfd_vma count, page_size;
16849   unsigned char *descdata, *filenames, *descend;
16850
16851   if (pnote->type != NT_FILE)
16852     {
16853       if (do_wide)
16854         printf ("\n");
16855       return TRUE;
16856     }
16857
16858 #ifndef BFD64
16859   if (!is_32bit_elf)
16860     {
16861       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16862       /* Still "successful".  */
16863       return TRUE;
16864     }
16865 #endif
16866
16867   if (pnote->descsz < 2 * addr_size)
16868     {
16869       error (_("    Malformed note - too short for header\n"));
16870       return FALSE;
16871     }
16872
16873   descdata = (unsigned char *) pnote->descdata;
16874   descend = descdata + pnote->descsz;
16875
16876   if (descdata[pnote->descsz - 1] != '\0')
16877     {
16878       error (_("    Malformed note - does not end with \\0\n"));
16879       return FALSE;
16880     }
16881
16882   count = byte_get (descdata, addr_size);
16883   descdata += addr_size;
16884
16885   page_size = byte_get (descdata, addr_size);
16886   descdata += addr_size;
16887
16888   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16889       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16890     {
16891       error (_("    Malformed note - too short for supplied file count\n"));
16892       return FALSE;
16893     }
16894
16895   printf (_("    Page size: "));
16896   print_vma (page_size, DEC);
16897   printf ("\n");
16898
16899   printf (_("    %*s%*s%*s\n"),
16900           (int) (2 + 2 * addr_size), _("Start"),
16901           (int) (4 + 2 * addr_size), _("End"),
16902           (int) (4 + 2 * addr_size), _("Page Offset"));
16903   filenames = descdata + count * 3 * addr_size;
16904   while (count-- > 0)
16905     {
16906       bfd_vma start, end, file_ofs;
16907
16908       if (filenames == descend)
16909         {
16910           error (_("    Malformed note - filenames end too early\n"));
16911           return FALSE;
16912         }
16913
16914       start = byte_get (descdata, addr_size);
16915       descdata += addr_size;
16916       end = byte_get (descdata, addr_size);
16917       descdata += addr_size;
16918       file_ofs = byte_get (descdata, addr_size);
16919       descdata += addr_size;
16920
16921       printf ("    ");
16922       print_vma (start, FULL_HEX);
16923       printf ("  ");
16924       print_vma (end, FULL_HEX);
16925       printf ("  ");
16926       print_vma (file_ofs, FULL_HEX);
16927       printf ("\n        %s\n", filenames);
16928
16929       filenames += 1 + strlen ((char *) filenames);
16930     }
16931
16932   return TRUE;
16933 }
16934
16935 static const char *
16936 get_gnu_elf_note_type (unsigned e_type)
16937 {
16938   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16939   switch (e_type)
16940     {
16941     case NT_GNU_ABI_TAG:
16942       return _("NT_GNU_ABI_TAG (ABI version tag)");
16943     case NT_GNU_HWCAP:
16944       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16945     case NT_GNU_BUILD_ID:
16946       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16947     case NT_GNU_GOLD_VERSION:
16948       return _("NT_GNU_GOLD_VERSION (gold version)");
16949     case NT_GNU_PROPERTY_TYPE_0:
16950       return _("NT_GNU_PROPERTY_TYPE_0");
16951     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16952       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16953     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16954       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16955     default:
16956       {
16957         static char buff[64];
16958
16959         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16960         return buff;
16961       }
16962     }
16963 }
16964
16965 static void
16966 decode_x86_compat_isa (unsigned int bitmask)
16967 {
16968   while (bitmask)
16969     {
16970       unsigned int bit = bitmask & (- bitmask);
16971
16972       bitmask &= ~ bit;
16973       switch (bit)
16974         {
16975         case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
16976           printf ("i486");
16977           break;
16978         case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
16979           printf ("586");
16980           break;
16981         case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
16982           printf ("686");
16983           break;
16984         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
16985           printf ("SSE");
16986           break;
16987         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
16988           printf ("SSE2");
16989           break;
16990         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
16991           printf ("SSE3");
16992           break;
16993         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
16994           printf ("SSSE3");
16995           break;
16996         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
16997           printf ("SSE4_1");
16998           break;
16999         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17000           printf ("SSE4_2");
17001           break;
17002         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17003           printf ("AVX");
17004           break;
17005         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17006           printf ("AVX2");
17007           break;
17008         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17009           printf ("AVX512F");
17010           break;
17011         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17012           printf ("AVX512CD");
17013           break;
17014         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17015           printf ("AVX512ER");
17016           break;
17017         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17018           printf ("AVX512PF");
17019           break;
17020         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17021           printf ("AVX512VL");
17022           break;
17023         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17024           printf ("AVX512DQ");
17025           break;
17026         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17027           printf ("AVX512BW");
17028           break;
17029         default:
17030           printf (_("<unknown: %x>"), bit);
17031           break;
17032         }
17033       if (bitmask)
17034         printf (", ");
17035     }
17036 }
17037
17038 static void
17039 decode_x86_isa (unsigned int bitmask)
17040 {
17041   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17042     {
17043       printf (_("<None>"));
17044       return;
17045     }
17046   else
17047     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17048
17049   while (bitmask)
17050     {
17051       unsigned int bit = bitmask & (- bitmask);
17052
17053       bitmask &= ~ bit;
17054       switch (bit)
17055         {
17056         case GNU_PROPERTY_X86_ISA_1_CMOV:
17057           printf ("CMOV");
17058           break;
17059         case GNU_PROPERTY_X86_ISA_1_SSE:
17060           printf ("SSE");
17061           break;
17062         case GNU_PROPERTY_X86_ISA_1_SSE2:
17063           printf ("SSE2");
17064           break;
17065         case GNU_PROPERTY_X86_ISA_1_SSE3:
17066           printf ("SSE3");
17067           break;
17068         case GNU_PROPERTY_X86_ISA_1_SSSE3:
17069           printf ("SSSE3");
17070           break;
17071         case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17072           printf ("SSE4_1");
17073           break;
17074         case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17075           printf ("SSE4_2");
17076           break;
17077         case GNU_PROPERTY_X86_ISA_1_AVX:
17078           printf ("AVX");
17079           break;
17080         case GNU_PROPERTY_X86_ISA_1_AVX2:
17081           printf ("AVX2");
17082           break;
17083         case GNU_PROPERTY_X86_ISA_1_FMA:
17084           printf ("FMA");
17085           break;
17086         case GNU_PROPERTY_X86_ISA_1_AVX512F:
17087           printf ("AVX512F");
17088           break;
17089         case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17090           printf ("AVX512CD");
17091           break;
17092         case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17093           printf ("AVX512ER");
17094           break;
17095         case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17096           printf ("AVX512PF");
17097           break;
17098         case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17099           printf ("AVX512VL");
17100           break;
17101         case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17102           printf ("AVX512DQ");
17103           break;
17104         case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17105           printf ("AVX512BW");
17106           break;
17107         case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17108           printf ("AVX512_4FMAPS");
17109           break;
17110         case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17111           printf ("AVX512_4VNNIW");
17112           break;
17113         case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17114           printf ("AVX512_BITALG");
17115           break;
17116         case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17117           printf ("AVX512_IFMA");
17118           break;
17119         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17120           printf ("AVX512_VBMI");
17121           break;
17122         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17123           printf ("AVX512_VBMI2");
17124           break;
17125         case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17126           printf ("AVX512_VNNI");
17127           break;
17128         default:
17129           printf (_("<unknown: %x>"), bit);
17130           break;
17131         }
17132       if (bitmask)
17133         printf (", ");
17134     }
17135 }
17136
17137 static void
17138 decode_x86_feature_1 (unsigned int bitmask)
17139 {
17140   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17141     {
17142       printf (_("<None>"));
17143       return;
17144     }
17145   else
17146     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17147
17148   while (bitmask)
17149     {
17150       unsigned int bit = bitmask & (- bitmask);
17151
17152       bitmask &= ~ bit;
17153       switch (bit)
17154         {
17155         case GNU_PROPERTY_X86_FEATURE_1_IBT:
17156           printf ("IBT");
17157           break;
17158         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17159           printf ("SHSTK");
17160           break;
17161         default:
17162           printf (_("<unknown: %x>"), bit);
17163           break;
17164         }
17165       if (bitmask)
17166         printf (", ");
17167     }
17168 }
17169
17170 static void
17171 decode_x86_feature_2 (unsigned int bitmask)
17172 {
17173   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17174     {
17175       printf (_("<None>"));
17176       return;
17177     }
17178   else
17179     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17180
17181   while (bitmask)
17182     {
17183       unsigned int bit = bitmask & (- bitmask);
17184
17185       bitmask &= ~ bit;
17186       switch (bit)
17187         {
17188         case GNU_PROPERTY_X86_FEATURE_2_X86:
17189           printf ("x86");
17190           break;
17191         case GNU_PROPERTY_X86_FEATURE_2_X87:
17192           printf ("x87");
17193           break;
17194         case GNU_PROPERTY_X86_FEATURE_2_MMX:
17195           printf ("MMX");
17196           break;
17197         case GNU_PROPERTY_X86_FEATURE_2_XMM:
17198           printf ("XMM");
17199           break;
17200         case GNU_PROPERTY_X86_FEATURE_2_YMM:
17201           printf ("YMM");
17202           break;
17203         case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17204           printf ("ZMM");
17205           break;
17206         case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17207           printf ("FXSR");
17208           break;
17209         case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17210           printf ("XSAVE");
17211           break;
17212         case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17213           printf ("XSAVEOPT");
17214           break;
17215         case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17216           printf ("XSAVEC");
17217           break;
17218         default:
17219           printf (_("<unknown: %x>"), bit);
17220           break;
17221         }
17222       if (bitmask)
17223         printf (", ");
17224     }
17225 }
17226
17227 static void
17228 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17229 {
17230   unsigned char * ptr = (unsigned char *) pnote->descdata;
17231   unsigned char * ptr_end = ptr + pnote->descsz;
17232   unsigned int    size = is_32bit_elf ? 4 : 8;
17233
17234   printf (_("      Properties: "));
17235
17236   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17237     {
17238       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17239       return;
17240     }
17241
17242   while (ptr < ptr_end)
17243     {
17244       unsigned int j;
17245       unsigned int type;
17246       unsigned int datasz;
17247
17248       if ((size_t) (ptr_end - ptr) < 8)
17249         {
17250           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17251           break;
17252         }
17253
17254       type = byte_get (ptr, 4);
17255       datasz = byte_get (ptr + 4, 4);
17256
17257       ptr += 8;
17258
17259       if (datasz > (size_t) (ptr_end - ptr))
17260         {
17261           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17262                   type, datasz);
17263           break;
17264         }
17265
17266       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17267         {
17268           if (filedata->file_header.e_machine == EM_X86_64
17269               || filedata->file_header.e_machine == EM_IAMCU
17270               || filedata->file_header.e_machine == EM_386)
17271             {
17272               unsigned int bitmask;
17273
17274               if (datasz == 4)
17275                 {
17276                   bitmask = byte_get (ptr, 4);
17277                   if ((filedata->file_header.e_type == ET_EXEC
17278                        || filedata->file_header.e_type == ET_DYN)
17279                       && !(bitmask & GNU_PROPERTY_X86_UINT32_VALID))
17280                     printf ("Invalid ");
17281                 }
17282               else
17283                 bitmask = 0;
17284
17285               switch (type)
17286                 {
17287                 case GNU_PROPERTY_X86_ISA_1_USED:
17288                   if (datasz != 4)
17289                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17290                             datasz);
17291                   else
17292                     {
17293                       printf ("x86 ISA used: ");
17294                       decode_x86_isa (bitmask);
17295                     }
17296                   goto next;
17297
17298                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17299                   if (datasz != 4)
17300                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17301                             datasz);
17302                   else
17303                     {
17304                       printf ("x86 ISA needed: ");
17305                       decode_x86_isa (bitmask);
17306                     }
17307                   goto next;
17308
17309                 case GNU_PROPERTY_X86_FEATURE_1_AND:
17310                   if (datasz != 4)
17311                     printf (_("x86 feature: <corrupt length: %#x> "),
17312                             datasz);
17313                   else
17314                     {
17315                       printf ("x86 feature: ");
17316                       decode_x86_feature_1 (bitmask);
17317                     }
17318                   goto next;
17319
17320                 case GNU_PROPERTY_X86_FEATURE_2_USED:
17321                   if (datasz != 4)
17322                     printf (_("x86 feature used: <corrupt length: %#x> "),
17323                             datasz);
17324                   else
17325                     {
17326                       printf ("x86 feature used: ");
17327                       decode_x86_feature_2 (bitmask);
17328                     }
17329                   goto next;
17330
17331                 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17332                   if (datasz != 4)
17333                     printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17334                   else
17335                     {
17336                       printf ("x86 feature needed: ");
17337                       decode_x86_feature_2 (bitmask);
17338                     }
17339                   goto next;
17340
17341                 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17342                   if (datasz != 4)
17343                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17344                             datasz);
17345                   else
17346                     {
17347                       printf ("x86 ISA used: ");
17348                       decode_x86_compat_isa (bitmask);
17349                     }
17350                   goto next;
17351
17352                 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17353                   if (datasz != 4)
17354                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17355                             datasz);
17356                   else
17357                     {
17358                       printf ("x86 ISA needed: ");
17359                       decode_x86_compat_isa (bitmask);
17360                     }
17361                   goto next;
17362
17363                 default:
17364                   break;
17365                 }
17366             }
17367         }
17368       else
17369         {
17370           switch (type)
17371             {
17372             case GNU_PROPERTY_STACK_SIZE:
17373               printf (_("stack size: "));
17374               if (datasz != size)
17375                 printf (_("<corrupt length: %#x> "), datasz);
17376               else
17377                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17378               goto next;
17379
17380             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17381               printf ("no copy on protected ");
17382               if (datasz)
17383                 printf (_("<corrupt length: %#x> "), datasz);
17384               goto next;
17385
17386             default:
17387               break;
17388             }
17389         }
17390
17391       if (type < GNU_PROPERTY_LOPROC)
17392         printf (_("<unknown type %#x data: "), type);
17393       else if (type < GNU_PROPERTY_LOUSER)
17394         printf (_("<procesor-specific type %#x data: "), type);
17395       else
17396         printf (_("<application-specific type %#x data: "), type);
17397       for (j = 0; j < datasz; ++j)
17398         printf ("%02x ", ptr[j] & 0xff);
17399       printf (">");
17400
17401 next:
17402       ptr += ((datasz + (size - 1)) & ~ (size - 1));
17403       if (ptr == ptr_end)
17404         break;
17405
17406       if (do_wide)
17407         printf (", ");
17408       else
17409         printf ("\n\t");
17410     }
17411
17412   printf ("\n");
17413 }
17414
17415 static bfd_boolean
17416 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17417 {
17418   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17419   switch (pnote->type)
17420     {
17421     case NT_GNU_BUILD_ID:
17422       {
17423         unsigned long i;
17424
17425         printf (_("    Build ID: "));
17426         for (i = 0; i < pnote->descsz; ++i)
17427           printf ("%02x", pnote->descdata[i] & 0xff);
17428         printf ("\n");
17429       }
17430       break;
17431
17432     case NT_GNU_ABI_TAG:
17433       {
17434         unsigned long os, major, minor, subminor;
17435         const char *osname;
17436
17437         /* PR 17531: file: 030-599401-0.004.  */
17438         if (pnote->descsz < 16)
17439           {
17440             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17441             break;
17442           }
17443
17444         os = byte_get ((unsigned char *) pnote->descdata, 4);
17445         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17446         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17447         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17448
17449         switch (os)
17450           {
17451           case GNU_ABI_TAG_LINUX:
17452             osname = "Linux";
17453             break;
17454           case GNU_ABI_TAG_HURD:
17455             osname = "Hurd";
17456             break;
17457           case GNU_ABI_TAG_SOLARIS:
17458             osname = "Solaris";
17459             break;
17460           case GNU_ABI_TAG_FREEBSD:
17461             osname = "FreeBSD";
17462             break;
17463           case GNU_ABI_TAG_NETBSD:
17464             osname = "NetBSD";
17465             break;
17466           case GNU_ABI_TAG_SYLLABLE:
17467             osname = "Syllable";
17468             break;
17469           case GNU_ABI_TAG_NACL:
17470             osname = "NaCl";
17471             break;
17472           default:
17473             osname = "Unknown";
17474             break;
17475           }
17476
17477         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17478                 major, minor, subminor);
17479       }
17480       break;
17481
17482     case NT_GNU_GOLD_VERSION:
17483       {
17484         unsigned long i;
17485
17486         printf (_("    Version: "));
17487         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17488           printf ("%c", pnote->descdata[i]);
17489         printf ("\n");
17490       }
17491       break;
17492
17493     case NT_GNU_HWCAP:
17494       {
17495         unsigned long num_entries, mask;
17496
17497         /* Hardware capabilities information.  Word 0 is the number of entries.
17498            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17499            is a series of entries, where each entry is a single byte followed
17500            by a nul terminated string.  The byte gives the bit number to test
17501            if enabled in the bitmask.  */
17502         printf (_("      Hardware Capabilities: "));
17503         if (pnote->descsz < 8)
17504           {
17505             error (_("<corrupt GNU_HWCAP>\n"));
17506             return FALSE;
17507           }
17508         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17509         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17510         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17511         /* FIXME: Add code to display the entries... */
17512       }
17513       break;
17514
17515     case NT_GNU_PROPERTY_TYPE_0:
17516       print_gnu_property_note (filedata, pnote);
17517       break;
17518
17519     default:
17520       /* Handle unrecognised types.  An error message should have already been
17521          created by get_gnu_elf_note_type(), so all that we need to do is to
17522          display the data.  */
17523       {
17524         unsigned long i;
17525
17526         printf (_("    Description data: "));
17527         for (i = 0; i < pnote->descsz; ++i)
17528           printf ("%02x ", pnote->descdata[i] & 0xff);
17529         printf ("\n");
17530       }
17531       break;
17532     }
17533
17534   return TRUE;
17535 }
17536
17537 static const char *
17538 get_v850_elf_note_type (enum v850_notes n_type)
17539 {
17540   static char buff[64];
17541
17542   switch (n_type)
17543     {
17544     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17545     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17546     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17547     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17548     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17549     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17550     default:
17551       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17552       return buff;
17553     }
17554 }
17555
17556 static bfd_boolean
17557 print_v850_note (Elf_Internal_Note * pnote)
17558 {
17559   unsigned int val;
17560
17561   if (pnote->descsz != 4)
17562     return FALSE;
17563
17564   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17565
17566   if (val == 0)
17567     {
17568       printf (_("not set\n"));
17569       return TRUE;
17570     }
17571
17572   switch (pnote->type)
17573     {
17574     case V850_NOTE_ALIGNMENT:
17575       switch (val)
17576         {
17577         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17578         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17579         }
17580       break;
17581
17582     case V850_NOTE_DATA_SIZE:
17583       switch (val)
17584         {
17585         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17586         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17587         }
17588       break;
17589
17590     case V850_NOTE_FPU_INFO:
17591       switch (val)
17592         {
17593         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17594         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17595         }
17596       break;
17597
17598     case V850_NOTE_MMU_INFO:
17599     case V850_NOTE_CACHE_INFO:
17600     case V850_NOTE_SIMD_INFO:
17601       if (val == EF_RH850_SIMD)
17602         {
17603           printf (_("yes\n"));
17604           return TRUE;
17605         }
17606       break;
17607
17608     default:
17609       /* An 'unknown note type' message will already have been displayed.  */
17610       break;
17611     }
17612
17613   printf (_("unknown value: %x\n"), val);
17614   return FALSE;
17615 }
17616
17617 static bfd_boolean
17618 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17619 {
17620   unsigned int version;
17621
17622   switch (pnote->type)
17623     {
17624     case NT_NETBSD_IDENT:
17625       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17626       if ((version / 10000) % 100)
17627         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17628                 version, version / 100000000, (version / 1000000) % 100,
17629                 (version / 10000) % 100 > 26 ? "Z" : "",
17630                 'A' + (version / 10000) % 26);
17631       else
17632         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17633                 version, version / 100000000, (version / 1000000) % 100,
17634                 (version / 100) % 100);
17635       return TRUE;
17636
17637     case NT_NETBSD_MARCH:
17638       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17639               pnote->descdata);
17640       return TRUE;
17641
17642     default:
17643       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17644               pnote->type);
17645       return FALSE;
17646     }
17647 }
17648
17649 static const char *
17650 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17651 {
17652   switch (e_type)
17653     {
17654     case NT_FREEBSD_THRMISC:
17655       return _("NT_THRMISC (thrmisc structure)");
17656     case NT_FREEBSD_PROCSTAT_PROC:
17657       return _("NT_PROCSTAT_PROC (proc data)");
17658     case NT_FREEBSD_PROCSTAT_FILES:
17659       return _("NT_PROCSTAT_FILES (files data)");
17660     case NT_FREEBSD_PROCSTAT_VMMAP:
17661       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17662     case NT_FREEBSD_PROCSTAT_GROUPS:
17663       return _("NT_PROCSTAT_GROUPS (groups data)");
17664     case NT_FREEBSD_PROCSTAT_UMASK:
17665       return _("NT_PROCSTAT_UMASK (umask data)");
17666     case NT_FREEBSD_PROCSTAT_RLIMIT:
17667       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17668     case NT_FREEBSD_PROCSTAT_OSREL:
17669       return _("NT_PROCSTAT_OSREL (osreldate data)");
17670     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17671       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17672     case NT_FREEBSD_PROCSTAT_AUXV:
17673       return _("NT_PROCSTAT_AUXV (auxv data)");
17674     case NT_FREEBSD_PTLWPINFO:
17675       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17676     }
17677   return get_note_type (filedata, e_type);
17678 }
17679
17680 static const char *
17681 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17682 {
17683   static char buff[64];
17684
17685   if (e_type == NT_NETBSDCORE_PROCINFO)
17686     return _("NetBSD procinfo structure");
17687
17688   /* As of Jan 2002 there are no other machine-independent notes
17689      defined for NetBSD core files.  If the note type is less
17690      than the start of the machine-dependent note types, we don't
17691      understand it.  */
17692
17693   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17694     {
17695       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17696       return buff;
17697     }
17698
17699   switch (filedata->file_header.e_machine)
17700     {
17701     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17702        and PT_GETFPREGS == mach+2.  */
17703
17704     case EM_OLD_ALPHA:
17705     case EM_ALPHA:
17706     case EM_SPARC:
17707     case EM_SPARC32PLUS:
17708     case EM_SPARCV9:
17709       switch (e_type)
17710         {
17711         case NT_NETBSDCORE_FIRSTMACH + 0:
17712           return _("PT_GETREGS (reg structure)");
17713         case NT_NETBSDCORE_FIRSTMACH + 2:
17714           return _("PT_GETFPREGS (fpreg structure)");
17715         default:
17716           break;
17717         }
17718       break;
17719
17720     /* On all other arch's, PT_GETREGS == mach+1 and
17721        PT_GETFPREGS == mach+3.  */
17722     default:
17723       switch (e_type)
17724         {
17725         case NT_NETBSDCORE_FIRSTMACH + 1:
17726           return _("PT_GETREGS (reg structure)");
17727         case NT_NETBSDCORE_FIRSTMACH + 3:
17728           return _("PT_GETFPREGS (fpreg structure)");
17729         default:
17730           break;
17731         }
17732     }
17733
17734   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17735             e_type - NT_NETBSDCORE_FIRSTMACH);
17736   return buff;
17737 }
17738
17739 static const char *
17740 get_stapsdt_note_type (unsigned e_type)
17741 {
17742   static char buff[64];
17743
17744   switch (e_type)
17745     {
17746     case NT_STAPSDT:
17747       return _("NT_STAPSDT (SystemTap probe descriptors)");
17748
17749     default:
17750       break;
17751     }
17752
17753   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17754   return buff;
17755 }
17756
17757 static bfd_boolean
17758 print_stapsdt_note (Elf_Internal_Note *pnote)
17759 {
17760   int addr_size = is_32bit_elf ? 4 : 8;
17761   char *data = pnote->descdata;
17762   char *data_end = pnote->descdata + pnote->descsz;
17763   bfd_vma pc, base_addr, semaphore;
17764   char *provider, *probe, *arg_fmt;
17765
17766   pc = byte_get ((unsigned char *) data, addr_size);
17767   data += addr_size;
17768   base_addr = byte_get ((unsigned char *) data, addr_size);
17769   data += addr_size;
17770   semaphore = byte_get ((unsigned char *) data, addr_size);
17771   data += addr_size;
17772
17773   provider = data;
17774   data += strlen (data) + 1;
17775   probe = data;
17776   data += strlen (data) + 1;
17777   arg_fmt = data;
17778   data += strlen (data) + 1;
17779
17780   printf (_("    Provider: %s\n"), provider);
17781   printf (_("    Name: %s\n"), probe);
17782   printf (_("    Location: "));
17783   print_vma (pc, FULL_HEX);
17784   printf (_(", Base: "));
17785   print_vma (base_addr, FULL_HEX);
17786   printf (_(", Semaphore: "));
17787   print_vma (semaphore, FULL_HEX);
17788   printf ("\n");
17789   printf (_("    Arguments: %s\n"), arg_fmt);
17790
17791   return data == data_end;
17792 }
17793
17794 static const char *
17795 get_ia64_vms_note_type (unsigned e_type)
17796 {
17797   static char buff[64];
17798
17799   switch (e_type)
17800     {
17801     case NT_VMS_MHD:
17802       return _("NT_VMS_MHD (module header)");
17803     case NT_VMS_LNM:
17804       return _("NT_VMS_LNM (language name)");
17805     case NT_VMS_SRC:
17806       return _("NT_VMS_SRC (source files)");
17807     case NT_VMS_TITLE:
17808       return "NT_VMS_TITLE";
17809     case NT_VMS_EIDC:
17810       return _("NT_VMS_EIDC (consistency check)");
17811     case NT_VMS_FPMODE:
17812       return _("NT_VMS_FPMODE (FP mode)");
17813     case NT_VMS_LINKTIME:
17814       return "NT_VMS_LINKTIME";
17815     case NT_VMS_IMGNAM:
17816       return _("NT_VMS_IMGNAM (image name)");
17817     case NT_VMS_IMGID:
17818       return _("NT_VMS_IMGID (image id)");
17819     case NT_VMS_LINKID:
17820       return _("NT_VMS_LINKID (link id)");
17821     case NT_VMS_IMGBID:
17822       return _("NT_VMS_IMGBID (build id)");
17823     case NT_VMS_GSTNAM:
17824       return _("NT_VMS_GSTNAM (sym table name)");
17825     case NT_VMS_ORIG_DYN:
17826       return "NT_VMS_ORIG_DYN";
17827     case NT_VMS_PATCHTIME:
17828       return "NT_VMS_PATCHTIME";
17829     default:
17830       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17831       return buff;
17832     }
17833 }
17834
17835 static bfd_boolean
17836 print_ia64_vms_note (Elf_Internal_Note * pnote)
17837 {
17838   switch (pnote->type)
17839     {
17840     case NT_VMS_MHD:
17841       if (pnote->descsz > 36)
17842         {
17843           size_t l = strlen (pnote->descdata + 34);
17844           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17845           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17846           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17847           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17848         }
17849       else
17850         printf (_("    Invalid size\n"));
17851       break;
17852     case NT_VMS_LNM:
17853       printf (_("   Language: %s\n"), pnote->descdata);
17854       break;
17855 #ifdef BFD64
17856     case NT_VMS_FPMODE:
17857       printf (_("   Floating Point mode: "));
17858       printf ("0x%016" BFD_VMA_FMT "x\n",
17859               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17860       break;
17861     case NT_VMS_LINKTIME:
17862       printf (_("   Link time: "));
17863       print_vms_time
17864         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17865       printf ("\n");
17866       break;
17867     case NT_VMS_PATCHTIME:
17868       printf (_("   Patch time: "));
17869       print_vms_time
17870         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17871       printf ("\n");
17872       break;
17873     case NT_VMS_ORIG_DYN:
17874       printf (_("   Major id: %u,  minor id: %u\n"),
17875               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17876               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17877       printf (_("   Last modified  : "));
17878       print_vms_time
17879         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17880       printf (_("\n   Link flags  : "));
17881       printf ("0x%016" BFD_VMA_FMT "x\n",
17882               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17883       printf (_("   Header flags: 0x%08x\n"),
17884               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17885       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17886       break;
17887 #endif
17888     case NT_VMS_IMGNAM:
17889       printf (_("    Image name: %s\n"), pnote->descdata);
17890       break;
17891     case NT_VMS_GSTNAM:
17892       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17893       break;
17894     case NT_VMS_IMGID:
17895       printf (_("    Image id: %s\n"), pnote->descdata);
17896       break;
17897     case NT_VMS_LINKID:
17898       printf (_("    Linker id: %s\n"), pnote->descdata);
17899       break;
17900     default:
17901       return FALSE;
17902     }
17903   return TRUE;
17904 }
17905
17906 /* Find the symbol associated with a build attribute that is attached
17907    to address OFFSET.  If PNAME is non-NULL then store the name of
17908    the symbol (if found) in the provided pointer,  Returns NULL if a
17909    symbol could not be found.  */
17910
17911 static Elf_Internal_Sym *
17912 get_symbol_for_build_attribute (Filedata *       filedata,
17913                                 unsigned long    offset,
17914                                 bfd_boolean      is_open_attr,
17915                                 const char **    pname)
17916 {
17917   static Filedata *         saved_filedata = NULL;
17918   static char *             strtab;
17919   static unsigned long      strtablen;
17920   static Elf_Internal_Sym * symtab;
17921   static unsigned long      nsyms;
17922   Elf_Internal_Sym *        saved_sym = NULL;
17923   Elf_Internal_Sym *        sym;
17924
17925   if (filedata->section_headers != NULL
17926       && (saved_filedata == NULL || filedata != saved_filedata))
17927     {
17928       Elf_Internal_Shdr * symsec;
17929
17930       /* Load the symbol and string sections.  */
17931       for (symsec = filedata->section_headers;
17932            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17933            symsec ++)
17934         {
17935           if (symsec->sh_type == SHT_SYMTAB)
17936             {
17937               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17938
17939               if (symsec->sh_link < filedata->file_header.e_shnum)
17940                 {
17941                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17942
17943                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17944                                               1, strtab_sec->sh_size,
17945                                               _("string table"));
17946                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17947                 }
17948             }
17949         }
17950       saved_filedata = filedata;
17951     }
17952
17953   if (symtab == NULL || strtab == NULL)
17954     return NULL;
17955
17956   /* Find a symbol whose value matches offset.  */
17957   for (sym = symtab; sym < symtab + nsyms; sym ++)
17958     if (sym->st_value == offset)
17959       {
17960         if (sym->st_name >= strtablen)
17961           /* Huh ?  This should not happen.  */
17962           continue;
17963
17964         if (strtab[sym->st_name] == 0)
17965           continue;
17966
17967         /* The AArch64 and ARM architectures define mapping symbols
17968            (eg $d, $x, $t) which we want to ignore.  */
17969         if (strtab[sym->st_name] == '$'
17970             && strtab[sym->st_name + 1] != 0
17971             && strtab[sym->st_name + 2] == 0)
17972           continue;
17973
17974         if (is_open_attr)
17975           {
17976             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17977                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17978                FUNC symbols entirely.  */
17979             switch (ELF_ST_TYPE (sym->st_info))
17980               {
17981               case STT_OBJECT:
17982               case STT_FILE:
17983                 saved_sym = sym;
17984                 if (sym->st_size)
17985                   {
17986                     /* If the symbol has a size associated
17987                        with it then we can stop searching.  */
17988                     sym = symtab + nsyms;
17989                   }
17990                 continue;
17991
17992               case STT_FUNC:
17993                 /* Ignore function symbols.  */
17994                 continue;
17995
17996               default:
17997                 break;
17998               }
17999
18000             switch (ELF_ST_BIND (sym->st_info))
18001               {
18002               case STB_GLOBAL:
18003                 if (saved_sym == NULL
18004                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18005                   saved_sym = sym;
18006                 break;
18007
18008               case STB_LOCAL:
18009                 if (saved_sym == NULL)
18010                   saved_sym = sym;
18011                 break;
18012
18013               default:
18014                 break;
18015               }
18016           }
18017         else
18018           {
18019             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18020               continue;
18021
18022             saved_sym = sym;
18023             break;
18024           }
18025       }
18026
18027   if (saved_sym && pname)
18028     * pname = strtab + saved_sym->st_name;
18029
18030   return saved_sym;
18031 }
18032
18033 /* Returns true iff addr1 and addr2 are in the same section.  */
18034
18035 static bfd_boolean
18036 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18037 {
18038   Elf_Internal_Shdr * a1;
18039   Elf_Internal_Shdr * a2;
18040
18041   a1 = find_section_by_address (filedata, addr1);
18042   a2 = find_section_by_address (filedata, addr2);
18043
18044   return a1 == a2 && a1 != NULL;
18045 }
18046
18047 static bfd_boolean
18048 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
18049                                        Filedata *           filedata)
18050 {
18051   static unsigned long  global_offset = 0;
18052   static unsigned long  global_end = 0;
18053   static unsigned long  func_offset = 0;
18054   static unsigned long  func_end = 0;
18055
18056   Elf_Internal_Sym *    sym;
18057   const char *          name;
18058   unsigned long         start;
18059   unsigned long         end;
18060   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18061
18062   switch (pnote->descsz)
18063     {
18064     case 0:
18065       /* A zero-length description means that the range of
18066          the previous note of the same type should be used.  */
18067       if (is_open_attr)
18068         {
18069           if (global_end > global_offset)
18070             printf (_("    Applies to region from %#lx to %#lx\n"),
18071                     global_offset, global_end);
18072           else
18073             printf (_("    Applies to region from %#lx\n"), global_offset);
18074         }
18075       else
18076         {
18077           if (func_end > func_offset)
18078             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18079           else
18080             printf (_("    Applies to region from %#lx\n"), func_offset);
18081         }
18082       return TRUE;
18083
18084     case 4:
18085       start = byte_get ((unsigned char *) pnote->descdata, 4);
18086       end = 0;
18087       break;
18088
18089     case 8:
18090       if (is_32bit_elf)
18091         {
18092           /* FIXME: We should check that version 3+ notes are being used here...  */
18093           start = byte_get ((unsigned char *) pnote->descdata, 4);
18094           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18095         }
18096       else
18097         {
18098           start = byte_get ((unsigned char *) pnote->descdata, 8);
18099           end = 0;
18100         }
18101       break;
18102
18103     case 16:
18104       start = byte_get ((unsigned char *) pnote->descdata, 8);
18105       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18106       break;
18107
18108     default:
18109       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
18110       printf (_("    <invalid descsz>"));
18111       return FALSE;
18112     }
18113
18114   name = NULL;
18115   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18116   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18117      in order to avoid them being confused with the start address of the
18118      first function in the file...  */
18119   if (sym == NULL && is_open_attr)
18120     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18121                                           & name);
18122
18123   if (end == 0 && sym != NULL && sym->st_size > 0)
18124     end = start + sym->st_size;
18125
18126   if (is_open_attr)
18127     {
18128       /* FIXME: Need to properly allow for section alignment.
18129          16 is just the alignment used on x86_64.  */
18130       if (global_end > 0
18131           && start > BFD_ALIGN (global_end, 16)
18132           /* Build notes are not guaranteed to be organised in order of
18133              increasing address, but we should find the all of the notes
18134              for one section in the same place.  */
18135           && same_section (filedata, start, global_end))
18136         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18137               global_end + 1, start - 1);
18138
18139       printf (_("    Applies to region from %#lx"), start);
18140       global_offset = start;
18141
18142       if (end)
18143         {
18144           printf (_(" to %#lx"), end);
18145           global_end = end;
18146         }
18147     }
18148   else
18149     {
18150       printf (_("    Applies to region from %#lx"), start);
18151       func_offset = start;
18152
18153       if (end)
18154         {
18155           printf (_(" to %#lx"), end);
18156           func_end = end;
18157         }
18158     }
18159
18160   if (sym && name)
18161     printf (_(" (%s)"), name);
18162
18163   printf ("\n");
18164   return TRUE;
18165 }
18166
18167 static bfd_boolean
18168 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18169 {
18170   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18171   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18172   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18173   char         name_type;
18174   char         name_attribute;
18175   const char * expected_types;
18176   const char * name = pnote->namedata;
18177   const char * text;
18178   signed int   left;
18179
18180   if (name == NULL || pnote->namesz < 2)
18181     {
18182       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18183       print_symbol (-20, _("  <corrupt name>"));
18184       return FALSE;
18185     }
18186
18187   if (do_wide)
18188     left = 28;
18189   else
18190     left = 20;
18191
18192   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
18193   if (name[0] == 'G' && name[1] == 'A')
18194     {
18195       if (pnote->namesz < 4)
18196         {
18197           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18198           print_symbol (-20, _("  <corrupt name>"));
18199           return FALSE;
18200         }
18201
18202       printf ("GA");
18203       name += 2;
18204       left -= 2;
18205     }
18206
18207   switch ((name_type = * name))
18208     {
18209     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18210     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18211     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18212     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18213       printf ("%c", * name);
18214       left --;
18215       break;
18216     default:
18217       error (_("unrecognised attribute type in name field: %d\n"), name_type);
18218       print_symbol (-20, _("<unknown name type>"));
18219       return FALSE;
18220     }
18221
18222   ++ name;
18223   text = NULL;
18224
18225   switch ((name_attribute = * name))
18226     {
18227     case GNU_BUILD_ATTRIBUTE_VERSION:
18228       text = _("<version>");
18229       expected_types = string_expected;
18230       ++ name;
18231       break;
18232     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18233       text = _("<stack prot>");
18234       expected_types = "!+*";
18235       ++ name;
18236       break;
18237     case GNU_BUILD_ATTRIBUTE_RELRO:
18238       text = _("<relro>");
18239       expected_types = bool_expected;
18240       ++ name;
18241       break;
18242     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18243       text = _("<stack size>");
18244       expected_types = number_expected;
18245       ++ name;
18246       break;
18247     case GNU_BUILD_ATTRIBUTE_TOOL:
18248       text = _("<tool>");
18249       expected_types = string_expected;
18250       ++ name;
18251       break;
18252     case GNU_BUILD_ATTRIBUTE_ABI:
18253       text = _("<ABI>");
18254       expected_types = "$*";
18255       ++ name;
18256       break;
18257     case GNU_BUILD_ATTRIBUTE_PIC:
18258       text = _("<PIC>");
18259       expected_types = number_expected;
18260       ++ name;
18261       break;
18262     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18263       text = _("<short enum>");
18264       expected_types = bool_expected;
18265       ++ name;
18266       break;
18267     default:
18268       if (ISPRINT (* name))
18269         {
18270           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18271
18272           if (len > left && ! do_wide)
18273             len = left;
18274           printf ("%.*s:", len, name);
18275           left -= len;
18276           name += len;
18277         }
18278       else
18279         {
18280           static char tmpbuf [128];
18281
18282           error (_("unrecognised byte in name field: %d\n"), * name);
18283           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18284           text = tmpbuf;
18285           name ++;
18286         }
18287       expected_types = "*$!+";
18288       break;
18289     }
18290
18291   if (text)
18292     left -= printf ("%s", text);
18293
18294   if (strchr (expected_types, name_type) == NULL)
18295     warn (_("attribute does not have an expected type (%c)\n"), name_type);
18296
18297   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18298     {
18299       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18300              (unsigned long) pnote->namesz,
18301              (long) (name - pnote->namedata));
18302       return FALSE;
18303     }
18304
18305   if (left < 1 && ! do_wide)
18306     return TRUE;
18307
18308   switch (name_type)
18309     {
18310     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18311       {
18312         unsigned int        bytes;
18313         unsigned long long  val = 0;
18314         unsigned int        shift = 0;
18315         char *              decoded = NULL;
18316
18317         bytes = pnote->namesz - (name - pnote->namedata);
18318         if (bytes > 0)
18319           /* The -1 is because the name field is always 0 terminated, and we
18320              want to be able to ensure that the shift in the while loop below
18321              will not overflow.  */
18322           -- bytes;
18323
18324         if (bytes > sizeof (val))
18325           {
18326             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18327                    bytes);
18328             bytes = sizeof (val);
18329           }
18330         /* We do not bother to warn if bytes == 0 as this can
18331            happen with some early versions of the gcc plugin.  */
18332
18333         while (bytes --)
18334           {
18335             unsigned long byte = (* name ++) & 0xff;
18336
18337             val |= byte << shift;
18338             shift += 8;
18339           }
18340
18341         switch (name_attribute)
18342           {
18343           case GNU_BUILD_ATTRIBUTE_PIC:
18344             switch (val)
18345               {
18346               case 0: decoded = "static"; break;
18347               case 1: decoded = "pic"; break;
18348               case 2: decoded = "PIC"; break;
18349               case 3: decoded = "pie"; break;
18350               case 4: decoded = "PIE"; break;
18351               default: break;
18352               }
18353             break;
18354           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18355             switch (val)
18356               {
18357                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
18358               case 0: decoded = "off"; break;
18359               case 1: decoded = "on"; break;
18360               case 2: decoded = "all"; break;
18361               case 3: decoded = "strong"; break;
18362               case 4: decoded = "explicit"; break;
18363               default: break;
18364               }
18365             break;
18366           default:
18367             break;
18368           }
18369
18370         if (decoded != NULL)
18371           {
18372             print_symbol (-left, decoded);
18373             left = 0;
18374           }
18375         else if (val == 0)
18376           {
18377             printf ("0x0");
18378             left -= 3;
18379           }
18380         else
18381           {
18382             if (do_wide)
18383               left -= printf ("0x%llx", val);
18384             else
18385               left -= printf ("0x%-.*llx", left, val);
18386           }
18387       }
18388       break;
18389     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18390       left -= print_symbol (- left, name);
18391       break;
18392     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18393       left -= print_symbol (- left, "true");
18394       break;
18395     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18396       left -= print_symbol (- left, "false");
18397       break;
18398     }
18399
18400   if (do_wide && left > 0)
18401     printf ("%-*s", left, " ");
18402
18403   return TRUE;
18404 }
18405
18406 /* Note that by the ELF standard, the name field is already null byte
18407    terminated, and namesz includes the terminating null byte.
18408    I.E. the value of namesz for the name "FSF" is 4.
18409
18410    If the value of namesz is zero, there is no name present.  */
18411
18412 static bfd_boolean
18413 process_note (Elf_Internal_Note *  pnote,
18414               Filedata *           filedata)
18415 {
18416   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18417   const char * nt;
18418
18419   if (pnote->namesz == 0)
18420     /* If there is no note name, then use the default set of
18421        note type strings.  */
18422     nt = get_note_type (filedata, pnote->type);
18423
18424   else if (const_strneq (pnote->namedata, "GNU"))
18425     /* GNU-specific object file notes.  */
18426     nt = get_gnu_elf_note_type (pnote->type);
18427
18428   else if (const_strneq (pnote->namedata, "FreeBSD"))
18429     /* FreeBSD-specific core file notes.  */
18430     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18431
18432   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18433     /* NetBSD-specific core file notes.  */
18434     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18435
18436   else if (const_strneq (pnote->namedata, "NetBSD"))
18437     /* NetBSD-specific core file notes.  */
18438     return process_netbsd_elf_note (pnote);
18439
18440   else if (strneq (pnote->namedata, "SPU/", 4))
18441     {
18442       /* SPU-specific core file notes.  */
18443       nt = pnote->namedata + 4;
18444       name = "SPU";
18445     }
18446
18447   else if (const_strneq (pnote->namedata, "IPF/VMS"))
18448     /* VMS/ia64-specific file notes.  */
18449     nt = get_ia64_vms_note_type (pnote->type);
18450
18451   else if (const_strneq (pnote->namedata, "stapsdt"))
18452     nt = get_stapsdt_note_type (pnote->type);
18453
18454   else
18455     /* Don't recognize this note name; just use the default set of
18456        note type strings.  */
18457     nt = get_note_type (filedata, pnote->type);
18458
18459   printf ("  ");
18460
18461   if (((const_strneq (pnote->namedata, "GA")
18462         && strchr ("*$!+", pnote->namedata[2]) != NULL)
18463        || strchr ("*$!+", pnote->namedata[0]) != NULL)
18464       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18465           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18466     print_gnu_build_attribute_name (pnote);
18467   else
18468     print_symbol (-20, name);
18469
18470   if (do_wide)
18471     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18472   else
18473     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18474
18475   if (const_strneq (pnote->namedata, "IPF/VMS"))
18476     return print_ia64_vms_note (pnote);
18477   else if (const_strneq (pnote->namedata, "GNU"))
18478     return print_gnu_note (filedata, pnote);
18479   else if (const_strneq (pnote->namedata, "stapsdt"))
18480     return print_stapsdt_note (pnote);
18481   else if (const_strneq (pnote->namedata, "CORE"))
18482     return print_core_note (pnote);
18483   else if (((const_strneq (pnote->namedata, "GA")
18484              && strchr ("*$!+", pnote->namedata[2]) != NULL)
18485             || strchr ("*$!+", pnote->namedata[0]) != NULL)
18486            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18487                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18488     return print_gnu_build_attribute_description (pnote, filedata);
18489
18490   if (pnote->descsz)
18491     {
18492       unsigned long i;
18493
18494       printf (_("   description data: "));
18495       for (i = 0; i < pnote->descsz; i++)
18496         printf ("%02x ", pnote->descdata[i]);
18497       if (!do_wide)
18498         printf ("\n");
18499     }
18500
18501   if (do_wide)
18502     printf ("\n");
18503
18504   return TRUE;
18505 }
18506
18507 static bfd_boolean
18508 process_notes_at (Filedata *           filedata,
18509                   Elf_Internal_Shdr *  section,
18510                   bfd_vma              offset,
18511                   bfd_vma              length,
18512                   bfd_vma              align)
18513 {
18514   Elf_External_Note * pnotes;
18515   Elf_External_Note * external;
18516   char *              end;
18517   bfd_boolean         res = TRUE;
18518
18519   if (length <= 0)
18520     return FALSE;
18521
18522   if (section)
18523     {
18524       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18525       if (pnotes)
18526         {
18527           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18528             return FALSE;
18529         }
18530     }
18531   else
18532     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18533                                              _("notes"));
18534
18535   if (pnotes == NULL)
18536     return FALSE;
18537
18538   external = pnotes;
18539
18540   if (section)
18541     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18542   else
18543     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18544             (unsigned long) offset, (unsigned long) length);
18545
18546   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18547      specifies that notes should be aligned to 4 bytes in 32-bit
18548      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18549      we also support 4 byte alignment in 64-bit objects.  If section
18550      alignment is less than 4, we treate alignment as 4 bytes.   */
18551   if (align < 4)
18552     align = 4;
18553   else if (align != 4 && align != 8)
18554     {
18555       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18556             (long) align);
18557       return FALSE;
18558     }
18559
18560   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18561
18562   end = (char *) pnotes + length;
18563   while ((char *) external < end)
18564     {
18565       Elf_Internal_Note inote;
18566       size_t min_notesz;
18567       char * next;
18568       char * temp = NULL;
18569       size_t data_remaining = end - (char *) external;
18570
18571       if (!is_ia64_vms (filedata))
18572         {
18573           /* PR binutils/15191
18574              Make sure that there is enough data to read.  */
18575           min_notesz = offsetof (Elf_External_Note, name);
18576           if (data_remaining < min_notesz)
18577             {
18578               warn (ngettext ("Corrupt note: only %ld byte remains, "
18579                               "not enough for a full note\n",
18580                               "Corrupt note: only %ld bytes remain, "
18581                               "not enough for a full note\n",
18582                               data_remaining),
18583                     (long) data_remaining);
18584               break;
18585             }
18586           data_remaining -= min_notesz;
18587
18588           inote.type     = BYTE_GET (external->type);
18589           inote.namesz   = BYTE_GET (external->namesz);
18590           inote.namedata = external->name;
18591           inote.descsz   = BYTE_GET (external->descsz);
18592           inote.descdata = ((char *) external
18593                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18594           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18595           next = ((char *) external
18596                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18597         }
18598       else
18599         {
18600           Elf64_External_VMS_Note *vms_external;
18601
18602           /* PR binutils/15191
18603              Make sure that there is enough data to read.  */
18604           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18605           if (data_remaining < min_notesz)
18606             {
18607               warn (ngettext ("Corrupt note: only %ld byte remains, "
18608                               "not enough for a full note\n",
18609                               "Corrupt note: only %ld bytes remain, "
18610                               "not enough for a full note\n",
18611                               data_remaining),
18612                     (long) data_remaining);
18613               break;
18614             }
18615           data_remaining -= min_notesz;
18616
18617           vms_external = (Elf64_External_VMS_Note *) external;
18618           inote.type     = BYTE_GET (vms_external->type);
18619           inote.namesz   = BYTE_GET (vms_external->namesz);
18620           inote.namedata = vms_external->name;
18621           inote.descsz   = BYTE_GET (vms_external->descsz);
18622           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18623           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18624           next = inote.descdata + align_power (inote.descsz, 3);
18625         }
18626
18627       /* PR 17531: file: 3443835e.  */
18628       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18629       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18630           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18631           || (size_t) (next - inote.descdata) < inote.descsz
18632           || ((size_t) (next - inote.descdata)
18633               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18634         {
18635           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18636                 (unsigned long) ((char *) external - (char *) pnotes));
18637           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18638                 inote.type, inote.namesz, inote.descsz, (int) align);
18639           break;
18640         }
18641
18642       external = (Elf_External_Note *) next;
18643
18644       /* Verify that name is null terminated.  It appears that at least
18645          one version of Linux (RedHat 6.0) generates corefiles that don't
18646          comply with the ELF spec by failing to include the null byte in
18647          namesz.  */
18648       if (inote.namedata[inote.namesz - 1] != '\0')
18649         {
18650           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18651             {
18652               temp = (char *) malloc (inote.namesz + 1);
18653               if (temp == NULL)
18654                 {
18655                   error (_("Out of memory allocating space for inote name\n"));
18656                   res = FALSE;
18657                   break;
18658                 }
18659
18660               memcpy (temp, inote.namedata, inote.namesz);
18661               inote.namedata = temp;
18662             }
18663           inote.namedata[inote.namesz] = 0;
18664         }
18665
18666       if (! process_note (& inote, filedata))
18667         res = FALSE;
18668
18669       if (temp != NULL)
18670         {
18671           free (temp);
18672           temp = NULL;
18673         }
18674     }
18675
18676   free (pnotes);
18677
18678   return res;
18679 }
18680
18681 static bfd_boolean
18682 process_corefile_note_segments (Filedata * filedata)
18683 {
18684   Elf_Internal_Phdr * segment;
18685   unsigned int i;
18686   bfd_boolean res = TRUE;
18687
18688   if (! get_program_headers (filedata))
18689     return TRUE;
18690
18691   for (i = 0, segment = filedata->program_headers;
18692        i < filedata->file_header.e_phnum;
18693        i++, segment++)
18694     {
18695       if (segment->p_type == PT_NOTE)
18696         if (! process_notes_at (filedata, NULL,
18697                                 (bfd_vma) segment->p_offset,
18698                                 (bfd_vma) segment->p_filesz,
18699                                 (bfd_vma) segment->p_align))
18700           res = FALSE;
18701     }
18702
18703   return res;
18704 }
18705
18706 static bfd_boolean
18707 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18708 {
18709   Elf_External_Note * pnotes;
18710   Elf_External_Note * external;
18711   char * end;
18712   bfd_boolean res = TRUE;
18713
18714   if (length <= 0)
18715     return FALSE;
18716
18717   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18718                                            _("v850 notes"));
18719   if (pnotes == NULL)
18720     return FALSE;
18721
18722   external = pnotes;
18723   end = (char*) pnotes + length;
18724
18725   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18726           (unsigned long) offset, (unsigned long) length);
18727
18728   while ((char *) external + sizeof (Elf_External_Note) < end)
18729     {
18730       Elf_External_Note * next;
18731       Elf_Internal_Note inote;
18732
18733       inote.type     = BYTE_GET (external->type);
18734       inote.namesz   = BYTE_GET (external->namesz);
18735       inote.namedata = external->name;
18736       inote.descsz   = BYTE_GET (external->descsz);
18737       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18738       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18739
18740       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18741         {
18742           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18743           inote.descdata = inote.namedata;
18744           inote.namesz   = 0;
18745         }
18746
18747       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18748
18749       if (   ((char *) next > end)
18750           || ((char *) next <  (char *) pnotes))
18751         {
18752           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18753                 (unsigned long) ((char *) external - (char *) pnotes));
18754           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18755                 inote.type, inote.namesz, inote.descsz);
18756           break;
18757         }
18758
18759       external = next;
18760
18761       /* Prevent out-of-bounds indexing.  */
18762       if (   inote.namedata + inote.namesz > end
18763           || inote.namedata + inote.namesz < inote.namedata)
18764         {
18765           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18766                 (unsigned long) ((char *) external - (char *) pnotes));
18767           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18768                 inote.type, inote.namesz, inote.descsz);
18769           break;
18770         }
18771
18772       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18773
18774       if (! print_v850_note (& inote))
18775         {
18776           res = FALSE;
18777           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18778                   inote.namesz, inote.descsz);
18779         }
18780     }
18781
18782   free (pnotes);
18783
18784   return res;
18785 }
18786
18787 static bfd_boolean
18788 process_note_sections (Filedata * filedata)
18789 {
18790   Elf_Internal_Shdr * section;
18791   unsigned long i;
18792   unsigned int n = 0;
18793   bfd_boolean res = TRUE;
18794
18795   for (i = 0, section = filedata->section_headers;
18796        i < filedata->file_header.e_shnum && section != NULL;
18797        i++, section++)
18798     {
18799       if (section->sh_type == SHT_NOTE)
18800         {
18801           if (! process_notes_at (filedata, section,
18802                                   (bfd_vma) section->sh_offset,
18803                                   (bfd_vma) section->sh_size,
18804                                   (bfd_vma) section->sh_addralign))
18805             res = FALSE;
18806           n++;
18807         }
18808
18809       if ((   filedata->file_header.e_machine == EM_V800
18810            || filedata->file_header.e_machine == EM_V850
18811            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18812           && section->sh_type == SHT_RENESAS_INFO)
18813         {
18814           if (! process_v850_notes (filedata,
18815                                     (bfd_vma) section->sh_offset,
18816                                     (bfd_vma) section->sh_size))
18817             res = FALSE;
18818           n++;
18819         }
18820     }
18821
18822   if (n == 0)
18823     /* Try processing NOTE segments instead.  */
18824     return process_corefile_note_segments (filedata);
18825
18826   return res;
18827 }
18828
18829 static bfd_boolean
18830 process_notes (Filedata * filedata)
18831 {
18832   /* If we have not been asked to display the notes then do nothing.  */
18833   if (! do_notes)
18834     return TRUE;
18835
18836   if (filedata->file_header.e_type != ET_CORE)
18837     return process_note_sections (filedata);
18838
18839   /* No program headers means no NOTE segment.  */
18840   if (filedata->file_header.e_phnum > 0)
18841     return process_corefile_note_segments (filedata);
18842
18843   printf (_("No note segments present in the core file.\n"));
18844   return TRUE;
18845 }
18846
18847 static unsigned char *
18848 display_public_gnu_attributes (unsigned char * start,
18849                                const unsigned char * const end)
18850 {
18851   printf (_("  Unknown GNU attribute: %s\n"), start);
18852
18853   start += strnlen ((char *) start, end - start);
18854   display_raw_attribute (start, end);
18855
18856   return (unsigned char *) end;
18857 }
18858
18859 static unsigned char *
18860 display_generic_attribute (unsigned char * start,
18861                            unsigned int tag,
18862                            const unsigned char * const end)
18863 {
18864   if (tag == 0)
18865     return (unsigned char *) end;
18866
18867   return display_tag_value (tag, start, end);
18868 }
18869
18870 static bfd_boolean
18871 process_arch_specific (Filedata * filedata)
18872 {
18873   if (! do_arch)
18874     return TRUE;
18875
18876   switch (filedata->file_header.e_machine)
18877     {
18878     case EM_ARC:
18879     case EM_ARC_COMPACT:
18880     case EM_ARC_COMPACT2:
18881       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18882                                  display_arc_attribute,
18883                                  display_generic_attribute);
18884     case EM_ARM:
18885       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18886                                  display_arm_attribute,
18887                                  display_generic_attribute);
18888
18889     case EM_MIPS:
18890     case EM_MIPS_RS3_LE:
18891       return process_mips_specific (filedata);
18892
18893     case EM_MSP430:
18894      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18895                                 display_msp430x_attribute,
18896                                 display_generic_attribute);
18897
18898     case EM_NDS32:
18899       return process_nds32_specific (filedata);
18900
18901     case EM_PPC:
18902     case EM_PPC64:
18903       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18904                                  display_power_gnu_attribute);
18905
18906     case EM_S390:
18907     case EM_S390_OLD:
18908       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18909                                  display_s390_gnu_attribute);
18910
18911     case EM_SPARC:
18912     case EM_SPARC32PLUS:
18913     case EM_SPARCV9:
18914       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18915                                  display_sparc_gnu_attribute);
18916
18917     case EM_TI_C6000:
18918       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18919                                  display_tic6x_attribute,
18920                                  display_generic_attribute);
18921
18922     default:
18923       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18924                                  display_public_gnu_attributes,
18925                                  display_generic_attribute);
18926     }
18927 }
18928
18929 static bfd_boolean
18930 get_file_header (Filedata * filedata)
18931 {
18932   /* Read in the identity array.  */
18933   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18934     return FALSE;
18935
18936   /* Determine how to read the rest of the header.  */
18937   switch (filedata->file_header.e_ident[EI_DATA])
18938     {
18939     default:
18940     case ELFDATANONE:
18941     case ELFDATA2LSB:
18942       byte_get = byte_get_little_endian;
18943       byte_put = byte_put_little_endian;
18944       break;
18945     case ELFDATA2MSB:
18946       byte_get = byte_get_big_endian;
18947       byte_put = byte_put_big_endian;
18948       break;
18949     }
18950
18951   /* For now we only support 32 bit and 64 bit ELF files.  */
18952   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18953
18954   /* Read in the rest of the header.  */
18955   if (is_32bit_elf)
18956     {
18957       Elf32_External_Ehdr ehdr32;
18958
18959       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18960         return FALSE;
18961
18962       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18963       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18964       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18965       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18966       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18967       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18968       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18969       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18970       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18971       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18972       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18973       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18974       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18975     }
18976   else
18977     {
18978       Elf64_External_Ehdr ehdr64;
18979
18980       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18981          we will not be able to cope with the 64bit data found in
18982          64 ELF files.  Detect this now and abort before we start
18983          overwriting things.  */
18984       if (sizeof (bfd_vma) < 8)
18985         {
18986           error (_("This instance of readelf has been built without support for a\n\
18987 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18988           return FALSE;
18989         }
18990
18991       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18992         return FALSE;
18993
18994       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18995       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18996       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18997       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18998       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18999       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
19000       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
19001       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
19002       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19003       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
19004       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19005       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
19006       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
19007     }
19008
19009   if (filedata->file_header.e_shoff)
19010     {
19011       /* There may be some extensions in the first section header.  Don't
19012          bomb if we can't read it.  */
19013       if (is_32bit_elf)
19014         get_32bit_section_headers (filedata, TRUE);
19015       else
19016         get_64bit_section_headers (filedata, TRUE);
19017     }
19018
19019   return TRUE;
19020 }
19021
19022 static void
19023 close_file (Filedata * filedata)
19024 {
19025   if (filedata)
19026     {
19027       if (filedata->handle)
19028         fclose (filedata->handle);
19029       free (filedata);
19030     }
19031 }
19032
19033 void
19034 close_debug_file (void * data)
19035 {
19036   close_file ((Filedata *) data);
19037 }
19038
19039 static Filedata *
19040 open_file (const char * pathname)
19041 {
19042   struct stat  statbuf;
19043   Filedata *   filedata = NULL;
19044
19045   if (stat (pathname, & statbuf) < 0
19046       || ! S_ISREG (statbuf.st_mode))
19047     goto fail;
19048
19049   filedata = calloc (1, sizeof * filedata);
19050   if (filedata == NULL)
19051     goto fail;
19052
19053   filedata->handle = fopen (pathname, "rb");
19054   if (filedata->handle == NULL)
19055     goto fail;
19056
19057   filedata->file_size = (bfd_size_type) statbuf.st_size;
19058   filedata->file_name = pathname;
19059
19060   if (! get_file_header (filedata))
19061     goto fail;
19062
19063   if (filedata->file_header.e_shoff)
19064     {
19065       bfd_boolean res;
19066
19067       /* Read the section headers again, this time for real.  */
19068       if (is_32bit_elf)
19069         res = get_32bit_section_headers (filedata, FALSE);
19070       else
19071         res = get_64bit_section_headers (filedata, FALSE);
19072
19073       if (!res)
19074         goto fail;
19075     }
19076
19077   return filedata;
19078
19079  fail:
19080   if (filedata)
19081     {
19082       if (filedata->handle)
19083         fclose (filedata->handle);
19084       free (filedata);
19085     }
19086   return NULL;
19087 }
19088
19089 void *
19090 open_debug_file (const char * pathname)
19091 {
19092   return open_file (pathname);
19093 }
19094
19095 /* Process one ELF object file according to the command line options.
19096    This file may actually be stored in an archive.  The file is
19097    positioned at the start of the ELF object.  Returns TRUE if no
19098    problems were encountered, FALSE otherwise.  */
19099
19100 static bfd_boolean
19101 process_object (Filedata * filedata)
19102 {
19103   Filedata * separates;
19104   unsigned int i;
19105   bfd_boolean res = TRUE;
19106
19107   if (! get_file_header (filedata))
19108     {
19109       error (_("%s: Failed to read file header\n"), filedata->file_name);
19110       return FALSE;
19111     }
19112
19113   /* Initialise per file variables.  */
19114   for (i = ARRAY_SIZE (version_info); i--;)
19115     version_info[i] = 0;
19116
19117   for (i = ARRAY_SIZE (dynamic_info); i--;)
19118     dynamic_info[i] = 0;
19119   dynamic_info_DT_GNU_HASH = 0;
19120
19121   /* Process the file.  */
19122   if (show_name)
19123     printf (_("\nFile: %s\n"), filedata->file_name);
19124
19125   /* Initialise the dump_sects array from the cmdline_dump_sects array.
19126      Note we do this even if cmdline_dump_sects is empty because we
19127      must make sure that the dump_sets array is zeroed out before each
19128      object file is processed.  */
19129   if (filedata->num_dump_sects > cmdline.num_dump_sects)
19130     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19131
19132   if (cmdline.num_dump_sects > 0)
19133     {
19134       if (filedata->num_dump_sects == 0)
19135         /* A sneaky way of allocating the dump_sects array.  */
19136         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19137
19138       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19139       memcpy (filedata->dump_sects, cmdline.dump_sects,
19140               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19141     }
19142
19143   if (! process_file_header (filedata))
19144     return FALSE;
19145
19146   if (! process_section_headers (filedata))
19147     {
19148       /* Without loaded section headers we cannot process lots of things.  */
19149       do_unwind = do_version = do_dump = do_arch = FALSE;
19150
19151       if (! do_using_dynamic)
19152         do_syms = do_dyn_syms = do_reloc = FALSE;
19153     }
19154
19155   if (! process_section_groups (filedata))
19156     /* Without loaded section groups we cannot process unwind.  */
19157     do_unwind = FALSE;
19158
19159   if (process_program_headers (filedata))
19160     process_dynamic_section (filedata);
19161   else
19162     res = FALSE;
19163
19164   if (! process_relocs (filedata))
19165     res = FALSE;
19166
19167   if (! process_unwind (filedata))
19168     res = FALSE;
19169
19170   if (! process_symbol_table (filedata))
19171     res = FALSE;
19172
19173   if (! process_syminfo (filedata))
19174     res = FALSE;
19175
19176   if (! process_version_sections (filedata))
19177     res = FALSE;
19178
19179   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19180     separates = load_separate_debug_file (filedata, filedata->file_name);
19181   else
19182     separates = NULL;
19183
19184   if (! process_section_contents (filedata))
19185     res = FALSE;
19186
19187   if (separates)
19188     {
19189       if (! process_section_headers (separates))
19190         res = FALSE;
19191       else if (! process_section_contents (separates))
19192         res = FALSE;
19193     }
19194
19195   if (! process_notes (filedata))
19196     res = FALSE;
19197
19198   if (! process_gnu_liblist (filedata))
19199     res = FALSE;
19200
19201   if (! process_arch_specific (filedata))
19202     res = FALSE;
19203
19204   free (filedata->program_headers);
19205   filedata->program_headers = NULL;
19206
19207   free (filedata->section_headers);
19208   filedata->section_headers = NULL;
19209
19210   free (filedata->string_table);
19211   filedata->string_table = NULL;
19212   filedata->string_table_length = 0;
19213
19214   if (dynamic_strings)
19215     {
19216       free (dynamic_strings);
19217       dynamic_strings = NULL;
19218       dynamic_strings_length = 0;
19219     }
19220
19221   if (dynamic_symbols)
19222     {
19223       free (dynamic_symbols);
19224       dynamic_symbols = NULL;
19225       num_dynamic_syms = 0;
19226     }
19227
19228   if (dynamic_syminfo)
19229     {
19230       free (dynamic_syminfo);
19231       dynamic_syminfo = NULL;
19232     }
19233
19234   if (dynamic_section)
19235     {
19236       free (dynamic_section);
19237       dynamic_section = NULL;
19238     }
19239
19240   if (section_headers_groups)
19241     {
19242       free (section_headers_groups);
19243       section_headers_groups = NULL;
19244     }
19245
19246   if (section_groups)
19247     {
19248       struct group_list * g;
19249       struct group_list * next;
19250
19251       for (i = 0; i < group_count; i++)
19252         {
19253           for (g = section_groups [i].root; g != NULL; g = next)
19254             {
19255               next = g->next;
19256               free (g);
19257             }
19258         }
19259
19260       free (section_groups);
19261       section_groups = NULL;
19262     }
19263
19264   free_debug_memory ();
19265
19266   return res;
19267 }
19268
19269 /* Process an ELF archive.
19270    On entry the file is positioned just after the ARMAG string.
19271    Returns TRUE upon success, FALSE otherwise.  */
19272
19273 static bfd_boolean
19274 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19275 {
19276   struct archive_info arch;
19277   struct archive_info nested_arch;
19278   size_t got;
19279   bfd_boolean ret = TRUE;
19280
19281   show_name = TRUE;
19282
19283   /* The ARCH structure is used to hold information about this archive.  */
19284   arch.file_name = NULL;
19285   arch.file = NULL;
19286   arch.index_array = NULL;
19287   arch.sym_table = NULL;
19288   arch.longnames = NULL;
19289
19290   /* The NESTED_ARCH structure is used as a single-item cache of information
19291      about a nested archive (when members of a thin archive reside within
19292      another regular archive file).  */
19293   nested_arch.file_name = NULL;
19294   nested_arch.file = NULL;
19295   nested_arch.index_array = NULL;
19296   nested_arch.sym_table = NULL;
19297   nested_arch.longnames = NULL;
19298
19299   if (setup_archive (&arch, filedata->file_name, filedata->handle,
19300                      is_thin_archive, do_archive_index) != 0)
19301     {
19302       ret = FALSE;
19303       goto out;
19304     }
19305
19306   if (do_archive_index)
19307     {
19308       if (arch.sym_table == NULL)
19309         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19310       else
19311         {
19312           unsigned long i, l;
19313           unsigned long current_pos;
19314
19315           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19316                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19317
19318           current_pos = ftell (filedata->handle);
19319
19320           for (i = l = 0; i < arch.index_num; i++)
19321             {
19322               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19323                 {
19324                   char * member_name;
19325
19326                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19327
19328                   if (member_name != NULL)
19329                     {
19330                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19331
19332                       if (qualified_name != NULL)
19333                         {
19334                           printf (_("Contents of binary %s at offset "), qualified_name);
19335                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
19336                           putchar ('\n');
19337                           free (qualified_name);
19338                         }
19339                     }
19340                 }
19341
19342               if (l >= arch.sym_size)
19343                 {
19344                   error (_("%s: end of the symbol table reached before the end of the index\n"),
19345                          filedata->file_name);
19346                   ret = FALSE;
19347                   break;
19348                 }
19349               /* PR 17531: file: 0b6630b2.  */
19350               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19351               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19352             }
19353
19354           if (arch.uses_64bit_indices)
19355             l = (l + 7) & ~ 7;
19356           else
19357             l += l & 1;
19358
19359           if (l < arch.sym_size)
19360             {
19361               error (ngettext ("%s: %ld byte remains in the symbol table, "
19362                                "but without corresponding entries in "
19363                                "the index table\n",
19364                                "%s: %ld bytes remain in the symbol table, "
19365                                "but without corresponding entries in "
19366                                "the index table\n",
19367                                arch.sym_size - l),
19368                      filedata->file_name, arch.sym_size - l);
19369               ret = FALSE;
19370             }
19371
19372           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19373             {
19374               error (_("%s: failed to seek back to start of object files in the archive\n"),
19375                      filedata->file_name);
19376               ret = FALSE;
19377               goto out;
19378             }
19379         }
19380
19381       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19382           && !do_segments && !do_header && !do_dump && !do_version
19383           && !do_histogram && !do_debugging && !do_arch && !do_notes
19384           && !do_section_groups && !do_dyn_syms)
19385         {
19386           ret = TRUE; /* Archive index only.  */
19387           goto out;
19388         }
19389     }
19390
19391   while (1)
19392     {
19393       char * name;
19394       size_t namelen;
19395       char * qualified_name;
19396
19397       /* Read the next archive header.  */
19398       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19399         {
19400           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
19401           return FALSE;
19402         }
19403       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19404       if (got != sizeof arch.arhdr)
19405         {
19406           if (got == 0)
19407             break;
19408           error (_("%s: failed to read archive header\n"), filedata->file_name);
19409           ret = FALSE;
19410           break;
19411         }
19412       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19413         {
19414           error (_("%s: did not find a valid archive header\n"), arch.file_name);
19415           ret = FALSE;
19416           break;
19417         }
19418
19419       arch.next_arhdr_offset += sizeof arch.arhdr;
19420
19421       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19422       if (archive_file_size & 01)
19423         ++archive_file_size;
19424
19425       name = get_archive_member_name (&arch, &nested_arch);
19426       if (name == NULL)
19427         {
19428           error (_("%s: bad archive file name\n"), filedata->file_name);
19429           ret = FALSE;
19430           break;
19431         }
19432       namelen = strlen (name);
19433
19434       qualified_name = make_qualified_name (&arch, &nested_arch, name);
19435       if (qualified_name == NULL)
19436         {
19437           error (_("%s: bad archive file name\n"), filedata->file_name);
19438           ret = FALSE;
19439           break;
19440         }
19441
19442       if (is_thin_archive && arch.nested_member_origin == 0)
19443         {
19444           /* This is a proxy for an external member of a thin archive.  */
19445           Filedata * member_filedata;
19446           char * member_file_name = adjust_relative_path
19447             (filedata->file_name, name, namelen);
19448
19449           if (member_file_name == NULL)
19450             {
19451               ret = FALSE;
19452               break;
19453             }
19454
19455           member_filedata = open_file (member_file_name);
19456           if (member_filedata == NULL)
19457             {
19458               error (_("Input file '%s' is not readable.\n"), member_file_name);
19459               free (member_file_name);
19460               ret = FALSE;
19461               break;
19462             }
19463
19464           archive_file_offset = arch.nested_member_origin;
19465           member_filedata->file_name = qualified_name;
19466
19467           if (! process_object (member_filedata))
19468             ret = FALSE;
19469
19470           close_file (member_filedata);
19471           free (member_file_name);
19472         }
19473       else if (is_thin_archive)
19474         {
19475           Filedata thin_filedata;
19476
19477           memset (&thin_filedata, 0, sizeof (thin_filedata));
19478
19479           /* PR 15140: Allow for corrupt thin archives.  */
19480           if (nested_arch.file == NULL)
19481             {
19482               error (_("%s: contains corrupt thin archive: %s\n"),
19483                      filedata->file_name, name);
19484               ret = FALSE;
19485               break;
19486             }
19487
19488           /* This is a proxy for a member of a nested archive.  */
19489           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19490
19491           /* The nested archive file will have been opened and setup by
19492              get_archive_member_name.  */
19493           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19494             {
19495               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19496               ret = FALSE;
19497               break;
19498             }
19499
19500           thin_filedata.handle = nested_arch.file;
19501           thin_filedata.file_name = qualified_name;
19502
19503           if (! process_object (& thin_filedata))
19504             ret = FALSE;
19505         }
19506       else
19507         {
19508           archive_file_offset = arch.next_arhdr_offset;
19509           arch.next_arhdr_offset += archive_file_size;
19510
19511           filedata->file_name = qualified_name;
19512           if (! process_object (filedata))
19513             ret = FALSE;
19514         }
19515
19516       if (filedata->dump_sects != NULL)
19517         {
19518           free (filedata->dump_sects);
19519           filedata->dump_sects = NULL;
19520           filedata->num_dump_sects = 0;
19521         }
19522
19523       free (qualified_name);
19524     }
19525
19526  out:
19527   if (nested_arch.file != NULL)
19528     fclose (nested_arch.file);
19529   release_archive (&nested_arch);
19530   release_archive (&arch);
19531
19532   return ret;
19533 }
19534
19535 static bfd_boolean
19536 process_file (char * file_name)
19537 {
19538   Filedata * filedata = NULL;
19539   struct stat statbuf;
19540   char armag[SARMAG];
19541   bfd_boolean ret = TRUE;
19542
19543   if (stat (file_name, &statbuf) < 0)
19544     {
19545       if (errno == ENOENT)
19546         error (_("'%s': No such file\n"), file_name);
19547       else
19548         error (_("Could not locate '%s'.  System error message: %s\n"),
19549                file_name, strerror (errno));
19550       return FALSE;
19551     }
19552
19553   if (! S_ISREG (statbuf.st_mode))
19554     {
19555       error (_("'%s' is not an ordinary file\n"), file_name);
19556       return FALSE;
19557     }
19558
19559   filedata = calloc (1, sizeof * filedata);
19560   if (filedata == NULL)
19561     {
19562       error (_("Out of memory allocating file data structure\n"));
19563       return FALSE;
19564     }
19565
19566   filedata->file_name = file_name;
19567   filedata->handle = fopen (file_name, "rb");
19568   if (filedata->handle == NULL)
19569     {
19570       error (_("Input file '%s' is not readable.\n"), file_name);
19571       free (filedata);
19572       return FALSE;
19573     }
19574
19575   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19576     {
19577       error (_("%s: Failed to read file's magic number\n"), file_name);
19578       fclose (filedata->handle);
19579       free (filedata);
19580       return FALSE;
19581     }
19582
19583   filedata->file_size = (bfd_size_type) statbuf.st_size;
19584
19585   if (memcmp (armag, ARMAG, SARMAG) == 0)
19586     {
19587       if (! process_archive (filedata, FALSE))
19588         ret = FALSE;
19589     }
19590   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19591     {
19592       if ( ! process_archive (filedata, TRUE))
19593         ret = FALSE;
19594     }
19595   else
19596     {
19597       if (do_archive_index)
19598         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19599                file_name);
19600
19601       rewind (filedata->handle);
19602       archive_file_size = archive_file_offset = 0;
19603
19604       if (! process_object (filedata))
19605         ret = FALSE;
19606     }
19607
19608   fclose (filedata->handle);
19609   free (filedata);
19610
19611   return ret;
19612 }
19613
19614 #ifdef SUPPORT_DISASSEMBLY
19615 /* Needed by the i386 disassembler.  For extra credit, someone could
19616    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19617    symbols.  */
19618
19619 void
19620 print_address (unsigned int addr, FILE * outfile)
19621 {
19622   fprintf (outfile,"0x%8.8x", addr);
19623 }
19624
19625 /* Needed by the i386 disassembler.  */
19626
19627 void
19628 db_task_printsym (unsigned int addr)
19629 {
19630   print_address (addr, stderr);
19631 }
19632 #endif
19633
19634 int
19635 main (int argc, char ** argv)
19636 {
19637   int err;
19638
19639 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19640   setlocale (LC_MESSAGES, "");
19641 #endif
19642 #if defined (HAVE_SETLOCALE)
19643   setlocale (LC_CTYPE, "");
19644 #endif
19645   bindtextdomain (PACKAGE, LOCALEDIR);
19646   textdomain (PACKAGE);
19647
19648   expandargv (&argc, &argv);
19649
19650   cmdline.file_name = "<cmdline>";
19651   parse_args (& cmdline, argc, argv);
19652
19653   if (optind < (argc - 1))
19654     show_name = TRUE;
19655   else if (optind >= argc)
19656     {
19657       warn (_("Nothing to do.\n"));
19658       usage (stderr);
19659     }
19660
19661   err = FALSE;
19662   while (optind < argc)
19663     if (! process_file (argv[optind++]))
19664       err = TRUE;
19665
19666   if (cmdline.dump_sects != NULL)
19667     free (cmdline.dump_sects);
19668
19669   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19670 }