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_REL:
6303         case SHT_RELA:
6304           if (section->sh_link == 0
6305               && (filedata->file_header.e_type == ET_EXEC
6306                   || filedata->file_header.e_type == ET_DYN))
6307             /* A dynamic relocation section where all entries use a
6308                zero symbol index need not specify a symtab section.  */
6309             break;
6310           /* Fall through.  */
6311         case SHT_SYMTAB_SHNDX:
6312         case SHT_GROUP:
6313         case SHT_HASH:
6314         case SHT_GNU_HASH:
6315         case SHT_GNU_versym:
6316           if (section->sh_link == 0
6317               || section->sh_link >= filedata->file_header.e_shnum
6318               || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6319                   && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6320             warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6321                   i, section->sh_link);
6322           break;
6323
6324         case SHT_DYNAMIC:
6325         case SHT_SYMTAB:
6326         case SHT_DYNSYM:
6327         case SHT_GNU_verneed:
6328         case SHT_GNU_verdef:
6329         case SHT_GNU_LIBLIST:
6330           if (section->sh_link == 0
6331               || section->sh_link >= filedata->file_header.e_shnum
6332               || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6333             warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6334                   i, section->sh_link);
6335           break;
6336
6337         case SHT_INIT_ARRAY:
6338         case SHT_FINI_ARRAY:
6339         case SHT_PREINIT_ARRAY:
6340           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6341             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6342                   i, section->sh_link);
6343           break;
6344
6345         default:
6346           /* FIXME: Add support for target specific section types.  */
6347 #if 0     /* Currently we do not check other section types as there are too
6348              many special cases.  Stab sections for example have a type
6349              of SHT_PROGBITS but an sh_link field that links to the .stabstr
6350              section.  */
6351           if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6352             warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6353                   i, section->sh_link);
6354 #endif
6355           break;
6356         }
6357
6358       /* Check the sh_info field.  */
6359       switch (section->sh_type)
6360         {
6361         case SHT_REL:
6362         case SHT_RELA:
6363           if (section->sh_info == 0
6364               && (filedata->file_header.e_type == ET_EXEC
6365                   || filedata->file_header.e_type == ET_DYN))
6366             /* Dynamic relocations apply to segments, so they do not
6367                need to specify the section they relocate.  */
6368             break;
6369           if (section->sh_info == 0
6370               || section->sh_info >= filedata->file_header.e_shnum
6371               || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6372                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6373                   && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6374                   && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6375                   && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6376                   && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6377                   /* FIXME: Are other section types valid ?  */
6378                   && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6379             warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6380                   i, section->sh_info);
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           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7601           relname = elf_ia64_reloc_type (r_type);
7602           sym = aux->symtab + get_reloc_symindex (rp->r_info);
7603
7604           /* PR 17531: file: 9fa67536.  */
7605           if (relname == NULL)
7606             {
7607               warn (_("Skipping unknown relocation type: %u\n"), r_type);
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           unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8057           relname = elf_hppa_reloc_type (r_type);
8058           sym = aux->symtab + get_reloc_symindex (rp->r_info);
8059
8060           if (relname == NULL)
8061             {
8062               warn (_("Skipping unknown relocation type: %u\n"), r_type);
8063               continue;
8064             }
8065
8066           /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64.  */
8067           if (! const_strneq (relname, "R_PARISC_SEGREL"))
8068             {
8069               warn (_("Skipping unexpected relocation type: %s\n"), relname);
8070               continue;
8071             }
8072
8073           i = rp->r_offset / unw_ent_size;
8074           if (i >= aux->table_len)
8075             {
8076               warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8077               continue;
8078             }
8079
8080           switch ((rp->r_offset % unw_ent_size) / 4)
8081             {
8082             case 0:
8083               aux->table[i].start.section = sym->st_shndx;
8084               aux->table[i].start.offset  = sym->st_value + rp->r_addend;
8085               break;
8086             case 1:
8087               aux->table[i].end.section   = sym->st_shndx;
8088               aux->table[i].end.offset    = sym->st_value + rp->r_addend;
8089               break;
8090             default:
8091               break;
8092             }
8093         }
8094
8095       free (rela);
8096     }
8097
8098   aux->table_len = nentries;
8099
8100   return TRUE;
8101 }
8102
8103 static bfd_boolean
8104 hppa_process_unwind (Filedata * filedata)
8105 {
8106   struct hppa_unw_aux_info aux;
8107   Elf_Internal_Shdr * unwsec = NULL;
8108   Elf_Internal_Shdr * strsec;
8109   Elf_Internal_Shdr * sec;
8110   unsigned long i;
8111   bfd_boolean res = TRUE;
8112
8113   if (filedata->string_table == NULL)
8114     return FALSE;
8115
8116   memset (& aux, 0, sizeof (aux));
8117
8118   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8119     {
8120       if (sec->sh_type == SHT_SYMTAB
8121           && sec->sh_link < filedata->file_header.e_shnum)
8122         {
8123           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8124
8125           strsec = filedata->section_headers + sec->sh_link;
8126           if (aux.strtab != NULL)
8127             {
8128               error (_("Multiple auxillary string tables encountered\n"));
8129               free (aux.strtab);
8130               res = FALSE;
8131             }
8132           aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8133                                           1, strsec->sh_size,
8134                                           _("string table"));
8135           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8136         }
8137       else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8138         unwsec = sec;
8139     }
8140
8141   if (!unwsec)
8142     printf (_("\nThere are no unwind sections in this file.\n"));
8143
8144   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8145     {
8146       if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8147         {
8148           unsigned long num_unwind = sec->sh_size / 16;
8149
8150           printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8151                             "contains %lu entry:\n",
8152                             "\nUnwind section '%s' at offset 0x%lx "
8153                             "contains %lu entries:\n",
8154                             num_unwind),
8155                   printable_section_name (filedata, sec),
8156                   (unsigned long) sec->sh_offset,
8157                   num_unwind);
8158
8159           if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8160             res = FALSE;
8161
8162           if (res && aux.table_len > 0)
8163             {
8164               if (! dump_hppa_unwind (filedata, &aux))
8165                 res = FALSE;
8166             }
8167
8168           if (aux.table)
8169             free ((char *) aux.table);
8170           aux.table = NULL;
8171         }
8172     }
8173
8174   if (aux.symtab)
8175     free (aux.symtab);
8176   if (aux.strtab)
8177     free ((char *) aux.strtab);
8178
8179   return res;
8180 }
8181
8182 struct arm_section
8183 {
8184   unsigned char *      data;            /* The unwind data.  */
8185   Elf_Internal_Shdr *  sec;             /* The cached unwind section header.  */
8186   Elf_Internal_Rela *  rela;            /* The cached relocations for this section.  */
8187   unsigned long        nrelas;          /* The number of relocations.  */
8188   unsigned int         rel_type;        /* REL or RELA ?  */
8189   Elf_Internal_Rela *  next_rela;       /* Cyclic pointer to the next reloc to process.  */
8190 };
8191
8192 struct arm_unw_aux_info
8193 {
8194   Filedata *          filedata;         /* The file containing the unwind sections.  */
8195   Elf_Internal_Sym *  symtab;           /* The file's symbol table.  */
8196   unsigned long       nsyms;            /* Number of symbols.  */
8197   Elf_Internal_Sym *  funtab;           /* Sorted table of STT_FUNC symbols.  */
8198   unsigned long       nfuns;            /* Number of these symbols.  */
8199   char *              strtab;           /* The file's string table.  */
8200   unsigned long       strtab_size;      /* Size of string table.  */
8201 };
8202
8203 static const char *
8204 arm_print_vma_and_name (Filedata *                 filedata,
8205                         struct arm_unw_aux_info *  aux,
8206                         bfd_vma                    fn,
8207                         struct absaddr             addr)
8208 {
8209   const char *procname;
8210   bfd_vma sym_offset;
8211
8212   if (addr.section == SHN_UNDEF)
8213     addr.offset = fn;
8214
8215   find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8216                            aux->strtab_size, addr, &procname,
8217                            &sym_offset);
8218
8219   print_vma (fn, PREFIX_HEX);
8220
8221   if (procname)
8222     {
8223       fputs (" <", stdout);
8224       fputs (procname, stdout);
8225
8226       if (sym_offset)
8227         printf ("+0x%lx", (unsigned long) sym_offset);
8228       fputc ('>', stdout);
8229     }
8230
8231   return procname;
8232 }
8233
8234 static void
8235 arm_free_section (struct arm_section *arm_sec)
8236 {
8237   if (arm_sec->data != NULL)
8238     free (arm_sec->data);
8239
8240   if (arm_sec->rela != NULL)
8241     free (arm_sec->rela);
8242 }
8243
8244 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8245       cached section and install SEC instead.
8246    2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8247       and return its valued in * WORDP, relocating if necessary.
8248    3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8249       relocation's offset in ADDR.
8250    4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8251       into the string table of the symbol associated with the reloc.  If no
8252       reloc was applied store -1 there.
8253    5) Return TRUE upon success, FALSE otherwise.  */
8254
8255 static bfd_boolean
8256 get_unwind_section_word (Filedata *                 filedata,
8257                          struct arm_unw_aux_info *  aux,
8258                          struct arm_section *       arm_sec,
8259                          Elf_Internal_Shdr *        sec,
8260                          bfd_vma                    word_offset,
8261                          unsigned int *             wordp,
8262                          struct absaddr *           addr,
8263                          bfd_vma *                  sym_name)
8264 {
8265   Elf_Internal_Rela *rp;
8266   Elf_Internal_Sym *sym;
8267   const char * relname;
8268   unsigned int word;
8269   bfd_boolean wrapped;
8270
8271   if (sec == NULL || arm_sec == NULL)
8272     return FALSE;
8273
8274   addr->section = SHN_UNDEF;
8275   addr->offset = 0;
8276
8277   if (sym_name != NULL)
8278     *sym_name = (bfd_vma) -1;
8279
8280   /* If necessary, update the section cache.  */
8281   if (sec != arm_sec->sec)
8282     {
8283       Elf_Internal_Shdr *relsec;
8284
8285       arm_free_section (arm_sec);
8286
8287       arm_sec->sec = sec;
8288       arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8289                                 sec->sh_size, _("unwind data"));
8290       arm_sec->rela = NULL;
8291       arm_sec->nrelas = 0;
8292
8293       for (relsec = filedata->section_headers;
8294            relsec < filedata->section_headers + filedata->file_header.e_shnum;
8295            ++relsec)
8296         {
8297           if (relsec->sh_info >= filedata->file_header.e_shnum
8298               || filedata->section_headers + relsec->sh_info != sec
8299               /* PR 15745: Check the section type as well.  */
8300               || (relsec->sh_type != SHT_REL
8301                   && relsec->sh_type != SHT_RELA))
8302             continue;
8303
8304           arm_sec->rel_type = relsec->sh_type;
8305           if (relsec->sh_type == SHT_REL)
8306             {
8307               if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8308                                      relsec->sh_size,
8309                                      & arm_sec->rela, & arm_sec->nrelas))
8310                 return FALSE;
8311             }
8312           else /* relsec->sh_type == SHT_RELA */
8313             {
8314               if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8315                                       relsec->sh_size,
8316                                       & arm_sec->rela, & arm_sec->nrelas))
8317                 return FALSE;
8318             }
8319           break;
8320         }
8321
8322       arm_sec->next_rela = arm_sec->rela;
8323     }
8324
8325   /* If there is no unwind data we can do nothing.  */
8326   if (arm_sec->data == NULL)
8327     return FALSE;
8328
8329   /* If the offset is invalid then fail.  */
8330   if (/* PR 21343 *//* PR 18879 */
8331       sec->sh_size < 4
8332       || word_offset > (sec->sh_size - 4)
8333       || ((bfd_signed_vma) word_offset) < 0)
8334     return FALSE;
8335
8336   /* Get the word at the required offset.  */
8337   word = byte_get (arm_sec->data + word_offset, 4);
8338
8339   /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128.  */
8340   if (arm_sec->rela == NULL)
8341     {
8342       * wordp = word;
8343       return TRUE;
8344     }
8345
8346   /* Look through the relocs to find the one that applies to the provided offset.  */
8347   wrapped = FALSE;
8348   for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8349     {
8350       bfd_vma prelval, offset;
8351
8352       if (rp->r_offset > word_offset && !wrapped)
8353         {
8354           rp = arm_sec->rela;
8355           wrapped = TRUE;
8356         }
8357       if (rp->r_offset > word_offset)
8358         break;
8359
8360       if (rp->r_offset & 3)
8361         {
8362           warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8363                 (unsigned long) rp->r_offset);
8364           continue;
8365         }
8366
8367       if (rp->r_offset < word_offset)
8368         continue;
8369
8370       /* PR 17531: file: 027-161405-0.004  */
8371       if (aux->symtab == NULL)
8372         continue;
8373
8374       if (arm_sec->rel_type == SHT_REL)
8375         {
8376           offset = word & 0x7fffffff;
8377           if (offset & 0x40000000)
8378             offset |= ~ (bfd_vma) 0x7fffffff;
8379         }
8380       else if (arm_sec->rel_type == SHT_RELA)
8381         offset = rp->r_addend;
8382       else
8383         {
8384           error (_("Unknown section relocation type %d encountered\n"),
8385                  arm_sec->rel_type);
8386           break;
8387         }
8388
8389       /* PR 17531 file: 027-1241568-0.004.  */
8390       if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8391         {
8392           error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8393                  (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8394           break;
8395         }
8396
8397       sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8398       offset += sym->st_value;
8399       prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8400
8401       /* Check that we are processing the expected reloc type.  */
8402       if (filedata->file_header.e_machine == EM_ARM)
8403         {
8404           relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8405           if (relname == NULL)
8406             {
8407               warn (_("Skipping unknown ARM relocation type: %d\n"),
8408                     (int) ELF32_R_TYPE (rp->r_info));
8409               continue;
8410             }
8411
8412           if (streq (relname, "R_ARM_NONE"))
8413               continue;
8414
8415           if (! streq (relname, "R_ARM_PREL31"))
8416             {
8417               warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8418               continue;
8419             }
8420         }
8421       else if (filedata->file_header.e_machine == EM_TI_C6000)
8422         {
8423           relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8424           if (relname == NULL)
8425             {
8426               warn (_("Skipping unknown C6000 relocation type: %d\n"),
8427                     (int) ELF32_R_TYPE (rp->r_info));
8428               continue;
8429             }
8430
8431           if (streq (relname, "R_C6000_NONE"))
8432             continue;
8433
8434           if (! streq (relname, "R_C6000_PREL31"))
8435             {
8436               warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8437               continue;
8438             }
8439
8440           prelval >>= 1;
8441         }
8442       else
8443         {
8444           /* This function currently only supports ARM and TI unwinders.  */
8445           warn (_("Only TI and ARM unwinders are currently supported\n"));
8446           break;
8447         }
8448
8449       word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8450       addr->section = sym->st_shndx;
8451       addr->offset = offset;
8452
8453       if (sym_name)
8454         * sym_name = sym->st_name;
8455       break;
8456     }
8457
8458   *wordp = word;
8459   arm_sec->next_rela = rp;
8460
8461   return TRUE;
8462 }
8463
8464 static const char *tic6x_unwind_regnames[16] =
8465 {
8466   "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8467   "A14", "A13", "A12", "A11", "A10",
8468   "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8469 };
8470
8471 static void
8472 decode_tic6x_unwind_regmask (unsigned int mask)
8473 {
8474   int i;
8475
8476   for (i = 12; mask; mask >>= 1, i--)
8477     {
8478       if (mask & 1)
8479         {
8480           fputs (tic6x_unwind_regnames[i], stdout);
8481           if (mask > 1)
8482             fputs (", ", stdout);
8483         }
8484     }
8485 }
8486
8487 #define ADVANCE                                                 \
8488   if (remaining == 0 && more_words)                             \
8489     {                                                           \
8490       data_offset += 4;                                         \
8491       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec,     \
8492                                      data_offset, & word, & addr, NULL))        \
8493         return FALSE;                                           \
8494       remaining = 4;                                            \
8495       more_words--;                                             \
8496     }                                                           \
8497
8498 #define GET_OP(OP)                      \
8499   ADVANCE;                              \
8500   if (remaining)                        \
8501     {                                   \
8502       remaining--;                      \
8503       (OP) = word >> 24;                \
8504       word <<= 8;                       \
8505     }                                   \
8506   else                                  \
8507     {                                   \
8508       printf (_("[Truncated opcode]\n"));       \
8509       return FALSE;                     \
8510     }                                   \
8511   printf ("0x%02x ", OP)
8512
8513 static bfd_boolean
8514 decode_arm_unwind_bytecode (Filedata *                 filedata,
8515                             struct arm_unw_aux_info *  aux,
8516                             unsigned int               word,
8517                             unsigned int               remaining,
8518                             unsigned int               more_words,
8519                             bfd_vma                    data_offset,
8520                             Elf_Internal_Shdr *        data_sec,
8521                             struct arm_section *       data_arm_sec)
8522 {
8523   struct absaddr addr;
8524   bfd_boolean res = TRUE;
8525
8526   /* Decode the unwinding instructions.  */
8527   while (1)
8528     {
8529       unsigned int op, op2;
8530
8531       ADVANCE;
8532       if (remaining == 0)
8533         break;
8534       remaining--;
8535       op = word >> 24;
8536       word <<= 8;
8537
8538       printf ("  0x%02x ", op);
8539
8540       if ((op & 0xc0) == 0x00)
8541         {
8542           int offset = ((op & 0x3f) << 2) + 4;
8543
8544           printf ("     vsp = vsp + %d", offset);
8545         }
8546       else if ((op & 0xc0) == 0x40)
8547         {
8548           int offset = ((op & 0x3f) << 2) + 4;
8549
8550           printf ("     vsp = vsp - %d", offset);
8551         }
8552       else if ((op & 0xf0) == 0x80)
8553         {
8554           GET_OP (op2);
8555           if (op == 0x80 && op2 == 0)
8556             printf (_("Refuse to unwind"));
8557           else
8558             {
8559               unsigned int mask = ((op & 0x0f) << 8) | op2;
8560               bfd_boolean first = TRUE;
8561               int i;
8562
8563               printf ("pop {");
8564               for (i = 0; i < 12; i++)
8565                 if (mask & (1 << i))
8566                   {
8567                     if (first)
8568                       first = FALSE;
8569                     else
8570                       printf (", ");
8571                     printf ("r%d", 4 + i);
8572                   }
8573               printf ("}");
8574             }
8575         }
8576       else if ((op & 0xf0) == 0x90)
8577         {
8578           if (op == 0x9d || op == 0x9f)
8579             printf (_("     [Reserved]"));
8580           else
8581             printf ("     vsp = r%d", op & 0x0f);
8582         }
8583       else if ((op & 0xf0) == 0xa0)
8584         {
8585           int end = 4 + (op & 0x07);
8586           bfd_boolean first = TRUE;
8587           int i;
8588
8589           printf ("     pop {");
8590           for (i = 4; i <= end; i++)
8591             {
8592               if (first)
8593                 first = FALSE;
8594               else
8595                 printf (", ");
8596               printf ("r%d", i);
8597             }
8598           if (op & 0x08)
8599             {
8600               if (!first)
8601                 printf (", ");
8602               printf ("r14");
8603             }
8604           printf ("}");
8605         }
8606       else if (op == 0xb0)
8607         printf (_("     finish"));
8608       else if (op == 0xb1)
8609         {
8610           GET_OP (op2);
8611           if (op2 == 0 || (op2 & 0xf0) != 0)
8612             printf (_("[Spare]"));
8613           else
8614             {
8615               unsigned int mask = op2 & 0x0f;
8616               bfd_boolean first = TRUE;
8617               int i;
8618
8619               printf ("pop {");
8620               for (i = 0; i < 12; i++)
8621                 if (mask & (1 << i))
8622                   {
8623                     if (first)
8624                       first = FALSE;
8625                     else
8626                       printf (", ");
8627                     printf ("r%d", i);
8628                   }
8629               printf ("}");
8630             }
8631         }
8632       else if (op == 0xb2)
8633         {
8634           unsigned char buf[9];
8635           unsigned int i, len;
8636           unsigned long offset;
8637
8638           for (i = 0; i < sizeof (buf); i++)
8639             {
8640               GET_OP (buf[i]);
8641               if ((buf[i] & 0x80) == 0)
8642                 break;
8643             }
8644           if (i == sizeof (buf))
8645             {
8646               error (_("corrupt change to vsp"));
8647               res = FALSE;
8648             }
8649           else
8650             {
8651               offset = read_uleb128 (buf, &len, buf + i + 1);
8652               assert (len == i + 1);
8653               offset = offset * 4 + 0x204;
8654               printf ("vsp = vsp + %ld", offset);
8655             }
8656         }
8657       else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8658         {
8659           unsigned int first, last;
8660
8661           GET_OP (op2);
8662           first = op2 >> 4;
8663           last = op2 & 0x0f;
8664           if (op == 0xc8)
8665             first = first + 16;
8666           printf ("pop {D%d", first);
8667           if (last)
8668             printf ("-D%d", first + last);
8669           printf ("}");
8670         }
8671       else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8672         {
8673           unsigned int count = op & 0x07;
8674
8675           printf ("pop {D8");
8676           if (count)
8677             printf ("-D%d", 8 + count);
8678           printf ("}");
8679         }
8680       else if (op >= 0xc0 && op <= 0xc5)
8681         {
8682           unsigned int count = op & 0x07;
8683
8684           printf ("     pop {wR10");
8685           if (count)
8686             printf ("-wR%d", 10 + count);
8687           printf ("}");
8688         }
8689       else if (op == 0xc6)
8690         {
8691           unsigned int first, last;
8692
8693           GET_OP (op2);
8694           first = op2 >> 4;
8695           last = op2 & 0x0f;
8696           printf ("pop {wR%d", first);
8697           if (last)
8698             printf ("-wR%d", first + last);
8699           printf ("}");
8700         }
8701       else if (op == 0xc7)
8702         {
8703           GET_OP (op2);
8704           if (op2 == 0 || (op2 & 0xf0) != 0)
8705             printf (_("[Spare]"));
8706           else
8707             {
8708               unsigned int mask = op2 & 0x0f;
8709               bfd_boolean first = TRUE;
8710               int i;
8711
8712               printf ("pop {");
8713               for (i = 0; i < 4; i++)
8714                 if (mask & (1 << i))
8715                   {
8716                     if (first)
8717                       first = FALSE;
8718                     else
8719                       printf (", ");
8720                     printf ("wCGR%d", i);
8721                   }
8722               printf ("}");
8723             }
8724         }
8725       else
8726         {
8727           printf (_("     [unsupported opcode]"));
8728           res = FALSE;
8729         }
8730
8731       printf ("\n");
8732     }
8733
8734   return res;
8735 }
8736
8737 static bfd_boolean
8738 decode_tic6x_unwind_bytecode (Filedata *                 filedata,
8739                               struct arm_unw_aux_info *  aux,
8740                               unsigned int               word,
8741                               unsigned int               remaining,
8742                               unsigned int               more_words,
8743                               bfd_vma                    data_offset,
8744                               Elf_Internal_Shdr *        data_sec,
8745                               struct arm_section *       data_arm_sec)
8746 {
8747   struct absaddr addr;
8748
8749   /* Decode the unwinding instructions.  */
8750   while (1)
8751     {
8752       unsigned int op, op2;
8753
8754       ADVANCE;
8755       if (remaining == 0)
8756         break;
8757       remaining--;
8758       op = word >> 24;
8759       word <<= 8;
8760
8761       printf ("  0x%02x ", op);
8762
8763       if ((op & 0xc0) == 0x00)
8764         {
8765           int offset = ((op & 0x3f) << 3) + 8;
8766           printf ("     sp = sp + %d", offset);
8767         }
8768       else if ((op & 0xc0) == 0x80)
8769         {
8770           GET_OP (op2);
8771           if (op == 0x80 && op2 == 0)
8772             printf (_("Refuse to unwind"));
8773           else
8774             {
8775               unsigned int mask = ((op & 0x1f) << 8) | op2;
8776               if (op & 0x20)
8777                 printf ("pop compact {");
8778               else
8779                 printf ("pop {");
8780
8781               decode_tic6x_unwind_regmask (mask);
8782               printf("}");
8783             }
8784         }
8785       else if ((op & 0xf0) == 0xc0)
8786         {
8787           unsigned int reg;
8788           unsigned int nregs;
8789           unsigned int i;
8790           const char *name;
8791           struct
8792           {
8793             unsigned int offset;
8794             unsigned int reg;
8795           } regpos[16];
8796
8797           /* Scan entire instruction first so that GET_OP output is not
8798              interleaved with disassembly.  */
8799           nregs = 0;
8800           for (i = 0; nregs < (op & 0xf); i++)
8801             {
8802               GET_OP (op2);
8803               reg = op2 >> 4;
8804               if (reg != 0xf)
8805                 {
8806                   regpos[nregs].offset = i * 2;
8807                   regpos[nregs].reg = reg;
8808                   nregs++;
8809                 }
8810
8811               reg = op2 & 0xf;
8812               if (reg != 0xf)
8813                 {
8814                   regpos[nregs].offset = i * 2 + 1;
8815                   regpos[nregs].reg = reg;
8816                   nregs++;
8817                 }
8818             }
8819
8820           printf (_("pop frame {"));
8821           reg = nregs - 1;
8822           for (i = i * 2; i > 0; i--)
8823             {
8824               if (regpos[reg].offset == i - 1)
8825                 {
8826                   name = tic6x_unwind_regnames[regpos[reg].reg];
8827                   if (reg > 0)
8828                     reg--;
8829                 }
8830               else
8831                 name = _("[pad]");
8832
8833               fputs (name, stdout);
8834               if (i > 1)
8835                 printf (", ");
8836             }
8837
8838           printf ("}");
8839         }
8840       else if (op == 0xd0)
8841         printf ("     MOV FP, SP");
8842       else if (op == 0xd1)
8843         printf ("     __c6xabi_pop_rts");
8844       else if (op == 0xd2)
8845         {
8846           unsigned char buf[9];
8847           unsigned int i, len;
8848           unsigned long offset;
8849
8850           for (i = 0; i < sizeof (buf); i++)
8851             {
8852               GET_OP (buf[i]);
8853               if ((buf[i] & 0x80) == 0)
8854                 break;
8855             }
8856           /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2.  */
8857           if (i == sizeof (buf))
8858             {
8859               warn (_("Corrupt stack pointer adjustment detected\n"));
8860               return FALSE;
8861             }
8862
8863           offset = read_uleb128 (buf, &len, buf + i + 1);
8864           assert (len == i + 1);
8865           offset = offset * 8 + 0x408;
8866           printf (_("sp = sp + %ld"), offset);
8867         }
8868       else if ((op & 0xf0) == 0xe0)
8869         {
8870           if ((op & 0x0f) == 7)
8871             printf ("     RETURN");
8872           else
8873             printf ("     MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8874         }
8875       else
8876         {
8877           printf (_("     [unsupported opcode]"));
8878         }
8879       putchar ('\n');
8880     }
8881
8882   return TRUE;
8883 }
8884
8885 static bfd_vma
8886 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8887 {
8888   bfd_vma offset;
8889
8890   offset = word & 0x7fffffff;
8891   if (offset & 0x40000000)
8892     offset |= ~ (bfd_vma) 0x7fffffff;
8893
8894   if (filedata->file_header.e_machine == EM_TI_C6000)
8895     offset <<= 1;
8896
8897   return offset + where;
8898 }
8899
8900 static bfd_boolean
8901 decode_arm_unwind (Filedata *                 filedata,
8902                    struct arm_unw_aux_info *  aux,
8903                    unsigned int               word,
8904                    unsigned int               remaining,
8905                    bfd_vma                    data_offset,
8906                    Elf_Internal_Shdr *        data_sec,
8907                    struct arm_section *       data_arm_sec)
8908 {
8909   int per_index;
8910   unsigned int more_words = 0;
8911   struct absaddr addr;
8912   bfd_vma sym_name = (bfd_vma) -1;
8913   bfd_boolean res = TRUE;
8914
8915   if (remaining == 0)
8916     {
8917       /* Fetch the first word.
8918          Note - when decoding an object file the address extracted
8919          here will always be 0.  So we also pass in the sym_name
8920          parameter so that we can find the symbol associated with
8921          the personality routine.  */
8922       if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8923                                      & word, & addr, & sym_name))
8924         return FALSE;
8925
8926       remaining = 4;
8927     }
8928
8929   if ((word & 0x80000000) == 0)
8930     {
8931       /* Expand prel31 for personality routine.  */
8932       bfd_vma fn;
8933       const char *procname;
8934
8935       fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8936       printf (_("  Personality routine: "));
8937       if (fn == 0
8938           && addr.section == SHN_UNDEF && addr.offset == 0
8939           && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8940         {
8941           procname = aux->strtab + sym_name;
8942           print_vma (fn, PREFIX_HEX);
8943           if (procname)
8944             {
8945               fputs (" <", stdout);
8946               fputs (procname, stdout);
8947               fputc ('>', stdout);
8948             }
8949         }
8950       else
8951         procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8952       fputc ('\n', stdout);
8953
8954       /* The GCC personality routines use the standard compact
8955          encoding, starting with one byte giving the number of
8956          words.  */
8957       if (procname != NULL
8958           && (const_strneq (procname, "__gcc_personality_v0")
8959               || const_strneq (procname, "__gxx_personality_v0")
8960               || const_strneq (procname, "__gcj_personality_v0")
8961               || const_strneq (procname, "__gnu_objc_personality_v0")))
8962         {
8963           remaining = 0;
8964           more_words = 1;
8965           ADVANCE;
8966           if (!remaining)
8967             {
8968               printf (_("  [Truncated data]\n"));
8969               return FALSE;
8970             }
8971           more_words = word >> 24;
8972           word <<= 8;
8973           remaining--;
8974           per_index = -1;
8975         }
8976       else
8977         return TRUE;
8978     }
8979   else
8980     {
8981       /* ARM EHABI Section 6.3:
8982
8983          An exception-handling table entry for the compact model looks like:
8984
8985            31 30-28 27-24 23-0
8986            -- ----- ----- ----
8987             1   0   index Data for personalityRoutine[index]    */
8988
8989       if (filedata->file_header.e_machine == EM_ARM
8990           && (word & 0x70000000))
8991         {
8992           warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8993           res = FALSE;
8994         }
8995
8996       per_index = (word >> 24) & 0x7f;
8997       printf (_("  Compact model index: %d\n"), per_index);
8998       if (per_index == 0)
8999         {
9000           more_words = 0;
9001           word <<= 8;
9002           remaining--;
9003         }
9004       else if (per_index < 3)
9005         {
9006           more_words = (word >> 16) & 0xff;
9007           word <<= 16;
9008           remaining -= 2;
9009         }
9010     }
9011
9012   switch (filedata->file_header.e_machine)
9013     {
9014     case EM_ARM:
9015       if (per_index < 3)
9016         {
9017           if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9018                                             data_offset, data_sec, data_arm_sec))
9019             res = FALSE;
9020         }
9021       else
9022         {
9023           warn (_("Unknown ARM compact model index encountered\n"));
9024           printf (_("  [reserved]\n"));
9025           res = FALSE;
9026         }
9027       break;
9028
9029     case EM_TI_C6000:
9030       if (per_index < 3)
9031         {
9032           if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9033                                               data_offset, data_sec, data_arm_sec))
9034             res = FALSE;
9035         }
9036       else if (per_index < 5)
9037         {
9038           if (((word >> 17) & 0x7f) == 0x7f)
9039             printf (_("  Restore stack from frame pointer\n"));
9040           else
9041             printf (_("  Stack increment %d\n"), (word >> 14) & 0x1fc);
9042           printf (_("  Registers restored: "));
9043           if (per_index == 4)
9044             printf (" (compact) ");
9045           decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9046           putchar ('\n');
9047           printf (_("  Return register: %s\n"),
9048                   tic6x_unwind_regnames[word & 0xf]);
9049         }
9050       else
9051         printf (_("  [reserved (%d)]\n"), per_index);
9052       break;
9053
9054     default:
9055       error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9056              filedata->file_header.e_machine);
9057       res = FALSE;
9058     }
9059
9060   /* Decode the descriptors.  Not implemented.  */
9061
9062   return res;
9063 }
9064
9065 static bfd_boolean
9066 dump_arm_unwind (Filedata *                 filedata,
9067                  struct arm_unw_aux_info *  aux,
9068                  Elf_Internal_Shdr *        exidx_sec)
9069 {
9070   struct arm_section exidx_arm_sec, extab_arm_sec;
9071   unsigned int i, exidx_len;
9072   unsigned long j, nfuns;
9073   bfd_boolean res = TRUE;
9074
9075   memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9076   memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9077   exidx_len = exidx_sec->sh_size / 8;
9078
9079   aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9080   for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9081     if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9082       aux->funtab[nfuns++] = aux->symtab[j];
9083   aux->nfuns = nfuns;
9084   qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9085
9086   for (i = 0; i < exidx_len; i++)
9087     {
9088       unsigned int exidx_fn, exidx_entry;
9089       struct absaddr fn_addr, entry_addr;
9090       bfd_vma fn;
9091
9092       fputc ('\n', stdout);
9093
9094       if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9095                                      8 * i, & exidx_fn, & fn_addr, NULL)
9096           || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9097                                         8 * i + 4, & exidx_entry, & entry_addr, NULL))
9098         {
9099           free (aux->funtab);
9100           arm_free_section (& exidx_arm_sec);
9101           arm_free_section (& extab_arm_sec);
9102           return FALSE;
9103         }
9104
9105       /* ARM EHABI, Section 5:
9106          An index table entry consists of 2 words.
9107          The first word contains a prel31 offset to the start of a function, with bit 31 clear.  */
9108       if (exidx_fn & 0x80000000)
9109         {
9110           warn (_("corrupt index table entry: %x\n"), exidx_fn);
9111           res = FALSE;
9112         }
9113
9114       fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9115
9116       arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9117       fputs (": ", stdout);
9118
9119       if (exidx_entry == 1)
9120         {
9121           print_vma (exidx_entry, PREFIX_HEX);
9122           fputs (" [cantunwind]\n", stdout);
9123         }
9124       else if (exidx_entry & 0x80000000)
9125         {
9126           print_vma (exidx_entry, PREFIX_HEX);
9127           fputc ('\n', stdout);
9128           decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9129         }
9130       else
9131         {
9132           bfd_vma table, table_offset = 0;
9133           Elf_Internal_Shdr *table_sec;
9134
9135           fputs ("@", stdout);
9136           table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9137           print_vma (table, PREFIX_HEX);
9138           printf ("\n");
9139
9140           /* Locate the matching .ARM.extab.  */
9141           if (entry_addr.section != SHN_UNDEF
9142               && entry_addr.section < filedata->file_header.e_shnum)
9143             {
9144               table_sec = filedata->section_headers + entry_addr.section;
9145               table_offset = entry_addr.offset;
9146               /* PR 18879 */
9147               if (table_offset > table_sec->sh_size
9148                   || ((bfd_signed_vma) table_offset) < 0)
9149                 {
9150                   warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9151                         (unsigned long) table_offset,
9152                         printable_section_name (filedata, table_sec));
9153                   res = FALSE;
9154                   continue;
9155                 }
9156             }
9157           else
9158             {
9159               table_sec = find_section_by_address (filedata, table);
9160               if (table_sec != NULL)
9161                 table_offset = table - table_sec->sh_addr;
9162             }
9163
9164           if (table_sec == NULL)
9165             {
9166               warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9167                     (unsigned long) table);
9168               res = FALSE;
9169               continue;
9170             }
9171
9172           if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9173                                    &extab_arm_sec))
9174             res = FALSE;
9175         }
9176     }
9177
9178   printf ("\n");
9179
9180   free (aux->funtab);
9181   arm_free_section (&exidx_arm_sec);
9182   arm_free_section (&extab_arm_sec);
9183
9184   return res;
9185 }
9186
9187 /* Used for both ARM and C6X unwinding tables.  */
9188
9189 static bfd_boolean
9190 arm_process_unwind (Filedata * filedata)
9191 {
9192   struct arm_unw_aux_info aux;
9193   Elf_Internal_Shdr *unwsec = NULL;
9194   Elf_Internal_Shdr *strsec;
9195   Elf_Internal_Shdr *sec;
9196   unsigned long i;
9197   unsigned int sec_type;
9198   bfd_boolean res = TRUE;
9199
9200   switch (filedata->file_header.e_machine)
9201     {
9202     case EM_ARM:
9203       sec_type = SHT_ARM_EXIDX;
9204       break;
9205
9206     case EM_TI_C6000:
9207       sec_type = SHT_C6000_UNWIND;
9208       break;
9209
9210     default:
9211       error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9212              filedata->file_header.e_machine);
9213       return FALSE;
9214     }
9215
9216   if (filedata->string_table == NULL)
9217     return FALSE;
9218
9219   memset (& aux, 0, sizeof (aux));
9220   aux.filedata = filedata;
9221
9222   for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9223     {
9224       if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9225         {
9226           aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9227
9228           strsec = filedata->section_headers + sec->sh_link;
9229
9230           /* PR binutils/17531 file: 011-12666-0.004.  */
9231           if (aux.strtab != NULL)
9232             {
9233               error (_("Multiple string tables found in file.\n"));
9234               free (aux.strtab);
9235               res = FALSE;
9236             }
9237           aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9238                                  1, strsec->sh_size, _("string table"));
9239           aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9240         }
9241       else if (sec->sh_type == sec_type)
9242         unwsec = sec;
9243     }
9244
9245   if (unwsec == NULL)
9246     printf (_("\nThere are no unwind sections in this file.\n"));
9247   else
9248     for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9249       {
9250         if (sec->sh_type == sec_type)
9251           {
9252             unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9253             printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9254                               "contains %lu entry:\n",
9255                               "\nUnwind section '%s' at offset 0x%lx "
9256                               "contains %lu entries:\n",
9257                               num_unwind),
9258                     printable_section_name (filedata, sec),
9259                     (unsigned long) sec->sh_offset,
9260                     num_unwind);
9261
9262             if (! dump_arm_unwind (filedata, &aux, sec))
9263               res = FALSE;
9264           }
9265       }
9266
9267   if (aux.symtab)
9268     free (aux.symtab);
9269   if (aux.strtab)
9270     free ((char *) aux.strtab);
9271
9272   return res;
9273 }
9274
9275 static bfd_boolean
9276 process_unwind (Filedata * filedata)
9277 {
9278   struct unwind_handler
9279   {
9280     unsigned int machtype;
9281     bfd_boolean (* handler)(Filedata *);
9282   } handlers[] =
9283   {
9284     { EM_ARM, arm_process_unwind },
9285     { EM_IA_64, ia64_process_unwind },
9286     { EM_PARISC, hppa_process_unwind },
9287     { EM_TI_C6000, arm_process_unwind },
9288     { 0, NULL }
9289   };
9290   int i;
9291
9292   if (!do_unwind)
9293     return TRUE;
9294
9295   for (i = 0; handlers[i].handler != NULL; i++)
9296     if (filedata->file_header.e_machine == handlers[i].machtype)
9297       return handlers[i].handler (filedata);
9298
9299   printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9300           get_machine_name (filedata->file_header.e_machine));
9301   return TRUE;
9302 }
9303
9304 static void
9305 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9306 {
9307   switch (entry->d_tag)
9308     {
9309     case DT_MIPS_FLAGS:
9310       if (entry->d_un.d_val == 0)
9311         printf (_("NONE"));
9312       else
9313         {
9314           static const char * opts[] =
9315           {
9316             "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9317             "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9318             "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9319             "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9320             "RLD_ORDER_SAFE"
9321           };
9322           unsigned int cnt;
9323           bfd_boolean first = TRUE;
9324
9325           for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9326             if (entry->d_un.d_val & (1 << cnt))
9327               {
9328                 printf ("%s%s", first ? "" : " ", opts[cnt]);
9329                 first = FALSE;
9330               }
9331         }
9332       break;
9333
9334     case DT_MIPS_IVERSION:
9335       if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9336         printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9337       else
9338         {
9339           char buf[40];
9340           sprintf_vma (buf, entry->d_un.d_ptr);
9341           /* Note: coded this way so that there is a single string for translation.  */
9342           printf (_("<corrupt: %s>"), buf);
9343         }
9344       break;
9345
9346     case DT_MIPS_TIME_STAMP:
9347       {
9348         char timebuf[128];
9349         struct tm * tmp;
9350         time_t atime = entry->d_un.d_val;
9351
9352         tmp = gmtime (&atime);
9353         /* PR 17531: file: 6accc532.  */
9354         if (tmp == NULL)
9355           snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9356         else
9357           snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9358                     tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9359                     tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9360         printf (_("Time Stamp: %s"), timebuf);
9361       }
9362       break;
9363
9364     case DT_MIPS_RLD_VERSION:
9365     case DT_MIPS_LOCAL_GOTNO:
9366     case DT_MIPS_CONFLICTNO:
9367     case DT_MIPS_LIBLISTNO:
9368     case DT_MIPS_SYMTABNO:
9369     case DT_MIPS_UNREFEXTNO:
9370     case DT_MIPS_HIPAGENO:
9371     case DT_MIPS_DELTA_CLASS_NO:
9372     case DT_MIPS_DELTA_INSTANCE_NO:
9373     case DT_MIPS_DELTA_RELOC_NO:
9374     case DT_MIPS_DELTA_SYM_NO:
9375     case DT_MIPS_DELTA_CLASSSYM_NO:
9376     case DT_MIPS_COMPACT_SIZE:
9377       print_vma (entry->d_un.d_val, DEC);
9378       break;
9379
9380     default:
9381       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9382     }
9383     putchar ('\n');
9384 }
9385
9386 static void
9387 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9388 {
9389   switch (entry->d_tag)
9390     {
9391     case DT_HP_DLD_FLAGS:
9392       {
9393         static struct
9394         {
9395           long int bit;
9396           const char * str;
9397         }
9398         flags[] =
9399         {
9400           { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9401           { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9402           { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9403           { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9404           { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9405           { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9406           { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9407           { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9408           { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9409           { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9410           { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9411           { DT_HP_GST, "HP_GST" },
9412           { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9413           { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9414           { DT_HP_NODELETE, "HP_NODELETE" },
9415           { DT_HP_GROUP, "HP_GROUP" },
9416           { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9417         };
9418         bfd_boolean first = TRUE;
9419         size_t cnt;
9420         bfd_vma val = entry->d_un.d_val;
9421
9422         for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9423           if (val & flags[cnt].bit)
9424             {
9425               if (! first)
9426                 putchar (' ');
9427               fputs (flags[cnt].str, stdout);
9428               first = FALSE;
9429               val ^= flags[cnt].bit;
9430             }
9431
9432         if (val != 0 || first)
9433           {
9434             if (! first)
9435               putchar (' ');
9436             print_vma (val, HEX);
9437           }
9438       }
9439       break;
9440
9441     default:
9442       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9443       break;
9444     }
9445   putchar ('\n');
9446 }
9447
9448 #ifdef BFD64
9449
9450 /* VMS vs Unix time offset and factor.  */
9451
9452 #define VMS_EPOCH_OFFSET 35067168000000000LL
9453 #define VMS_GRANULARITY_FACTOR 10000000
9454
9455 /* Display a VMS time in a human readable format.  */
9456
9457 static void
9458 print_vms_time (bfd_int64_t vmstime)
9459 {
9460   struct tm *tm;
9461   time_t unxtime;
9462
9463   unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9464   tm = gmtime (&unxtime);
9465   printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9466           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9467           tm->tm_hour, tm->tm_min, tm->tm_sec);
9468 }
9469 #endif /* BFD64 */
9470
9471 static void
9472 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9473 {
9474   switch (entry->d_tag)
9475     {
9476     case DT_IA_64_PLT_RESERVE:
9477       /* First 3 slots reserved.  */
9478       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9479       printf (" -- ");
9480       print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9481       break;
9482
9483     case DT_IA_64_VMS_LINKTIME:
9484 #ifdef BFD64
9485       print_vms_time (entry->d_un.d_val);
9486 #endif
9487       break;
9488
9489     case DT_IA_64_VMS_LNKFLAGS:
9490       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9491       if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9492         printf (" CALL_DEBUG");
9493       if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9494         printf (" NOP0BUFS");
9495       if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9496         printf (" P0IMAGE");
9497       if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9498         printf (" MKTHREADS");
9499       if (entry->d_un.d_val & VMS_LF_UPCALLS)
9500         printf (" UPCALLS");
9501       if (entry->d_un.d_val & VMS_LF_IMGSTA)
9502         printf (" IMGSTA");
9503       if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9504         printf (" INITIALIZE");
9505       if (entry->d_un.d_val & VMS_LF_MAIN)
9506         printf (" MAIN");
9507       if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9508         printf (" EXE_INIT");
9509       if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9510         printf (" TBK_IN_IMG");
9511       if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9512         printf (" DBG_IN_IMG");
9513       if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9514         printf (" TBK_IN_DSF");
9515       if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9516         printf (" DBG_IN_DSF");
9517       if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9518         printf (" SIGNATURES");
9519       if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9520         printf (" REL_SEG_OFF");
9521       break;
9522
9523     default:
9524       print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9525       break;
9526     }
9527   putchar ('\n');
9528 }
9529
9530 static bfd_boolean
9531 get_32bit_dynamic_section (Filedata * filedata)
9532 {
9533   Elf32_External_Dyn * edyn;
9534   Elf32_External_Dyn * ext;
9535   Elf_Internal_Dyn * entry;
9536
9537   edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9538                                           dynamic_size, _("dynamic section"));
9539   if (!edyn)
9540     return FALSE;
9541
9542   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9543      might not have the luxury of section headers.  Look for the DT_NULL
9544      terminator to determine the number of entries.  */
9545   for (ext = edyn, dynamic_nent = 0;
9546        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9547        ext++)
9548     {
9549       dynamic_nent++;
9550       if (BYTE_GET (ext->d_tag) == DT_NULL)
9551         break;
9552     }
9553
9554   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9555                                                   sizeof (* entry));
9556   if (dynamic_section == NULL)
9557     {
9558       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9559              (unsigned long) dynamic_nent);
9560       free (edyn);
9561       return FALSE;
9562     }
9563
9564   for (ext = edyn, entry = dynamic_section;
9565        entry < dynamic_section + dynamic_nent;
9566        ext++, entry++)
9567     {
9568       entry->d_tag      = BYTE_GET (ext->d_tag);
9569       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9570     }
9571
9572   free (edyn);
9573
9574   return TRUE;
9575 }
9576
9577 static bfd_boolean
9578 get_64bit_dynamic_section (Filedata * filedata)
9579 {
9580   Elf64_External_Dyn * edyn;
9581   Elf64_External_Dyn * ext;
9582   Elf_Internal_Dyn * entry;
9583
9584   /* Read in the data.  */
9585   edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9586                                           dynamic_size, _("dynamic section"));
9587   if (!edyn)
9588     return FALSE;
9589
9590   /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9591      might not have the luxury of section headers.  Look for the DT_NULL
9592      terminator to determine the number of entries.  */
9593   for (ext = edyn, dynamic_nent = 0;
9594        /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer.  */
9595        (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9596        ext++)
9597     {
9598       dynamic_nent++;
9599       if (BYTE_GET (ext->d_tag) == DT_NULL)
9600         break;
9601     }
9602
9603   dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9604                                                   sizeof (* entry));
9605   if (dynamic_section == NULL)
9606     {
9607       error (_("Out of memory allocating space for %lu dynamic entries\n"),
9608              (unsigned long) dynamic_nent);
9609       free (edyn);
9610       return FALSE;
9611     }
9612
9613   /* Convert from external to internal formats.  */
9614   for (ext = edyn, entry = dynamic_section;
9615        entry < dynamic_section + dynamic_nent;
9616        ext++, entry++)
9617     {
9618       entry->d_tag      = BYTE_GET (ext->d_tag);
9619       entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9620     }
9621
9622   free (edyn);
9623
9624   return TRUE;
9625 }
9626
9627 static void
9628 print_dynamic_flags (bfd_vma flags)
9629 {
9630   bfd_boolean first = TRUE;
9631
9632   while (flags)
9633     {
9634       bfd_vma flag;
9635
9636       flag = flags & - flags;
9637       flags &= ~ flag;
9638
9639       if (first)
9640         first = FALSE;
9641       else
9642         putc (' ', stdout);
9643
9644       switch (flag)
9645         {
9646         case DF_ORIGIN:         fputs ("ORIGIN", stdout); break;
9647         case DF_SYMBOLIC:       fputs ("SYMBOLIC", stdout); break;
9648         case DF_TEXTREL:        fputs ("TEXTREL", stdout); break;
9649         case DF_BIND_NOW:       fputs ("BIND_NOW", stdout); break;
9650         case DF_STATIC_TLS:     fputs ("STATIC_TLS", stdout); break;
9651         default:                fputs (_("unknown"), stdout); break;
9652         }
9653     }
9654   puts ("");
9655 }
9656
9657 /* Parse and display the contents of the dynamic section.  */
9658
9659 static bfd_boolean
9660 process_dynamic_section (Filedata * filedata)
9661 {
9662   Elf_Internal_Dyn * entry;
9663
9664   if (dynamic_size == 0)
9665     {
9666       if (do_dynamic)
9667         printf (_("\nThere is no dynamic section in this file.\n"));
9668
9669       return TRUE;
9670     }
9671
9672   if (is_32bit_elf)
9673     {
9674       if (! get_32bit_dynamic_section (filedata))
9675         return FALSE;
9676     }
9677   else
9678     {
9679       if (! get_64bit_dynamic_section (filedata))
9680         return FALSE;
9681     }
9682
9683   /* Find the appropriate symbol table.  */
9684   if (dynamic_symbols == NULL)
9685     {
9686       for (entry = dynamic_section;
9687            entry < dynamic_section + dynamic_nent;
9688            ++entry)
9689         {
9690           Elf_Internal_Shdr section;
9691
9692           if (entry->d_tag != DT_SYMTAB)
9693             continue;
9694
9695           dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9696
9697           /* Since we do not know how big the symbol table is,
9698              we default to reading in the entire file (!) and
9699              processing that.  This is overkill, I know, but it
9700              should work.  */
9701           section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9702           if ((bfd_size_type) section.sh_offset > filedata->file_size)
9703             {
9704               /* See PR 21379 for a reproducer.  */
9705               error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9706               return FALSE;
9707             }
9708
9709           if (archive_file_offset != 0)
9710             section.sh_size = archive_file_size - section.sh_offset;
9711           else
9712             section.sh_size = filedata->file_size - section.sh_offset;
9713
9714           if (is_32bit_elf)
9715             section.sh_entsize = sizeof (Elf32_External_Sym);
9716           else
9717             section.sh_entsize = sizeof (Elf64_External_Sym);
9718           section.sh_name = filedata->string_table_length;
9719
9720           if (dynamic_symbols != NULL)
9721             {
9722               error (_("Multiple dynamic symbol table sections found\n"));
9723               free (dynamic_symbols);
9724             }
9725           dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9726           if (num_dynamic_syms < 1)
9727             {
9728               error (_("Unable to determine the number of symbols to load\n"));
9729               continue;
9730             }
9731         }
9732     }
9733
9734   /* Similarly find a string table.  */
9735   if (dynamic_strings == NULL)
9736     {
9737       for (entry = dynamic_section;
9738            entry < dynamic_section + dynamic_nent;
9739            ++entry)
9740         {
9741           unsigned long offset;
9742           long str_tab_len;
9743
9744           if (entry->d_tag != DT_STRTAB)
9745             continue;
9746
9747           dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9748
9749           /* Since we do not know how big the string table is,
9750              we default to reading in the entire file (!) and
9751              processing that.  This is overkill, I know, but it
9752              should work.  */
9753
9754           offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9755
9756           if (archive_file_offset != 0)
9757             str_tab_len = archive_file_size - offset;
9758           else
9759             str_tab_len = filedata->file_size - offset;
9760
9761           if (str_tab_len < 1)
9762             {
9763               error
9764                 (_("Unable to determine the length of the dynamic string table\n"));
9765               continue;
9766             }
9767
9768           if (dynamic_strings != NULL)
9769             {
9770               error (_("Multiple dynamic string tables found\n"));
9771               free (dynamic_strings);
9772             }
9773
9774           dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9775                                                str_tab_len,
9776                                                _("dynamic string table"));
9777           dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9778         }
9779     }
9780
9781   /* And find the syminfo section if available.  */
9782   if (dynamic_syminfo == NULL)
9783     {
9784       unsigned long syminsz = 0;
9785
9786       for (entry = dynamic_section;
9787            entry < dynamic_section + dynamic_nent;
9788            ++entry)
9789         {
9790           if (entry->d_tag == DT_SYMINENT)
9791             {
9792               /* Note: these braces are necessary to avoid a syntax
9793                  error from the SunOS4 C compiler.  */
9794               /* PR binutils/17531: A corrupt file can trigger this test.
9795                  So do not use an assert, instead generate an error message.  */
9796               if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9797                 error (_("Bad value (%d) for SYMINENT entry\n"),
9798                        (int) entry->d_un.d_val);
9799             }
9800           else if (entry->d_tag == DT_SYMINSZ)
9801             syminsz = entry->d_un.d_val;
9802           else if (entry->d_tag == DT_SYMINFO)
9803             dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9804                                                       syminsz);
9805         }
9806
9807       if (dynamic_syminfo_offset != 0 && syminsz != 0)
9808         {
9809           Elf_External_Syminfo * extsyminfo;
9810           Elf_External_Syminfo * extsym;
9811           Elf_Internal_Syminfo * syminfo;
9812
9813           /* There is a syminfo section.  Read the data.  */
9814           extsyminfo = (Elf_External_Syminfo *)
9815               get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9816                         _("symbol information"));
9817           if (!extsyminfo)
9818             return FALSE;
9819
9820           if (dynamic_syminfo != NULL)
9821             {
9822               error (_("Multiple dynamic symbol information sections found\n"));
9823               free (dynamic_syminfo);
9824             }
9825           dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9826           if (dynamic_syminfo == NULL)
9827             {
9828               error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9829                      (unsigned long) syminsz);
9830               return FALSE;
9831             }
9832
9833           dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9834           for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9835                syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9836                ++syminfo, ++extsym)
9837             {
9838               syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9839               syminfo->si_flags = BYTE_GET (extsym->si_flags);
9840             }
9841
9842           free (extsyminfo);
9843         }
9844     }
9845
9846   if (do_dynamic && dynamic_addr)
9847     printf (ngettext ("\nDynamic section at offset 0x%lx "
9848                       "contains %lu entry:\n",
9849                       "\nDynamic section at offset 0x%lx "
9850                       "contains %lu entries:\n",
9851                       dynamic_nent),
9852             dynamic_addr, (unsigned long) dynamic_nent);
9853   if (do_dynamic)
9854     printf (_("  Tag        Type                         Name/Value\n"));
9855
9856   for (entry = dynamic_section;
9857        entry < dynamic_section + dynamic_nent;
9858        entry++)
9859     {
9860       if (do_dynamic)
9861         {
9862           const char * dtype;
9863
9864           putchar (' ');
9865           print_vma (entry->d_tag, FULL_HEX);
9866           dtype = get_dynamic_type (filedata, entry->d_tag);
9867           printf (" (%s)%*s", dtype,
9868                   ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9869         }
9870
9871       switch (entry->d_tag)
9872         {
9873         case DT_FLAGS:
9874           if (do_dynamic)
9875             print_dynamic_flags (entry->d_un.d_val);
9876           break;
9877
9878         case DT_AUXILIARY:
9879         case DT_FILTER:
9880         case DT_CONFIG:
9881         case DT_DEPAUDIT:
9882         case DT_AUDIT:
9883           if (do_dynamic)
9884             {
9885               switch (entry->d_tag)
9886                 {
9887                 case DT_AUXILIARY:
9888                   printf (_("Auxiliary library"));
9889                   break;
9890
9891                 case DT_FILTER:
9892                   printf (_("Filter library"));
9893                   break;
9894
9895                 case DT_CONFIG:
9896                   printf (_("Configuration file"));
9897                   break;
9898
9899                 case DT_DEPAUDIT:
9900                   printf (_("Dependency audit library"));
9901                   break;
9902
9903                 case DT_AUDIT:
9904                   printf (_("Audit library"));
9905                   break;
9906                 }
9907
9908               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9909                 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9910               else
9911                 {
9912                   printf (": ");
9913                   print_vma (entry->d_un.d_val, PREFIX_HEX);
9914                   putchar ('\n');
9915                 }
9916             }
9917           break;
9918
9919         case DT_FEATURE:
9920           if (do_dynamic)
9921             {
9922               printf (_("Flags:"));
9923
9924               if (entry->d_un.d_val == 0)
9925                 printf (_(" None\n"));
9926               else
9927                 {
9928                   unsigned long int val = entry->d_un.d_val;
9929
9930                   if (val & DTF_1_PARINIT)
9931                     {
9932                       printf (" PARINIT");
9933                       val ^= DTF_1_PARINIT;
9934                     }
9935                   if (val & DTF_1_CONFEXP)
9936                     {
9937                       printf (" CONFEXP");
9938                       val ^= DTF_1_CONFEXP;
9939                     }
9940                   if (val != 0)
9941                     printf (" %lx", val);
9942                   puts ("");
9943                 }
9944             }
9945           break;
9946
9947         case DT_POSFLAG_1:
9948           if (do_dynamic)
9949             {
9950               printf (_("Flags:"));
9951
9952               if (entry->d_un.d_val == 0)
9953                 printf (_(" None\n"));
9954               else
9955                 {
9956                   unsigned long int val = entry->d_un.d_val;
9957
9958                   if (val & DF_P1_LAZYLOAD)
9959                     {
9960                       printf (" LAZYLOAD");
9961                       val ^= DF_P1_LAZYLOAD;
9962                     }
9963                   if (val & DF_P1_GROUPPERM)
9964                     {
9965                       printf (" GROUPPERM");
9966                       val ^= DF_P1_GROUPPERM;
9967                     }
9968                   if (val != 0)
9969                     printf (" %lx", val);
9970                   puts ("");
9971                 }
9972             }
9973           break;
9974
9975         case DT_FLAGS_1:
9976           if (do_dynamic)
9977             {
9978               printf (_("Flags:"));
9979               if (entry->d_un.d_val == 0)
9980                 printf (_(" None\n"));
9981               else
9982                 {
9983                   unsigned long int val = entry->d_un.d_val;
9984
9985                   if (val & DF_1_NOW)
9986                     {
9987                       printf (" NOW");
9988                       val ^= DF_1_NOW;
9989                     }
9990                   if (val & DF_1_GLOBAL)
9991                     {
9992                       printf (" GLOBAL");
9993                       val ^= DF_1_GLOBAL;
9994                     }
9995                   if (val & DF_1_GROUP)
9996                     {
9997                       printf (" GROUP");
9998                       val ^= DF_1_GROUP;
9999                     }
10000                   if (val & DF_1_NODELETE)
10001                     {
10002                       printf (" NODELETE");
10003                       val ^= DF_1_NODELETE;
10004                     }
10005                   if (val & DF_1_LOADFLTR)
10006                     {
10007                       printf (" LOADFLTR");
10008                       val ^= DF_1_LOADFLTR;
10009                     }
10010                   if (val & DF_1_INITFIRST)
10011                     {
10012                       printf (" INITFIRST");
10013                       val ^= DF_1_INITFIRST;
10014                     }
10015                   if (val & DF_1_NOOPEN)
10016                     {
10017                       printf (" NOOPEN");
10018                       val ^= DF_1_NOOPEN;
10019                     }
10020                   if (val & DF_1_ORIGIN)
10021                     {
10022                       printf (" ORIGIN");
10023                       val ^= DF_1_ORIGIN;
10024                     }
10025                   if (val & DF_1_DIRECT)
10026                     {
10027                       printf (" DIRECT");
10028                       val ^= DF_1_DIRECT;
10029                     }
10030                   if (val & DF_1_TRANS)
10031                     {
10032                       printf (" TRANS");
10033                       val ^= DF_1_TRANS;
10034                     }
10035                   if (val & DF_1_INTERPOSE)
10036                     {
10037                       printf (" INTERPOSE");
10038                       val ^= DF_1_INTERPOSE;
10039                     }
10040                   if (val & DF_1_NODEFLIB)
10041                     {
10042                       printf (" NODEFLIB");
10043                       val ^= DF_1_NODEFLIB;
10044                     }
10045                   if (val & DF_1_NODUMP)
10046                     {
10047                       printf (" NODUMP");
10048                       val ^= DF_1_NODUMP;
10049                     }
10050                   if (val & DF_1_CONFALT)
10051                     {
10052                       printf (" CONFALT");
10053                       val ^= DF_1_CONFALT;
10054                     }
10055                   if (val & DF_1_ENDFILTEE)
10056                     {
10057                       printf (" ENDFILTEE");
10058                       val ^= DF_1_ENDFILTEE;
10059                     }
10060                   if (val & DF_1_DISPRELDNE)
10061                     {
10062                       printf (" DISPRELDNE");
10063                       val ^= DF_1_DISPRELDNE;
10064                     }
10065                   if (val & DF_1_DISPRELPND)
10066                     {
10067                       printf (" DISPRELPND");
10068                       val ^= DF_1_DISPRELPND;
10069                     }
10070                   if (val & DF_1_NODIRECT)
10071                     {
10072                       printf (" NODIRECT");
10073                       val ^= DF_1_NODIRECT;
10074                     }
10075                   if (val & DF_1_IGNMULDEF)
10076                     {
10077                       printf (" IGNMULDEF");
10078                       val ^= DF_1_IGNMULDEF;
10079                     }
10080                   if (val & DF_1_NOKSYMS)
10081                     {
10082                       printf (" NOKSYMS");
10083                       val ^= DF_1_NOKSYMS;
10084                     }
10085                   if (val & DF_1_NOHDR)
10086                     {
10087                       printf (" NOHDR");
10088                       val ^= DF_1_NOHDR;
10089                     }
10090                   if (val & DF_1_EDITED)
10091                     {
10092                       printf (" EDITED");
10093                       val ^= DF_1_EDITED;
10094                     }
10095                   if (val & DF_1_NORELOC)
10096                     {
10097                       printf (" NORELOC");
10098                       val ^= DF_1_NORELOC;
10099                     }
10100                   if (val & DF_1_SYMINTPOSE)
10101                     {
10102                       printf (" SYMINTPOSE");
10103                       val ^= DF_1_SYMINTPOSE;
10104                     }
10105                   if (val & DF_1_GLOBAUDIT)
10106                     {
10107                       printf (" GLOBAUDIT");
10108                       val ^= DF_1_GLOBAUDIT;
10109                     }
10110                   if (val & DF_1_SINGLETON)
10111                     {
10112                       printf (" SINGLETON");
10113                       val ^= DF_1_SINGLETON;
10114                     }
10115                   if (val & DF_1_STUB)
10116                     {
10117                       printf (" STUB");
10118                       val ^= DF_1_STUB;
10119                     }
10120                   if (val & DF_1_PIE)
10121                     {
10122                       printf (" PIE");
10123                       val ^= DF_1_PIE;
10124                     }
10125                   if (val & DF_1_KMOD)
10126                     {
10127                       printf (" KMOD");
10128                       val ^= DF_1_KMOD;
10129                     }
10130                   if (val & DF_1_WEAKFILTER)
10131                     {
10132                       printf (" WEAKFILTER");
10133                       val ^= DF_1_WEAKFILTER;
10134                     }
10135                   if (val & DF_1_NOCOMMON)
10136                     {
10137                       printf (" NOCOMMON");
10138                       val ^= DF_1_NOCOMMON;
10139                     }
10140                   if (val != 0)
10141                     printf (" %lx", val);
10142                   puts ("");
10143                 }
10144             }
10145           break;
10146
10147         case DT_PLTREL:
10148           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10149           if (do_dynamic)
10150             puts (get_dynamic_type (filedata, entry->d_un.d_val));
10151           break;
10152
10153         case DT_NULL    :
10154         case DT_NEEDED  :
10155         case DT_PLTGOT  :
10156         case DT_HASH    :
10157         case DT_STRTAB  :
10158         case DT_SYMTAB  :
10159         case DT_RELA    :
10160         case DT_INIT    :
10161         case DT_FINI    :
10162         case DT_SONAME  :
10163         case DT_RPATH   :
10164         case DT_SYMBOLIC:
10165         case DT_REL     :
10166         case DT_DEBUG   :
10167         case DT_TEXTREL :
10168         case DT_JMPREL  :
10169         case DT_RUNPATH :
10170           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10171
10172           if (do_dynamic)
10173             {
10174               char * name;
10175
10176               if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10177                 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10178               else
10179                 name = NULL;
10180
10181               if (name)
10182                 {
10183                   switch (entry->d_tag)
10184                     {
10185                     case DT_NEEDED:
10186                       printf (_("Shared library: [%s]"), name);
10187
10188                       if (streq (name, program_interpreter))
10189                         printf (_(" program interpreter"));
10190                       break;
10191
10192                     case DT_SONAME:
10193                       printf (_("Library soname: [%s]"), name);
10194                       break;
10195
10196                     case DT_RPATH:
10197                       printf (_("Library rpath: [%s]"), name);
10198                       break;
10199
10200                     case DT_RUNPATH:
10201                       printf (_("Library runpath: [%s]"), name);
10202                       break;
10203
10204                     default:
10205                       print_vma (entry->d_un.d_val, PREFIX_HEX);
10206                       break;
10207                     }
10208                 }
10209               else
10210                 print_vma (entry->d_un.d_val, PREFIX_HEX);
10211
10212               putchar ('\n');
10213             }
10214           break;
10215
10216         case DT_PLTRELSZ:
10217         case DT_RELASZ  :
10218         case DT_STRSZ   :
10219         case DT_RELSZ   :
10220         case DT_RELAENT :
10221         case DT_SYMENT  :
10222         case DT_RELENT  :
10223           dynamic_info[entry->d_tag] = entry->d_un.d_val;
10224           /* Fall through.  */
10225         case DT_PLTPADSZ:
10226         case DT_MOVEENT :
10227         case DT_MOVESZ  :
10228         case DT_INIT_ARRAYSZ:
10229         case DT_FINI_ARRAYSZ:
10230         case DT_GNU_CONFLICTSZ:
10231         case DT_GNU_LIBLISTSZ:
10232           if (do_dynamic)
10233             {
10234               print_vma (entry->d_un.d_val, UNSIGNED);
10235               printf (_(" (bytes)\n"));
10236             }
10237           break;
10238
10239         case DT_VERDEFNUM:
10240         case DT_VERNEEDNUM:
10241         case DT_RELACOUNT:
10242         case DT_RELCOUNT:
10243           if (do_dynamic)
10244             {
10245               print_vma (entry->d_un.d_val, UNSIGNED);
10246               putchar ('\n');
10247             }
10248           break;
10249
10250         case DT_SYMINSZ:
10251         case DT_SYMINENT:
10252         case DT_SYMINFO:
10253         case DT_USED:
10254         case DT_INIT_ARRAY:
10255         case DT_FINI_ARRAY:
10256           if (do_dynamic)
10257             {
10258               if (entry->d_tag == DT_USED
10259                   && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10260                 {
10261                   char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10262
10263                   if (*name)
10264                     {
10265                       printf (_("Not needed object: [%s]\n"), name);
10266                       break;
10267                     }
10268                 }
10269
10270               print_vma (entry->d_un.d_val, PREFIX_HEX);
10271               putchar ('\n');
10272             }
10273           break;
10274
10275         case DT_BIND_NOW:
10276           /* The value of this entry is ignored.  */
10277           if (do_dynamic)
10278             putchar ('\n');
10279           break;
10280
10281         case DT_GNU_PRELINKED:
10282           if (do_dynamic)
10283             {
10284               struct tm * tmp;
10285               time_t atime = entry->d_un.d_val;
10286
10287               tmp = gmtime (&atime);
10288               /* PR 17533 file: 041-1244816-0.004.  */
10289               if (tmp == NULL)
10290                 printf (_("<corrupt time val: %lx"),
10291                         (unsigned long) atime);
10292               else
10293                 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10294                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10295                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10296
10297             }
10298           break;
10299
10300         case DT_GNU_HASH:
10301           dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10302           if (do_dynamic)
10303             {
10304               print_vma (entry->d_un.d_val, PREFIX_HEX);
10305               putchar ('\n');
10306             }
10307           break;
10308
10309         default:
10310           if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10311             version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10312               entry->d_un.d_val;
10313
10314           if (do_dynamic)
10315             {
10316               switch (filedata->file_header.e_machine)
10317                 {
10318                 case EM_MIPS:
10319                 case EM_MIPS_RS3_LE:
10320                   dynamic_section_mips_val (entry);
10321                   break;
10322                 case EM_PARISC:
10323                   dynamic_section_parisc_val (entry);
10324                   break;
10325                 case EM_IA_64:
10326                   dynamic_section_ia64_val (entry);
10327                   break;
10328                 default:
10329                   print_vma (entry->d_un.d_val, PREFIX_HEX);
10330                   putchar ('\n');
10331                 }
10332             }
10333           break;
10334         }
10335     }
10336
10337   return TRUE;
10338 }
10339
10340 static char *
10341 get_ver_flags (unsigned int flags)
10342 {
10343   static char buff[128];
10344
10345   buff[0] = 0;
10346
10347   if (flags == 0)
10348     return _("none");
10349
10350   if (flags & VER_FLG_BASE)
10351     strcat (buff, "BASE");
10352
10353   if (flags & VER_FLG_WEAK)
10354     {
10355       if (flags & VER_FLG_BASE)
10356         strcat (buff, " | ");
10357
10358       strcat (buff, "WEAK");
10359     }
10360
10361   if (flags & VER_FLG_INFO)
10362     {
10363       if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10364         strcat (buff, " | ");
10365
10366       strcat (buff, "INFO");
10367     }
10368
10369   if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10370     {
10371       if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10372         strcat (buff, " | ");
10373
10374       strcat (buff, _("<unknown>"));
10375     }
10376
10377   return buff;
10378 }
10379
10380 /* Display the contents of the version sections.  */
10381
10382 static bfd_boolean
10383 process_version_sections (Filedata * filedata)
10384 {
10385   Elf_Internal_Shdr * section;
10386   unsigned i;
10387   bfd_boolean found = FALSE;
10388
10389   if (! do_version)
10390     return TRUE;
10391
10392   for (i = 0, section = filedata->section_headers;
10393        i < filedata->file_header.e_shnum;
10394        i++, section++)
10395     {
10396       switch (section->sh_type)
10397         {
10398         case SHT_GNU_verdef:
10399           {
10400             Elf_External_Verdef * edefs;
10401             unsigned long idx;
10402             unsigned long cnt;
10403             char * endbuf;
10404
10405             found = TRUE;
10406
10407             printf (ngettext ("\nVersion definition section '%s' "
10408                               "contains %u entry:\n",
10409                               "\nVersion definition section '%s' "
10410                               "contains %u entries:\n",
10411                               section->sh_info),
10412                     printable_section_name (filedata, section),
10413                     section->sh_info);
10414
10415             printf (_("  Addr: 0x"));
10416             printf_vma (section->sh_addr);
10417             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10418                     (unsigned long) section->sh_offset, section->sh_link,
10419                     printable_section_name_from_index (filedata, section->sh_link));
10420
10421             edefs = (Elf_External_Verdef *)
10422                 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10423                           _("version definition section"));
10424             if (!edefs)
10425               break;
10426             endbuf = (char *) edefs + section->sh_size;
10427
10428             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10429               {
10430                 char * vstart;
10431                 Elf_External_Verdef * edef;
10432                 Elf_Internal_Verdef ent;
10433                 Elf_External_Verdaux * eaux;
10434                 Elf_Internal_Verdaux aux;
10435                 unsigned long isum;
10436                 int j;
10437
10438                 vstart = ((char *) edefs) + idx;
10439                 if (vstart + sizeof (*edef) > endbuf)
10440                   break;
10441
10442                 edef = (Elf_External_Verdef *) vstart;
10443
10444                 ent.vd_version = BYTE_GET (edef->vd_version);
10445                 ent.vd_flags   = BYTE_GET (edef->vd_flags);
10446                 ent.vd_ndx     = BYTE_GET (edef->vd_ndx);
10447                 ent.vd_cnt     = BYTE_GET (edef->vd_cnt);
10448                 ent.vd_hash    = BYTE_GET (edef->vd_hash);
10449                 ent.vd_aux     = BYTE_GET (edef->vd_aux);
10450                 ent.vd_next    = BYTE_GET (edef->vd_next);
10451
10452                 printf (_("  %#06lx: Rev: %d  Flags: %s"),
10453                         idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10454
10455                 printf (_("  Index: %d  Cnt: %d  "),
10456                         ent.vd_ndx, ent.vd_cnt);
10457
10458                 /* Check for overflow.  */
10459                 if (ent.vd_aux > (size_t) (endbuf - vstart))
10460                   break;
10461
10462                 vstart += ent.vd_aux;
10463
10464                 if (vstart + sizeof (*eaux) > endbuf)
10465                   break;
10466                 eaux = (Elf_External_Verdaux *) vstart;
10467
10468                 aux.vda_name = BYTE_GET (eaux->vda_name);
10469                 aux.vda_next = BYTE_GET (eaux->vda_next);
10470
10471                 if (VALID_DYNAMIC_NAME (aux.vda_name))
10472                   printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10473                 else
10474                   printf (_("Name index: %ld\n"), aux.vda_name);
10475
10476                 isum = idx + ent.vd_aux;
10477
10478                 for (j = 1; j < ent.vd_cnt; j++)
10479                   {
10480                     if (aux.vda_next < sizeof (*eaux)
10481                         && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10482                       {
10483                         warn (_("Invalid vda_next field of %lx\n"),
10484                               aux.vda_next);
10485                         j = ent.vd_cnt;
10486                         break;
10487                       }
10488                     /* Check for overflow.  */
10489                     if (aux.vda_next > (size_t) (endbuf - vstart))
10490                       break;
10491
10492                     isum   += aux.vda_next;
10493                     vstart += aux.vda_next;
10494
10495                     if (vstart + sizeof (*eaux) > endbuf)
10496                       break;
10497                     eaux = (Elf_External_Verdaux *) vstart;
10498
10499                     aux.vda_name = BYTE_GET (eaux->vda_name);
10500                     aux.vda_next = BYTE_GET (eaux->vda_next);
10501
10502                     if (VALID_DYNAMIC_NAME (aux.vda_name))
10503                       printf (_("  %#06lx: Parent %d: %s\n"),
10504                               isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10505                     else
10506                       printf (_("  %#06lx: Parent %d, name index: %ld\n"),
10507                               isum, j, aux.vda_name);
10508                   }
10509
10510                 if (j < ent.vd_cnt)
10511                   printf (_("  Version def aux past end of section\n"));
10512
10513                 /* PR 17531:
10514                    file: id:000001,src:000172+005151,op:splice,rep:2.  */
10515                 if (ent.vd_next < sizeof (*edef)
10516                     && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10517                   {
10518                     warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10519                     cnt = section->sh_info;
10520                     break;
10521                   }
10522                 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10523                   break;
10524
10525                 idx += ent.vd_next;
10526               }
10527
10528             if (cnt < section->sh_info)
10529               printf (_("  Version definition past end of section\n"));
10530
10531             free (edefs);
10532           }
10533           break;
10534
10535         case SHT_GNU_verneed:
10536           {
10537             Elf_External_Verneed * eneed;
10538             unsigned long idx;
10539             unsigned long cnt;
10540             char * endbuf;
10541
10542             found = TRUE;
10543
10544             printf (ngettext ("\nVersion needs section '%s' "
10545                               "contains %u entry:\n",
10546                               "\nVersion needs section '%s' "
10547                               "contains %u entries:\n",
10548                               section->sh_info),
10549                     printable_section_name (filedata, section), section->sh_info);
10550
10551             printf (_(" Addr: 0x"));
10552             printf_vma (section->sh_addr);
10553             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10554                     (unsigned long) section->sh_offset, section->sh_link,
10555                     printable_section_name_from_index (filedata, section->sh_link));
10556
10557             eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10558                                                        section->sh_offset, 1,
10559                                                        section->sh_size,
10560                                                        _("Version Needs section"));
10561             if (!eneed)
10562               break;
10563             endbuf = (char *) eneed + section->sh_size;
10564
10565             for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10566               {
10567                 Elf_External_Verneed * entry;
10568                 Elf_Internal_Verneed ent;
10569                 unsigned long isum;
10570                 int j;
10571                 char * vstart;
10572
10573                 vstart = ((char *) eneed) + idx;
10574                 if (vstart + sizeof (*entry) > endbuf)
10575                   break;
10576
10577                 entry = (Elf_External_Verneed *) vstart;
10578
10579                 ent.vn_version = BYTE_GET (entry->vn_version);
10580                 ent.vn_cnt     = BYTE_GET (entry->vn_cnt);
10581                 ent.vn_file    = BYTE_GET (entry->vn_file);
10582                 ent.vn_aux     = BYTE_GET (entry->vn_aux);
10583                 ent.vn_next    = BYTE_GET (entry->vn_next);
10584
10585                 printf (_("  %#06lx: Version: %d"), idx, ent.vn_version);
10586
10587                 if (VALID_DYNAMIC_NAME (ent.vn_file))
10588                   printf (_("  File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10589                 else
10590                   printf (_("  File: %lx"), ent.vn_file);
10591
10592                 printf (_("  Cnt: %d\n"), ent.vn_cnt);
10593
10594                 /* Check for overflow.  */
10595                 if (ent.vn_aux > (size_t) (endbuf - vstart))
10596                   break;
10597                 vstart += ent.vn_aux;
10598
10599                 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10600                   {
10601                     Elf_External_Vernaux * eaux;
10602                     Elf_Internal_Vernaux aux;
10603
10604                     if (vstart + sizeof (*eaux) > endbuf)
10605                       break;
10606                     eaux = (Elf_External_Vernaux *) vstart;
10607
10608                     aux.vna_hash  = BYTE_GET (eaux->vna_hash);
10609                     aux.vna_flags = BYTE_GET (eaux->vna_flags);
10610                     aux.vna_other = BYTE_GET (eaux->vna_other);
10611                     aux.vna_name  = BYTE_GET (eaux->vna_name);
10612                     aux.vna_next  = BYTE_GET (eaux->vna_next);
10613
10614                     if (VALID_DYNAMIC_NAME (aux.vna_name))
10615                       printf (_("  %#06lx:   Name: %s"),
10616                               isum, GET_DYNAMIC_NAME (aux.vna_name));
10617                     else
10618                       printf (_("  %#06lx:   Name index: %lx"),
10619                               isum, aux.vna_name);
10620
10621                     printf (_("  Flags: %s  Version: %d\n"),
10622                             get_ver_flags (aux.vna_flags), aux.vna_other);
10623
10624                     if (aux.vna_next < sizeof (*eaux)
10625                         && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10626                       {
10627                         warn (_("Invalid vna_next field of %lx\n"),
10628                               aux.vna_next);
10629                         j = ent.vn_cnt;
10630                         break;
10631                       }
10632                     /* Check for overflow.  */
10633                     if (aux.vna_next > (size_t) (endbuf - vstart))
10634                       break;
10635                     isum   += aux.vna_next;
10636                     vstart += aux.vna_next;
10637                   }
10638
10639                 if (j < ent.vn_cnt)
10640                   warn (_("Missing Version Needs auxillary information\n"));
10641
10642                 if (ent.vn_next < sizeof (*entry)
10643                     && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10644                   {
10645                     warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10646                     cnt = section->sh_info;
10647                     break;
10648                   }
10649                 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10650                   break;
10651                 idx += ent.vn_next;
10652               }
10653
10654             if (cnt < section->sh_info)
10655               warn (_("Missing Version Needs information\n"));
10656
10657             free (eneed);
10658           }
10659           break;
10660
10661         case SHT_GNU_versym:
10662           {
10663             Elf_Internal_Shdr * link_section;
10664             size_t total;
10665             unsigned int cnt;
10666             unsigned char * edata;
10667             unsigned short * data;
10668             char * strtab;
10669             Elf_Internal_Sym * symbols;
10670             Elf_Internal_Shdr * string_sec;
10671             unsigned long num_syms;
10672             long off;
10673
10674             if (section->sh_link >= filedata->file_header.e_shnum)
10675               break;
10676
10677             link_section = filedata->section_headers + section->sh_link;
10678             total = section->sh_size / sizeof (Elf_External_Versym);
10679
10680             if (link_section->sh_link >= filedata->file_header.e_shnum)
10681               break;
10682
10683             found = TRUE;
10684
10685             symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10686             if (symbols == NULL)
10687               break;
10688
10689             string_sec = filedata->section_headers + link_section->sh_link;
10690
10691             strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10692                                         string_sec->sh_size,
10693                                         _("version string table"));
10694             if (!strtab)
10695               {
10696                 free (symbols);
10697                 break;
10698               }
10699
10700             printf (ngettext ("\nVersion symbols section '%s' "
10701                               "contains %lu entry:\n",
10702                               "\nVersion symbols section '%s' "
10703                               "contains %lu entries:\n",
10704                               total),
10705                     printable_section_name (filedata, section), (unsigned long) total);
10706
10707             printf (_(" Addr: "));
10708             printf_vma (section->sh_addr);
10709             printf (_("  Offset: %#08lx  Link: %u (%s)\n"),
10710                     (unsigned long) section->sh_offset, section->sh_link,
10711                     printable_section_name (filedata, link_section));
10712
10713             off = offset_from_vma (filedata,
10714                                    version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10715                                    total * sizeof (short));
10716             edata = (unsigned char *) get_data (NULL, filedata, off, total,
10717                                                 sizeof (short),
10718                                                 _("version symbol data"));
10719             if (!edata)
10720               {
10721                 free (strtab);
10722                 free (symbols);
10723                 break;
10724               }
10725
10726             data = (short unsigned int *) cmalloc (total, sizeof (short));
10727
10728             for (cnt = total; cnt --;)
10729               data[cnt] = byte_get (edata + cnt * sizeof (short),
10730                                     sizeof (short));
10731
10732             free (edata);
10733
10734             for (cnt = 0; cnt < total; cnt += 4)
10735               {
10736                 int j, nn;
10737                 char *name;
10738                 char *invalid = _("*invalid*");
10739
10740                 printf ("  %03x:", cnt);
10741
10742                 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10743                   switch (data[cnt + j])
10744                     {
10745                     case 0:
10746                       fputs (_("   0 (*local*)    "), stdout);
10747                       break;
10748
10749                     case 1:
10750                       fputs (_("   1 (*global*)   "), stdout);
10751                       break;
10752
10753                     default:
10754                       nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10755                                    data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10756
10757                       /* If this index value is greater than the size of the symbols
10758                          array, break to avoid an out-of-bounds read.  */
10759                       if ((unsigned long)(cnt + j) >= num_syms)
10760                         {
10761                           warn (_("invalid index into symbol array\n"));
10762                           break;
10763                         }
10764
10765                       name = NULL;
10766                       if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10767                         {
10768                           Elf_Internal_Verneed ivn;
10769                           unsigned long offset;
10770
10771                           offset = offset_from_vma
10772                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10773                              sizeof (Elf_External_Verneed));
10774
10775                           do
10776                             {
10777                               Elf_Internal_Vernaux ivna;
10778                               Elf_External_Verneed evn;
10779                               Elf_External_Vernaux evna;
10780                               unsigned long a_off;
10781
10782                               if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10783                                             _("version need")) == NULL)
10784                                 break;
10785
10786                               ivn.vn_aux  = BYTE_GET (evn.vn_aux);
10787                               ivn.vn_next = BYTE_GET (evn.vn_next);
10788
10789                               a_off = offset + ivn.vn_aux;
10790
10791                               do
10792                                 {
10793                                   if (get_data (&evna, filedata, a_off, sizeof (evna),
10794                                                 1, _("version need aux (2)")) == NULL)
10795                                     {
10796                                       ivna.vna_next  = 0;
10797                                       ivna.vna_other = 0;
10798                                     }
10799                                   else
10800                                     {
10801                                       ivna.vna_next  = BYTE_GET (evna.vna_next);
10802                                       ivna.vna_other = BYTE_GET (evna.vna_other);
10803                                     }
10804
10805                                   a_off += ivna.vna_next;
10806                                 }
10807                               while (ivna.vna_other != data[cnt + j]
10808                                      && ivna.vna_next != 0);
10809
10810                               if (ivna.vna_other == data[cnt + j])
10811                                 {
10812                                   ivna.vna_name = BYTE_GET (evna.vna_name);
10813
10814                                   if (ivna.vna_name >= string_sec->sh_size)
10815                                     name = invalid;
10816                                   else
10817                                     name = strtab + ivna.vna_name;
10818                                   break;
10819                                 }
10820
10821                               offset += ivn.vn_next;
10822                             }
10823                           while (ivn.vn_next);
10824                         }
10825
10826                       if (data[cnt + j] != 0x8001
10827                           && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10828                         {
10829                           Elf_Internal_Verdef ivd;
10830                           Elf_External_Verdef evd;
10831                           unsigned long offset;
10832
10833                           offset = offset_from_vma
10834                             (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10835                              sizeof evd);
10836
10837                           do
10838                             {
10839                               if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10840                                             _("version def")) == NULL)
10841                                 {
10842                                   ivd.vd_next = 0;
10843                                   /* PR 17531: file: 046-1082287-0.004.  */
10844                                   ivd.vd_ndx  = (data[cnt + j] & VERSYM_VERSION) + 1;
10845                                   break;
10846                                 }
10847                               else
10848                                 {
10849                                   ivd.vd_next = BYTE_GET (evd.vd_next);
10850                                   ivd.vd_ndx  = BYTE_GET (evd.vd_ndx);
10851                                 }
10852
10853                               offset += ivd.vd_next;
10854                             }
10855                           while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10856                                  && ivd.vd_next != 0);
10857
10858                           if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10859                             {
10860                               Elf_External_Verdaux evda;
10861                               Elf_Internal_Verdaux ivda;
10862
10863                               ivd.vd_aux = BYTE_GET (evd.vd_aux);
10864
10865                               if (get_data (&evda, filedata,
10866                                             offset - ivd.vd_next + ivd.vd_aux,
10867                                             sizeof (evda), 1,
10868                                             _("version def aux")) == NULL)
10869                                 break;
10870
10871                               ivda.vda_name = BYTE_GET (evda.vda_name);
10872
10873                               if (ivda.vda_name >= string_sec->sh_size)
10874                                 name = invalid;
10875                               else if (name != NULL && name != invalid)
10876                                 name = _("*both*");
10877                               else
10878                                 name = strtab + ivda.vda_name;
10879                             }
10880                         }
10881                       if (name != NULL)
10882                         nn += printf ("(%s%-*s",
10883                                       name,
10884                                       12 - (int) strlen (name),
10885                                       ")");
10886
10887                       if (nn < 18)
10888                         printf ("%*c", 18 - nn, ' ');
10889                     }
10890
10891                 putchar ('\n');
10892               }
10893
10894             free (data);
10895             free (strtab);
10896             free (symbols);
10897           }
10898           break;
10899
10900         default:
10901           break;
10902         }
10903     }
10904
10905   if (! found)
10906     printf (_("\nNo version information found in this file.\n"));
10907
10908   return TRUE;
10909 }
10910
10911 static const char *
10912 get_symbol_binding (Filedata * filedata, unsigned int binding)
10913 {
10914   static char buff[32];
10915
10916   switch (binding)
10917     {
10918     case STB_LOCAL:     return "LOCAL";
10919     case STB_GLOBAL:    return "GLOBAL";
10920     case STB_WEAK:      return "WEAK";
10921     default:
10922       if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10923         snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10924                   binding);
10925       else if (binding >= STB_LOOS && binding <= STB_HIOS)
10926         {
10927           if (binding == STB_GNU_UNIQUE
10928               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10929                   /* GNU is still using the default value 0.  */
10930                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10931             return "UNIQUE";
10932           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10933         }
10934       else
10935         snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10936       return buff;
10937     }
10938 }
10939
10940 static const char *
10941 get_symbol_type (Filedata * filedata, unsigned int type)
10942 {
10943   static char buff[32];
10944
10945   switch (type)
10946     {
10947     case STT_NOTYPE:    return "NOTYPE";
10948     case STT_OBJECT:    return "OBJECT";
10949     case STT_FUNC:      return "FUNC";
10950     case STT_SECTION:   return "SECTION";
10951     case STT_FILE:      return "FILE";
10952     case STT_COMMON:    return "COMMON";
10953     case STT_TLS:       return "TLS";
10954     case STT_RELC:      return "RELC";
10955     case STT_SRELC:     return "SRELC";
10956     default:
10957       if (type >= STT_LOPROC && type <= STT_HIPROC)
10958         {
10959           if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10960             return "THUMB_FUNC";
10961
10962           if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10963             return "REGISTER";
10964
10965           if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10966             return "PARISC_MILLI";
10967
10968           snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10969         }
10970       else if (type >= STT_LOOS && type <= STT_HIOS)
10971         {
10972           if (filedata->file_header.e_machine == EM_PARISC)
10973             {
10974               if (type == STT_HP_OPAQUE)
10975                 return "HP_OPAQUE";
10976               if (type == STT_HP_STUB)
10977                 return "HP_STUB";
10978             }
10979
10980           if (type == STT_GNU_IFUNC
10981               && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10982                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10983                   /* GNU is still using the default value 0.  */
10984                   || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10985             return "IFUNC";
10986
10987           snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10988         }
10989       else
10990         snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10991       return buff;
10992     }
10993 }
10994
10995 static const char *
10996 get_symbol_visibility (unsigned int visibility)
10997 {
10998   switch (visibility)
10999     {
11000     case STV_DEFAULT:   return "DEFAULT";
11001     case STV_INTERNAL:  return "INTERNAL";
11002     case STV_HIDDEN:    return "HIDDEN";
11003     case STV_PROTECTED: return "PROTECTED";
11004     default:
11005       error (_("Unrecognized visibility value: %u"), visibility);
11006       return _("<unknown>");
11007     }
11008 }
11009
11010 static const char *
11011 get_solaris_symbol_visibility (unsigned int visibility)
11012 {
11013   switch (visibility)
11014     {
11015     case 4: return "EXPORTED";
11016     case 5: return "SINGLETON";
11017     case 6: return "ELIMINATE";
11018     default: return get_symbol_visibility (visibility);
11019     }
11020 }
11021
11022 static const char *
11023 get_mips_symbol_other (unsigned int other)
11024 {
11025   switch (other)
11026     {
11027     case STO_OPTIONAL:      return "OPTIONAL";
11028     case STO_MIPS_PLT:      return "MIPS PLT";
11029     case STO_MIPS_PIC:      return "MIPS PIC";
11030     case STO_MICROMIPS:     return "MICROMIPS";
11031     case STO_MICROMIPS | STO_MIPS_PIC:      return "MICROMIPS, MIPS PIC";
11032     case STO_MIPS16:        return "MIPS16";
11033     default:                return NULL;
11034     }
11035 }
11036
11037 static const char *
11038 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11039 {
11040   if (is_ia64_vms (filedata))
11041     {
11042       static char res[32];
11043
11044       res[0] = 0;
11045
11046       /* Function types is for images and .STB files only.  */
11047       switch (filedata->file_header.e_type)
11048         {
11049         case ET_DYN:
11050         case ET_EXEC:
11051           switch (VMS_ST_FUNC_TYPE (other))
11052             {
11053             case VMS_SFT_CODE_ADDR:
11054               strcat (res, " CA");
11055               break;
11056             case VMS_SFT_SYMV_IDX:
11057               strcat (res, " VEC");
11058               break;
11059             case VMS_SFT_FD:
11060               strcat (res, " FD");
11061               break;
11062             case VMS_SFT_RESERVE:
11063               strcat (res, " RSV");
11064               break;
11065             default:
11066               warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11067                     VMS_ST_FUNC_TYPE (other));
11068               strcat (res, " <unknown>");
11069               break;
11070             }
11071           break;
11072         default:
11073           break;
11074         }
11075       switch (VMS_ST_LINKAGE (other))
11076         {
11077         case VMS_STL_IGNORE:
11078           strcat (res, " IGN");
11079           break;
11080         case VMS_STL_RESERVE:
11081           strcat (res, " RSV");
11082           break;
11083         case VMS_STL_STD:
11084           strcat (res, " STD");
11085           break;
11086         case VMS_STL_LNK:
11087           strcat (res, " LNK");
11088           break;
11089         default:
11090           warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11091                 VMS_ST_LINKAGE (other));
11092           strcat (res, " <unknown>");
11093           break;
11094         }
11095
11096       if (res[0] != 0)
11097         return res + 1;
11098       else
11099         return res;
11100     }
11101   return NULL;
11102 }
11103
11104 static const char *
11105 get_ppc64_symbol_other (unsigned int other)
11106 {
11107   if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11108     return NULL;
11109
11110   other >>= STO_PPC64_LOCAL_BIT;
11111   if (other <= 6)
11112     {
11113       static char buf[32];
11114       if (other >= 2)
11115         other = ppc64_decode_local_entry (other);
11116       snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11117       return buf;
11118     }
11119   return NULL;
11120 }
11121
11122 static const char *
11123 get_symbol_other (Filedata * filedata, unsigned int other)
11124 {
11125   const char * result = NULL;
11126   static char buff [32];
11127
11128   if (other == 0)
11129     return "";
11130
11131   switch (filedata->file_header.e_machine)
11132     {
11133     case EM_MIPS:
11134       result = get_mips_symbol_other (other);
11135       break;
11136     case EM_IA_64:
11137       result = get_ia64_symbol_other (filedata, other);
11138       break;
11139     case EM_PPC64:
11140       result = get_ppc64_symbol_other (other);
11141       break;
11142     default:
11143       result = NULL;
11144       break;
11145     }
11146
11147   if (result)
11148     return result;
11149
11150   snprintf (buff, sizeof buff, _("<other>: %x"), other);
11151   return buff;
11152 }
11153
11154 static const char *
11155 get_symbol_index_type (Filedata * filedata, unsigned int type)
11156 {
11157   static char buff[32];
11158
11159   switch (type)
11160     {
11161     case SHN_UNDEF:     return "UND";
11162     case SHN_ABS:       return "ABS";
11163     case SHN_COMMON:    return "COM";
11164     default:
11165       if (type == SHN_IA_64_ANSI_COMMON
11166           && filedata->file_header.e_machine == EM_IA_64
11167           && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11168         return "ANSI_COM";
11169       else if ((filedata->file_header.e_machine == EM_X86_64
11170                 || filedata->file_header.e_machine == EM_L1OM
11171                 || filedata->file_header.e_machine == EM_K1OM)
11172                && type == SHN_X86_64_LCOMMON)
11173         return "LARGE_COM";
11174       else if ((type == SHN_MIPS_SCOMMON
11175                 && filedata->file_header.e_machine == EM_MIPS)
11176                || (type == SHN_TIC6X_SCOMMON
11177                    && filedata->file_header.e_machine == EM_TI_C6000))
11178         return "SCOM";
11179       else if (type == SHN_MIPS_SUNDEFINED
11180                && filedata->file_header.e_machine == EM_MIPS)
11181         return "SUND";
11182       else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11183         sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11184       else if (type >= SHN_LOOS && type <= SHN_HIOS)
11185         sprintf (buff, "OS [0x%04x]", type & 0xffff);
11186       else if (type >= SHN_LORESERVE)
11187         sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11188       else if (type >= filedata->file_header.e_shnum)
11189         sprintf (buff, _("bad section index[%3d]"), type);
11190       else
11191         sprintf (buff, "%3d", type);
11192       break;
11193     }
11194
11195   return buff;
11196 }
11197
11198 static bfd_vma *
11199 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11200 {
11201   unsigned char * e_data;
11202   bfd_vma * i_data;
11203
11204   /* If the size_t type is smaller than the bfd_size_type, eg because
11205      you are building a 32-bit tool on a 64-bit host, then make sure
11206      that when (number) is cast to (size_t) no information is lost.  */
11207   if (sizeof (size_t) < sizeof (bfd_size_type)
11208       && (bfd_size_type) ((size_t) number) != number)
11209     {
11210       error (_("Size truncation prevents reading %s elements of size %u\n"),
11211              bfd_vmatoa ("u", number), ent_size);
11212       return NULL;
11213     }
11214
11215   /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11216      attempting to allocate memory when the read is bound to fail.  */
11217   if (ent_size * number > filedata->file_size)
11218     {
11219       error (_("Invalid number of dynamic entries: %s\n"),
11220              bfd_vmatoa ("u", number));
11221       return NULL;
11222     }
11223
11224   e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11225   if (e_data == NULL)
11226     {
11227       error (_("Out of memory reading %s dynamic entries\n"),
11228              bfd_vmatoa ("u", number));
11229       return NULL;
11230     }
11231
11232   if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11233     {
11234       error (_("Unable to read in %s bytes of dynamic data\n"),
11235              bfd_vmatoa ("u", number * ent_size));
11236       free (e_data);
11237       return NULL;
11238     }
11239
11240   i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11241   if (i_data == NULL)
11242     {
11243       error (_("Out of memory allocating space for %s dynamic entries\n"),
11244              bfd_vmatoa ("u", number));
11245       free (e_data);
11246       return NULL;
11247     }
11248
11249   while (number--)
11250     i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11251
11252   free (e_data);
11253
11254   return i_data;
11255 }
11256
11257 static void
11258 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11259 {
11260   Elf_Internal_Sym * psym;
11261   int n;
11262
11263   n = print_vma (si, DEC_5);
11264   if (n < 5)
11265     fputs (&"     "[n], stdout);
11266   printf (" %3lu: ", hn);
11267
11268   if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11269     {
11270       printf (_("<No info available for dynamic symbol number %lu>\n"),
11271               (unsigned long) si);
11272       return;
11273     }
11274
11275   psym = dynamic_symbols + si;
11276   print_vma (psym->st_value, LONG_HEX);
11277   putchar (' ');
11278   print_vma (psym->st_size, DEC_5);
11279
11280   printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11281   printf (" %-6s",  get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11282
11283   if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11284     printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11285   else
11286     {
11287       unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11288
11289       printf (" %-7s",  get_symbol_visibility (vis));
11290       /* Check to see if any other bits in the st_other field are set.
11291          Note - displaying this information disrupts the layout of the
11292          table being generated, but for the moment this case is very
11293          rare.  */
11294       if (psym->st_other ^ vis)
11295         printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11296     }
11297
11298   printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11299   if (VALID_DYNAMIC_NAME (psym->st_name))
11300     print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11301   else
11302     printf (_(" <corrupt: %14ld>"), psym->st_name);
11303   putchar ('\n');
11304 }
11305
11306 static const char *
11307 get_symbol_version_string (Filedata *                   filedata,
11308                            bfd_boolean                  is_dynsym,
11309                            const char *                 strtab,
11310                            unsigned long int            strtab_size,
11311                            unsigned int                 si,
11312                            Elf_Internal_Sym *           psym,
11313                            enum versioned_symbol_info * sym_info,
11314                            unsigned short *             vna_other)
11315 {
11316   unsigned char data[2];
11317   unsigned short vers_data;
11318   unsigned long offset;
11319   unsigned short max_vd_ndx;
11320
11321   if (!is_dynsym
11322       || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11323     return NULL;
11324
11325   offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11326                             sizeof data + si * sizeof (vers_data));
11327
11328   if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11329                 sizeof (data), 1, _("version data")) == NULL)
11330     return NULL;
11331
11332   vers_data = byte_get (data, 2);
11333
11334   if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11335     return NULL;
11336
11337   max_vd_ndx = 0;
11338
11339   /* Usually we'd only see verdef for defined symbols, and verneed for
11340      undefined symbols.  However, symbols defined by the linker in
11341      .dynbss for variables copied from a shared library in order to
11342      avoid text relocations are defined yet have verneed.  We could
11343      use a heuristic to detect the special case, for example, check
11344      for verneed first on symbols defined in SHT_NOBITS sections, but
11345      it is simpler and more reliable to just look for both verdef and
11346      verneed.  .dynbss might not be mapped to a SHT_NOBITS section.  */
11347
11348   if (psym->st_shndx != SHN_UNDEF
11349       && vers_data != 0x8001
11350       && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11351     {
11352       Elf_Internal_Verdef ivd;
11353       Elf_Internal_Verdaux ivda;
11354       Elf_External_Verdaux evda;
11355       unsigned long off;
11356
11357       off = offset_from_vma (filedata,
11358                              version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11359                              sizeof (Elf_External_Verdef));
11360
11361       do
11362         {
11363           Elf_External_Verdef evd;
11364
11365           if (get_data (&evd, filedata, off, sizeof (evd), 1,
11366                         _("version def")) == NULL)
11367             {
11368               ivd.vd_ndx = 0;
11369               ivd.vd_aux = 0;
11370               ivd.vd_next = 0;
11371               ivd.vd_flags = 0;
11372             }
11373           else
11374             {
11375               ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11376               ivd.vd_aux = BYTE_GET (evd.vd_aux);
11377               ivd.vd_next = BYTE_GET (evd.vd_next);
11378               ivd.vd_flags = BYTE_GET (evd.vd_flags);
11379             }
11380
11381           if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11382             max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11383
11384           off += ivd.vd_next;
11385         }
11386       while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11387
11388       if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11389         {
11390           if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11391             return NULL;
11392
11393           off -= ivd.vd_next;
11394           off += ivd.vd_aux;
11395
11396           if (get_data (&evda, filedata, off, sizeof (evda), 1,
11397                         _("version def aux")) != NULL)
11398             {
11399               ivda.vda_name = BYTE_GET (evda.vda_name);
11400
11401               if (psym->st_name != ivda.vda_name)
11402                 {
11403                   *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11404                                ? symbol_hidden : symbol_public);
11405                   return (ivda.vda_name < strtab_size
11406                           ? strtab + ivda.vda_name : _("<corrupt>"));
11407                 }
11408             }
11409         }
11410     }
11411
11412   if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11413     {
11414       Elf_External_Verneed evn;
11415       Elf_Internal_Verneed ivn;
11416       Elf_Internal_Vernaux ivna;
11417
11418       offset = offset_from_vma (filedata,
11419                                 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11420                                 sizeof evn);
11421       do
11422         {
11423           unsigned long vna_off;
11424
11425           if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11426                         _("version need")) == NULL)
11427             {
11428               ivna.vna_next = 0;
11429               ivna.vna_other = 0;
11430               ivna.vna_name = 0;
11431               break;
11432             }
11433
11434           ivn.vn_aux  = BYTE_GET (evn.vn_aux);
11435           ivn.vn_next = BYTE_GET (evn.vn_next);
11436
11437           vna_off = offset + ivn.vn_aux;
11438
11439           do
11440             {
11441               Elf_External_Vernaux evna;
11442
11443               if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11444                             _("version need aux (3)")) == NULL)
11445                 {
11446                   ivna.vna_next = 0;
11447                   ivna.vna_other = 0;
11448                   ivna.vna_name = 0;
11449                 }
11450               else
11451                 {
11452                   ivna.vna_other = BYTE_GET (evna.vna_other);
11453                   ivna.vna_next  = BYTE_GET (evna.vna_next);
11454                   ivna.vna_name  = BYTE_GET (evna.vna_name);
11455                 }
11456
11457               vna_off += ivna.vna_next;
11458             }
11459           while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11460
11461           if (ivna.vna_other == vers_data)
11462             break;
11463
11464           offset += ivn.vn_next;
11465         }
11466       while (ivn.vn_next != 0);
11467
11468       if (ivna.vna_other == vers_data)
11469         {
11470           *sym_info = symbol_undefined;
11471           *vna_other = ivna.vna_other;
11472           return (ivna.vna_name < strtab_size
11473                   ? strtab + ivna.vna_name : _("<corrupt>"));
11474         }
11475       else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11476                && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11477         return _("<corrupt>");
11478     }
11479   return NULL;
11480 }
11481
11482 /* Dump the symbol table.  */
11483 static bfd_boolean
11484 process_symbol_table (Filedata * filedata)
11485 {
11486   Elf_Internal_Shdr * section;
11487   bfd_size_type nbuckets = 0;
11488   bfd_size_type nchains = 0;
11489   bfd_vma * buckets = NULL;
11490   bfd_vma * chains = NULL;
11491   bfd_vma ngnubuckets = 0;
11492   bfd_vma * gnubuckets = NULL;
11493   bfd_vma * gnuchains = NULL;
11494   bfd_vma gnusymidx = 0;
11495   bfd_size_type ngnuchains = 0;
11496
11497   if (!do_syms && !do_dyn_syms && !do_histogram)
11498     return TRUE;
11499
11500   if (dynamic_info[DT_HASH]
11501       && (do_histogram
11502           || (do_using_dynamic
11503               && !do_dyn_syms
11504               && dynamic_strings != NULL)))
11505     {
11506       unsigned char nb[8];
11507       unsigned char nc[8];
11508       unsigned int hash_ent_size = 4;
11509
11510       if ((filedata->file_header.e_machine == EM_ALPHA
11511            || filedata->file_header.e_machine == EM_S390
11512            || filedata->file_header.e_machine == EM_S390_OLD)
11513           && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11514         hash_ent_size = 8;
11515
11516       if (fseek (filedata->handle,
11517                  (archive_file_offset
11518                   + offset_from_vma (filedata, dynamic_info[DT_HASH],
11519                                      sizeof nb + sizeof nc)),
11520                  SEEK_SET))
11521         {
11522           error (_("Unable to seek to start of dynamic information\n"));
11523           goto no_hash;
11524         }
11525
11526       if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11527         {
11528           error (_("Failed to read in number of buckets\n"));
11529           goto no_hash;
11530         }
11531
11532       if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11533         {
11534           error (_("Failed to read in number of chains\n"));
11535           goto no_hash;
11536         }
11537
11538       nbuckets = byte_get (nb, hash_ent_size);
11539       nchains  = byte_get (nc, hash_ent_size);
11540
11541       buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11542       chains  = get_dynamic_data (filedata, nchains, hash_ent_size);
11543
11544     no_hash:
11545       if (buckets == NULL || chains == NULL)
11546         {
11547           if (do_using_dynamic)
11548             return FALSE;
11549           free (buckets);
11550           free (chains);
11551           buckets = NULL;
11552           chains = NULL;
11553           nbuckets = 0;
11554           nchains = 0;
11555         }
11556     }
11557
11558   if (dynamic_info_DT_GNU_HASH
11559       && (do_histogram
11560           || (do_using_dynamic
11561               && !do_dyn_syms
11562               && dynamic_strings != NULL)))
11563     {
11564       unsigned char nb[16];
11565       bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11566       bfd_vma buckets_vma;
11567
11568       if (fseek (filedata->handle,
11569                  (archive_file_offset
11570                   + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11571                                      sizeof nb)),
11572                  SEEK_SET))
11573         {
11574           error (_("Unable to seek to start of dynamic information\n"));
11575           goto no_gnu_hash;
11576         }
11577
11578       if (fread (nb, 16, 1, filedata->handle) != 1)
11579         {
11580           error (_("Failed to read in number of buckets\n"));
11581           goto no_gnu_hash;
11582         }
11583
11584       ngnubuckets = byte_get (nb, 4);
11585       gnusymidx = byte_get (nb + 4, 4);
11586       bitmaskwords = byte_get (nb + 8, 4);
11587       buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11588       if (is_32bit_elf)
11589         buckets_vma += bitmaskwords * 4;
11590       else
11591         buckets_vma += bitmaskwords * 8;
11592
11593       if (fseek (filedata->handle,
11594                  (archive_file_offset
11595                   + offset_from_vma (filedata, buckets_vma, 4)),
11596                  SEEK_SET))
11597         {
11598           error (_("Unable to seek to start of dynamic information\n"));
11599           goto no_gnu_hash;
11600         }
11601
11602       gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11603
11604       if (gnubuckets == NULL)
11605         goto no_gnu_hash;
11606
11607       for (i = 0; i < ngnubuckets; i++)
11608         if (gnubuckets[i] != 0)
11609           {
11610             if (gnubuckets[i] < gnusymidx)
11611               return FALSE;
11612
11613             if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11614               maxchain = gnubuckets[i];
11615           }
11616
11617       if (maxchain == 0xffffffff)
11618         goto no_gnu_hash;
11619
11620       maxchain -= gnusymidx;
11621
11622       if (fseek (filedata->handle,
11623                  (archive_file_offset
11624                   + offset_from_vma (filedata, buckets_vma
11625                                            + 4 * (ngnubuckets + maxchain), 4)),
11626                  SEEK_SET))
11627         {
11628           error (_("Unable to seek to start of dynamic information\n"));
11629           goto no_gnu_hash;
11630         }
11631
11632       do
11633         {
11634           if (fread (nb, 4, 1, filedata->handle) != 1)
11635             {
11636               error (_("Failed to determine last chain length\n"));
11637               goto no_gnu_hash;
11638             }
11639
11640           if (maxchain + 1 == 0)
11641             goto no_gnu_hash;
11642
11643           ++maxchain;
11644         }
11645       while ((byte_get (nb, 4) & 1) == 0);
11646
11647       if (fseek (filedata->handle,
11648                  (archive_file_offset
11649                   + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11650                  SEEK_SET))
11651         {
11652           error (_("Unable to seek to start of dynamic information\n"));
11653           goto no_gnu_hash;
11654         }
11655
11656       gnuchains = get_dynamic_data (filedata, maxchain, 4);
11657       ngnuchains = maxchain;
11658
11659     no_gnu_hash:
11660       if (gnuchains == NULL)
11661         {
11662           free (gnubuckets);
11663           gnubuckets = NULL;
11664           ngnubuckets = 0;
11665           if (do_using_dynamic)
11666             return FALSE;
11667         }
11668     }
11669
11670   if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11671       && do_syms
11672       && do_using_dynamic
11673       && dynamic_strings != NULL
11674       && dynamic_symbols != NULL)
11675     {
11676       unsigned long hn;
11677
11678       if (dynamic_info[DT_HASH])
11679         {
11680           bfd_vma si;
11681           char *visited;
11682
11683           printf (_("\nSymbol table for image:\n"));
11684           if (is_32bit_elf)
11685             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11686           else
11687             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11688
11689           visited = xcmalloc (nchains, 1);
11690           memset (visited, 0, nchains);
11691           for (hn = 0; hn < nbuckets; hn++)
11692             {
11693               for (si = buckets[hn]; si > 0; si = chains[si])
11694                 {
11695                   print_dynamic_symbol (filedata, si, hn);
11696                   if (si >= nchains || visited[si])
11697                     {
11698                       error (_("histogram chain is corrupt\n"));
11699                       break;
11700                     }
11701                   visited[si] = 1;
11702                 }
11703             }
11704           free (visited);
11705         }
11706
11707       if (dynamic_info_DT_GNU_HASH)
11708         {
11709           printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11710           if (is_32bit_elf)
11711             printf (_("  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n"));
11712           else
11713             printf (_("  Num Buc:    Value          Size   Type   Bind Vis      Ndx Name\n"));
11714
11715           for (hn = 0; hn < ngnubuckets; ++hn)
11716             if (gnubuckets[hn] != 0)
11717               {
11718                 bfd_vma si = gnubuckets[hn];
11719                 bfd_vma off = si - gnusymidx;
11720
11721                 do
11722                   {
11723                     print_dynamic_symbol (filedata, si, hn);
11724                     si++;
11725                   }
11726                 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11727               }
11728         }
11729     }
11730   else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11731            && filedata->section_headers != NULL)
11732     {
11733       unsigned int i;
11734
11735       for (i = 0, section = filedata->section_headers;
11736            i < filedata->file_header.e_shnum;
11737            i++, section++)
11738         {
11739           unsigned int si;
11740           char * strtab = NULL;
11741           unsigned long int strtab_size = 0;
11742           Elf_Internal_Sym * symtab;
11743           Elf_Internal_Sym * psym;
11744           unsigned long num_syms;
11745
11746           if ((section->sh_type != SHT_SYMTAB
11747                && section->sh_type != SHT_DYNSYM)
11748               || (!do_syms
11749                   && section->sh_type == SHT_SYMTAB))
11750             continue;
11751
11752           if (section->sh_entsize == 0)
11753             {
11754               printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11755                       printable_section_name (filedata, section));
11756               continue;
11757             }
11758
11759           num_syms = section->sh_size / section->sh_entsize;
11760           printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11761                             "\nSymbol table '%s' contains %lu entries:\n",
11762                             num_syms),
11763                   printable_section_name (filedata, section),
11764                   num_syms);
11765
11766           if (is_32bit_elf)
11767             printf (_("   Num:    Value  Size Type    Bind   Vis      Ndx Name\n"));
11768           else
11769             printf (_("   Num:    Value          Size Type    Bind   Vis      Ndx Name\n"));
11770
11771           symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11772           if (symtab == NULL)
11773             continue;
11774
11775           if (section->sh_link == filedata->file_header.e_shstrndx)
11776             {
11777               strtab = filedata->string_table;
11778               strtab_size = filedata->string_table_length;
11779             }
11780           else if (section->sh_link < filedata->file_header.e_shnum)
11781             {
11782               Elf_Internal_Shdr * string_sec;
11783
11784               string_sec = filedata->section_headers + section->sh_link;
11785
11786               strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11787                                           1, string_sec->sh_size,
11788                                           _("string table"));
11789               strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11790             }
11791
11792           for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11793             {
11794               const char *version_string;
11795               enum versioned_symbol_info sym_info;
11796               unsigned short vna_other;
11797
11798               printf ("%6d: ", si);
11799               print_vma (psym->st_value, LONG_HEX);
11800               putchar (' ');
11801               print_vma (psym->st_size, DEC_5);
11802               printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11803               printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11804               if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11805                 printf (" %-7s",  get_solaris_symbol_visibility (psym->st_other));
11806               else
11807                 {
11808                   unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11809
11810                   printf (" %-7s", get_symbol_visibility (vis));
11811                   /* Check to see if any other bits in the st_other field are set.
11812                      Note - displaying this information disrupts the layout of the
11813                      table being generated, but for the moment this case is very rare.  */
11814                   if (psym->st_other ^ vis)
11815                     printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11816                 }
11817               printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11818               print_symbol (25, psym->st_name < strtab_size
11819                             ? strtab + psym->st_name : _("<corrupt>"));
11820
11821               version_string
11822                 = get_symbol_version_string (filedata,
11823                                              section->sh_type == SHT_DYNSYM,
11824                                              strtab, strtab_size, si,
11825                                              psym, &sym_info, &vna_other);
11826               if (version_string)
11827                 {
11828                   if (sym_info == symbol_undefined)
11829                     printf ("@%s (%d)", version_string, vna_other);
11830                   else
11831                     printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11832                             version_string);
11833                 }
11834
11835               putchar ('\n');
11836
11837               if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11838                   && si >= section->sh_info
11839                   /* Irix 5 and 6 MIPS binaries are known to ignore this requirement.  */
11840                   && filedata->file_header.e_machine != EM_MIPS
11841                   /* Solaris binaries have been found to violate this requirement as
11842                      well.  Not sure if this is a bug or an ABI requirement.  */
11843                   && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11844                 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11845                       si, printable_section_name (filedata, section), section->sh_info);
11846             }
11847
11848           free (symtab);
11849           if (strtab != filedata->string_table)
11850             free (strtab);
11851         }
11852     }
11853   else if (do_syms)
11854     printf
11855       (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11856
11857   if (do_histogram && buckets != NULL)
11858     {
11859       unsigned long * lengths;
11860       unsigned long * counts;
11861       unsigned long hn;
11862       bfd_vma si;
11863       unsigned long maxlength = 0;
11864       unsigned long nzero_counts = 0;
11865       unsigned long nsyms = 0;
11866       char *visited;
11867
11868       printf (ngettext ("\nHistogram for bucket list length "
11869                         "(total of %lu bucket):\n",
11870                         "\nHistogram for bucket list length "
11871                         "(total of %lu buckets):\n",
11872                         (unsigned long) nbuckets),
11873               (unsigned long) nbuckets);
11874
11875       lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11876       if (lengths == NULL)
11877         {
11878           error (_("Out of memory allocating space for histogram buckets\n"));
11879           return FALSE;
11880         }
11881       visited = xcmalloc (nchains, 1);
11882       memset (visited, 0, nchains);
11883
11884       printf (_(" Length  Number     %% of total  Coverage\n"));
11885       for (hn = 0; hn < nbuckets; ++hn)
11886         {
11887           for (si = buckets[hn]; si > 0; si = chains[si])
11888             {
11889               ++nsyms;
11890               if (maxlength < ++lengths[hn])
11891                 ++maxlength;
11892               if (si >= nchains || visited[si])
11893                 {
11894                   error (_("histogram chain is corrupt\n"));
11895                   break;
11896                 }
11897               visited[si] = 1;
11898             }
11899         }
11900       free (visited);
11901
11902       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11903       if (counts == NULL)
11904         {
11905           free (lengths);
11906           error (_("Out of memory allocating space for histogram counts\n"));
11907           return FALSE;
11908         }
11909
11910       for (hn = 0; hn < nbuckets; ++hn)
11911         ++counts[lengths[hn]];
11912
11913       if (nbuckets > 0)
11914         {
11915           unsigned long i;
11916           printf ("      0  %-10lu (%5.1f%%)\n",
11917                   counts[0], (counts[0] * 100.0) / nbuckets);
11918           for (i = 1; i <= maxlength; ++i)
11919             {
11920               nzero_counts += counts[i] * i;
11921               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11922                       i, counts[i], (counts[i] * 100.0) / nbuckets,
11923                       (nzero_counts * 100.0) / nsyms);
11924             }
11925         }
11926
11927       free (counts);
11928       free (lengths);
11929     }
11930
11931   if (buckets != NULL)
11932     {
11933       free (buckets);
11934       free (chains);
11935     }
11936
11937   if (do_histogram && gnubuckets != NULL)
11938     {
11939       unsigned long * lengths;
11940       unsigned long * counts;
11941       unsigned long hn;
11942       unsigned long maxlength = 0;
11943       unsigned long nzero_counts = 0;
11944       unsigned long nsyms = 0;
11945
11946       printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11947                         "(total of %lu bucket):\n",
11948                         "\nHistogram for `.gnu.hash' bucket list length "
11949                         "(total of %lu buckets):\n",
11950                         (unsigned long) ngnubuckets),
11951               (unsigned long) ngnubuckets);
11952
11953       lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11954       if (lengths == NULL)
11955         {
11956           error (_("Out of memory allocating space for gnu histogram buckets\n"));
11957           return FALSE;
11958         }
11959
11960       printf (_(" Length  Number     %% of total  Coverage\n"));
11961
11962       for (hn = 0; hn < ngnubuckets; ++hn)
11963         if (gnubuckets[hn] != 0)
11964           {
11965             bfd_vma off, length = 1;
11966
11967             for (off = gnubuckets[hn] - gnusymidx;
11968                  /* PR 17531 file: 010-77222-0.004.  */
11969                  off < ngnuchains && (gnuchains[off] & 1) == 0;
11970                  ++off)
11971               ++length;
11972             lengths[hn] = length;
11973             if (length > maxlength)
11974               maxlength = length;
11975             nsyms += length;
11976           }
11977
11978       counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11979       if (counts == NULL)
11980         {
11981           free (lengths);
11982           error (_("Out of memory allocating space for gnu histogram counts\n"));
11983           return FALSE;
11984         }
11985
11986       for (hn = 0; hn < ngnubuckets; ++hn)
11987         ++counts[lengths[hn]];
11988
11989       if (ngnubuckets > 0)
11990         {
11991           unsigned long j;
11992           printf ("      0  %-10lu (%5.1f%%)\n",
11993                   counts[0], (counts[0] * 100.0) / ngnubuckets);
11994           for (j = 1; j <= maxlength; ++j)
11995             {
11996               nzero_counts += counts[j] * j;
11997               printf ("%7lu  %-10lu (%5.1f%%)    %5.1f%%\n",
11998                       j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11999                       (nzero_counts * 100.0) / nsyms);
12000             }
12001         }
12002
12003       free (counts);
12004       free (lengths);
12005       free (gnubuckets);
12006       free (gnuchains);
12007     }
12008
12009   return TRUE;
12010 }
12011
12012 static bfd_boolean
12013 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12014 {
12015   unsigned int i;
12016
12017   if (dynamic_syminfo == NULL
12018       || !do_dynamic)
12019     /* No syminfo, this is ok.  */
12020     return TRUE;
12021
12022   /* There better should be a dynamic symbol section.  */
12023   if (dynamic_symbols == NULL || dynamic_strings == NULL)
12024     return FALSE;
12025
12026   if (dynamic_addr)
12027     printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12028                       "contains %d entry:\n",
12029                       "\nDynamic info segment at offset 0x%lx "
12030                       "contains %d entries:\n",
12031                       dynamic_syminfo_nent),
12032             dynamic_syminfo_offset, dynamic_syminfo_nent);
12033
12034   printf (_(" Num: Name                           BoundTo     Flags\n"));
12035   for (i = 0; i < dynamic_syminfo_nent; ++i)
12036     {
12037       unsigned short int flags = dynamic_syminfo[i].si_flags;
12038
12039       printf ("%4d: ", i);
12040       if (i >= num_dynamic_syms)
12041         printf (_("<corrupt index>"));
12042       else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12043         print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12044       else
12045         printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12046       putchar (' ');
12047
12048       switch (dynamic_syminfo[i].si_boundto)
12049         {
12050         case SYMINFO_BT_SELF:
12051           fputs ("SELF       ", stdout);
12052           break;
12053         case SYMINFO_BT_PARENT:
12054           fputs ("PARENT     ", stdout);
12055           break;
12056         default:
12057           if (dynamic_syminfo[i].si_boundto > 0
12058               && dynamic_syminfo[i].si_boundto < dynamic_nent
12059               && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12060             {
12061               print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12062               putchar (' ' );
12063             }
12064           else
12065             printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12066           break;
12067         }
12068
12069       if (flags & SYMINFO_FLG_DIRECT)
12070         printf (" DIRECT");
12071       if (flags & SYMINFO_FLG_PASSTHRU)
12072         printf (" PASSTHRU");
12073       if (flags & SYMINFO_FLG_COPY)
12074         printf (" COPY");
12075       if (flags & SYMINFO_FLG_LAZYLOAD)
12076         printf (" LAZYLOAD");
12077
12078       puts ("");
12079     }
12080
12081   return TRUE;
12082 }
12083
12084 #define IN_RANGE(START,END,ADDR,OFF)            \
12085   (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12086
12087 /* Check to see if the given reloc needs to be handled in a target specific
12088    manner.  If so then process the reloc and return TRUE otherwise return
12089    FALSE.
12090
12091    If called with reloc == NULL, then this is a signal that reloc processing
12092    for the current section has finished, and any saved state should be
12093    discarded.  */
12094
12095 static bfd_boolean
12096 target_specific_reloc_handling (Filedata *           filedata,
12097                                 Elf_Internal_Rela *  reloc,
12098                                 unsigned char *      start,
12099                                 unsigned char *      end,
12100                                 Elf_Internal_Sym *   symtab,
12101                                 unsigned long        num_syms)
12102 {
12103   unsigned int reloc_type = 0;
12104   unsigned long sym_index = 0;
12105
12106   if (reloc)
12107     {
12108       reloc_type = get_reloc_type (filedata, reloc->r_info);
12109       sym_index = get_reloc_symindex (reloc->r_info);
12110     }
12111
12112   switch (filedata->file_header.e_machine)
12113     {
12114     case EM_MSP430:
12115     case EM_MSP430_OLD:
12116       {
12117         static Elf_Internal_Sym * saved_sym = NULL;
12118
12119         if (reloc == NULL)
12120           {
12121             saved_sym = NULL;
12122             return TRUE;
12123           }
12124
12125         switch (reloc_type)
12126           {
12127           case 10: /* R_MSP430_SYM_DIFF */
12128             if (uses_msp430x_relocs (filedata))
12129               break;
12130             /* Fall through.  */
12131           case 21: /* R_MSP430X_SYM_DIFF */
12132             /* PR 21139.  */
12133             if (sym_index >= num_syms)
12134               error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12135                      sym_index);
12136             else
12137               saved_sym = symtab + sym_index;
12138             return TRUE;
12139
12140           case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12141           case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12142             goto handle_sym_diff;
12143
12144           case 5: /* R_MSP430_16_BYTE */
12145           case 9: /* R_MSP430_8 */
12146             if (uses_msp430x_relocs (filedata))
12147               break;
12148             goto handle_sym_diff;
12149
12150           case 2: /* R_MSP430_ABS16 */
12151           case 15: /* R_MSP430X_ABS16 */
12152             if (! uses_msp430x_relocs (filedata))
12153               break;
12154             goto handle_sym_diff;
12155
12156           handle_sym_diff:
12157             if (saved_sym != NULL)
12158               {
12159                 int reloc_size = reloc_type == 1 ? 4 : 2;
12160                 bfd_vma value;
12161
12162                 if (sym_index >= num_syms)
12163                   error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12164                          sym_index);
12165                 else
12166                   {
12167                     value = reloc->r_addend + (symtab[sym_index].st_value
12168                                                - saved_sym->st_value);
12169
12170                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12171                       byte_put (start + reloc->r_offset, value, reloc_size);
12172                     else
12173                       /* PR 21137 */
12174                       error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12175                              (long) reloc->r_offset);
12176                   }
12177
12178                 saved_sym = NULL;
12179                 return TRUE;
12180               }
12181             break;
12182
12183           default:
12184             if (saved_sym != NULL)
12185               error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12186             break;
12187           }
12188         break;
12189       }
12190
12191     case EM_MN10300:
12192     case EM_CYGNUS_MN10300:
12193       {
12194         static Elf_Internal_Sym * saved_sym = NULL;
12195
12196         if (reloc == NULL)
12197           {
12198             saved_sym = NULL;
12199             return TRUE;
12200           }
12201
12202         switch (reloc_type)
12203           {
12204           case 34: /* R_MN10300_ALIGN */
12205             return TRUE;
12206           case 33: /* R_MN10300_SYM_DIFF */
12207             if (sym_index >= num_syms)
12208               error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12209                      sym_index);
12210             else
12211               saved_sym = symtab + sym_index;
12212             return TRUE;
12213
12214           case 1: /* R_MN10300_32 */
12215           case 2: /* R_MN10300_16 */
12216             if (saved_sym != NULL)
12217               {
12218                 int reloc_size = reloc_type == 1 ? 4 : 2;
12219                 bfd_vma value;
12220
12221                 if (sym_index >= num_syms)
12222                   error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12223                          sym_index);
12224                 else
12225                   {
12226                     value = reloc->r_addend + (symtab[sym_index].st_value
12227                                                - saved_sym->st_value);
12228
12229                     if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12230                       byte_put (start + reloc->r_offset, value, reloc_size);
12231                     else
12232                       error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12233                              (long) reloc->r_offset);
12234                   }
12235
12236                 saved_sym = NULL;
12237                 return TRUE;
12238               }
12239             break;
12240           default:
12241             if (saved_sym != NULL)
12242               error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12243             break;
12244           }
12245         break;
12246       }
12247
12248     case EM_RL78:
12249       {
12250         static bfd_vma saved_sym1 = 0;
12251         static bfd_vma saved_sym2 = 0;
12252         static bfd_vma value;
12253
12254         if (reloc == NULL)
12255           {
12256             saved_sym1 = saved_sym2 = 0;
12257             return TRUE;
12258           }
12259
12260         switch (reloc_type)
12261           {
12262           case 0x80: /* R_RL78_SYM.  */
12263             saved_sym1 = saved_sym2;
12264             if (sym_index >= num_syms)
12265               error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12266                      sym_index);
12267             else
12268               {
12269                 saved_sym2 = symtab[sym_index].st_value;
12270                 saved_sym2 += reloc->r_addend;
12271               }
12272             return TRUE;
12273
12274           case 0x83: /* R_RL78_OPsub.  */
12275             value = saved_sym1 - saved_sym2;
12276             saved_sym2 = saved_sym1 = 0;
12277             return TRUE;
12278             break;
12279
12280           case 0x41: /* R_RL78_ABS32.  */
12281             if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12282               byte_put (start + reloc->r_offset, value, 4);
12283             else
12284               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12285                      (long) reloc->r_offset);
12286             value = 0;
12287             return TRUE;
12288
12289           case 0x43: /* R_RL78_ABS16.  */
12290             if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12291               byte_put (start + reloc->r_offset, value, 2);
12292             else
12293               error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12294                      (long) reloc->r_offset);
12295             value = 0;
12296             return TRUE;
12297
12298           default:
12299             break;
12300           }
12301         break;
12302       }
12303     }
12304
12305   return FALSE;
12306 }
12307
12308 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12309    DWARF debug sections.  This is a target specific test.  Note - we do not
12310    go through the whole including-target-headers-multiple-times route, (as
12311    we have already done with <elf/h8.h>) because this would become very
12312    messy and even then this function would have to contain target specific
12313    information (the names of the relocs instead of their numeric values).
12314    FIXME: This is not the correct way to solve this problem.  The proper way
12315    is to have target specific reloc sizing and typing functions created by
12316    the reloc-macros.h header, in the same way that it already creates the
12317    reloc naming functions.  */
12318
12319 static bfd_boolean
12320 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12321 {
12322   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12323   switch (filedata->file_header.e_machine)
12324     {
12325     case EM_386:
12326     case EM_IAMCU:
12327       return reloc_type == 1; /* R_386_32.  */
12328     case EM_68K:
12329       return reloc_type == 1; /* R_68K_32.  */
12330     case EM_860:
12331       return reloc_type == 1; /* R_860_32.  */
12332     case EM_960:
12333       return reloc_type == 2; /* R_960_32.  */
12334     case EM_AARCH64:
12335       return (reloc_type == 258
12336               || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12337     case EM_ADAPTEVA_EPIPHANY:
12338       return reloc_type == 3;
12339     case EM_ALPHA:
12340       return reloc_type == 1; /* R_ALPHA_REFLONG.  */
12341     case EM_ARC:
12342       return reloc_type == 1; /* R_ARC_32.  */
12343     case EM_ARC_COMPACT:
12344     case EM_ARC_COMPACT2:
12345       return reloc_type == 4; /* R_ARC_32.  */
12346     case EM_ARM:
12347       return reloc_type == 2; /* R_ARM_ABS32 */
12348     case EM_AVR_OLD:
12349     case EM_AVR:
12350       return reloc_type == 1;
12351     case EM_BLACKFIN:
12352       return reloc_type == 0x12; /* R_byte4_data.  */
12353     case EM_CRIS:
12354       return reloc_type == 3; /* R_CRIS_32.  */
12355     case EM_CR16:
12356       return reloc_type == 3; /* R_CR16_NUM32.  */
12357     case EM_CRX:
12358       return reloc_type == 15; /* R_CRX_NUM32.  */
12359     case EM_CSKY:
12360       return reloc_type == 1; /* R_CKCORE_ADDR32.  */
12361     case EM_CYGNUS_FRV:
12362       return reloc_type == 1;
12363     case EM_CYGNUS_D10V:
12364     case EM_D10V:
12365       return reloc_type == 6; /* R_D10V_32.  */
12366     case EM_CYGNUS_D30V:
12367     case EM_D30V:
12368       return reloc_type == 12; /* R_D30V_32_NORMAL.  */
12369     case EM_DLX:
12370       return reloc_type == 3; /* R_DLX_RELOC_32.  */
12371     case EM_CYGNUS_FR30:
12372     case EM_FR30:
12373       return reloc_type == 3; /* R_FR30_32.  */
12374     case EM_FT32:
12375       return reloc_type == 1; /* R_FT32_32.  */
12376     case EM_H8S:
12377     case EM_H8_300:
12378     case EM_H8_300H:
12379       return reloc_type == 1; /* R_H8_DIR32.  */
12380     case EM_IA_64:
12381       return (reloc_type == 0x64    /* R_IA64_SECREL32MSB.  */
12382               || reloc_type == 0x65 /* R_IA64_SECREL32LSB.  */
12383               || reloc_type == 0x24 /* R_IA64_DIR32MSB.  */
12384               || reloc_type == 0x25 /* R_IA64_DIR32LSB.  */);
12385     case EM_IP2K_OLD:
12386     case EM_IP2K:
12387       return reloc_type == 2; /* R_IP2K_32.  */
12388     case EM_IQ2000:
12389       return reloc_type == 2; /* R_IQ2000_32.  */
12390     case EM_LATTICEMICO32:
12391       return reloc_type == 3; /* R_LM32_32.  */
12392     case EM_M32C_OLD:
12393     case EM_M32C:
12394       return reloc_type == 3; /* R_M32C_32.  */
12395     case EM_M32R:
12396       return reloc_type == 34; /* R_M32R_32_RELA.  */
12397     case EM_68HC11:
12398     case EM_68HC12:
12399       return reloc_type == 6; /* R_M68HC11_32.  */
12400     case EM_S12Z:
12401       return reloc_type == 7 || /* R_S12Z_EXT32 */
12402         reloc_type == 6;        /* R_S12Z_CW32.  */
12403     case EM_MCORE:
12404       return reloc_type == 1; /* R_MCORE_ADDR32.  */
12405     case EM_CYGNUS_MEP:
12406       return reloc_type == 4; /* R_MEP_32.  */
12407     case EM_METAG:
12408       return reloc_type == 2; /* R_METAG_ADDR32.  */
12409     case EM_MICROBLAZE:
12410       return reloc_type == 1; /* R_MICROBLAZE_32.  */
12411     case EM_MIPS:
12412       return reloc_type == 2; /* R_MIPS_32.  */
12413     case EM_MMIX:
12414       return reloc_type == 4; /* R_MMIX_32.  */
12415     case EM_CYGNUS_MN10200:
12416     case EM_MN10200:
12417       return reloc_type == 1; /* R_MN10200_32.  */
12418     case EM_CYGNUS_MN10300:
12419     case EM_MN10300:
12420       return reloc_type == 1; /* R_MN10300_32.  */
12421     case EM_MOXIE:
12422       return reloc_type == 1; /* R_MOXIE_32.  */
12423     case EM_MSP430_OLD:
12424     case EM_MSP430:
12425       return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32.  */
12426     case EM_MT:
12427       return reloc_type == 2; /* R_MT_32.  */
12428     case EM_NDS32:
12429       return reloc_type == 20; /* R_NDS32_RELA.  */
12430     case EM_ALTERA_NIOS2:
12431       return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32.  */
12432     case EM_NIOS32:
12433       return reloc_type == 1; /* R_NIOS_32.  */
12434     case EM_OR1K:
12435       return reloc_type == 1; /* R_OR1K_32.  */
12436     case EM_PARISC:
12437       return (reloc_type == 1 /* R_PARISC_DIR32.  */
12438               || reloc_type == 2 /* R_PARISC_DIR21L.  */
12439               || reloc_type == 41); /* R_PARISC_SECREL32.  */
12440     case EM_PJ:
12441     case EM_PJ_OLD:
12442       return reloc_type == 1; /* R_PJ_DATA_DIR32.  */
12443     case EM_PPC64:
12444       return reloc_type == 1; /* R_PPC64_ADDR32.  */
12445     case EM_PPC:
12446       return reloc_type == 1; /* R_PPC_ADDR32.  */
12447     case EM_TI_PRU:
12448       return reloc_type == 11; /* R_PRU_BFD_RELOC_32.  */
12449     case EM_RISCV:
12450       return reloc_type == 1; /* R_RISCV_32.  */
12451     case EM_RL78:
12452       return reloc_type == 1; /* R_RL78_DIR32.  */
12453     case EM_RX:
12454       return reloc_type == 1; /* R_RX_DIR32.  */
12455     case EM_S370:
12456       return reloc_type == 1; /* R_I370_ADDR31.  */
12457     case EM_S390_OLD:
12458     case EM_S390:
12459       return reloc_type == 4; /* R_S390_32.  */
12460     case EM_SCORE:
12461       return reloc_type == 8; /* R_SCORE_ABS32.  */
12462     case EM_SH:
12463       return reloc_type == 1; /* R_SH_DIR32.  */
12464     case EM_SPARC32PLUS:
12465     case EM_SPARCV9:
12466     case EM_SPARC:
12467       return reloc_type == 3 /* R_SPARC_32.  */
12468         || reloc_type == 23; /* R_SPARC_UA32.  */
12469     case EM_SPU:
12470       return reloc_type == 6; /* R_SPU_ADDR32 */
12471     case EM_TI_C6000:
12472       return reloc_type == 1; /* R_C6000_ABS32.  */
12473     case EM_TILEGX:
12474       return reloc_type == 2; /* R_TILEGX_32.  */
12475     case EM_TILEPRO:
12476       return reloc_type == 1; /* R_TILEPRO_32.  */
12477     case EM_CYGNUS_V850:
12478     case EM_V850:
12479       return reloc_type == 6; /* R_V850_ABS32.  */
12480     case EM_V800:
12481       return reloc_type == 0x33; /* R_V810_WORD.  */
12482     case EM_VAX:
12483       return reloc_type == 1; /* R_VAX_32.  */
12484     case EM_VISIUM:
12485       return reloc_type == 3;  /* R_VISIUM_32. */
12486     case EM_WEBASSEMBLY:
12487       return reloc_type == 1;  /* R_WASM32_32.  */
12488     case EM_X86_64:
12489     case EM_L1OM:
12490     case EM_K1OM:
12491       return reloc_type == 10; /* R_X86_64_32.  */
12492     case EM_XC16X:
12493     case EM_C166:
12494       return reloc_type == 3; /* R_XC16C_ABS_32.  */
12495     case EM_XGATE:
12496       return reloc_type == 4; /* R_XGATE_32.  */
12497     case EM_XSTORMY16:
12498       return reloc_type == 1; /* R_XSTROMY16_32.  */
12499     case EM_XTENSA_OLD:
12500     case EM_XTENSA:
12501       return reloc_type == 1; /* R_XTENSA_32.  */
12502     default:
12503       {
12504         static unsigned int prev_warn = 0;
12505
12506         /* Avoid repeating the same warning multiple times.  */
12507         if (prev_warn != filedata->file_header.e_machine)
12508           error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12509                  filedata->file_header.e_machine);
12510         prev_warn = filedata->file_header.e_machine;
12511         return FALSE;
12512       }
12513     }
12514 }
12515
12516 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12517    a 32-bit pc-relative RELA relocation used in DWARF debug sections.  */
12518
12519 static bfd_boolean
12520 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12521 {
12522   switch (filedata->file_header.e_machine)
12523   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12524     {
12525     case EM_386:
12526     case EM_IAMCU:
12527       return reloc_type == 2;  /* R_386_PC32.  */
12528     case EM_68K:
12529       return reloc_type == 4;  /* R_68K_PC32.  */
12530     case EM_AARCH64:
12531       return reloc_type == 261; /* R_AARCH64_PREL32 */
12532     case EM_ADAPTEVA_EPIPHANY:
12533       return reloc_type == 6;
12534     case EM_ALPHA:
12535       return reloc_type == 10; /* R_ALPHA_SREL32.  */
12536     case EM_ARC_COMPACT:
12537     case EM_ARC_COMPACT2:
12538       return reloc_type == 49; /* R_ARC_32_PCREL.  */
12539     case EM_ARM:
12540       return reloc_type == 3;  /* R_ARM_REL32 */
12541     case EM_AVR_OLD:
12542     case EM_AVR:
12543       return reloc_type == 36; /* R_AVR_32_PCREL.  */
12544     case EM_MICROBLAZE:
12545       return reloc_type == 2;  /* R_MICROBLAZE_32_PCREL.  */
12546     case EM_OR1K:
12547       return reloc_type == 9; /* R_OR1K_32_PCREL.  */
12548     case EM_PARISC:
12549       return reloc_type == 9;  /* R_PARISC_PCREL32.  */
12550     case EM_PPC:
12551       return reloc_type == 26; /* R_PPC_REL32.  */
12552     case EM_PPC64:
12553       return reloc_type == 26; /* R_PPC64_REL32.  */
12554     case EM_RISCV:
12555       return reloc_type == 57;  /* R_RISCV_32_PCREL.  */
12556     case EM_S390_OLD:
12557     case EM_S390:
12558       return reloc_type == 5;  /* R_390_PC32.  */
12559     case EM_SH:
12560       return reloc_type == 2;  /* R_SH_REL32.  */
12561     case EM_SPARC32PLUS:
12562     case EM_SPARCV9:
12563     case EM_SPARC:
12564       return reloc_type == 6;  /* R_SPARC_DISP32.  */
12565     case EM_SPU:
12566       return reloc_type == 13; /* R_SPU_REL32.  */
12567     case EM_TILEGX:
12568       return reloc_type == 6; /* R_TILEGX_32_PCREL.  */
12569     case EM_TILEPRO:
12570       return reloc_type == 4; /* R_TILEPRO_32_PCREL.  */
12571     case EM_VISIUM:
12572       return reloc_type == 6;  /* R_VISIUM_32_PCREL */
12573     case EM_X86_64:
12574     case EM_L1OM:
12575     case EM_K1OM:
12576       return reloc_type == 2;  /* R_X86_64_PC32.  */
12577     case EM_XTENSA_OLD:
12578     case EM_XTENSA:
12579       return reloc_type == 14; /* R_XTENSA_32_PCREL.  */
12580     default:
12581       /* Do not abort or issue an error message here.  Not all targets use
12582          pc-relative 32-bit relocs in their DWARF debug information and we
12583          have already tested for target coverage in is_32bit_abs_reloc.  A
12584          more helpful warning message will be generated by apply_relocations
12585          anyway, so just return.  */
12586       return FALSE;
12587     }
12588 }
12589
12590 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12591    a 64-bit absolute RELA relocation used in DWARF debug sections.  */
12592
12593 static bfd_boolean
12594 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12595 {
12596   switch (filedata->file_header.e_machine)
12597     {
12598     case EM_AARCH64:
12599       return reloc_type == 257; /* R_AARCH64_ABS64.  */
12600     case EM_ALPHA:
12601       return reloc_type == 2; /* R_ALPHA_REFQUAD.  */
12602     case EM_IA_64:
12603       return (reloc_type == 0x26    /* R_IA64_DIR64MSB.  */
12604               || reloc_type == 0x27 /* R_IA64_DIR64LSB.  */);
12605     case EM_PARISC:
12606       return reloc_type == 80; /* R_PARISC_DIR64.  */
12607     case EM_PPC64:
12608       return reloc_type == 38; /* R_PPC64_ADDR64.  */
12609     case EM_RISCV:
12610       return reloc_type == 2; /* R_RISCV_64.  */
12611     case EM_SPARC32PLUS:
12612     case EM_SPARCV9:
12613     case EM_SPARC:
12614       return reloc_type == 32 /* R_SPARC_64.  */
12615         || reloc_type == 54; /* R_SPARC_UA64.  */
12616     case EM_X86_64:
12617     case EM_L1OM:
12618     case EM_K1OM:
12619       return reloc_type == 1; /* R_X86_64_64.  */
12620     case EM_S390_OLD:
12621     case EM_S390:
12622       return reloc_type == 22;  /* R_S390_64.  */
12623     case EM_TILEGX:
12624       return reloc_type == 1; /* R_TILEGX_64.  */
12625     case EM_MIPS:
12626       return reloc_type == 18;  /* R_MIPS_64.  */
12627     default:
12628       return FALSE;
12629     }
12630 }
12631
12632 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12633    a 64-bit pc-relative RELA relocation used in DWARF debug sections.  */
12634
12635 static bfd_boolean
12636 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12637 {
12638   switch (filedata->file_header.e_machine)
12639     {
12640     case EM_AARCH64:
12641       return reloc_type == 260; /* R_AARCH64_PREL64.  */
12642     case EM_ALPHA:
12643       return reloc_type == 11; /* R_ALPHA_SREL64.  */
12644     case EM_IA_64:
12645       return (reloc_type == 0x4e    /* R_IA64_PCREL64MSB.  */
12646               || reloc_type == 0x4f /* R_IA64_PCREL64LSB.  */);
12647     case EM_PARISC:
12648       return reloc_type == 72; /* R_PARISC_PCREL64.  */
12649     case EM_PPC64:
12650       return reloc_type == 44; /* R_PPC64_REL64.  */
12651     case EM_SPARC32PLUS:
12652     case EM_SPARCV9:
12653     case EM_SPARC:
12654       return reloc_type == 46; /* R_SPARC_DISP64.  */
12655     case EM_X86_64:
12656     case EM_L1OM:
12657     case EM_K1OM:
12658       return reloc_type == 24; /* R_X86_64_PC64.  */
12659     case EM_S390_OLD:
12660     case EM_S390:
12661       return reloc_type == 23;  /* R_S390_PC64.  */
12662     case EM_TILEGX:
12663       return reloc_type == 5;  /* R_TILEGX_64_PCREL.  */
12664     default:
12665       return FALSE;
12666     }
12667 }
12668
12669 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12670    a 24-bit absolute RELA relocation used in DWARF debug sections.  */
12671
12672 static bfd_boolean
12673 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12674 {
12675   switch (filedata->file_header.e_machine)
12676     {
12677     case EM_CYGNUS_MN10200:
12678     case EM_MN10200:
12679       return reloc_type == 4; /* R_MN10200_24.  */
12680     case EM_FT32:
12681       return reloc_type == 5; /* R_FT32_20.  */
12682     default:
12683       return FALSE;
12684     }
12685 }
12686
12687 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12688    a 16-bit absolute RELA relocation used in DWARF debug sections.  */
12689
12690 static bfd_boolean
12691 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12692 {
12693   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12694   switch (filedata->file_header.e_machine)
12695     {
12696     case EM_ARC:
12697     case EM_ARC_COMPACT:
12698     case EM_ARC_COMPACT2:
12699       return reloc_type == 2; /* R_ARC_16.  */
12700     case EM_ADAPTEVA_EPIPHANY:
12701       return reloc_type == 5;
12702     case EM_AVR_OLD:
12703     case EM_AVR:
12704       return reloc_type == 4; /* R_AVR_16.  */
12705     case EM_CYGNUS_D10V:
12706     case EM_D10V:
12707       return reloc_type == 3; /* R_D10V_16.  */
12708     case EM_FT32:
12709       return reloc_type == 2; /* R_FT32_16.  */
12710     case EM_H8S:
12711     case EM_H8_300:
12712     case EM_H8_300H:
12713       return reloc_type == R_H8_DIR16;
12714     case EM_IP2K_OLD:
12715     case EM_IP2K:
12716       return reloc_type == 1; /* R_IP2K_16.  */
12717     case EM_M32C_OLD:
12718     case EM_M32C:
12719       return reloc_type == 1; /* R_M32C_16 */
12720     case EM_CYGNUS_MN10200:
12721     case EM_MN10200:
12722       return reloc_type == 2; /* R_MN10200_16.  */
12723     case EM_CYGNUS_MN10300:
12724     case EM_MN10300:
12725       return reloc_type == 2; /* R_MN10300_16.  */
12726     case EM_MSP430:
12727       if (uses_msp430x_relocs (filedata))
12728         return reloc_type == 2; /* R_MSP430_ABS16.  */
12729       /* Fall through.  */
12730     case EM_MSP430_OLD:
12731       return reloc_type == 5; /* R_MSP430_16_BYTE.  */
12732     case EM_NDS32:
12733       return reloc_type == 19; /* R_NDS32_RELA.  */
12734     case EM_ALTERA_NIOS2:
12735       return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16.  */
12736     case EM_NIOS32:
12737       return reloc_type == 9; /* R_NIOS_16.  */
12738     case EM_OR1K:
12739       return reloc_type == 2; /* R_OR1K_16.  */
12740     case EM_RISCV:
12741       return reloc_type == 55; /* R_RISCV_SET16.  */
12742     case EM_TI_PRU:
12743       return reloc_type == 8; /* R_PRU_BFD_RELOC_16.  */
12744     case EM_TI_C6000:
12745       return reloc_type == 2; /* R_C6000_ABS16.  */
12746     case EM_VISIUM:
12747       return reloc_type == 2; /* R_VISIUM_16. */
12748     case EM_XC16X:
12749     case EM_C166:
12750       return reloc_type == 2; /* R_XC16C_ABS_16.  */
12751     case EM_XGATE:
12752       return reloc_type == 3; /* R_XGATE_16.  */
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 8-bit absolute RELA relocation used in DWARF debug sections.  */
12760
12761 static bfd_boolean
12762 is_8bit_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 == 54; /* R_RISCV_SET8.  */
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 6-bit absolute RELA relocation used in DWARF debug sections.  */
12775
12776 static bfd_boolean
12777 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12778 {
12779   switch (filedata->file_header.e_machine)
12780     {
12781     case EM_RISCV:
12782       return reloc_type == 53; /* R_RISCV_SET6.  */
12783     default:
12784       return FALSE;
12785     }
12786 }
12787
12788 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12789    a 32-bit inplace add RELA relocation used in DWARF debug sections.  */
12790
12791 static bfd_boolean
12792 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12793 {
12794   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12795   switch (filedata->file_header.e_machine)
12796     {
12797     case EM_RISCV:
12798       return reloc_type == 35; /* R_RISCV_ADD32.  */
12799     default:
12800       return FALSE;
12801     }
12802 }
12803
12804 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12805    a 32-bit inplace sub RELA relocation used in DWARF debug sections.  */
12806
12807 static bfd_boolean
12808 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12809 {
12810   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12811   switch (filedata->file_header.e_machine)
12812     {
12813     case EM_RISCV:
12814       return reloc_type == 39; /* R_RISCV_SUB32.  */
12815     default:
12816       return FALSE;
12817     }
12818 }
12819
12820 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12821    a 64-bit inplace add RELA relocation used in DWARF debug sections.  */
12822
12823 static bfd_boolean
12824 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12825 {
12826   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12827   switch (filedata->file_header.e_machine)
12828     {
12829     case EM_RISCV:
12830       return reloc_type == 36; /* R_RISCV_ADD64.  */
12831     default:
12832       return FALSE;
12833     }
12834 }
12835
12836 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12837    a 64-bit inplace sub RELA relocation used in DWARF debug sections.  */
12838
12839 static bfd_boolean
12840 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12841 {
12842   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12843   switch (filedata->file_header.e_machine)
12844     {
12845     case EM_RISCV:
12846       return reloc_type == 40; /* R_RISCV_SUB64.  */
12847     default:
12848       return FALSE;
12849     }
12850 }
12851
12852 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12853    a 16-bit inplace add RELA relocation used in DWARF debug sections.  */
12854
12855 static bfd_boolean
12856 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12857 {
12858   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12859   switch (filedata->file_header.e_machine)
12860     {
12861     case EM_RISCV:
12862       return reloc_type == 34; /* R_RISCV_ADD16.  */
12863     default:
12864       return FALSE;
12865     }
12866 }
12867
12868 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12869    a 16-bit inplace sub RELA relocation used in DWARF debug sections.  */
12870
12871 static bfd_boolean
12872 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12873 {
12874   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12875   switch (filedata->file_header.e_machine)
12876     {
12877     case EM_RISCV:
12878       return reloc_type == 38; /* R_RISCV_SUB16.  */
12879     default:
12880       return FALSE;
12881     }
12882 }
12883
12884 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12885    a 8-bit inplace add RELA relocation used in DWARF debug sections.  */
12886
12887 static bfd_boolean
12888 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12889 {
12890   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12891   switch (filedata->file_header.e_machine)
12892     {
12893     case EM_RISCV:
12894       return reloc_type == 33; /* R_RISCV_ADD8.  */
12895     default:
12896       return FALSE;
12897     }
12898 }
12899
12900 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12901    a 8-bit inplace sub RELA relocation used in DWARF debug sections.  */
12902
12903 static bfd_boolean
12904 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12905 {
12906   /* Please keep this table alpha-sorted for ease of visual lookup.  */
12907   switch (filedata->file_header.e_machine)
12908     {
12909     case EM_RISCV:
12910       return reloc_type == 37; /* R_RISCV_SUB8.  */
12911     default:
12912       return FALSE;
12913     }
12914 }
12915
12916 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12917    a 6-bit inplace sub RELA relocation used in DWARF debug sections.  */
12918
12919 static bfd_boolean
12920 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12921 {
12922   switch (filedata->file_header.e_machine)
12923     {
12924     case EM_RISCV:
12925       return reloc_type == 52; /* R_RISCV_SUB6.  */
12926     default:
12927       return FALSE;
12928     }
12929 }
12930
12931 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12932    relocation entries (possibly formerly used for SHT_GROUP sections).  */
12933
12934 static bfd_boolean
12935 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12936 {
12937   switch (filedata->file_header.e_machine)
12938     {
12939     case EM_386:     /* R_386_NONE.  */
12940     case EM_68K:     /* R_68K_NONE.  */
12941     case EM_ADAPTEVA_EPIPHANY:
12942     case EM_ALPHA:   /* R_ALPHA_NONE.  */
12943     case EM_ALTERA_NIOS2: /* R_NIOS2_NONE.  */
12944     case EM_ARC:     /* R_ARC_NONE.  */
12945     case EM_ARC_COMPACT2: /* R_ARC_NONE.  */
12946     case EM_ARC_COMPACT: /* R_ARC_NONE.  */
12947     case EM_ARM:     /* R_ARM_NONE.  */
12948     case EM_C166:    /* R_XC16X_NONE.  */
12949     case EM_CRIS:    /* R_CRIS_NONE.  */
12950     case EM_FT32:    /* R_FT32_NONE.  */
12951     case EM_IA_64:   /* R_IA64_NONE.  */
12952     case EM_K1OM:    /* R_X86_64_NONE.  */
12953     case EM_L1OM:    /* R_X86_64_NONE.  */
12954     case EM_M32R:    /* R_M32R_NONE.  */
12955     case EM_MIPS:    /* R_MIPS_NONE.  */
12956     case EM_MN10300: /* R_MN10300_NONE.  */
12957     case EM_MOXIE:   /* R_MOXIE_NONE.  */
12958     case EM_NIOS32:  /* R_NIOS_NONE.  */
12959     case EM_OR1K:    /* R_OR1K_NONE. */
12960     case EM_PARISC:  /* R_PARISC_NONE.  */
12961     case EM_PPC64:   /* R_PPC64_NONE.  */
12962     case EM_PPC:     /* R_PPC_NONE.  */
12963     case EM_RISCV:   /* R_RISCV_NONE.  */
12964     case EM_S390:    /* R_390_NONE.  */
12965     case EM_S390_OLD:
12966     case EM_SH:      /* R_SH_NONE.  */
12967     case EM_SPARC32PLUS:
12968     case EM_SPARC:   /* R_SPARC_NONE.  */
12969     case EM_SPARCV9:
12970     case EM_TILEGX:  /* R_TILEGX_NONE.  */
12971     case EM_TILEPRO: /* R_TILEPRO_NONE.  */
12972     case EM_TI_C6000:/* R_C6000_NONE.  */
12973     case EM_X86_64:  /* R_X86_64_NONE.  */
12974     case EM_XC16X:
12975     case EM_WEBASSEMBLY: /* R_WASM32_NONE.  */
12976       return reloc_type == 0;
12977
12978     case EM_AARCH64:
12979       return reloc_type == 0 || reloc_type == 256;
12980     case EM_AVR_OLD:
12981     case EM_AVR:
12982       return (reloc_type == 0 /* R_AVR_NONE.  */
12983               || reloc_type == 30 /* R_AVR_DIFF8.  */
12984               || reloc_type == 31 /* R_AVR_DIFF16.  */
12985               || reloc_type == 32 /* R_AVR_DIFF32.  */);
12986     case EM_METAG:
12987       return reloc_type == 3; /* R_METAG_NONE.  */
12988     case EM_NDS32:
12989       return (reloc_type == 0       /* R_XTENSA_NONE.  */
12990               || reloc_type == 204  /* R_NDS32_DIFF8.  */
12991               || reloc_type == 205  /* R_NDS32_DIFF16.  */
12992               || reloc_type == 206  /* R_NDS32_DIFF32.  */
12993               || reloc_type == 207  /* R_NDS32_ULEB128.  */);
12994     case EM_TI_PRU:
12995       return (reloc_type == 0       /* R_PRU_NONE.  */
12996               || reloc_type == 65   /* R_PRU_DIFF8.  */
12997               || reloc_type == 66   /* R_PRU_DIFF16.  */
12998               || reloc_type == 67   /* R_PRU_DIFF32.  */);
12999     case EM_XTENSA_OLD:
13000     case EM_XTENSA:
13001       return (reloc_type == 0      /* R_XTENSA_NONE.  */
13002               || reloc_type == 17  /* R_XTENSA_DIFF8.  */
13003               || reloc_type == 18  /* R_XTENSA_DIFF16.  */
13004               || reloc_type == 19  /* R_XTENSA_DIFF32.  */);
13005     }
13006   return FALSE;
13007 }
13008
13009 /* Returns TRUE if there is a relocation against
13010    section NAME at OFFSET bytes.  */
13011
13012 bfd_boolean
13013 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13014 {
13015   Elf_Internal_Rela * relocs;
13016   Elf_Internal_Rela * rp;
13017
13018   if (dsec == NULL || dsec->reloc_info == NULL)
13019     return FALSE;
13020
13021   relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13022
13023   for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13024     if (rp->r_offset == offset)
13025       return TRUE;
13026
13027    return FALSE;
13028 }
13029
13030 /* Apply relocations to a section.
13031    Returns TRUE upon success, FALSE otherwise.
13032    If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13033    It is then the caller's responsibility to free them.  NUM_RELOCS_RETURN
13034    will be set to the number of relocs loaded.
13035
13036    Note: So far support has been added only for those relocations
13037    which can be found in debug sections. FIXME: Add support for
13038    more relocations ?  */
13039
13040 static bfd_boolean
13041 apply_relocations (Filedata *                 filedata,
13042                    const Elf_Internal_Shdr *  section,
13043                    unsigned char *            start,
13044                    bfd_size_type              size,
13045                    void **                    relocs_return,
13046                    unsigned long *            num_relocs_return)
13047 {
13048   Elf_Internal_Shdr * relsec;
13049   unsigned char * end = start + size;
13050
13051   if (relocs_return != NULL)
13052     {
13053       * (Elf_Internal_Rela **) relocs_return = NULL;
13054       * num_relocs_return = 0;
13055     }
13056
13057   if (filedata->file_header.e_type != ET_REL)
13058     /* No relocs to apply.  */
13059     return TRUE;
13060
13061   /* Find the reloc section associated with the section.  */
13062   for (relsec = filedata->section_headers;
13063        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13064        ++relsec)
13065     {
13066       bfd_boolean is_rela;
13067       unsigned long num_relocs;
13068       Elf_Internal_Rela * relocs;
13069       Elf_Internal_Rela * rp;
13070       Elf_Internal_Shdr * symsec;
13071       Elf_Internal_Sym * symtab;
13072       unsigned long num_syms;
13073       Elf_Internal_Sym * sym;
13074
13075       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13076           || relsec->sh_info >= filedata->file_header.e_shnum
13077           || filedata->section_headers + relsec->sh_info != section
13078           || relsec->sh_size == 0
13079           || relsec->sh_link >= filedata->file_header.e_shnum)
13080         continue;
13081
13082       is_rela = relsec->sh_type == SHT_RELA;
13083
13084       if (is_rela)
13085         {
13086           if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13087                                   relsec->sh_size, & relocs, & num_relocs))
13088             return FALSE;
13089         }
13090       else
13091         {
13092           if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13093                                  relsec->sh_size, & relocs, & num_relocs))
13094             return FALSE;
13095         }
13096
13097       /* SH uses RELA but uses in place value instead of the addend field.  */
13098       if (filedata->file_header.e_machine == EM_SH)
13099         is_rela = FALSE;
13100
13101       symsec = filedata->section_headers + relsec->sh_link;
13102       if (symsec->sh_type != SHT_SYMTAB
13103           && symsec->sh_type != SHT_DYNSYM)
13104         return FALSE;
13105       symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13106
13107       for (rp = relocs; rp < relocs + num_relocs; ++rp)
13108         {
13109           bfd_vma         addend;
13110           unsigned int    reloc_type;
13111           unsigned int    reloc_size;
13112           bfd_boolean     reloc_inplace = FALSE;
13113           bfd_boolean     reloc_subtract = FALSE;
13114           unsigned char * rloc;
13115           unsigned long   sym_index;
13116
13117           reloc_type = get_reloc_type (filedata, rp->r_info);
13118
13119           if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13120             continue;
13121           else if (is_none_reloc (filedata, reloc_type))
13122             continue;
13123           else if (is_32bit_abs_reloc (filedata, reloc_type)
13124                    || is_32bit_pcrel_reloc (filedata, reloc_type))
13125             reloc_size = 4;
13126           else if (is_64bit_abs_reloc (filedata, reloc_type)
13127                    || is_64bit_pcrel_reloc (filedata, reloc_type))
13128             reloc_size = 8;
13129           else if (is_24bit_abs_reloc (filedata, reloc_type))
13130             reloc_size = 3;
13131           else if (is_16bit_abs_reloc (filedata, reloc_type))
13132             reloc_size = 2;
13133           else if (is_8bit_abs_reloc (filedata, reloc_type)
13134                    || is_6bit_abs_reloc (filedata, reloc_type))
13135             reloc_size = 1;
13136           else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13137                                                                  reloc_type))
13138                    || is_32bit_inplace_add_reloc (filedata, reloc_type))
13139             {
13140               reloc_size = 4;
13141               reloc_inplace = TRUE;
13142             }
13143           else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13144                                                                  reloc_type))
13145                    || is_64bit_inplace_add_reloc (filedata, reloc_type))
13146             {
13147               reloc_size = 8;
13148               reloc_inplace = TRUE;
13149             }
13150           else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13151                                                                  reloc_type))
13152                    || is_16bit_inplace_add_reloc (filedata, reloc_type))
13153             {
13154               reloc_size = 2;
13155               reloc_inplace = TRUE;
13156             }
13157           else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13158                                                                 reloc_type))
13159                    || is_8bit_inplace_add_reloc (filedata, reloc_type))
13160             {
13161               reloc_size = 1;
13162               reloc_inplace = TRUE;
13163             }
13164           else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13165                                                                 reloc_type)))
13166             {
13167               reloc_size = 1;
13168               reloc_inplace = TRUE;
13169             }
13170           else
13171             {
13172               static unsigned int prev_reloc = 0;
13173
13174               if (reloc_type != prev_reloc)
13175                 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13176                       reloc_type, printable_section_name (filedata, section));
13177               prev_reloc = reloc_type;
13178               continue;
13179             }
13180
13181           rloc = start + rp->r_offset;
13182           if ((rloc + reloc_size) > end || (rloc < start))
13183             {
13184               warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13185                     (unsigned long) rp->r_offset,
13186                     printable_section_name (filedata, section));
13187               continue;
13188             }
13189
13190           sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13191           if (sym_index >= num_syms)
13192             {
13193               warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13194                     sym_index, printable_section_name (filedata, section));
13195               continue;
13196             }
13197           sym = symtab + sym_index;
13198
13199           /* If the reloc has a symbol associated with it,
13200              make sure that it is of an appropriate type.
13201
13202              Relocations against symbols without type can happen.
13203              Gcc -feliminate-dwarf2-dups may generate symbols
13204              without type for debug info.
13205
13206              Icc generates relocations against function symbols
13207              instead of local labels.
13208
13209              Relocations against object symbols can happen, eg when
13210              referencing a global array.  For an example of this see
13211              the _clz.o binary in libgcc.a.  */
13212           if (sym != symtab
13213               && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13214               && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13215             {
13216               warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13217                     get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13218                     printable_section_name (filedata, relsec),
13219                     (long int)(rp - relocs));
13220               continue;
13221             }
13222
13223           addend = 0;
13224           if (is_rela)
13225             addend += rp->r_addend;
13226           /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13227              partial_inplace.  */
13228           if (!is_rela
13229               || (filedata->file_header.e_machine == EM_XTENSA
13230                   && reloc_type == 1)
13231               || ((filedata->file_header.e_machine == EM_PJ
13232                    || filedata->file_header.e_machine == EM_PJ_OLD)
13233                   && reloc_type == 1)
13234               || ((filedata->file_header.e_machine == EM_D30V
13235                    || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13236                   && reloc_type == 12)
13237               || reloc_inplace)
13238             {
13239               if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13240                 addend += byte_get (rloc, reloc_size) & 0x3f;
13241               else
13242                 addend += byte_get (rloc, reloc_size);
13243             }
13244
13245           if (is_32bit_pcrel_reloc (filedata, reloc_type)
13246               || is_64bit_pcrel_reloc (filedata, reloc_type))
13247             {
13248               /* On HPPA, all pc-relative relocations are biased by 8.  */
13249               if (filedata->file_header.e_machine == EM_PARISC)
13250                 addend -= 8;
13251               byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13252                         reloc_size);
13253             }
13254           else if (is_6bit_abs_reloc (filedata, reloc_type)
13255                    || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13256             {
13257               if (reloc_subtract)
13258                 addend -= sym->st_value;
13259               else
13260                 addend += sym->st_value;
13261               addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13262               byte_put (rloc, addend, reloc_size);
13263             }
13264           else if (reloc_subtract)
13265             byte_put (rloc, addend - sym->st_value, reloc_size);
13266           else
13267             byte_put (rloc, addend + sym->st_value, reloc_size);
13268         }
13269
13270       free (symtab);
13271       /* Let the target specific reloc processing code know that
13272          we have finished with these relocs.  */
13273       target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13274
13275       if (relocs_return)
13276         {
13277           * (Elf_Internal_Rela **) relocs_return = relocs;
13278           * num_relocs_return = num_relocs;
13279         }
13280       else
13281         free (relocs);
13282
13283       break;
13284     }
13285
13286   return TRUE;
13287 }
13288
13289 #ifdef SUPPORT_DISASSEMBLY
13290 static bfd_boolean
13291 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13292 {
13293   printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13294
13295   /* FIXME: XXX -- to be done --- XXX */
13296
13297   return TRUE;
13298 }
13299 #endif
13300
13301 /* Reads in the contents of SECTION from FILE, returning a pointer
13302    to a malloc'ed buffer or NULL if something went wrong.  */
13303
13304 static char *
13305 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13306 {
13307   bfd_size_type num_bytes = section->sh_size;
13308
13309   if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13310     {
13311       printf (_("Section '%s' has no data to dump.\n"),
13312               printable_section_name (filedata, section));
13313       return NULL;
13314     }
13315
13316   return  (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13317                              _("section contents"));
13318 }
13319
13320 /* Uncompresses a section that was compressed using zlib, in place.  */
13321
13322 static bfd_boolean
13323 uncompress_section_contents (unsigned char **   buffer,
13324                              dwarf_size_type    uncompressed_size,
13325                              dwarf_size_type *  size)
13326 {
13327   dwarf_size_type compressed_size = *size;
13328   unsigned char * compressed_buffer = *buffer;
13329   unsigned char * uncompressed_buffer;
13330   z_stream strm;
13331   int rc;
13332
13333   /* It is possible the section consists of several compressed
13334      buffers concatenated together, so we uncompress in a loop.  */
13335   /* PR 18313: The state field in the z_stream structure is supposed
13336      to be invisible to the user (ie us), but some compilers will
13337      still complain about it being used without initialisation.  So
13338      we first zero the entire z_stream structure and then set the fields
13339      that we need.  */
13340   memset (& strm, 0, sizeof strm);
13341   strm.avail_in = compressed_size;
13342   strm.next_in = (Bytef *) compressed_buffer;
13343   strm.avail_out = uncompressed_size;
13344   uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13345
13346   rc = inflateInit (& strm);
13347   while (strm.avail_in > 0)
13348     {
13349       if (rc != Z_OK)
13350         goto fail;
13351       strm.next_out = ((Bytef *) uncompressed_buffer
13352                        + (uncompressed_size - strm.avail_out));
13353       rc = inflate (&strm, Z_FINISH);
13354       if (rc != Z_STREAM_END)
13355         goto fail;
13356       rc = inflateReset (& strm);
13357     }
13358   rc = inflateEnd (& strm);
13359   if (rc != Z_OK
13360       || strm.avail_out != 0)
13361     goto fail;
13362
13363   *buffer = uncompressed_buffer;
13364   *size = uncompressed_size;
13365   return TRUE;
13366
13367  fail:
13368   free (uncompressed_buffer);
13369   /* Indicate decompression failure.  */
13370   *buffer = NULL;
13371   return FALSE;
13372 }
13373
13374 static bfd_boolean
13375 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13376 {
13377   Elf_Internal_Shdr *  relsec;
13378   bfd_size_type        num_bytes;
13379   unsigned char *      data;
13380   unsigned char *      end;
13381   unsigned char *      real_start;
13382   unsigned char *      start;
13383   bfd_boolean          some_strings_shown;
13384
13385   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13386   if (start == NULL)
13387     /* PR 21820: Do not fail if the section was empty.  */
13388     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13389
13390   num_bytes = section->sh_size;
13391
13392   printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13393
13394   if (decompress_dumps)
13395     {
13396       dwarf_size_type new_size = num_bytes;
13397       dwarf_size_type uncompressed_size = 0;
13398
13399       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13400         {
13401           Elf_Internal_Chdr chdr;
13402           unsigned int compression_header_size
13403             = get_compression_header (& chdr, (unsigned char *) start,
13404                                       num_bytes);
13405
13406           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13407             {
13408               warn (_("section '%s' has unsupported compress type: %d\n"),
13409                     printable_section_name (filedata, section), chdr.ch_type);
13410               return FALSE;
13411             }
13412           uncompressed_size = chdr.ch_size;
13413           start += compression_header_size;
13414           new_size -= compression_header_size;
13415         }
13416       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13417         {
13418           /* Read the zlib header.  In this case, it should be "ZLIB"
13419              followed by the uncompressed section size, 8 bytes in
13420              big-endian order.  */
13421           uncompressed_size = start[4]; uncompressed_size <<= 8;
13422           uncompressed_size += start[5]; uncompressed_size <<= 8;
13423           uncompressed_size += start[6]; uncompressed_size <<= 8;
13424           uncompressed_size += start[7]; uncompressed_size <<= 8;
13425           uncompressed_size += start[8]; uncompressed_size <<= 8;
13426           uncompressed_size += start[9]; uncompressed_size <<= 8;
13427           uncompressed_size += start[10]; uncompressed_size <<= 8;
13428           uncompressed_size += start[11];
13429           start += 12;
13430           new_size -= 12;
13431         }
13432
13433       if (uncompressed_size)
13434         {
13435           if (uncompress_section_contents (& start,
13436                                            uncompressed_size, & new_size))
13437             num_bytes = new_size;
13438           else
13439             {
13440               error (_("Unable to decompress section %s\n"),
13441                      printable_section_name (filedata, section));
13442               return FALSE;
13443             }
13444         }
13445       else
13446         start = real_start;
13447     }
13448
13449   /* If the section being dumped has relocations against it the user might
13450      be expecting these relocations to have been applied.  Check for this
13451      case and issue a warning message in order to avoid confusion.
13452      FIXME: Maybe we ought to have an option that dumps a section with
13453      relocs applied ?  */
13454   for (relsec = filedata->section_headers;
13455        relsec < filedata->section_headers + filedata->file_header.e_shnum;
13456        ++relsec)
13457     {
13458       if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13459           || relsec->sh_info >= filedata->file_header.e_shnum
13460           || filedata->section_headers + relsec->sh_info != section
13461           || relsec->sh_size == 0
13462           || relsec->sh_link >= filedata->file_header.e_shnum)
13463         continue;
13464
13465       printf (_("  Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13466       break;
13467     }
13468
13469   data = start;
13470   end  = start + num_bytes;
13471   some_strings_shown = FALSE;
13472
13473   while (data < end)
13474     {
13475       while (!ISPRINT (* data))
13476         if (++ data >= end)
13477           break;
13478
13479       if (data < end)
13480         {
13481           size_t maxlen = end - data;
13482
13483 #ifndef __MSVCRT__
13484           /* PR 11128: Use two separate invocations in order to work
13485              around bugs in the Solaris 8 implementation of printf.  */
13486           printf ("  [%6tx]  ", data - start);
13487 #else
13488           printf ("  [%6Ix]  ", (size_t) (data - start));
13489 #endif
13490           if (maxlen > 0)
13491             {
13492               print_symbol ((int) maxlen, (const char *) data);
13493               putchar ('\n');
13494               data += strnlen ((const char *) data, maxlen);
13495             }
13496           else
13497             {
13498               printf (_("<corrupt>\n"));
13499               data = end;
13500             }
13501           some_strings_shown = TRUE;
13502         }
13503     }
13504
13505   if (! some_strings_shown)
13506     printf (_("  No strings found in this section."));
13507
13508   free (real_start);
13509
13510   putchar ('\n');
13511   return TRUE;
13512 }
13513
13514 static bfd_boolean
13515 dump_section_as_bytes (Elf_Internal_Shdr *  section,
13516                        Filedata *           filedata,
13517                        bfd_boolean          relocate)
13518 {
13519   Elf_Internal_Shdr * relsec;
13520   bfd_size_type       bytes;
13521   bfd_size_type       section_size;
13522   bfd_vma             addr;
13523   unsigned char *     data;
13524   unsigned char *     real_start;
13525   unsigned char *     start;
13526
13527   real_start = start = (unsigned char *) get_section_contents (section, filedata);
13528   if (start == NULL)
13529     /* PR 21820: Do not fail if the section was empty.  */
13530     return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13531
13532   section_size = section->sh_size;
13533
13534   printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13535
13536   if (decompress_dumps)
13537     {
13538       dwarf_size_type new_size = section_size;
13539       dwarf_size_type uncompressed_size = 0;
13540
13541       if ((section->sh_flags & SHF_COMPRESSED) != 0)
13542         {
13543           Elf_Internal_Chdr chdr;
13544           unsigned int compression_header_size
13545             = get_compression_header (& chdr, start, section_size);
13546
13547           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13548             {
13549               warn (_("section '%s' has unsupported compress type: %d\n"),
13550                     printable_section_name (filedata, section), chdr.ch_type);
13551               return FALSE;
13552             }
13553           uncompressed_size = chdr.ch_size;
13554           start += compression_header_size;
13555           new_size -= compression_header_size;
13556         }
13557       else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13558         {
13559           /* Read the zlib header.  In this case, it should be "ZLIB"
13560              followed by the uncompressed section size, 8 bytes in
13561              big-endian order.  */
13562           uncompressed_size = start[4]; uncompressed_size <<= 8;
13563           uncompressed_size += start[5]; uncompressed_size <<= 8;
13564           uncompressed_size += start[6]; uncompressed_size <<= 8;
13565           uncompressed_size += start[7]; uncompressed_size <<= 8;
13566           uncompressed_size += start[8]; uncompressed_size <<= 8;
13567           uncompressed_size += start[9]; uncompressed_size <<= 8;
13568           uncompressed_size += start[10]; uncompressed_size <<= 8;
13569           uncompressed_size += start[11];
13570           start += 12;
13571           new_size -= 12;
13572         }
13573
13574       if (uncompressed_size)
13575         {
13576           if (uncompress_section_contents (& start, uncompressed_size,
13577                                            & new_size))
13578             {
13579               section_size = new_size;
13580             }
13581           else
13582             {
13583               error (_("Unable to decompress section %s\n"),
13584                      printable_section_name (filedata, section));
13585               /* FIXME: Print the section anyway ?  */
13586               return FALSE;
13587             }
13588         }
13589       else
13590         start = real_start;
13591     }
13592
13593   if (relocate)
13594     {
13595       if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13596         return FALSE;
13597     }
13598   else
13599     {
13600       /* If the section being dumped has relocations against it the user might
13601          be expecting these relocations to have been applied.  Check for this
13602          case and issue a warning message in order to avoid confusion.
13603          FIXME: Maybe we ought to have an option that dumps a section with
13604          relocs applied ?  */
13605       for (relsec = filedata->section_headers;
13606            relsec < filedata->section_headers + filedata->file_header.e_shnum;
13607            ++relsec)
13608         {
13609           if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13610               || relsec->sh_info >= filedata->file_header.e_shnum
13611               || filedata->section_headers + relsec->sh_info != section
13612               || relsec->sh_size == 0
13613               || relsec->sh_link >= filedata->file_header.e_shnum)
13614             continue;
13615
13616           printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13617           break;
13618         }
13619     }
13620
13621   addr = section->sh_addr;
13622   bytes = section_size;
13623   data = start;
13624
13625   while (bytes)
13626     {
13627       int j;
13628       int k;
13629       int lbytes;
13630
13631       lbytes = (bytes > 16 ? 16 : bytes);
13632
13633       printf ("  0x%8.8lx ", (unsigned long) addr);
13634
13635       for (j = 0; j < 16; j++)
13636         {
13637           if (j < lbytes)
13638             printf ("%2.2x", data[j]);
13639           else
13640             printf ("  ");
13641
13642           if ((j & 3) == 3)
13643             printf (" ");
13644         }
13645
13646       for (j = 0; j < lbytes; j++)
13647         {
13648           k = data[j];
13649           if (k >= ' ' && k < 0x7f)
13650             printf ("%c", k);
13651           else
13652             printf (".");
13653         }
13654
13655       putchar ('\n');
13656
13657       data  += lbytes;
13658       addr  += lbytes;
13659       bytes -= lbytes;
13660     }
13661
13662   free (real_start);
13663
13664   putchar ('\n');
13665   return TRUE;
13666 }
13667
13668 static bfd_boolean
13669 load_specific_debug_section (enum dwarf_section_display_enum  debug,
13670                              const Elf_Internal_Shdr *        sec,
13671                              void *                           data)
13672 {
13673   struct dwarf_section * section = &debug_displays [debug].section;
13674   char buf [64];
13675   Filedata * filedata = (Filedata *) data;
13676
13677   if (section->start != NULL)
13678     {
13679       /* If it is already loaded, do nothing.  */
13680       if (streq (section->filename, filedata->file_name))
13681         return TRUE;
13682       free (section->start);
13683     }
13684
13685   snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13686   section->address = sec->sh_addr;
13687   section->user_data = NULL;
13688   section->filename = filedata->file_name;
13689   section->start = (unsigned char *) get_data (NULL, filedata,
13690                                                sec->sh_offset, 1,
13691                                                sec->sh_size, buf);
13692   if (section->start == NULL)
13693     section->size = 0;
13694   else
13695     {
13696       unsigned char *start = section->start;
13697       dwarf_size_type size = sec->sh_size;
13698       dwarf_size_type uncompressed_size = 0;
13699
13700       if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13701         {
13702           Elf_Internal_Chdr chdr;
13703           unsigned int compression_header_size;
13704
13705           if (size < (is_32bit_elf
13706                       ? sizeof (Elf32_External_Chdr)
13707                       : sizeof (Elf64_External_Chdr)))
13708             {
13709               warn (_("compressed section %s is too small to contain a compression header"),
13710                     section->name);
13711               return FALSE;
13712             }
13713
13714           compression_header_size = get_compression_header (&chdr, start, size);
13715
13716           if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13717             {
13718               warn (_("section '%s' has unsupported compress type: %d\n"),
13719                     section->name, chdr.ch_type);
13720               return FALSE;
13721             }
13722           uncompressed_size = chdr.ch_size;
13723           start += compression_header_size;
13724           size -= compression_header_size;
13725         }
13726       else if (size > 12 && streq ((char *) start, "ZLIB"))
13727         {
13728           /* Read the zlib header.  In this case, it should be "ZLIB"
13729              followed by the uncompressed section size, 8 bytes in
13730              big-endian order.  */
13731           uncompressed_size = start[4]; uncompressed_size <<= 8;
13732           uncompressed_size += start[5]; uncompressed_size <<= 8;
13733           uncompressed_size += start[6]; uncompressed_size <<= 8;
13734           uncompressed_size += start[7]; uncompressed_size <<= 8;
13735           uncompressed_size += start[8]; uncompressed_size <<= 8;
13736           uncompressed_size += start[9]; uncompressed_size <<= 8;
13737           uncompressed_size += start[10]; uncompressed_size <<= 8;
13738           uncompressed_size += start[11];
13739           start += 12;
13740           size -= 12;
13741         }
13742
13743       if (uncompressed_size)
13744         {
13745           if (uncompress_section_contents (&start, uncompressed_size,
13746                                            &size))
13747             {
13748               /* Free the compressed buffer, update the section buffer
13749                  and the section size if uncompress is successful.  */
13750               free (section->start);
13751               section->start = start;
13752             }
13753           else
13754             {
13755               error (_("Unable to decompress section %s\n"),
13756                      printable_section_name (filedata, sec));
13757               return FALSE;
13758             }
13759         }
13760
13761       section->size = size;
13762     }
13763
13764   if (section->start == NULL)
13765     return FALSE;
13766
13767   if (debug_displays [debug].relocate)
13768     {
13769       if (! apply_relocations (filedata, sec, section->start, section->size,
13770                                & section->reloc_info, & section->num_relocs))
13771         return FALSE;
13772     }
13773   else
13774     {
13775       section->reloc_info = NULL;
13776       section->num_relocs = 0;
13777     }
13778
13779   return TRUE;
13780 }
13781
13782 /* If this is not NULL, load_debug_section will only look for sections
13783    within the list of sections given here.  */
13784 static unsigned int * section_subset = NULL;
13785
13786 bfd_boolean
13787 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13788 {
13789   struct dwarf_section * section = &debug_displays [debug].section;
13790   Elf_Internal_Shdr * sec;
13791   Filedata * filedata = (Filedata *) data;
13792
13793   /* Without section headers we cannot find any sections.  */
13794   if (filedata->section_headers == NULL)
13795     return FALSE;
13796
13797   if (filedata->string_table == NULL
13798       && filedata->file_header.e_shstrndx != SHN_UNDEF
13799       && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13800     {
13801       Elf_Internal_Shdr * strs;
13802
13803       /* Read in the string table, so that we have section names to scan.  */
13804       strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13805
13806       if (strs != NULL && strs->sh_size != 0)
13807         {
13808           filedata->string_table
13809             = (char *) get_data (NULL, filedata, strs->sh_offset,
13810                                  1, strs->sh_size, _("string table"));
13811
13812           filedata->string_table_length
13813             = filedata->string_table != NULL ? strs->sh_size : 0;
13814         }
13815     }
13816
13817   /* Locate the debug section.  */
13818   sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13819   if (sec != NULL)
13820     section->name = section->uncompressed_name;
13821   else
13822     {
13823       sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13824       if (sec != NULL)
13825         section->name = section->compressed_name;
13826     }
13827   if (sec == NULL)
13828     return FALSE;
13829
13830   /* If we're loading from a subset of sections, and we've loaded
13831      a section matching this name before, it's likely that it's a
13832      different one.  */
13833   if (section_subset != NULL)
13834     free_debug_section (debug);
13835
13836   return load_specific_debug_section (debug, sec, data);
13837 }
13838
13839 void
13840 free_debug_section (enum dwarf_section_display_enum debug)
13841 {
13842   struct dwarf_section * section = &debug_displays [debug].section;
13843
13844   if (section->start == NULL)
13845     return;
13846
13847   free ((char *) section->start);
13848   section->start = NULL;
13849   section->address = 0;
13850   section->size = 0;
13851 }
13852
13853 static bfd_boolean
13854 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13855 {
13856   char * name = SECTION_NAME (section);
13857   const char * print_name = printable_section_name (filedata, section);
13858   bfd_size_type length;
13859   bfd_boolean result = TRUE;
13860   int i;
13861
13862   length = section->sh_size;
13863   if (length == 0)
13864     {
13865       printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13866       return TRUE;
13867     }
13868   if (section->sh_type == SHT_NOBITS)
13869     {
13870       /* There is no point in dumping the contents of a debugging section
13871          which has the NOBITS type - the bits in the file will be random.
13872          This can happen when a file containing a .eh_frame section is
13873          stripped with the --only-keep-debug command line option.  */
13874       printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13875               print_name);
13876       return FALSE;
13877     }
13878
13879   if (const_strneq (name, ".gnu.linkonce.wi."))
13880     name = ".debug_info";
13881
13882   /* See if we know how to display the contents of this section.  */
13883   for (i = 0; i < max; i++)
13884     {
13885       enum dwarf_section_display_enum  id = (enum dwarf_section_display_enum) i;
13886       struct dwarf_section_display *   display = debug_displays + i;
13887       struct dwarf_section *           sec = & display->section;
13888
13889       if (streq (sec->uncompressed_name, name)
13890           || (id == line && const_strneq (name, ".debug_line."))
13891           || streq (sec->compressed_name, name))
13892         {
13893           bfd_boolean secondary = (section != find_section (filedata, name));
13894
13895           if (secondary)
13896             free_debug_section (id);
13897
13898           if (i == line && const_strneq (name, ".debug_line."))
13899             sec->name = name;
13900           else if (streq (sec->uncompressed_name, name))
13901             sec->name = sec->uncompressed_name;
13902           else
13903             sec->name = sec->compressed_name;
13904
13905           if (load_specific_debug_section (id, section, filedata))
13906             {
13907               /* If this debug section is part of a CU/TU set in a .dwp file,
13908                  restrict load_debug_section to the sections in that set.  */
13909               section_subset = find_cu_tu_set (filedata, shndx);
13910
13911               result &= display->display (sec, filedata);
13912
13913               section_subset = NULL;
13914
13915               if (secondary || (id != info && id != abbrev))
13916                 free_debug_section (id);
13917             }
13918           break;
13919         }
13920     }
13921
13922   if (i == max)
13923     {
13924       printf (_("Unrecognized debug section: %s\n"), print_name);
13925       result = FALSE;
13926     }
13927
13928   return result;
13929 }
13930
13931 /* Set DUMP_SECTS for all sections where dumps were requested
13932    based on section name.  */
13933
13934 static void
13935 initialise_dumps_byname (Filedata * filedata)
13936 {
13937   struct dump_list_entry * cur;
13938
13939   for (cur = dump_sects_byname; cur; cur = cur->next)
13940     {
13941       unsigned int i;
13942       bfd_boolean any = FALSE;
13943
13944       for (i = 0; i < filedata->file_header.e_shnum; i++)
13945         if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13946           {
13947             request_dump_bynumber (filedata, i, cur->type);
13948             any = TRUE;
13949           }
13950
13951       if (!any)
13952         warn (_("Section '%s' was not dumped because it does not exist!\n"),
13953               cur->name);
13954     }
13955 }
13956
13957 static bfd_boolean
13958 process_section_contents (Filedata * filedata)
13959 {
13960   Elf_Internal_Shdr * section;
13961   unsigned int i;
13962   bfd_boolean res = TRUE;
13963
13964   if (! do_dump)
13965     return TRUE;
13966
13967   initialise_dumps_byname (filedata);
13968
13969   for (i = 0, section = filedata->section_headers;
13970        i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13971        i++, section++)
13972     {
13973       dump_type dump = filedata->dump_sects[i];
13974
13975 #ifdef SUPPORT_DISASSEMBLY
13976       if (dump & DISASS_DUMP)
13977         {
13978           if (! disassemble_section (section, filedata))
13979             res = FALSE;
13980         }
13981 #endif
13982       if (dump & HEX_DUMP)
13983         {
13984           if (! dump_section_as_bytes (section, filedata, FALSE))
13985             res = FALSE;
13986         }
13987
13988       if (dump & RELOC_DUMP)
13989         {
13990           if (! dump_section_as_bytes (section, filedata, TRUE))
13991             res = FALSE;
13992         }
13993
13994       if (dump & STRING_DUMP)
13995         {
13996           if (! dump_section_as_strings (section, filedata))
13997             res = FALSE;
13998         }
13999
14000       if (dump & DEBUG_DUMP)
14001         {
14002           if (! display_debug_section (i, section, filedata))
14003             res = FALSE;
14004         }
14005     }
14006
14007   /* Check to see if the user requested a
14008      dump of a section that does not exist.  */
14009   while (i < filedata->num_dump_sects)
14010     {
14011       if (filedata->dump_sects[i])
14012         {
14013           warn (_("Section %d was not dumped because it does not exist!\n"), i);
14014           res = FALSE;
14015         }
14016       i++;
14017     }
14018
14019   return res;
14020 }
14021
14022 static void
14023 process_mips_fpe_exception (int mask)
14024 {
14025   if (mask)
14026     {
14027       bfd_boolean first = TRUE;
14028
14029       if (mask & OEX_FPU_INEX)
14030         fputs ("INEX", stdout), first = FALSE;
14031       if (mask & OEX_FPU_UFLO)
14032         printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14033       if (mask & OEX_FPU_OFLO)
14034         printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14035       if (mask & OEX_FPU_DIV0)
14036         printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14037       if (mask & OEX_FPU_INVAL)
14038         printf ("%sINVAL", first ? "" : "|");
14039     }
14040   else
14041     fputs ("0", stdout);
14042 }
14043
14044 /* Display's the value of TAG at location P.  If TAG is
14045    greater than 0 it is assumed to be an unknown tag, and
14046    a message is printed to this effect.  Otherwise it is
14047    assumed that a message has already been printed.
14048
14049    If the bottom bit of TAG is set it assumed to have a
14050    string value, otherwise it is assumed to have an integer
14051    value.
14052
14053    Returns an updated P pointing to the first unread byte
14054    beyond the end of TAG's value.
14055
14056    Reads at or beyond END will not be made.  */
14057
14058 static unsigned char *
14059 display_tag_value (signed int tag,
14060                    unsigned char * p,
14061                    const unsigned char * const end)
14062 {
14063   unsigned long val;
14064
14065   if (tag > 0)
14066     printf ("  Tag_unknown_%d: ", tag);
14067
14068   if (p >= end)
14069     {
14070       warn (_("<corrupt tag>\n"));
14071     }
14072   else if (tag & 1)
14073     {
14074       /* PR 17531 file: 027-19978-0.004.  */
14075       size_t maxlen = (end - p) - 1;
14076
14077       putchar ('"');
14078       if (maxlen > 0)
14079         {
14080           print_symbol ((int) maxlen, (const char *) p);
14081           p += strnlen ((char *) p, maxlen) + 1;
14082         }
14083       else
14084         {
14085           printf (_("<corrupt string tag>"));
14086           p = (unsigned char *) end;
14087         }
14088       printf ("\"\n");
14089     }
14090   else
14091     {
14092       unsigned int len;
14093
14094       val = read_uleb128 (p, &len, end);
14095       p += len;
14096       printf ("%ld (0x%lx)\n", val, val);
14097     }
14098
14099   assert (p <= end);
14100   return p;
14101 }
14102
14103 /* ARC ABI attributes section.  */
14104
14105 static unsigned char *
14106 display_arc_attribute (unsigned char * p,
14107                        const unsigned char * const end)
14108 {
14109   unsigned int tag;
14110   unsigned int len;
14111   unsigned int val;
14112
14113   tag = read_uleb128 (p, &len, end);
14114   p += len;
14115
14116   switch (tag)
14117     {
14118     case Tag_ARC_PCS_config:
14119       val = read_uleb128 (p, &len, end);
14120       p += len;
14121       printf ("  Tag_ARC_PCS_config: ");
14122       switch (val)
14123         {
14124         case 0:
14125           printf (_("Absent/Non standard\n"));
14126           break;
14127         case 1:
14128           printf (_("Bare metal/mwdt\n"));
14129           break;
14130         case 2:
14131           printf (_("Bare metal/newlib\n"));
14132           break;
14133         case 3:
14134           printf (_("Linux/uclibc\n"));
14135           break;
14136         case 4:
14137           printf (_("Linux/glibc\n"));
14138           break;
14139         default:
14140           printf (_("Unknown\n"));
14141           break;
14142         }
14143       break;
14144
14145     case Tag_ARC_CPU_base:
14146       val = read_uleb128 (p, &len, end);
14147       p += len;
14148       printf ("  Tag_ARC_CPU_base: ");
14149       switch (val)
14150         {
14151         default:
14152         case TAG_CPU_NONE:
14153           printf (_("Absent\n"));
14154           break;
14155         case TAG_CPU_ARC6xx:
14156           printf ("ARC6xx\n");
14157           break;
14158         case TAG_CPU_ARC7xx:
14159           printf ("ARC7xx\n");
14160           break;
14161         case TAG_CPU_ARCEM:
14162           printf ("ARCEM\n");
14163           break;
14164         case TAG_CPU_ARCHS:
14165           printf ("ARCHS\n");
14166           break;
14167         }
14168       break;
14169
14170     case Tag_ARC_CPU_variation:
14171       val = read_uleb128 (p, &len, end);
14172       p += len;
14173       printf ("  Tag_ARC_CPU_variation: ");
14174       switch (val)
14175         {
14176         default:
14177           if (val > 0 && val < 16)
14178               printf ("Core%d\n", val);
14179           else
14180               printf ("Unknown\n");
14181           break;
14182
14183         case 0:
14184           printf (_("Absent\n"));
14185           break;
14186         }
14187       break;
14188
14189     case Tag_ARC_CPU_name:
14190       printf ("  Tag_ARC_CPU_name: ");
14191       p = display_tag_value (-1, p, end);
14192       break;
14193
14194     case Tag_ARC_ABI_rf16:
14195       val = read_uleb128 (p, &len, end);
14196       p += len;
14197       printf ("  Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14198       break;
14199
14200     case Tag_ARC_ABI_osver:
14201       val = read_uleb128 (p, &len, end);
14202       p += len;
14203       printf ("  Tag_ARC_ABI_osver: v%d\n", val);
14204       break;
14205
14206     case Tag_ARC_ABI_pic:
14207     case Tag_ARC_ABI_sda:
14208       val = read_uleb128 (p, &len, end);
14209       p += len;
14210       printf (tag == Tag_ARC_ABI_sda ? "  Tag_ARC_ABI_sda: "
14211               : "  Tag_ARC_ABI_pic: ");
14212       switch (val)
14213         {
14214         case 0:
14215           printf (_("Absent\n"));
14216           break;
14217         case 1:
14218           printf ("MWDT\n");
14219           break;
14220         case 2:
14221           printf ("GNU\n");
14222           break;
14223         default:
14224           printf (_("Unknown\n"));
14225           break;
14226         }
14227       break;
14228
14229     case Tag_ARC_ABI_tls:
14230       val = read_uleb128 (p, &len, end);
14231       p += len;
14232       printf ("  Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14233       break;
14234
14235     case Tag_ARC_ABI_enumsize:
14236       val = read_uleb128 (p, &len, end);
14237       p += len;
14238       printf ("  Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14239               _("smallest"));
14240       break;
14241
14242     case Tag_ARC_ABI_exceptions:
14243       val = read_uleb128 (p, &len, end);
14244       p += len;
14245       printf ("  Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14246               : _("default"));
14247       break;
14248
14249     case Tag_ARC_ABI_double_size:
14250       val = read_uleb128 (p, &len, end);
14251       p += len;
14252       printf ("  Tag_ARC_ABI_double_size: %d\n", val);
14253       break;
14254
14255     case Tag_ARC_ISA_config:
14256       printf ("  Tag_ARC_ISA_config: ");
14257       p = display_tag_value (-1, p, end);
14258       break;
14259
14260     case Tag_ARC_ISA_apex:
14261       printf ("  Tag_ARC_ISA_apex: ");
14262       p = display_tag_value (-1, p, end);
14263       break;
14264
14265     case Tag_ARC_ISA_mpy_option:
14266       val = read_uleb128 (p, &len, end);
14267       p += len;
14268       printf ("  Tag_ARC_ISA_mpy_option: %d\n", val);
14269       break;
14270
14271     case Tag_ARC_ATR_version:
14272       val = read_uleb128 (p, &len, end);
14273       p += len;
14274       printf ("  Tag_ARC_ATR_version: %d\n", val);
14275       break;
14276
14277     default:
14278       return display_tag_value (tag & 1, p, end);
14279     }
14280
14281   return p;
14282 }
14283
14284 /* ARM EABI attributes section.  */
14285 typedef struct
14286 {
14287   unsigned int tag;
14288   const char * name;
14289   /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup.  */
14290   unsigned int type;
14291   const char ** table;
14292 } arm_attr_public_tag;
14293
14294 static const char * arm_attr_tag_CPU_arch[] =
14295   {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14296    "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14297    "v8-M.mainline"};
14298 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14299 static const char * arm_attr_tag_THUMB_ISA_use[] =
14300   {"No", "Thumb-1", "Thumb-2", "Yes"};
14301 static const char * arm_attr_tag_FP_arch[] =
14302   {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14303    "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14304 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14305 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14306   {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14307    "NEON for ARMv8.1"};
14308 static const char * arm_attr_tag_PCS_config[] =
14309   {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14310    "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14311 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14312   {"V6", "SB", "TLS", "Unused"};
14313 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14314   {"Absolute", "PC-relative", "SB-relative", "None"};
14315 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14316   {"Absolute", "PC-relative", "None"};
14317 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14318   {"None", "direct", "GOT-indirect"};
14319 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14320   {"None", "??? 1", "2", "??? 3", "4"};
14321 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14322 static const char * arm_attr_tag_ABI_FP_denormal[] =
14323   {"Unused", "Needed", "Sign only"};
14324 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14325 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14326 static const char * arm_attr_tag_ABI_FP_number_model[] =
14327   {"Unused", "Finite", "RTABI", "IEEE 754"};
14328 static const char * arm_attr_tag_ABI_enum_size[] =
14329   {"Unused", "small", "int", "forced to int"};
14330 static const char * arm_attr_tag_ABI_HardFP_use[] =
14331   {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14332 static const char * arm_attr_tag_ABI_VFP_args[] =
14333   {"AAPCS", "VFP registers", "custom", "compatible"};
14334 static const char * arm_attr_tag_ABI_WMMX_args[] =
14335   {"AAPCS", "WMMX registers", "custom"};
14336 static const char * arm_attr_tag_ABI_optimization_goals[] =
14337   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14338     "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14339 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14340   {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14341     "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14342 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14343 static const char * arm_attr_tag_FP_HP_extension[] =
14344   {"Not Allowed", "Allowed"};
14345 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14346   {"None", "IEEE 754", "Alternative Format"};
14347 static const char * arm_attr_tag_DSP_extension[] =
14348   {"Follow architecture", "Allowed"};
14349 static const char * arm_attr_tag_MPextension_use[] =
14350   {"Not Allowed", "Allowed"};
14351 static const char * arm_attr_tag_DIV_use[] =
14352   {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14353     "Allowed in v7-A with integer division extension"};
14354 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14355 static const char * arm_attr_tag_Virtualization_use[] =
14356   {"Not Allowed", "TrustZone", "Virtualization Extensions",
14357     "TrustZone and Virtualization Extensions"};
14358 static const char * arm_attr_tag_MPextension_use_legacy[] =
14359   {"Not Allowed", "Allowed"};
14360
14361 #define LOOKUP(id, name) \
14362   {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14363 static arm_attr_public_tag arm_attr_public_tags[] =
14364 {
14365   {4, "CPU_raw_name", 1, NULL},
14366   {5, "CPU_name", 1, NULL},
14367   LOOKUP(6, CPU_arch),
14368   {7, "CPU_arch_profile", 0, NULL},
14369   LOOKUP(8, ARM_ISA_use),
14370   LOOKUP(9, THUMB_ISA_use),
14371   LOOKUP(10, FP_arch),
14372   LOOKUP(11, WMMX_arch),
14373   LOOKUP(12, Advanced_SIMD_arch),
14374   LOOKUP(13, PCS_config),
14375   LOOKUP(14, ABI_PCS_R9_use),
14376   LOOKUP(15, ABI_PCS_RW_data),
14377   LOOKUP(16, ABI_PCS_RO_data),
14378   LOOKUP(17, ABI_PCS_GOT_use),
14379   LOOKUP(18, ABI_PCS_wchar_t),
14380   LOOKUP(19, ABI_FP_rounding),
14381   LOOKUP(20, ABI_FP_denormal),
14382   LOOKUP(21, ABI_FP_exceptions),
14383   LOOKUP(22, ABI_FP_user_exceptions),
14384   LOOKUP(23, ABI_FP_number_model),
14385   {24, "ABI_align_needed", 0, NULL},
14386   {25, "ABI_align_preserved", 0, NULL},
14387   LOOKUP(26, ABI_enum_size),
14388   LOOKUP(27, ABI_HardFP_use),
14389   LOOKUP(28, ABI_VFP_args),
14390   LOOKUP(29, ABI_WMMX_args),
14391   LOOKUP(30, ABI_optimization_goals),
14392   LOOKUP(31, ABI_FP_optimization_goals),
14393   {32, "compatibility", 0, NULL},
14394   LOOKUP(34, CPU_unaligned_access),
14395   LOOKUP(36, FP_HP_extension),
14396   LOOKUP(38, ABI_FP_16bit_format),
14397   LOOKUP(42, MPextension_use),
14398   LOOKUP(44, DIV_use),
14399   LOOKUP(46, DSP_extension),
14400   {64, "nodefaults", 0, NULL},
14401   {65, "also_compatible_with", 0, NULL},
14402   LOOKUP(66, T2EE_use),
14403   {67, "conformance", 1, NULL},
14404   LOOKUP(68, Virtualization_use),
14405   LOOKUP(70, MPextension_use_legacy)
14406 };
14407 #undef LOOKUP
14408
14409 static unsigned char *
14410 display_arm_attribute (unsigned char * p,
14411                        const unsigned char * const end)
14412 {
14413   unsigned int tag;
14414   unsigned int len;
14415   unsigned int val;
14416   arm_attr_public_tag * attr;
14417   unsigned i;
14418   unsigned int type;
14419
14420   tag = read_uleb128 (p, &len, end);
14421   p += len;
14422   attr = NULL;
14423   for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14424     {
14425       if (arm_attr_public_tags[i].tag == tag)
14426         {
14427           attr = &arm_attr_public_tags[i];
14428           break;
14429         }
14430     }
14431
14432   if (attr)
14433     {
14434       printf ("  Tag_%s: ", attr->name);
14435       switch (attr->type)
14436         {
14437         case 0:
14438           switch (tag)
14439             {
14440             case 7: /* Tag_CPU_arch_profile.  */
14441               val = read_uleb128 (p, &len, end);
14442               p += len;
14443               switch (val)
14444                 {
14445                 case 0: printf (_("None\n")); break;
14446                 case 'A': printf (_("Application\n")); break;
14447                 case 'R': printf (_("Realtime\n")); break;
14448                 case 'M': printf (_("Microcontroller\n")); break;
14449                 case 'S': printf (_("Application or Realtime\n")); break;
14450                 default: printf ("??? (%d)\n", val); break;
14451                 }
14452               break;
14453
14454             case 24: /* Tag_align_needed.  */
14455               val = read_uleb128 (p, &len, end);
14456               p += len;
14457               switch (val)
14458                 {
14459                 case 0: printf (_("None\n")); break;
14460                 case 1: printf (_("8-byte\n")); break;
14461                 case 2: printf (_("4-byte\n")); break;
14462                 case 3: printf ("??? 3\n"); break;
14463                 default:
14464                   if (val <= 12)
14465                     printf (_("8-byte and up to %d-byte extended\n"),
14466                             1 << val);
14467                   else
14468                     printf ("??? (%d)\n", val);
14469                   break;
14470                 }
14471               break;
14472
14473             case 25: /* Tag_align_preserved.  */
14474               val = read_uleb128 (p, &len, end);
14475               p += len;
14476               switch (val)
14477                 {
14478                 case 0: printf (_("None\n")); break;
14479                 case 1: printf (_("8-byte, except leaf SP\n")); break;
14480                 case 2: printf (_("8-byte\n")); break;
14481                 case 3: printf ("??? 3\n"); break;
14482                 default:
14483                   if (val <= 12)
14484                     printf (_("8-byte and up to %d-byte extended\n"),
14485                             1 << val);
14486                   else
14487                     printf ("??? (%d)\n", val);
14488                   break;
14489                 }
14490               break;
14491
14492             case 32: /* Tag_compatibility.  */
14493               {
14494                 val = read_uleb128 (p, &len, end);
14495                 p += len;
14496                 printf (_("flag = %d, vendor = "), val);
14497                 if (p < end - 1)
14498                   {
14499                     size_t maxlen = (end - p) - 1;
14500
14501                     print_symbol ((int) maxlen, (const char *) p);
14502                     p += strnlen ((char *) p, maxlen) + 1;
14503                   }
14504                 else
14505                   {
14506                     printf (_("<corrupt>"));
14507                     p = (unsigned char *) end;
14508                   }
14509                 putchar ('\n');
14510               }
14511               break;
14512
14513             case 64: /* Tag_nodefaults.  */
14514               /* PR 17531: file: 001-505008-0.01.  */
14515               if (p < end)
14516                 p++;
14517               printf (_("True\n"));
14518               break;
14519
14520             case 65: /* Tag_also_compatible_with.  */
14521               val = read_uleb128 (p, &len, end);
14522               p += len;
14523               if (val == 6 /* Tag_CPU_arch.  */)
14524                 {
14525                   val = read_uleb128 (p, &len, end);
14526                   p += len;
14527                   if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14528                     printf ("??? (%d)\n", val);
14529                   else
14530                     printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14531                 }
14532               else
14533                 printf ("???\n");
14534               while (p < end && *(p++) != '\0' /* NUL terminator.  */)
14535                 ;
14536               break;
14537
14538             default:
14539               printf (_("<unknown: %d>\n"), tag);
14540               break;
14541             }
14542           return p;
14543
14544         case 1:
14545           return display_tag_value (-1, p, end);
14546         case 2:
14547           return display_tag_value (0, p, end);
14548
14549         default:
14550           assert (attr->type & 0x80);
14551           val = read_uleb128 (p, &len, end);
14552           p += len;
14553           type = attr->type & 0x7f;
14554           if (val >= type)
14555             printf ("??? (%d)\n", val);
14556           else
14557             printf ("%s\n", attr->table[val]);
14558           return p;
14559         }
14560     }
14561
14562   return display_tag_value (tag, p, end);
14563 }
14564
14565 static unsigned char *
14566 display_gnu_attribute (unsigned char * p,
14567                        unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14568                        const unsigned char * const end)
14569 {
14570   int tag;
14571   unsigned int len;
14572   unsigned int val;
14573
14574   tag = read_uleb128 (p, &len, end);
14575   p += len;
14576
14577   /* Tag_compatibility is the only generic GNU attribute defined at
14578      present.  */
14579   if (tag == 32)
14580     {
14581       val = read_uleb128 (p, &len, end);
14582       p += len;
14583
14584       printf (_("flag = %d, vendor = "), val);
14585       if (p == end)
14586         {
14587           printf (_("<corrupt>\n"));
14588           warn (_("corrupt vendor attribute\n"));
14589         }
14590       else
14591         {
14592           if (p < end - 1)
14593             {
14594               size_t maxlen = (end - p) - 1;
14595
14596               print_symbol ((int) maxlen, (const char *) p);
14597               p += strnlen ((char *) p, maxlen) + 1;
14598             }
14599           else
14600             {
14601               printf (_("<corrupt>"));
14602               p = (unsigned char *) end;
14603             }
14604           putchar ('\n');
14605         }
14606       return p;
14607     }
14608
14609   if ((tag & 2) == 0 && display_proc_gnu_attribute)
14610     return display_proc_gnu_attribute (p, tag, end);
14611
14612   return display_tag_value (tag, p, end);
14613 }
14614
14615 static unsigned char *
14616 display_power_gnu_attribute (unsigned char * p,
14617                              unsigned int tag,
14618                              const unsigned char * const end)
14619 {
14620   unsigned int len;
14621   unsigned int val;
14622
14623   if (tag == Tag_GNU_Power_ABI_FP)
14624     {
14625       val = read_uleb128 (p, &len, end);
14626       p += len;
14627       printf ("  Tag_GNU_Power_ABI_FP: ");
14628       if (len == 0)
14629         {
14630           printf (_("<corrupt>\n"));
14631           return p;
14632         }
14633
14634       if (val > 15)
14635         printf ("(%#x), ", val);
14636
14637       switch (val & 3)
14638         {
14639         case 0:
14640           printf (_("unspecified hard/soft float, "));
14641           break;
14642         case 1:
14643           printf (_("hard float, "));
14644           break;
14645         case 2:
14646           printf (_("soft float, "));
14647           break;
14648         case 3:
14649           printf (_("single-precision hard float, "));
14650           break;
14651         }
14652
14653       switch (val & 0xC)
14654         {
14655         case 0:
14656           printf (_("unspecified long double\n"));
14657           break;
14658         case 4:
14659           printf (_("128-bit IBM long double\n"));
14660           break;
14661         case 8:
14662           printf (_("64-bit long double\n"));
14663           break;
14664         case 12:
14665           printf (_("128-bit IEEE long double\n"));
14666           break;
14667         }
14668       return p;
14669     }
14670
14671   if (tag == Tag_GNU_Power_ABI_Vector)
14672     {
14673       val = read_uleb128 (p, &len, end);
14674       p += len;
14675       printf ("  Tag_GNU_Power_ABI_Vector: ");
14676       if (len == 0)
14677         {
14678           printf (_("<corrupt>\n"));
14679           return p;
14680         }
14681
14682       if (val > 3)
14683         printf ("(%#x), ", val);
14684
14685       switch (val & 3)
14686         {
14687         case 0:
14688           printf (_("unspecified\n"));
14689           break;
14690         case 1:
14691           printf (_("generic\n"));
14692           break;
14693         case 2:
14694           printf ("AltiVec\n");
14695           break;
14696         case 3:
14697           printf ("SPE\n");
14698           break;
14699         }
14700       return p;
14701     }
14702
14703   if (tag == Tag_GNU_Power_ABI_Struct_Return)
14704     {
14705       val = read_uleb128 (p, &len, end);
14706       p += len;
14707       printf ("  Tag_GNU_Power_ABI_Struct_Return: ");
14708       if (len == 0)
14709         {
14710           printf (_("<corrupt>\n"));
14711           return p;
14712         }
14713
14714       if (val > 2)
14715         printf ("(%#x), ", val);
14716
14717       switch (val & 3)
14718         {
14719         case 0:
14720           printf (_("unspecified\n"));
14721           break;
14722         case 1:
14723           printf ("r3/r4\n");
14724           break;
14725         case 2:
14726           printf (_("memory\n"));
14727           break;
14728         case 3:
14729           printf ("???\n");
14730           break;
14731         }
14732       return p;
14733     }
14734
14735   return display_tag_value (tag & 1, p, end);
14736 }
14737
14738 static unsigned char *
14739 display_s390_gnu_attribute (unsigned char * p,
14740                             unsigned int tag,
14741                             const unsigned char * const end)
14742 {
14743   unsigned int len;
14744   int val;
14745
14746   if (tag == Tag_GNU_S390_ABI_Vector)
14747     {
14748       val = read_uleb128 (p, &len, end);
14749       p += len;
14750       printf ("  Tag_GNU_S390_ABI_Vector: ");
14751
14752       switch (val)
14753         {
14754         case 0:
14755           printf (_("any\n"));
14756           break;
14757         case 1:
14758           printf (_("software\n"));
14759           break;
14760         case 2:
14761           printf (_("hardware\n"));
14762           break;
14763         default:
14764           printf ("??? (%d)\n", val);
14765           break;
14766         }
14767       return p;
14768    }
14769
14770   return display_tag_value (tag & 1, p, end);
14771 }
14772
14773 static void
14774 display_sparc_hwcaps (unsigned int mask)
14775 {
14776   if (mask)
14777     {
14778       bfd_boolean first = TRUE;
14779
14780       if (mask & ELF_SPARC_HWCAP_MUL32)
14781         fputs ("mul32", stdout), first = FALSE;
14782       if (mask & ELF_SPARC_HWCAP_DIV32)
14783         printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14784       if (mask & ELF_SPARC_HWCAP_FSMULD)
14785         printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14786       if (mask & ELF_SPARC_HWCAP_V8PLUS)
14787         printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14788       if (mask & ELF_SPARC_HWCAP_POPC)
14789         printf ("%spopc", first ? "" : "|"), first = FALSE;
14790       if (mask & ELF_SPARC_HWCAP_VIS)
14791         printf ("%svis", first ? "" : "|"), first = FALSE;
14792       if (mask & ELF_SPARC_HWCAP_VIS2)
14793         printf ("%svis2", first ? "" : "|"), first = FALSE;
14794       if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14795         printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14796       if (mask & ELF_SPARC_HWCAP_FMAF)
14797         printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14798       if (mask & ELF_SPARC_HWCAP_VIS3)
14799         printf ("%svis3", first ? "" : "|"), first = FALSE;
14800       if (mask & ELF_SPARC_HWCAP_HPC)
14801         printf ("%shpc", first ? "" : "|"), first = FALSE;
14802       if (mask & ELF_SPARC_HWCAP_RANDOM)
14803         printf ("%srandom", first ? "" : "|"), first = FALSE;
14804       if (mask & ELF_SPARC_HWCAP_TRANS)
14805         printf ("%strans", first ? "" : "|"), first = FALSE;
14806       if (mask & ELF_SPARC_HWCAP_FJFMAU)
14807         printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14808       if (mask & ELF_SPARC_HWCAP_IMA)
14809         printf ("%sima", first ? "" : "|"), first = FALSE;
14810       if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14811         printf ("%scspare", first ? "" : "|"), first = FALSE;
14812     }
14813   else
14814     fputc ('0', stdout);
14815   fputc ('\n', stdout);
14816 }
14817
14818 static void
14819 display_sparc_hwcaps2 (unsigned int mask)
14820 {
14821   if (mask)
14822     {
14823       bfd_boolean first = TRUE;
14824
14825       if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14826         fputs ("fjathplus", stdout), first = FALSE;
14827       if (mask & ELF_SPARC_HWCAP2_VIS3B)
14828         printf ("%svis3b", first ? "" : "|"), first = FALSE;
14829       if (mask & ELF_SPARC_HWCAP2_ADP)
14830         printf ("%sadp", first ? "" : "|"), first = FALSE;
14831       if (mask & ELF_SPARC_HWCAP2_SPARC5)
14832         printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14833       if (mask & ELF_SPARC_HWCAP2_MWAIT)
14834         printf ("%smwait", first ? "" : "|"), first = FALSE;
14835       if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14836         printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14837       if (mask & ELF_SPARC_HWCAP2_XMONT)
14838         printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14839       if (mask & ELF_SPARC_HWCAP2_NSEC)
14840         printf ("%snsec", first ? "" : "|"), first = FALSE;
14841       if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14842         printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14843       if (mask & ELF_SPARC_HWCAP2_FJDES)
14844         printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14845       if (mask & ELF_SPARC_HWCAP2_FJAES)
14846         printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14847     }
14848   else
14849     fputc ('0', stdout);
14850   fputc ('\n', stdout);
14851 }
14852
14853 static unsigned char *
14854 display_sparc_gnu_attribute (unsigned char * p,
14855                              unsigned int tag,
14856                              const unsigned char * const end)
14857 {
14858   unsigned int len;
14859   int val;
14860
14861   if (tag == Tag_GNU_Sparc_HWCAPS)
14862     {
14863       val = read_uleb128 (p, &len, end);
14864       p += len;
14865       printf ("  Tag_GNU_Sparc_HWCAPS: ");
14866       display_sparc_hwcaps (val);
14867       return p;
14868     }
14869   if (tag == Tag_GNU_Sparc_HWCAPS2)
14870     {
14871       val = read_uleb128 (p, &len, end);
14872       p += len;
14873       printf ("  Tag_GNU_Sparc_HWCAPS2: ");
14874       display_sparc_hwcaps2 (val);
14875       return p;
14876     }
14877
14878   return display_tag_value (tag, p, end);
14879 }
14880
14881 static void
14882 print_mips_fp_abi_value (unsigned int val)
14883 {
14884   switch (val)
14885     {
14886     case Val_GNU_MIPS_ABI_FP_ANY:
14887       printf (_("Hard or soft float\n"));
14888       break;
14889     case Val_GNU_MIPS_ABI_FP_DOUBLE:
14890       printf (_("Hard float (double precision)\n"));
14891       break;
14892     case Val_GNU_MIPS_ABI_FP_SINGLE:
14893       printf (_("Hard float (single precision)\n"));
14894       break;
14895     case Val_GNU_MIPS_ABI_FP_SOFT:
14896       printf (_("Soft float\n"));
14897       break;
14898     case Val_GNU_MIPS_ABI_FP_OLD_64:
14899       printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14900       break;
14901     case Val_GNU_MIPS_ABI_FP_XX:
14902       printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14903       break;
14904     case Val_GNU_MIPS_ABI_FP_64:
14905       printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14906       break;
14907     case Val_GNU_MIPS_ABI_FP_64A:
14908       printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14909       break;
14910     case Val_GNU_MIPS_ABI_FP_NAN2008:
14911       printf (_("NaN 2008 compatibility\n"));
14912       break;
14913     default:
14914       printf ("??? (%d)\n", val);
14915       break;
14916     }
14917 }
14918
14919 static unsigned char *
14920 display_mips_gnu_attribute (unsigned char * p,
14921                             unsigned int tag,
14922                             const unsigned char * const end)
14923 {
14924   if (tag == Tag_GNU_MIPS_ABI_FP)
14925     {
14926       unsigned int len;
14927       unsigned int val;
14928
14929       val = read_uleb128 (p, &len, end);
14930       p += len;
14931       printf ("  Tag_GNU_MIPS_ABI_FP: ");
14932
14933       print_mips_fp_abi_value (val);
14934
14935       return p;
14936    }
14937
14938   if (tag == Tag_GNU_MIPS_ABI_MSA)
14939     {
14940       unsigned int len;
14941       unsigned int val;
14942
14943       val = read_uleb128 (p, &len, end);
14944       p += len;
14945       printf ("  Tag_GNU_MIPS_ABI_MSA: ");
14946
14947       switch (val)
14948         {
14949         case Val_GNU_MIPS_ABI_MSA_ANY:
14950           printf (_("Any MSA or not\n"));
14951           break;
14952         case Val_GNU_MIPS_ABI_MSA_128:
14953           printf (_("128-bit MSA\n"));
14954           break;
14955         default:
14956           printf ("??? (%d)\n", val);
14957           break;
14958         }
14959       return p;
14960     }
14961
14962   return display_tag_value (tag & 1, p, end);
14963 }
14964
14965 static unsigned char *
14966 display_tic6x_attribute (unsigned char * p,
14967                          const unsigned char * const end)
14968 {
14969   unsigned int tag;
14970   unsigned int len;
14971   int val;
14972
14973   tag = read_uleb128 (p, &len, end);
14974   p += len;
14975
14976   switch (tag)
14977     {
14978     case Tag_ISA:
14979       val = read_uleb128 (p, &len, end);
14980       p += len;
14981       printf ("  Tag_ISA: ");
14982
14983       switch (val)
14984         {
14985         case C6XABI_Tag_ISA_none:
14986           printf (_("None\n"));
14987           break;
14988         case C6XABI_Tag_ISA_C62X:
14989           printf ("C62x\n");
14990           break;
14991         case C6XABI_Tag_ISA_C67X:
14992           printf ("C67x\n");
14993           break;
14994         case C6XABI_Tag_ISA_C67XP:
14995           printf ("C67x+\n");
14996           break;
14997         case C6XABI_Tag_ISA_C64X:
14998           printf ("C64x\n");
14999           break;
15000         case C6XABI_Tag_ISA_C64XP:
15001           printf ("C64x+\n");
15002           break;
15003         case C6XABI_Tag_ISA_C674X:
15004           printf ("C674x\n");
15005           break;
15006         default:
15007           printf ("??? (%d)\n", val);
15008           break;
15009         }
15010       return p;
15011
15012     case Tag_ABI_wchar_t:
15013       val = read_uleb128 (p, &len, end);
15014       p += len;
15015       printf ("  Tag_ABI_wchar_t: ");
15016       switch (val)
15017         {
15018         case 0:
15019           printf (_("Not used\n"));
15020           break;
15021         case 1:
15022           printf (_("2 bytes\n"));
15023           break;
15024         case 2:
15025           printf (_("4 bytes\n"));
15026           break;
15027         default:
15028           printf ("??? (%d)\n", val);
15029           break;
15030         }
15031       return p;
15032
15033     case Tag_ABI_stack_align_needed:
15034       val = read_uleb128 (p, &len, end);
15035       p += len;
15036       printf ("  Tag_ABI_stack_align_needed: ");
15037       switch (val)
15038         {
15039         case 0:
15040           printf (_("8-byte\n"));
15041           break;
15042         case 1:
15043           printf (_("16-byte\n"));
15044           break;
15045         default:
15046           printf ("??? (%d)\n", val);
15047           break;
15048         }
15049       return p;
15050
15051     case Tag_ABI_stack_align_preserved:
15052       val = read_uleb128 (p, &len, end);
15053       p += len;
15054       printf ("  Tag_ABI_stack_align_preserved: ");
15055       switch (val)
15056         {
15057         case 0:
15058           printf (_("8-byte\n"));
15059           break;
15060         case 1:
15061           printf (_("16-byte\n"));
15062           break;
15063         default:
15064           printf ("??? (%d)\n", val);
15065           break;
15066         }
15067       return p;
15068
15069     case Tag_ABI_DSBT:
15070       val = read_uleb128 (p, &len, end);
15071       p += len;
15072       printf ("  Tag_ABI_DSBT: ");
15073       switch (val)
15074         {
15075         case 0:
15076           printf (_("DSBT addressing not used\n"));
15077           break;
15078         case 1:
15079           printf (_("DSBT addressing used\n"));
15080           break;
15081         default:
15082           printf ("??? (%d)\n", val);
15083           break;
15084         }
15085       return p;
15086
15087     case Tag_ABI_PID:
15088       val = read_uleb128 (p, &len, end);
15089       p += len;
15090       printf ("  Tag_ABI_PID: ");
15091       switch (val)
15092         {
15093         case 0:
15094           printf (_("Data addressing position-dependent\n"));
15095           break;
15096         case 1:
15097           printf (_("Data addressing position-independent, GOT near DP\n"));
15098           break;
15099         case 2:
15100           printf (_("Data addressing position-independent, GOT far from DP\n"));
15101           break;
15102         default:
15103           printf ("??? (%d)\n", val);
15104           break;
15105         }
15106       return p;
15107
15108     case Tag_ABI_PIC:
15109       val = read_uleb128 (p, &len, end);
15110       p += len;
15111       printf ("  Tag_ABI_PIC: ");
15112       switch (val)
15113         {
15114         case 0:
15115           printf (_("Code addressing position-dependent\n"));
15116           break;
15117         case 1:
15118           printf (_("Code addressing position-independent\n"));
15119           break;
15120         default:
15121           printf ("??? (%d)\n", val);
15122           break;
15123         }
15124       return p;
15125
15126     case Tag_ABI_array_object_alignment:
15127       val = read_uleb128 (p, &len, end);
15128       p += len;
15129       printf ("  Tag_ABI_array_object_alignment: ");
15130       switch (val)
15131         {
15132         case 0:
15133           printf (_("8-byte\n"));
15134           break;
15135         case 1:
15136           printf (_("4-byte\n"));
15137           break;
15138         case 2:
15139           printf (_("16-byte\n"));
15140           break;
15141         default:
15142           printf ("??? (%d)\n", val);
15143           break;
15144         }
15145       return p;
15146
15147     case Tag_ABI_array_object_align_expected:
15148       val = read_uleb128 (p, &len, end);
15149       p += len;
15150       printf ("  Tag_ABI_array_object_align_expected: ");
15151       switch (val)
15152         {
15153         case 0:
15154           printf (_("8-byte\n"));
15155           break;
15156         case 1:
15157           printf (_("4-byte\n"));
15158           break;
15159         case 2:
15160           printf (_("16-byte\n"));
15161           break;
15162         default:
15163           printf ("??? (%d)\n", val);
15164           break;
15165         }
15166       return p;
15167
15168     case Tag_ABI_compatibility:
15169       {
15170         val = read_uleb128 (p, &len, end);
15171         p += len;
15172         printf ("  Tag_ABI_compatibility: ");
15173         printf (_("flag = %d, vendor = "), val);
15174         if (p < end - 1)
15175           {
15176             size_t maxlen = (end - p) - 1;
15177
15178             print_symbol ((int) maxlen, (const char *) p);
15179             p += strnlen ((char *) p, maxlen) + 1;
15180           }
15181         else
15182           {
15183             printf (_("<corrupt>"));
15184             p = (unsigned char *) end;
15185           }
15186         putchar ('\n');
15187         return p;
15188       }
15189
15190     case Tag_ABI_conformance:
15191       {
15192         printf ("  Tag_ABI_conformance: \"");
15193         if (p < end - 1)
15194           {
15195             size_t maxlen = (end - p) - 1;
15196
15197             print_symbol ((int) maxlen, (const char *) p);
15198             p += strnlen ((char *) p, maxlen) + 1;
15199           }
15200         else
15201           {
15202             printf (_("<corrupt>"));
15203             p = (unsigned char *) end;
15204           }
15205         printf ("\"\n");
15206         return p;
15207       }
15208     }
15209
15210   return display_tag_value (tag, p, end);
15211 }
15212
15213 static void
15214 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15215 {
15216   unsigned long addr = 0;
15217   size_t bytes = end - p;
15218
15219   assert (end >= p);
15220   while (bytes)
15221     {
15222       int j;
15223       int k;
15224       int lbytes = (bytes > 16 ? 16 : bytes);
15225
15226       printf ("  0x%8.8lx ", addr);
15227
15228       for (j = 0; j < 16; j++)
15229         {
15230           if (j < lbytes)
15231             printf ("%2.2x", p[j]);
15232           else
15233             printf ("  ");
15234
15235           if ((j & 3) == 3)
15236             printf (" ");
15237         }
15238
15239       for (j = 0; j < lbytes; j++)
15240         {
15241           k = p[j];
15242           if (k >= ' ' && k < 0x7f)
15243             printf ("%c", k);
15244           else
15245             printf (".");
15246         }
15247
15248       putchar ('\n');
15249
15250       p  += lbytes;
15251       bytes -= lbytes;
15252       addr += lbytes;
15253     }
15254
15255   putchar ('\n');
15256 }
15257
15258 static unsigned char *
15259 display_msp430x_attribute (unsigned char * p,
15260                            const unsigned char * const end)
15261 {
15262   unsigned int len;
15263   unsigned int val;
15264   unsigned int tag;
15265
15266   tag = read_uleb128 (p, & len, end);
15267   p += len;
15268
15269   switch (tag)
15270     {
15271     case OFBA_MSPABI_Tag_ISA:
15272       val = read_uleb128 (p, &len, end);
15273       p += len;
15274       printf ("  Tag_ISA: ");
15275       switch (val)
15276         {
15277         case 0: printf (_("None\n")); break;
15278         case 1: printf (_("MSP430\n")); break;
15279         case 2: printf (_("MSP430X\n")); break;
15280         default: printf ("??? (%d)\n", val); break;
15281         }
15282       break;
15283
15284     case OFBA_MSPABI_Tag_Code_Model:
15285       val = read_uleb128 (p, &len, end);
15286       p += len;
15287       printf ("  Tag_Code_Model: ");
15288       switch (val)
15289         {
15290         case 0: printf (_("None\n")); break;
15291         case 1: printf (_("Small\n")); break;
15292         case 2: printf (_("Large\n")); break;
15293         default: printf ("??? (%d)\n", val); break;
15294         }
15295       break;
15296
15297     case OFBA_MSPABI_Tag_Data_Model:
15298       val = read_uleb128 (p, &len, end);
15299       p += len;
15300       printf ("  Tag_Data_Model: ");
15301       switch (val)
15302         {
15303         case 0: printf (_("None\n")); break;
15304         case 1: printf (_("Small\n")); break;
15305         case 2: printf (_("Large\n")); break;
15306         case 3: printf (_("Restricted Large\n")); break;
15307         default: printf ("??? (%d)\n", val); break;
15308         }
15309       break;
15310
15311     default:
15312       printf (_("  <unknown tag %d>: "), tag);
15313
15314       if (tag & 1)
15315         {
15316           putchar ('"');
15317           if (p < end - 1)
15318             {
15319               size_t maxlen = (end - p) - 1;
15320
15321               print_symbol ((int) maxlen, (const char *) p);
15322               p += strnlen ((char *) p, maxlen) + 1;
15323             }
15324           else
15325             {
15326               printf (_("<corrupt>"));
15327               p = (unsigned char *) end;
15328             }
15329           printf ("\"\n");
15330         }
15331       else
15332         {
15333           val = read_uleb128 (p, &len, end);
15334           p += len;
15335           printf ("%d (0x%x)\n", val, val);
15336         }
15337       break;
15338    }
15339
15340   assert (p <= end);
15341   return p;
15342 }
15343
15344 static bfd_boolean
15345 process_attributes (Filedata * filedata,
15346                     const char * public_name,
15347                     unsigned int proc_type,
15348                     unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15349                     unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15350 {
15351   Elf_Internal_Shdr * sect;
15352   unsigned i;
15353   bfd_boolean res = TRUE;
15354
15355   /* Find the section header so that we get the size.  */
15356   for (i = 0, sect = filedata->section_headers;
15357        i < filedata->file_header.e_shnum;
15358        i++, sect++)
15359     {
15360       unsigned char * contents;
15361       unsigned char * p;
15362
15363       if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15364         continue;
15365
15366       contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15367                                              sect->sh_size, _("attributes"));
15368       if (contents == NULL)
15369         {
15370           res = FALSE;
15371           continue;
15372         }
15373
15374       p = contents;
15375       /* The first character is the version of the attributes.
15376          Currently only version 1, (aka 'A') is recognised here.  */
15377       if (*p != 'A')
15378         {
15379           printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15380           res = FALSE;
15381         }
15382       else
15383         {
15384           bfd_vma section_len;
15385
15386           section_len = sect->sh_size - 1;
15387           p++;
15388
15389           while (section_len > 0)
15390             {
15391               bfd_vma attr_len;
15392               unsigned int namelen;
15393               bfd_boolean public_section;
15394               bfd_boolean gnu_section;
15395
15396               if (section_len <= 4)
15397                 {
15398                   error (_("Tag section ends prematurely\n"));
15399                   res = FALSE;
15400                   break;
15401                 }
15402               attr_len = byte_get (p, 4);
15403               p += 4;
15404
15405               if (attr_len > section_len)
15406                 {
15407                   error (_("Bad attribute length (%u > %u)\n"),
15408                           (unsigned) attr_len, (unsigned) section_len);
15409                   attr_len = section_len;
15410                   res = FALSE;
15411                 }
15412               /* PR 17531: file: 001-101425-0.004  */
15413               else if (attr_len < 5)
15414                 {
15415                   error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15416                   res = FALSE;
15417                   break;
15418                 }
15419
15420               section_len -= attr_len;
15421               attr_len -= 4;
15422
15423               namelen = strnlen ((char *) p, attr_len) + 1;
15424               if (namelen == 0 || namelen >= attr_len)
15425                 {
15426                   error (_("Corrupt attribute section name\n"));
15427                   res = FALSE;
15428                   break;
15429                 }
15430
15431               printf (_("Attribute Section: "));
15432               print_symbol (INT_MAX, (const char *) p);
15433               putchar ('\n');
15434
15435               if (public_name && streq ((char *) p, public_name))
15436                 public_section = TRUE;
15437               else
15438                 public_section = FALSE;
15439
15440               if (streq ((char *) p, "gnu"))
15441                 gnu_section = TRUE;
15442               else
15443                 gnu_section = FALSE;
15444
15445               p += namelen;
15446               attr_len -= namelen;
15447
15448               while (attr_len > 0 && p < contents + sect->sh_size)
15449                 {
15450                   int tag;
15451                   int val;
15452                   bfd_vma size;
15453                   unsigned char * end;
15454
15455                   /* PR binutils/17531: Safe handling of corrupt files.  */
15456                   if (attr_len < 6)
15457                     {
15458                       error (_("Unused bytes at end of section\n"));
15459                       res = FALSE;
15460                       section_len = 0;
15461                       break;
15462                     }
15463
15464                   tag = *(p++);
15465                   size = byte_get (p, 4);
15466                   if (size > attr_len)
15467                     {
15468                       error (_("Bad subsection length (%u > %u)\n"),
15469                               (unsigned) size, (unsigned) attr_len);
15470                       res = FALSE;
15471                       size = attr_len;
15472                     }
15473                   /* PR binutils/17531: Safe handling of corrupt files.  */
15474                   if (size < 6)
15475                     {
15476                       error (_("Bad subsection length (%u < 6)\n"),
15477                               (unsigned) size);
15478                       res = FALSE;
15479                       section_len = 0;
15480                       break;
15481                     }
15482
15483                   attr_len -= size;
15484                   end = p + size - 1;
15485                   assert (end <= contents + sect->sh_size);
15486                   p += 4;
15487
15488                   switch (tag)
15489                     {
15490                     case 1:
15491                       printf (_("File Attributes\n"));
15492                       break;
15493                     case 2:
15494                       printf (_("Section Attributes:"));
15495                       goto do_numlist;
15496                     case 3:
15497                       printf (_("Symbol Attributes:"));
15498                       /* Fall through.  */
15499                     do_numlist:
15500                       for (;;)
15501                         {
15502                           unsigned int j;
15503
15504                           val = read_uleb128 (p, &j, end);
15505                           p += j;
15506                           if (val == 0)
15507                             break;
15508                           printf (" %d", val);
15509                         }
15510                       printf ("\n");
15511                       break;
15512                     default:
15513                       printf (_("Unknown tag: %d\n"), tag);
15514                       public_section = FALSE;
15515                       break;
15516                     }
15517
15518                   if (public_section && display_pub_attribute != NULL)
15519                     {
15520                       while (p < end)
15521                         p = display_pub_attribute (p, end);
15522                       assert (p == end);
15523                     }
15524                   else if (gnu_section && display_proc_gnu_attribute != NULL)
15525                     {
15526                       while (p < end)
15527                         p = display_gnu_attribute (p,
15528                                                    display_proc_gnu_attribute,
15529                                                    end);
15530                       assert (p == end);
15531                     }
15532                   else if (p < end)
15533                     {
15534                       printf (_("  Unknown attribute:\n"));
15535                       display_raw_attribute (p, end);
15536                       p = end;
15537                     }
15538                   else
15539                     attr_len = 0;
15540                 }
15541             }
15542         }
15543
15544       free (contents);
15545     }
15546
15547   return res;
15548 }
15549
15550 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15551    Print the Address, Access and Initial fields of an entry at VMA ADDR
15552    and return the VMA of the next entry, or -1 if there was a problem.
15553    Does not read from DATA_END or beyond.  */
15554
15555 static bfd_vma
15556 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15557                       unsigned char * data_end)
15558 {
15559   printf ("  ");
15560   print_vma (addr, LONG_HEX);
15561   printf (" ");
15562   if (addr < pltgot + 0xfff0)
15563     printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15564   else
15565     printf ("%10s", "");
15566   printf (" ");
15567   if (data == NULL)
15568     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15569   else
15570     {
15571       bfd_vma entry;
15572       unsigned char * from = data + addr - pltgot;
15573
15574       if (from + (is_32bit_elf ? 4 : 8) > data_end)
15575         {
15576           warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15577           printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15578           return (bfd_vma) -1;
15579         }
15580       else
15581         {
15582           entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15583           print_vma (entry, LONG_HEX);
15584         }
15585     }
15586   return addr + (is_32bit_elf ? 4 : 8);
15587 }
15588
15589 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15590    PLTGOT.  Print the Address and Initial fields of an entry at VMA
15591    ADDR and return the VMA of the next entry.  */
15592
15593 static bfd_vma
15594 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15595 {
15596   printf ("  ");
15597   print_vma (addr, LONG_HEX);
15598   printf (" ");
15599   if (data == NULL)
15600     printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15601   else
15602     {
15603       bfd_vma entry;
15604
15605       entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15606       print_vma (entry, LONG_HEX);
15607     }
15608   return addr + (is_32bit_elf ? 4 : 8);
15609 }
15610
15611 static void
15612 print_mips_ases (unsigned int mask)
15613 {
15614   if (mask & AFL_ASE_DSP)
15615     fputs ("\n\tDSP ASE", stdout);
15616   if (mask & AFL_ASE_DSPR2)
15617     fputs ("\n\tDSP R2 ASE", stdout);
15618   if (mask & AFL_ASE_DSPR3)
15619     fputs ("\n\tDSP R3 ASE", stdout);
15620   if (mask & AFL_ASE_EVA)
15621     fputs ("\n\tEnhanced VA Scheme", stdout);
15622   if (mask & AFL_ASE_MCU)
15623     fputs ("\n\tMCU (MicroController) ASE", stdout);
15624   if (mask & AFL_ASE_MDMX)
15625     fputs ("\n\tMDMX ASE", stdout);
15626   if (mask & AFL_ASE_MIPS3D)
15627     fputs ("\n\tMIPS-3D ASE", stdout);
15628   if (mask & AFL_ASE_MT)
15629     fputs ("\n\tMT ASE", stdout);
15630   if (mask & AFL_ASE_SMARTMIPS)
15631     fputs ("\n\tSmartMIPS ASE", stdout);
15632   if (mask & AFL_ASE_VIRT)
15633     fputs ("\n\tVZ ASE", stdout);
15634   if (mask & AFL_ASE_MSA)
15635     fputs ("\n\tMSA ASE", stdout);
15636   if (mask & AFL_ASE_MIPS16)
15637     fputs ("\n\tMIPS16 ASE", stdout);
15638   if (mask & AFL_ASE_MICROMIPS)
15639     fputs ("\n\tMICROMIPS ASE", stdout);
15640   if (mask & AFL_ASE_XPA)
15641     fputs ("\n\tXPA ASE", stdout);
15642   if (mask & AFL_ASE_MIPS16E2)
15643     fputs ("\n\tMIPS16e2 ASE", stdout);
15644   if (mask & AFL_ASE_CRC)
15645     fputs ("\n\tCRC ASE", stdout);
15646   if (mask & AFL_ASE_GINV)
15647     fputs ("\n\tGINV ASE", stdout);
15648   if (mask & AFL_ASE_LOONGSON_MMI)
15649     fputs ("\n\tLoongson MMI ASE", stdout);
15650   if (mask & AFL_ASE_LOONGSON_CAM)
15651     fputs ("\n\tLoongson CAM ASE", stdout);
15652   if (mask & AFL_ASE_LOONGSON_EXT)
15653     fputs ("\n\tLoongson EXT ASE", stdout);
15654   if (mask & AFL_ASE_LOONGSON_EXT2)
15655     fputs ("\n\tLoongson EXT2 ASE", stdout);
15656   if (mask == 0)
15657     fprintf (stdout, "\n\t%s", _("None"));
15658   else if ((mask & ~AFL_ASE_MASK) != 0)
15659     fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15660 }
15661
15662 static void
15663 print_mips_isa_ext (unsigned int isa_ext)
15664 {
15665   switch (isa_ext)
15666     {
15667     case 0:
15668       fputs (_("None"), stdout);
15669       break;
15670     case AFL_EXT_XLR:
15671       fputs ("RMI XLR", stdout);
15672       break;
15673     case AFL_EXT_OCTEON3:
15674       fputs ("Cavium Networks Octeon3", stdout);
15675       break;
15676     case AFL_EXT_OCTEON2:
15677       fputs ("Cavium Networks Octeon2", stdout);
15678       break;
15679     case AFL_EXT_OCTEONP:
15680       fputs ("Cavium Networks OcteonP", stdout);
15681       break;
15682     case AFL_EXT_OCTEON:
15683       fputs ("Cavium Networks Octeon", stdout);
15684       break;
15685     case AFL_EXT_5900:
15686       fputs ("Toshiba R5900", stdout);
15687       break;
15688     case AFL_EXT_4650:
15689       fputs ("MIPS R4650", stdout);
15690       break;
15691     case AFL_EXT_4010:
15692       fputs ("LSI R4010", stdout);
15693       break;
15694     case AFL_EXT_4100:
15695       fputs ("NEC VR4100", stdout);
15696       break;
15697     case AFL_EXT_3900:
15698       fputs ("Toshiba R3900", stdout);
15699       break;
15700     case AFL_EXT_10000:
15701       fputs ("MIPS R10000", stdout);
15702       break;
15703     case AFL_EXT_SB1:
15704       fputs ("Broadcom SB-1", stdout);
15705       break;
15706     case AFL_EXT_4111:
15707       fputs ("NEC VR4111/VR4181", stdout);
15708       break;
15709     case AFL_EXT_4120:
15710       fputs ("NEC VR4120", stdout);
15711       break;
15712     case AFL_EXT_5400:
15713       fputs ("NEC VR5400", stdout);
15714       break;
15715     case AFL_EXT_5500:
15716       fputs ("NEC VR5500", stdout);
15717       break;
15718     case AFL_EXT_LOONGSON_2E:
15719       fputs ("ST Microelectronics Loongson 2E", stdout);
15720       break;
15721     case AFL_EXT_LOONGSON_2F:
15722       fputs ("ST Microelectronics Loongson 2F", stdout);
15723       break;
15724     case AFL_EXT_INTERAPTIV_MR2:
15725       fputs ("Imagination interAptiv MR2", stdout);
15726       break;
15727     default:
15728       fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15729     }
15730 }
15731
15732 static signed int
15733 get_mips_reg_size (int reg_size)
15734 {
15735   return (reg_size == AFL_REG_NONE) ? 0
15736          : (reg_size == AFL_REG_32) ? 32
15737          : (reg_size == AFL_REG_64) ? 64
15738          : (reg_size == AFL_REG_128) ? 128
15739          : -1;
15740 }
15741
15742 static bfd_boolean
15743 process_mips_specific (Filedata * filedata)
15744 {
15745   Elf_Internal_Dyn * entry;
15746   Elf_Internal_Shdr *sect = NULL;
15747   size_t liblist_offset = 0;
15748   size_t liblistno = 0;
15749   size_t conflictsno = 0;
15750   size_t options_offset = 0;
15751   size_t conflicts_offset = 0;
15752   size_t pltrelsz = 0;
15753   size_t pltrel = 0;
15754   bfd_vma pltgot = 0;
15755   bfd_vma mips_pltgot = 0;
15756   bfd_vma jmprel = 0;
15757   bfd_vma local_gotno = 0;
15758   bfd_vma gotsym = 0;
15759   bfd_vma symtabno = 0;
15760   bfd_boolean res = TRUE;
15761
15762   if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15763                             display_mips_gnu_attribute))
15764     res = FALSE;
15765
15766   sect = find_section (filedata, ".MIPS.abiflags");
15767
15768   if (sect != NULL)
15769     {
15770       Elf_External_ABIFlags_v0 *abiflags_ext;
15771       Elf_Internal_ABIFlags_v0 abiflags_in;
15772
15773       if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15774         {
15775           error (_("Corrupt MIPS ABI Flags section.\n"));
15776           res = FALSE;
15777         }
15778       else
15779         {
15780           abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15781                                    sect->sh_size, _("MIPS ABI Flags section"));
15782           if (abiflags_ext)
15783             {
15784               abiflags_in.version = BYTE_GET (abiflags_ext->version);
15785               abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15786               abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15787               abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15788               abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15789               abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15790               abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15791               abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15792               abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15793               abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15794               abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15795
15796               printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15797               printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15798               if (abiflags_in.isa_rev > 1)
15799                 printf ("r%d", abiflags_in.isa_rev);
15800               printf ("\nGPR size: %d",
15801                       get_mips_reg_size (abiflags_in.gpr_size));
15802               printf ("\nCPR1 size: %d",
15803                       get_mips_reg_size (abiflags_in.cpr1_size));
15804               printf ("\nCPR2 size: %d",
15805                       get_mips_reg_size (abiflags_in.cpr2_size));
15806               fputs ("\nFP ABI: ", stdout);
15807               print_mips_fp_abi_value (abiflags_in.fp_abi);
15808               fputs ("ISA Extension: ", stdout);
15809               print_mips_isa_ext (abiflags_in.isa_ext);
15810               fputs ("\nASEs:", stdout);
15811               print_mips_ases (abiflags_in.ases);
15812               printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15813               printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15814               fputc ('\n', stdout);
15815               free (abiflags_ext);
15816             }
15817         }
15818     }
15819
15820   /* We have a lot of special sections.  Thanks SGI!  */
15821   if (dynamic_section == NULL)
15822     {
15823       /* No dynamic information available.  See if there is static GOT.  */
15824       sect = find_section (filedata, ".got");
15825       if (sect != NULL)
15826         {
15827           unsigned char *data_end;
15828           unsigned char *data;
15829           bfd_vma ent, end;
15830           int addr_size;
15831
15832           pltgot = sect->sh_addr;
15833
15834           ent = pltgot;
15835           addr_size = (is_32bit_elf ? 4 : 8);
15836           end = pltgot + sect->sh_size;
15837
15838           data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15839                                              end - pltgot, 1,
15840                                              _("Global Offset Table data"));
15841           /* PR 12855: Null data is handled gracefully throughout.  */
15842           data_end = data + (end - pltgot);
15843
15844           printf (_("\nStatic GOT:\n"));
15845           printf (_(" Canonical gp value: "));
15846           print_vma (ent + 0x7ff0, LONG_HEX);
15847           printf ("\n\n");
15848
15849           /* In a dynamic binary GOT[0] is reserved for the dynamic
15850              loader to store the lazy resolver pointer, however in
15851              a static binary it may well have been omitted and GOT
15852              reduced to a table of addresses.
15853              PR 21344: Check for the entry being fully available
15854              before fetching it.  */
15855           if (data
15856               && data + ent - pltgot + addr_size <= data_end
15857               && byte_get (data + ent - pltgot, addr_size) == 0)
15858             {
15859               printf (_(" Reserved entries:\n"));
15860               printf (_("  %*s %10s %*s\n"),
15861                       addr_size * 2, _("Address"), _("Access"),
15862                       addr_size * 2, _("Value"));
15863               ent = print_mips_got_entry (data, pltgot, ent, data_end);
15864               printf ("\n");
15865               if (ent == (bfd_vma) -1)
15866                 goto sgot_print_fail;
15867
15868               /* Check for the MSB of GOT[1] being set, identifying a
15869                  GNU object.  This entry will be used by some runtime
15870                  loaders, to store the module pointer.  Otherwise this
15871                  is an ordinary local entry.
15872                  PR 21344: Check for the entry being fully available
15873                  before fetching it.  */
15874               if (data
15875                   && data + ent - pltgot + addr_size <= data_end
15876                   && (byte_get (data + ent - pltgot, addr_size)
15877                       >> (addr_size * 8 - 1)) != 0)
15878                 {
15879                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15880                   printf ("\n");
15881                   if (ent == (bfd_vma) -1)
15882                     goto sgot_print_fail;
15883                 }
15884               printf ("\n");
15885             }
15886
15887           if (data != NULL && ent < end)
15888             {
15889               printf (_(" Local entries:\n"));
15890               printf ("  %*s %10s %*s\n",
15891                       addr_size * 2, _("Address"), _("Access"),
15892                       addr_size * 2, _("Value"));
15893               while (ent < end)
15894                 {
15895                   ent = print_mips_got_entry (data, pltgot, ent, data_end);
15896                   printf ("\n");
15897                   if (ent == (bfd_vma) -1)
15898                     goto sgot_print_fail;
15899                 }
15900               printf ("\n");
15901             }
15902
15903         sgot_print_fail:
15904           if (data)
15905             free (data);
15906         }
15907       return res;
15908     }
15909
15910   for (entry = dynamic_section;
15911        /* PR 17531 file: 012-50589-0.004.  */
15912        entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15913        ++entry)
15914     switch (entry->d_tag)
15915       {
15916       case DT_MIPS_LIBLIST:
15917         liblist_offset
15918           = offset_from_vma (filedata, entry->d_un.d_val,
15919                              liblistno * sizeof (Elf32_External_Lib));
15920         break;
15921       case DT_MIPS_LIBLISTNO:
15922         liblistno = entry->d_un.d_val;
15923         break;
15924       case DT_MIPS_OPTIONS:
15925         options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15926         break;
15927       case DT_MIPS_CONFLICT:
15928         conflicts_offset
15929           = offset_from_vma (filedata, entry->d_un.d_val,
15930                              conflictsno * sizeof (Elf32_External_Conflict));
15931         break;
15932       case DT_MIPS_CONFLICTNO:
15933         conflictsno = entry->d_un.d_val;
15934         break;
15935       case DT_PLTGOT:
15936         pltgot = entry->d_un.d_ptr;
15937         break;
15938       case DT_MIPS_LOCAL_GOTNO:
15939         local_gotno = entry->d_un.d_val;
15940         break;
15941       case DT_MIPS_GOTSYM:
15942         gotsym = entry->d_un.d_val;
15943         break;
15944       case DT_MIPS_SYMTABNO:
15945         symtabno = entry->d_un.d_val;
15946         break;
15947       case DT_MIPS_PLTGOT:
15948         mips_pltgot = entry->d_un.d_ptr;
15949         break;
15950       case DT_PLTREL:
15951         pltrel = entry->d_un.d_val;
15952         break;
15953       case DT_PLTRELSZ:
15954         pltrelsz = entry->d_un.d_val;
15955         break;
15956       case DT_JMPREL:
15957         jmprel = entry->d_un.d_ptr;
15958         break;
15959       default:
15960         break;
15961       }
15962
15963   if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15964     {
15965       Elf32_External_Lib * elib;
15966       size_t cnt;
15967
15968       elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15969                                               liblistno,
15970                                               sizeof (Elf32_External_Lib),
15971                                               _("liblist section data"));
15972       if (elib)
15973         {
15974           printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15975                             "\nSection '.liblist' contains %lu entries:\n",
15976                             (unsigned long) liblistno),
15977                   (unsigned long) liblistno);
15978           fputs (_("     Library              Time Stamp          Checksum   Version Flags\n"),
15979                  stdout);
15980
15981           for (cnt = 0; cnt < liblistno; ++cnt)
15982             {
15983               Elf32_Lib liblist;
15984               time_t atime;
15985               char timebuf[128];
15986               struct tm * tmp;
15987
15988               liblist.l_name = BYTE_GET (elib[cnt].l_name);
15989               atime = BYTE_GET (elib[cnt].l_time_stamp);
15990               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15991               liblist.l_version = BYTE_GET (elib[cnt].l_version);
15992               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15993
15994               tmp = gmtime (&atime);
15995               snprintf (timebuf, sizeof (timebuf),
15996                         "%04u-%02u-%02uT%02u:%02u:%02u",
15997                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15998                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15999
16000               printf ("%3lu: ", (unsigned long) cnt);
16001               if (VALID_DYNAMIC_NAME (liblist.l_name))
16002                 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16003               else
16004                 printf (_("<corrupt: %9ld>"), liblist.l_name);
16005               printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16006                       liblist.l_version);
16007
16008               if (liblist.l_flags == 0)
16009                 puts (_(" NONE"));
16010               else
16011                 {
16012                   static const struct
16013                   {
16014                     const char * name;
16015                     int bit;
16016                   }
16017                   l_flags_vals[] =
16018                   {
16019                     { " EXACT_MATCH", LL_EXACT_MATCH },
16020                     { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16021                     { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16022                     { " EXPORTS", LL_EXPORTS },
16023                     { " DELAY_LOAD", LL_DELAY_LOAD },
16024                     { " DELTA", LL_DELTA }
16025                   };
16026                   int flags = liblist.l_flags;
16027                   size_t fcnt;
16028
16029                   for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16030                     if ((flags & l_flags_vals[fcnt].bit) != 0)
16031                       {
16032                         fputs (l_flags_vals[fcnt].name, stdout);
16033                         flags ^= l_flags_vals[fcnt].bit;
16034                       }
16035                   if (flags != 0)
16036                     printf (" %#x", (unsigned int) flags);
16037
16038                   puts ("");
16039                 }
16040             }
16041
16042           free (elib);
16043         }
16044       else
16045         res = FALSE;
16046     }
16047
16048   if (options_offset != 0)
16049     {
16050       Elf_External_Options * eopt;
16051       Elf_Internal_Options * iopt;
16052       Elf_Internal_Options * option;
16053       size_t offset;
16054       int cnt;
16055       sect = filedata->section_headers;
16056
16057       /* Find the section header so that we get the size.  */
16058       sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16059       /* PR 17533 file: 012-277276-0.004.  */
16060       if (sect == NULL)
16061         {
16062           error (_("No MIPS_OPTIONS header found\n"));
16063           return FALSE;
16064         }
16065
16066       eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16067                                                 sect->sh_size, _("options"));
16068       if (eopt)
16069         {
16070           iopt = (Elf_Internal_Options *)
16071               cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16072           if (iopt == NULL)
16073             {
16074               error (_("Out of memory allocating space for MIPS options\n"));
16075               return FALSE;
16076             }
16077
16078           offset = cnt = 0;
16079           option = iopt;
16080
16081           while (offset <= sect->sh_size - sizeof (* eopt))
16082             {
16083               Elf_External_Options * eoption;
16084
16085               eoption = (Elf_External_Options *) ((char *) eopt + offset);
16086
16087               option->kind = BYTE_GET (eoption->kind);
16088               option->size = BYTE_GET (eoption->size);
16089               option->section = BYTE_GET (eoption->section);
16090               option->info = BYTE_GET (eoption->info);
16091
16092               /* PR 17531: file: ffa0fa3b.  */
16093               if (option->size < sizeof (* eopt)
16094                   || offset + option->size > sect->sh_size)
16095                 {
16096                   error (_("Invalid size (%u) for MIPS option\n"), option->size);
16097                   return FALSE;
16098                 }
16099               offset += option->size;
16100
16101               ++option;
16102               ++cnt;
16103             }
16104
16105           printf (ngettext ("\nSection '%s' contains %d entry:\n",
16106                             "\nSection '%s' contains %d entries:\n",
16107                             cnt),
16108                   printable_section_name (filedata, sect), cnt);
16109
16110           option = iopt;
16111           offset = 0;
16112
16113           while (cnt-- > 0)
16114             {
16115               size_t len;
16116
16117               switch (option->kind)
16118                 {
16119                 case ODK_NULL:
16120                   /* This shouldn't happen.  */
16121                   printf (" NULL       %d %lx", option->section, option->info);
16122                   break;
16123                 case ODK_REGINFO:
16124                   printf (" REGINFO    ");
16125                   if (filedata->file_header.e_machine == EM_MIPS)
16126                     {
16127                       /* 32bit form.  */
16128                       Elf32_External_RegInfo * ereg;
16129                       Elf32_RegInfo reginfo;
16130
16131                       ereg = (Elf32_External_RegInfo *) (option + 1);
16132                       reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16133                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16134                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16135                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16136                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16137                       reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16138
16139                       printf ("GPR %08lx  GP 0x%lx\n",
16140                               reginfo.ri_gprmask,
16141                               (unsigned long) reginfo.ri_gp_value);
16142                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16143                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16144                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16145                     }
16146                   else
16147                     {
16148                       /* 64 bit form.  */
16149                       Elf64_External_RegInfo * ereg;
16150                       Elf64_Internal_RegInfo reginfo;
16151
16152                       ereg = (Elf64_External_RegInfo *) (option + 1);
16153                       reginfo.ri_gprmask    = BYTE_GET (ereg->ri_gprmask);
16154                       reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16155                       reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16156                       reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16157                       reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16158                       reginfo.ri_gp_value   = BYTE_GET (ereg->ri_gp_value);
16159
16160                       printf ("GPR %08lx  GP 0x",
16161                               reginfo.ri_gprmask);
16162                       printf_vma (reginfo.ri_gp_value);
16163                       printf ("\n");
16164
16165                       printf ("            CPR0 %08lx  CPR1 %08lx  CPR2 %08lx  CPR3 %08lx\n",
16166                               reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16167                               reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16168                     }
16169                   ++option;
16170                   continue;
16171                 case ODK_EXCEPTIONS:
16172                   fputs (" EXCEPTIONS fpe_min(", stdout);
16173                   process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16174                   fputs (") fpe_max(", stdout);
16175                   process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16176                   fputs (")", stdout);
16177
16178                   if (option->info & OEX_PAGE0)
16179                     fputs (" PAGE0", stdout);
16180                   if (option->info & OEX_SMM)
16181                     fputs (" SMM", stdout);
16182                   if (option->info & OEX_FPDBUG)
16183                     fputs (" FPDBUG", stdout);
16184                   if (option->info & OEX_DISMISS)
16185                     fputs (" DISMISS", stdout);
16186                   break;
16187                 case ODK_PAD:
16188                   fputs (" PAD       ", stdout);
16189                   if (option->info & OPAD_PREFIX)
16190                     fputs (" PREFIX", stdout);
16191                   if (option->info & OPAD_POSTFIX)
16192                     fputs (" POSTFIX", stdout);
16193                   if (option->info & OPAD_SYMBOL)
16194                     fputs (" SYMBOL", stdout);
16195                   break;
16196                 case ODK_HWPATCH:
16197                   fputs (" HWPATCH   ", stdout);
16198                   if (option->info & OHW_R4KEOP)
16199                     fputs (" R4KEOP", stdout);
16200                   if (option->info & OHW_R8KPFETCH)
16201                     fputs (" R8KPFETCH", stdout);
16202                   if (option->info & OHW_R5KEOP)
16203                     fputs (" R5KEOP", stdout);
16204                   if (option->info & OHW_R5KCVTL)
16205                     fputs (" R5KCVTL", stdout);
16206                   break;
16207                 case ODK_FILL:
16208                   fputs (" FILL       ", stdout);
16209                   /* XXX Print content of info word?  */
16210                   break;
16211                 case ODK_TAGS:
16212                   fputs (" TAGS       ", stdout);
16213                   /* XXX Print content of info word?  */
16214                   break;
16215                 case ODK_HWAND:
16216                   fputs (" HWAND     ", stdout);
16217                   if (option->info & OHWA0_R4KEOP_CHECKED)
16218                     fputs (" R4KEOP_CHECKED", stdout);
16219                   if (option->info & OHWA0_R4KEOP_CLEAN)
16220                     fputs (" R4KEOP_CLEAN", stdout);
16221                   break;
16222                 case ODK_HWOR:
16223                   fputs (" HWOR      ", stdout);
16224                   if (option->info & OHWA0_R4KEOP_CHECKED)
16225                     fputs (" R4KEOP_CHECKED", stdout);
16226                   if (option->info & OHWA0_R4KEOP_CLEAN)
16227                     fputs (" R4KEOP_CLEAN", stdout);
16228                   break;
16229                 case ODK_GP_GROUP:
16230                   printf (" GP_GROUP  %#06lx  self-contained %#06lx",
16231                           option->info & OGP_GROUP,
16232                           (option->info & OGP_SELF) >> 16);
16233                   break;
16234                 case ODK_IDENT:
16235                   printf (" IDENT     %#06lx  self-contained %#06lx",
16236                           option->info & OGP_GROUP,
16237                           (option->info & OGP_SELF) >> 16);
16238                   break;
16239                 default:
16240                   /* This shouldn't happen.  */
16241                   printf (" %3d ???     %d %lx",
16242                           option->kind, option->section, option->info);
16243                   break;
16244                 }
16245
16246               len = sizeof (* eopt);
16247               while (len < option->size)
16248                 {
16249                   unsigned char datum = * ((unsigned char *) eopt + offset + len);
16250
16251                   if (ISPRINT (datum))
16252                     printf ("%c", datum);
16253                   else
16254                     printf ("\\%03o", datum);
16255                   len ++;
16256                 }
16257               fputs ("\n", stdout);
16258
16259               offset += option->size;
16260               ++option;
16261             }
16262
16263           free (eopt);
16264         }
16265       else
16266         res = FALSE;
16267     }
16268
16269   if (conflicts_offset != 0 && conflictsno != 0)
16270     {
16271       Elf32_Conflict * iconf;
16272       size_t cnt;
16273
16274       if (dynamic_symbols == NULL)
16275         {
16276           error (_("conflict list found without a dynamic symbol table\n"));
16277           return FALSE;
16278         }
16279
16280       /* PR 21345 - print a slightly more helpful error message
16281          if we are sure that the cmalloc will fail.  */
16282       if (conflictsno * sizeof (* iconf) > filedata->file_size)
16283         {
16284           error (_("Overlarge number of conflicts detected: %lx\n"),
16285                  (long) conflictsno);
16286           return FALSE;
16287         }
16288
16289       iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16290       if (iconf == NULL)
16291         {
16292           error (_("Out of memory allocating space for dynamic conflicts\n"));
16293           return FALSE;
16294         }
16295
16296       if (is_32bit_elf)
16297         {
16298           Elf32_External_Conflict * econf32;
16299
16300           econf32 = (Elf32_External_Conflict *)
16301               get_data (NULL, filedata, conflicts_offset, conflictsno,
16302                         sizeof (* econf32), _("conflict"));
16303           if (!econf32)
16304             return FALSE;
16305
16306           for (cnt = 0; cnt < conflictsno; ++cnt)
16307             iconf[cnt] = BYTE_GET (econf32[cnt]);
16308
16309           free (econf32);
16310         }
16311       else
16312         {
16313           Elf64_External_Conflict * econf64;
16314
16315           econf64 = (Elf64_External_Conflict *)
16316               get_data (NULL, filedata, conflicts_offset, conflictsno,
16317                         sizeof (* econf64), _("conflict"));
16318           if (!econf64)
16319             return FALSE;
16320
16321           for (cnt = 0; cnt < conflictsno; ++cnt)
16322             iconf[cnt] = BYTE_GET (econf64[cnt]);
16323
16324           free (econf64);
16325         }
16326
16327       printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16328                         "\nSection '.conflict' contains %lu entries:\n",
16329                         (unsigned long) conflictsno),
16330               (unsigned long) conflictsno);
16331       puts (_("  Num:    Index       Value  Name"));
16332
16333       for (cnt = 0; cnt < conflictsno; ++cnt)
16334         {
16335           printf ("%5lu: %8lu  ", (unsigned long) cnt, iconf[cnt]);
16336
16337           if (iconf[cnt] >= num_dynamic_syms)
16338             printf (_("<corrupt symbol index>"));
16339           else
16340             {
16341               Elf_Internal_Sym * psym;
16342
16343               psym = & dynamic_symbols[iconf[cnt]];
16344               print_vma (psym->st_value, FULL_HEX);
16345               putchar (' ');
16346               if (VALID_DYNAMIC_NAME (psym->st_name))
16347                 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16348               else
16349                 printf (_("<corrupt: %14ld>"), psym->st_name);
16350             }
16351           putchar ('\n');
16352         }
16353
16354       free (iconf);
16355     }
16356
16357   if (pltgot != 0 && local_gotno != 0)
16358     {
16359       bfd_vma ent, local_end, global_end;
16360       size_t i, offset;
16361       unsigned char * data;
16362       unsigned char * data_end;
16363       int addr_size;
16364
16365       ent = pltgot;
16366       addr_size = (is_32bit_elf ? 4 : 8);
16367       local_end = pltgot + local_gotno * addr_size;
16368
16369       /* PR binutils/17533 file: 012-111227-0.004  */
16370       if (symtabno < gotsym)
16371         {
16372           error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16373                  (unsigned long) gotsym, (unsigned long) symtabno);
16374           return FALSE;
16375         }
16376
16377       global_end = local_end + (symtabno - gotsym) * addr_size;
16378       /* PR 17531: file: 54c91a34.  */
16379       if (global_end < local_end)
16380         {
16381           error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16382           return FALSE;
16383         }
16384
16385       offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16386       data = (unsigned char *) get_data (NULL, filedata, offset,
16387                                          global_end - pltgot, 1,
16388                                          _("Global Offset Table data"));
16389       /* PR 12855: Null data is handled gracefully throughout.  */
16390       data_end = data + (global_end - pltgot);
16391
16392       printf (_("\nPrimary GOT:\n"));
16393       printf (_(" Canonical gp value: "));
16394       print_vma (pltgot + 0x7ff0, LONG_HEX);
16395       printf ("\n\n");
16396
16397       printf (_(" Reserved entries:\n"));
16398       printf (_("  %*s %10s %*s Purpose\n"),
16399               addr_size * 2, _("Address"), _("Access"),
16400               addr_size * 2, _("Initial"));
16401       ent = print_mips_got_entry (data, pltgot, ent, data_end);
16402       printf (_(" Lazy resolver\n"));
16403       if (ent == (bfd_vma) -1)
16404         goto got_print_fail;
16405
16406       /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16407          This entry will be used by some runtime loaders, to store the
16408          module pointer.  Otherwise this is an ordinary local entry.
16409          PR 21344: Check for the entry being fully available before
16410          fetching it.  */
16411       if (data
16412           && data + ent - pltgot + addr_size <= data_end
16413           && (byte_get (data + ent - pltgot, addr_size)
16414               >> (addr_size * 8 - 1)) != 0)
16415         {
16416           ent = print_mips_got_entry (data, pltgot, ent, data_end);
16417           printf (_(" Module pointer (GNU extension)\n"));
16418           if (ent == (bfd_vma) -1)
16419             goto got_print_fail;
16420         }
16421       printf ("\n");
16422
16423       if (data != NULL && ent < local_end)
16424         {
16425           printf (_(" Local entries:\n"));
16426           printf ("  %*s %10s %*s\n",
16427                   addr_size * 2, _("Address"), _("Access"),
16428                   addr_size * 2, _("Initial"));
16429           while (ent < local_end)
16430             {
16431               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16432               printf ("\n");
16433               if (ent == (bfd_vma) -1)
16434                 goto got_print_fail;
16435             }
16436           printf ("\n");
16437         }
16438
16439       if (data != NULL && gotsym < symtabno)
16440         {
16441           int sym_width;
16442
16443           printf (_(" Global entries:\n"));
16444           printf ("  %*s %10s %*s %*s %-7s %3s %s\n",
16445                   addr_size * 2, _("Address"),
16446                   _("Access"),
16447                   addr_size * 2, _("Initial"),
16448                   addr_size * 2, _("Sym.Val."),
16449                   _("Type"),
16450                   /* Note for translators: "Ndx" = abbreviated form of "Index".  */
16451                   _("Ndx"), _("Name"));
16452
16453           sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16454
16455           for (i = gotsym; i < symtabno; i++)
16456             {
16457               ent = print_mips_got_entry (data, pltgot, ent, data_end);
16458               printf (" ");
16459
16460               if (dynamic_symbols == NULL)
16461                 printf (_("<no dynamic symbols>"));
16462               else if (i < num_dynamic_syms)
16463                 {
16464                   Elf_Internal_Sym * psym = dynamic_symbols + i;
16465
16466                   print_vma (psym->st_value, LONG_HEX);
16467                   printf (" %-7s %3s ",
16468                           get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16469                           get_symbol_index_type (filedata, psym->st_shndx));
16470
16471                   if (VALID_DYNAMIC_NAME (psym->st_name))
16472                     print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16473                   else
16474                     printf (_("<corrupt: %14ld>"), psym->st_name);
16475                 }
16476               else
16477                 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16478                         (unsigned long) i);
16479
16480               printf ("\n");
16481               if (ent == (bfd_vma) -1)
16482                 break;
16483             }
16484           printf ("\n");
16485         }
16486
16487     got_print_fail:
16488       if (data)
16489         free (data);
16490     }
16491
16492   if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16493     {
16494       bfd_vma ent, end;
16495       size_t offset, rel_offset;
16496       unsigned long count, i;
16497       unsigned char * data;
16498       int addr_size, sym_width;
16499       Elf_Internal_Rela * rels;
16500
16501       rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16502       if (pltrel == DT_RELA)
16503         {
16504           if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16505             return FALSE;
16506         }
16507       else
16508         {
16509           if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16510             return FALSE;
16511         }
16512
16513       ent = mips_pltgot;
16514       addr_size = (is_32bit_elf ? 4 : 8);
16515       end = mips_pltgot + (2 + count) * addr_size;
16516
16517       offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16518       data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16519                                          1, _("Procedure Linkage Table data"));
16520       if (data == NULL)
16521         return FALSE;
16522
16523       printf ("\nPLT GOT:\n\n");
16524       printf (_(" Reserved entries:\n"));
16525       printf (_("  %*s %*s Purpose\n"),
16526               addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16527       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16528       printf (_(" PLT lazy resolver\n"));
16529       ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16530       printf (_(" Module pointer\n"));
16531       printf ("\n");
16532
16533       printf (_(" Entries:\n"));
16534       printf ("  %*s %*s %*s %-7s %3s %s\n",
16535               addr_size * 2, _("Address"),
16536               addr_size * 2, _("Initial"),
16537               addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16538       sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16539       for (i = 0; i < count; i++)
16540         {
16541           unsigned long idx = get_reloc_symindex (rels[i].r_info);
16542
16543           ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16544           printf (" ");
16545
16546           if (idx >= num_dynamic_syms)
16547             printf (_("<corrupt symbol index: %lu>"), idx);
16548           else
16549             {
16550               Elf_Internal_Sym * psym = dynamic_symbols + idx;
16551
16552               print_vma (psym->st_value, LONG_HEX);
16553               printf (" %-7s %3s ",
16554                       get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16555                       get_symbol_index_type (filedata, psym->st_shndx));
16556               if (VALID_DYNAMIC_NAME (psym->st_name))
16557                 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16558               else
16559                 printf (_("<corrupt: %14ld>"), psym->st_name);
16560             }
16561           printf ("\n");
16562         }
16563       printf ("\n");
16564
16565       if (data)
16566         free (data);
16567       free (rels);
16568     }
16569
16570   return res;
16571 }
16572
16573 static bfd_boolean
16574 process_nds32_specific (Filedata * filedata)
16575 {
16576   Elf_Internal_Shdr *sect = NULL;
16577
16578   sect = find_section (filedata, ".nds32_e_flags");
16579   if (sect != NULL)
16580     {
16581       unsigned int *flag;
16582
16583       printf ("\nNDS32 elf flags section:\n");
16584       flag = get_data (NULL, filedata, sect->sh_offset, 1,
16585                        sect->sh_size, _("NDS32 elf flags section"));
16586
16587       if (! flag)
16588         return FALSE;
16589
16590       switch ((*flag) & 0x3)
16591         {
16592         case 0:
16593           printf ("(VEC_SIZE):\tNo entry.\n");
16594           break;
16595         case 1:
16596           printf ("(VEC_SIZE):\t4 bytes\n");
16597           break;
16598         case 2:
16599           printf ("(VEC_SIZE):\t16 bytes\n");
16600           break;
16601         case 3:
16602           printf ("(VEC_SIZE):\treserved\n");
16603           break;
16604         }
16605     }
16606
16607   return TRUE;
16608 }
16609
16610 static bfd_boolean
16611 process_gnu_liblist (Filedata * filedata)
16612 {
16613   Elf_Internal_Shdr * section;
16614   Elf_Internal_Shdr * string_sec;
16615   Elf32_External_Lib * elib;
16616   char * strtab;
16617   size_t strtab_size;
16618   size_t cnt;
16619   unsigned long num_liblist;
16620   unsigned i;
16621   bfd_boolean res = TRUE;
16622
16623   if (! do_arch)
16624     return TRUE;
16625
16626   for (i = 0, section = filedata->section_headers;
16627        i < filedata->file_header.e_shnum;
16628        i++, section++)
16629     {
16630       switch (section->sh_type)
16631         {
16632         case SHT_GNU_LIBLIST:
16633           if (section->sh_link >= filedata->file_header.e_shnum)
16634             break;
16635
16636           elib = (Elf32_External_Lib *)
16637               get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16638                         _("liblist section data"));
16639
16640           if (elib == NULL)
16641             {
16642               res = FALSE;
16643               break;
16644             }
16645
16646           string_sec = filedata->section_headers + section->sh_link;
16647           strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16648                                       string_sec->sh_size,
16649                                       _("liblist string table"));
16650           if (strtab == NULL
16651               || section->sh_entsize != sizeof (Elf32_External_Lib))
16652             {
16653               free (elib);
16654               free (strtab);
16655               res = FALSE;
16656               break;
16657             }
16658           strtab_size = string_sec->sh_size;
16659
16660           num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16661           printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16662                             "\nLibrary list section '%s' contains %lu entries:\n",
16663                             num_liblist),
16664                   printable_section_name (filedata, section),
16665                   num_liblist);
16666
16667           puts (_("     Library              Time Stamp          Checksum   Version Flags"));
16668
16669           for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16670                ++cnt)
16671             {
16672               Elf32_Lib liblist;
16673               time_t atime;
16674               char timebuf[128];
16675               struct tm * tmp;
16676
16677               liblist.l_name = BYTE_GET (elib[cnt].l_name);
16678               atime = BYTE_GET (elib[cnt].l_time_stamp);
16679               liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16680               liblist.l_version = BYTE_GET (elib[cnt].l_version);
16681               liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16682
16683               tmp = gmtime (&atime);
16684               snprintf (timebuf, sizeof (timebuf),
16685                         "%04u-%02u-%02uT%02u:%02u:%02u",
16686                         tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16687                         tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16688
16689               printf ("%3lu: ", (unsigned long) cnt);
16690               if (do_wide)
16691                 printf ("%-20s", liblist.l_name < strtab_size
16692                         ? strtab + liblist.l_name : _("<corrupt>"));
16693               else
16694                 printf ("%-20.20s", liblist.l_name < strtab_size
16695                         ? strtab + liblist.l_name : _("<corrupt>"));
16696               printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16697                       liblist.l_version, liblist.l_flags);
16698             }
16699
16700           free (elib);
16701           free (strtab);
16702         }
16703     }
16704
16705   return res;
16706 }
16707
16708 static const char *
16709 get_note_type (Filedata * filedata, unsigned e_type)
16710 {
16711   static char buff[64];
16712
16713   if (filedata->file_header.e_type == ET_CORE)
16714     switch (e_type)
16715       {
16716       case NT_AUXV:
16717         return _("NT_AUXV (auxiliary vector)");
16718       case NT_PRSTATUS:
16719         return _("NT_PRSTATUS (prstatus structure)");
16720       case NT_FPREGSET:
16721         return _("NT_FPREGSET (floating point registers)");
16722       case NT_PRPSINFO:
16723         return _("NT_PRPSINFO (prpsinfo structure)");
16724       case NT_TASKSTRUCT:
16725         return _("NT_TASKSTRUCT (task structure)");
16726       case NT_PRXFPREG:
16727         return _("NT_PRXFPREG (user_xfpregs structure)");
16728       case NT_PPC_VMX:
16729         return _("NT_PPC_VMX (ppc Altivec registers)");
16730       case NT_PPC_VSX:
16731         return _("NT_PPC_VSX (ppc VSX registers)");
16732       case NT_PPC_TAR:
16733         return _("NT_PPC_TAR (ppc TAR register)");
16734       case NT_PPC_PPR:
16735         return _("NT_PPC_PPR (ppc PPR register)");
16736       case NT_PPC_DSCR:
16737         return _("NT_PPC_DSCR (ppc DSCR register)");
16738       case NT_PPC_EBB:
16739         return _("NT_PPC_EBB (ppc EBB registers)");
16740       case NT_PPC_PMU:
16741         return _("NT_PPC_PMU (ppc PMU registers)");
16742       case NT_PPC_TM_CGPR:
16743         return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16744       case NT_PPC_TM_CFPR:
16745         return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16746       case NT_PPC_TM_CVMX:
16747         return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16748       case NT_PPC_TM_CVSX:
16749         return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16750       case NT_PPC_TM_SPR:
16751         return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16752       case NT_PPC_TM_CTAR:
16753         return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16754       case NT_PPC_TM_CPPR:
16755         return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16756       case NT_PPC_TM_CDSCR:
16757         return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16758       case NT_386_TLS:
16759         return _("NT_386_TLS (x86 TLS information)");
16760       case NT_386_IOPERM:
16761         return _("NT_386_IOPERM (x86 I/O permissions)");
16762       case NT_X86_XSTATE:
16763         return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16764       case NT_S390_HIGH_GPRS:
16765         return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16766       case NT_S390_TIMER:
16767         return _("NT_S390_TIMER (s390 timer register)");
16768       case NT_S390_TODCMP:
16769         return _("NT_S390_TODCMP (s390 TOD comparator register)");
16770       case NT_S390_TODPREG:
16771         return _("NT_S390_TODPREG (s390 TOD programmable register)");
16772       case NT_S390_CTRS:
16773         return _("NT_S390_CTRS (s390 control registers)");
16774       case NT_S390_PREFIX:
16775         return _("NT_S390_PREFIX (s390 prefix register)");
16776       case NT_S390_LAST_BREAK:
16777         return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16778       case NT_S390_SYSTEM_CALL:
16779         return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16780       case NT_S390_TDB:
16781         return _("NT_S390_TDB (s390 transaction diagnostic block)");
16782       case NT_S390_VXRS_LOW:
16783         return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16784       case NT_S390_VXRS_HIGH:
16785         return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16786       case NT_S390_GS_CB:
16787         return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16788       case NT_S390_GS_BC:
16789         return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16790       case NT_ARM_VFP:
16791         return _("NT_ARM_VFP (arm VFP registers)");
16792       case NT_ARM_TLS:
16793         return _("NT_ARM_TLS (AArch TLS registers)");
16794       case NT_ARM_HW_BREAK:
16795         return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16796       case NT_ARM_HW_WATCH:
16797         return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16798       case NT_PSTATUS:
16799         return _("NT_PSTATUS (pstatus structure)");
16800       case NT_FPREGS:
16801         return _("NT_FPREGS (floating point registers)");
16802       case NT_PSINFO:
16803         return _("NT_PSINFO (psinfo structure)");
16804       case NT_LWPSTATUS:
16805         return _("NT_LWPSTATUS (lwpstatus_t structure)");
16806       case NT_LWPSINFO:
16807         return _("NT_LWPSINFO (lwpsinfo_t structure)");
16808       case NT_WIN32PSTATUS:
16809         return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16810       case NT_SIGINFO:
16811         return _("NT_SIGINFO (siginfo_t data)");
16812       case NT_FILE:
16813         return _("NT_FILE (mapped files)");
16814       default:
16815         break;
16816       }
16817   else
16818     switch (e_type)
16819       {
16820       case NT_VERSION:
16821         return _("NT_VERSION (version)");
16822       case NT_ARCH:
16823         return _("NT_ARCH (architecture)");
16824       case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16825         return _("OPEN");
16826       case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16827         return _("func");
16828       default:
16829         break;
16830       }
16831
16832   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16833   return buff;
16834 }
16835
16836 static bfd_boolean
16837 print_core_note (Elf_Internal_Note *pnote)
16838 {
16839   unsigned int addr_size = is_32bit_elf ? 4 : 8;
16840   bfd_vma count, page_size;
16841   unsigned char *descdata, *filenames, *descend;
16842
16843   if (pnote->type != NT_FILE)
16844     {
16845       if (do_wide)
16846         printf ("\n");
16847       return TRUE;
16848     }
16849
16850 #ifndef BFD64
16851   if (!is_32bit_elf)
16852     {
16853       printf (_("    Cannot decode 64-bit note in 32-bit build\n"));
16854       /* Still "successful".  */
16855       return TRUE;
16856     }
16857 #endif
16858
16859   if (pnote->descsz < 2 * addr_size)
16860     {
16861       error (_("    Malformed note - too short for header\n"));
16862       return FALSE;
16863     }
16864
16865   descdata = (unsigned char *) pnote->descdata;
16866   descend = descdata + pnote->descsz;
16867
16868   if (descdata[pnote->descsz - 1] != '\0')
16869     {
16870       error (_("    Malformed note - does not end with \\0\n"));
16871       return FALSE;
16872     }
16873
16874   count = byte_get (descdata, addr_size);
16875   descdata += addr_size;
16876
16877   page_size = byte_get (descdata, addr_size);
16878   descdata += addr_size;
16879
16880   if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16881       || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16882     {
16883       error (_("    Malformed note - too short for supplied file count\n"));
16884       return FALSE;
16885     }
16886
16887   printf (_("    Page size: "));
16888   print_vma (page_size, DEC);
16889   printf ("\n");
16890
16891   printf (_("    %*s%*s%*s\n"),
16892           (int) (2 + 2 * addr_size), _("Start"),
16893           (int) (4 + 2 * addr_size), _("End"),
16894           (int) (4 + 2 * addr_size), _("Page Offset"));
16895   filenames = descdata + count * 3 * addr_size;
16896   while (count-- > 0)
16897     {
16898       bfd_vma start, end, file_ofs;
16899
16900       if (filenames == descend)
16901         {
16902           error (_("    Malformed note - filenames end too early\n"));
16903           return FALSE;
16904         }
16905
16906       start = byte_get (descdata, addr_size);
16907       descdata += addr_size;
16908       end = byte_get (descdata, addr_size);
16909       descdata += addr_size;
16910       file_ofs = byte_get (descdata, addr_size);
16911       descdata += addr_size;
16912
16913       printf ("    ");
16914       print_vma (start, FULL_HEX);
16915       printf ("  ");
16916       print_vma (end, FULL_HEX);
16917       printf ("  ");
16918       print_vma (file_ofs, FULL_HEX);
16919       printf ("\n        %s\n", filenames);
16920
16921       filenames += 1 + strlen ((char *) filenames);
16922     }
16923
16924   return TRUE;
16925 }
16926
16927 static const char *
16928 get_gnu_elf_note_type (unsigned e_type)
16929 {
16930   /* NB/ Keep this switch statement in sync with print_gnu_note ().  */
16931   switch (e_type)
16932     {
16933     case NT_GNU_ABI_TAG:
16934       return _("NT_GNU_ABI_TAG (ABI version tag)");
16935     case NT_GNU_HWCAP:
16936       return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16937     case NT_GNU_BUILD_ID:
16938       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16939     case NT_GNU_GOLD_VERSION:
16940       return _("NT_GNU_GOLD_VERSION (gold version)");
16941     case NT_GNU_PROPERTY_TYPE_0:
16942       return _("NT_GNU_PROPERTY_TYPE_0");
16943     case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16944       return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16945     case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16946       return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16947     default:
16948       {
16949         static char buff[64];
16950
16951         snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16952         return buff;
16953       }
16954     }
16955 }
16956
16957 static void
16958 decode_x86_compat_isa (unsigned int bitmask)
16959 {
16960   while (bitmask)
16961     {
16962       unsigned int bit = bitmask & (- bitmask);
16963
16964       bitmask &= ~ bit;
16965       switch (bit)
16966         {
16967         case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
16968           printf ("i486");
16969           break;
16970         case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
16971           printf ("586");
16972           break;
16973         case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
16974           printf ("686");
16975           break;
16976         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
16977           printf ("SSE");
16978           break;
16979         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
16980           printf ("SSE2");
16981           break;
16982         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
16983           printf ("SSE3");
16984           break;
16985         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
16986           printf ("SSSE3");
16987           break;
16988         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
16989           printf ("SSE4_1");
16990           break;
16991         case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
16992           printf ("SSE4_2");
16993           break;
16994         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
16995           printf ("AVX");
16996           break;
16997         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
16998           printf ("AVX2");
16999           break;
17000         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17001           printf ("AVX512F");
17002           break;
17003         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17004           printf ("AVX512CD");
17005           break;
17006         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17007           printf ("AVX512ER");
17008           break;
17009         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17010           printf ("AVX512PF");
17011           break;
17012         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17013           printf ("AVX512VL");
17014           break;
17015         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17016           printf ("AVX512DQ");
17017           break;
17018         case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17019           printf ("AVX512BW");
17020           break;
17021         default:
17022           printf (_("<unknown: %x>"), bit);
17023           break;
17024         }
17025       if (bitmask)
17026         printf (", ");
17027     }
17028 }
17029
17030 static void
17031 decode_x86_isa (unsigned int bitmask)
17032 {
17033   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17034     {
17035       printf (_("<None>"));
17036       return;
17037     }
17038   else
17039     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17040
17041   while (bitmask)
17042     {
17043       unsigned int bit = bitmask & (- bitmask);
17044
17045       bitmask &= ~ bit;
17046       switch (bit)
17047         {
17048         case GNU_PROPERTY_X86_ISA_1_CMOV:
17049           printf ("CMOV");
17050           break;
17051         case GNU_PROPERTY_X86_ISA_1_SSE:
17052           printf ("SSE");
17053           break;
17054         case GNU_PROPERTY_X86_ISA_1_SSE2:
17055           printf ("SSE2");
17056           break;
17057         case GNU_PROPERTY_X86_ISA_1_SSE3:
17058           printf ("SSE3");
17059           break;
17060         case GNU_PROPERTY_X86_ISA_1_SSSE3:
17061           printf ("SSSE3");
17062           break;
17063         case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17064           printf ("SSE4_1");
17065           break;
17066         case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17067           printf ("SSE4_2");
17068           break;
17069         case GNU_PROPERTY_X86_ISA_1_AVX:
17070           printf ("AVX");
17071           break;
17072         case GNU_PROPERTY_X86_ISA_1_AVX2:
17073           printf ("AVX2");
17074           break;
17075         case GNU_PROPERTY_X86_ISA_1_FMA:
17076           printf ("FMA");
17077           break;
17078         case GNU_PROPERTY_X86_ISA_1_AVX512F:
17079           printf ("AVX512F");
17080           break;
17081         case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17082           printf ("AVX512CD");
17083           break;
17084         case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17085           printf ("AVX512ER");
17086           break;
17087         case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17088           printf ("AVX512PF");
17089           break;
17090         case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17091           printf ("AVX512VL");
17092           break;
17093         case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17094           printf ("AVX512DQ");
17095           break;
17096         case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17097           printf ("AVX512BW");
17098           break;
17099         case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17100           printf ("AVX512_4FMAPS");
17101           break;
17102         case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17103           printf ("AVX512_4VNNIW");
17104           break;
17105         case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17106           printf ("AVX512_BITALG");
17107           break;
17108         case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17109           printf ("AVX512_IFMA");
17110           break;
17111         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17112           printf ("AVX512_VBMI");
17113           break;
17114         case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17115           printf ("AVX512_VBMI2");
17116           break;
17117         case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17118           printf ("AVX512_VNNI");
17119           break;
17120         default:
17121           printf (_("<unknown: %x>"), bit);
17122           break;
17123         }
17124       if (bitmask)
17125         printf (", ");
17126     }
17127 }
17128
17129 static void
17130 decode_x86_feature_1 (unsigned int bitmask)
17131 {
17132   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17133     {
17134       printf (_("<None>"));
17135       return;
17136     }
17137   else
17138     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17139
17140   while (bitmask)
17141     {
17142       unsigned int bit = bitmask & (- bitmask);
17143
17144       bitmask &= ~ bit;
17145       switch (bit)
17146         {
17147         case GNU_PROPERTY_X86_FEATURE_1_IBT:
17148           printf ("IBT");
17149           break;
17150         case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17151           printf ("SHSTK");
17152           break;
17153         default:
17154           printf (_("<unknown: %x>"), bit);
17155           break;
17156         }
17157       if (bitmask)
17158         printf (", ");
17159     }
17160 }
17161
17162 static void
17163 decode_x86_feature_2 (unsigned int bitmask)
17164 {
17165   if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17166     {
17167       printf (_("<None>"));
17168       return;
17169     }
17170   else
17171     bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17172
17173   while (bitmask)
17174     {
17175       unsigned int bit = bitmask & (- bitmask);
17176
17177       bitmask &= ~ bit;
17178       switch (bit)
17179         {
17180         case GNU_PROPERTY_X86_FEATURE_2_X86:
17181           printf ("x86");
17182           break;
17183         case GNU_PROPERTY_X86_FEATURE_2_X87:
17184           printf ("x87");
17185           break;
17186         case GNU_PROPERTY_X86_FEATURE_2_MMX:
17187           printf ("MMX");
17188           break;
17189         case GNU_PROPERTY_X86_FEATURE_2_XMM:
17190           printf ("XMM");
17191           break;
17192         case GNU_PROPERTY_X86_FEATURE_2_YMM:
17193           printf ("YMM");
17194           break;
17195         case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17196           printf ("ZMM");
17197           break;
17198         case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17199           printf ("FXSR");
17200           break;
17201         case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17202           printf ("XSAVE");
17203           break;
17204         case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17205           printf ("XSAVEOPT");
17206           break;
17207         case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17208           printf ("XSAVEC");
17209           break;
17210         default:
17211           printf (_("<unknown: %x>"), bit);
17212           break;
17213         }
17214       if (bitmask)
17215         printf (", ");
17216     }
17217 }
17218
17219 static void
17220 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17221 {
17222   unsigned char * ptr = (unsigned char *) pnote->descdata;
17223   unsigned char * ptr_end = ptr + pnote->descsz;
17224   unsigned int    size = is_32bit_elf ? 4 : 8;
17225
17226   printf (_("      Properties: "));
17227
17228   if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17229     {
17230       printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17231       return;
17232     }
17233
17234   while (ptr < ptr_end)
17235     {
17236       unsigned int j;
17237       unsigned int type;
17238       unsigned int datasz;
17239
17240       if ((size_t) (ptr_end - ptr) < 8)
17241         {
17242           printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17243           break;
17244         }
17245
17246       type = byte_get (ptr, 4);
17247       datasz = byte_get (ptr + 4, 4);
17248
17249       ptr += 8;
17250
17251       if (datasz > (size_t) (ptr_end - ptr))
17252         {
17253           printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17254                   type, datasz);
17255           break;
17256         }
17257
17258       if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17259         {
17260           if (filedata->file_header.e_machine == EM_X86_64
17261               || filedata->file_header.e_machine == EM_IAMCU
17262               || filedata->file_header.e_machine == EM_386)
17263             {
17264               unsigned int bitmask;
17265
17266               if (datasz == 4)
17267                 {
17268                   bitmask = byte_get (ptr, 4);
17269                   if ((filedata->file_header.e_type == ET_EXEC
17270                        || filedata->file_header.e_type == ET_DYN)
17271                       && !(bitmask & GNU_PROPERTY_X86_UINT32_VALID))
17272                     printf ("Invalid ");
17273                 }
17274               else
17275                 bitmask = 0;
17276
17277               switch (type)
17278                 {
17279                 case GNU_PROPERTY_X86_ISA_1_USED:
17280                   if (datasz != 4)
17281                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17282                             datasz);
17283                   else
17284                     {
17285                       printf ("x86 ISA used: ");
17286                       decode_x86_isa (bitmask);
17287                     }
17288                   goto next;
17289
17290                 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17291                   if (datasz != 4)
17292                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17293                             datasz);
17294                   else
17295                     {
17296                       printf ("x86 ISA needed: ");
17297                       decode_x86_isa (bitmask);
17298                     }
17299                   goto next;
17300
17301                 case GNU_PROPERTY_X86_FEATURE_1_AND:
17302                   if (datasz != 4)
17303                     printf (_("x86 feature: <corrupt length: %#x> "),
17304                             datasz);
17305                   else
17306                     {
17307                       printf ("x86 feature: ");
17308                       decode_x86_feature_1 (bitmask);
17309                     }
17310                   goto next;
17311
17312                 case GNU_PROPERTY_X86_FEATURE_2_USED:
17313                   if (datasz != 4)
17314                     printf (_("x86 feature used: <corrupt length: %#x> "),
17315                             datasz);
17316                   else
17317                     {
17318                       printf ("x86 feature used: ");
17319                       decode_x86_feature_2 (bitmask);
17320                     }
17321                   goto next;
17322
17323                 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17324                   if (datasz != 4)
17325                     printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17326                   else
17327                     {
17328                       printf ("x86 feature needed: ");
17329                       decode_x86_feature_2 (bitmask);
17330                     }
17331                   goto next;
17332
17333                 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17334                   if (datasz != 4)
17335                     printf (_("x86 ISA used: <corrupt length: %#x> "),
17336                             datasz);
17337                   else
17338                     {
17339                       printf ("x86 ISA used: ");
17340                       decode_x86_compat_isa (bitmask);
17341                     }
17342                   goto next;
17343
17344                 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17345                   if (datasz != 4)
17346                     printf (_("x86 ISA needed: <corrupt length: %#x> "),
17347                             datasz);
17348                   else
17349                     {
17350                       printf ("x86 ISA needed: ");
17351                       decode_x86_compat_isa (bitmask);
17352                     }
17353                   goto next;
17354
17355                 default:
17356                   break;
17357                 }
17358             }
17359         }
17360       else
17361         {
17362           switch (type)
17363             {
17364             case GNU_PROPERTY_STACK_SIZE:
17365               printf (_("stack size: "));
17366               if (datasz != size)
17367                 printf (_("<corrupt length: %#x> "), datasz);
17368               else
17369                 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17370               goto next;
17371
17372             case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17373               printf ("no copy on protected ");
17374               if (datasz)
17375                 printf (_("<corrupt length: %#x> "), datasz);
17376               goto next;
17377
17378             default:
17379               break;
17380             }
17381         }
17382
17383       if (type < GNU_PROPERTY_LOPROC)
17384         printf (_("<unknown type %#x data: "), type);
17385       else if (type < GNU_PROPERTY_LOUSER)
17386         printf (_("<procesor-specific type %#x data: "), type);
17387       else
17388         printf (_("<application-specific type %#x data: "), type);
17389       for (j = 0; j < datasz; ++j)
17390         printf ("%02x ", ptr[j] & 0xff);
17391       printf (">");
17392
17393 next:
17394       ptr += ((datasz + (size - 1)) & ~ (size - 1));
17395       if (ptr == ptr_end)
17396         break;
17397
17398       if (do_wide)
17399         printf (", ");
17400       else
17401         printf ("\n\t");
17402     }
17403
17404   printf ("\n");
17405 }
17406
17407 static bfd_boolean
17408 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17409 {
17410   /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type ().  */
17411   switch (pnote->type)
17412     {
17413     case NT_GNU_BUILD_ID:
17414       {
17415         unsigned long i;
17416
17417         printf (_("    Build ID: "));
17418         for (i = 0; i < pnote->descsz; ++i)
17419           printf ("%02x", pnote->descdata[i] & 0xff);
17420         printf ("\n");
17421       }
17422       break;
17423
17424     case NT_GNU_ABI_TAG:
17425       {
17426         unsigned long os, major, minor, subminor;
17427         const char *osname;
17428
17429         /* PR 17531: file: 030-599401-0.004.  */
17430         if (pnote->descsz < 16)
17431           {
17432             printf (_("    <corrupt GNU_ABI_TAG>\n"));
17433             break;
17434           }
17435
17436         os = byte_get ((unsigned char *) pnote->descdata, 4);
17437         major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17438         minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17439         subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17440
17441         switch (os)
17442           {
17443           case GNU_ABI_TAG_LINUX:
17444             osname = "Linux";
17445             break;
17446           case GNU_ABI_TAG_HURD:
17447             osname = "Hurd";
17448             break;
17449           case GNU_ABI_TAG_SOLARIS:
17450             osname = "Solaris";
17451             break;
17452           case GNU_ABI_TAG_FREEBSD:
17453             osname = "FreeBSD";
17454             break;
17455           case GNU_ABI_TAG_NETBSD:
17456             osname = "NetBSD";
17457             break;
17458           case GNU_ABI_TAG_SYLLABLE:
17459             osname = "Syllable";
17460             break;
17461           case GNU_ABI_TAG_NACL:
17462             osname = "NaCl";
17463             break;
17464           default:
17465             osname = "Unknown";
17466             break;
17467           }
17468
17469         printf (_("    OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17470                 major, minor, subminor);
17471       }
17472       break;
17473
17474     case NT_GNU_GOLD_VERSION:
17475       {
17476         unsigned long i;
17477
17478         printf (_("    Version: "));
17479         for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17480           printf ("%c", pnote->descdata[i]);
17481         printf ("\n");
17482       }
17483       break;
17484
17485     case NT_GNU_HWCAP:
17486       {
17487         unsigned long num_entries, mask;
17488
17489         /* Hardware capabilities information.  Word 0 is the number of entries.
17490            Word 1 is a bitmask of enabled entries.  The rest of the descriptor
17491            is a series of entries, where each entry is a single byte followed
17492            by a nul terminated string.  The byte gives the bit number to test
17493            if enabled in the bitmask.  */
17494         printf (_("      Hardware Capabilities: "));
17495         if (pnote->descsz < 8)
17496           {
17497             error (_("<corrupt GNU_HWCAP>\n"));
17498             return FALSE;
17499           }
17500         num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17501         mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17502         printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17503         /* FIXME: Add code to display the entries... */
17504       }
17505       break;
17506
17507     case NT_GNU_PROPERTY_TYPE_0:
17508       print_gnu_property_note (filedata, pnote);
17509       break;
17510
17511     default:
17512       /* Handle unrecognised types.  An error message should have already been
17513          created by get_gnu_elf_note_type(), so all that we need to do is to
17514          display the data.  */
17515       {
17516         unsigned long i;
17517
17518         printf (_("    Description data: "));
17519         for (i = 0; i < pnote->descsz; ++i)
17520           printf ("%02x ", pnote->descdata[i] & 0xff);
17521         printf ("\n");
17522       }
17523       break;
17524     }
17525
17526   return TRUE;
17527 }
17528
17529 static const char *
17530 get_v850_elf_note_type (enum v850_notes n_type)
17531 {
17532   static char buff[64];
17533
17534   switch (n_type)
17535     {
17536     case V850_NOTE_ALIGNMENT:  return _("Alignment of 8-byte objects");
17537     case V850_NOTE_DATA_SIZE:  return _("Sizeof double and long double");
17538     case V850_NOTE_FPU_INFO:   return _("Type of FPU support needed");
17539     case V850_NOTE_SIMD_INFO:  return _("Use of SIMD instructions");
17540     case V850_NOTE_CACHE_INFO: return _("Use of cache");
17541     case V850_NOTE_MMU_INFO:   return _("Use of MMU");
17542     default:
17543       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17544       return buff;
17545     }
17546 }
17547
17548 static bfd_boolean
17549 print_v850_note (Elf_Internal_Note * pnote)
17550 {
17551   unsigned int val;
17552
17553   if (pnote->descsz != 4)
17554     return FALSE;
17555
17556   val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17557
17558   if (val == 0)
17559     {
17560       printf (_("not set\n"));
17561       return TRUE;
17562     }
17563
17564   switch (pnote->type)
17565     {
17566     case V850_NOTE_ALIGNMENT:
17567       switch (val)
17568         {
17569         case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17570         case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17571         }
17572       break;
17573
17574     case V850_NOTE_DATA_SIZE:
17575       switch (val)
17576         {
17577         case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17578         case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17579         }
17580       break;
17581
17582     case V850_NOTE_FPU_INFO:
17583       switch (val)
17584         {
17585         case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17586         case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17587         }
17588       break;
17589
17590     case V850_NOTE_MMU_INFO:
17591     case V850_NOTE_CACHE_INFO:
17592     case V850_NOTE_SIMD_INFO:
17593       if (val == EF_RH850_SIMD)
17594         {
17595           printf (_("yes\n"));
17596           return TRUE;
17597         }
17598       break;
17599
17600     default:
17601       /* An 'unknown note type' message will already have been displayed.  */
17602       break;
17603     }
17604
17605   printf (_("unknown value: %x\n"), val);
17606   return FALSE;
17607 }
17608
17609 static bfd_boolean
17610 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17611 {
17612   unsigned int version;
17613
17614   switch (pnote->type)
17615     {
17616     case NT_NETBSD_IDENT:
17617       version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17618       if ((version / 10000) % 100)
17619         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17620                 version, version / 100000000, (version / 1000000) % 100,
17621                 (version / 10000) % 100 > 26 ? "Z" : "",
17622                 'A' + (version / 10000) % 26);
17623       else
17624         printf ("  NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17625                 version, version / 100000000, (version / 1000000) % 100,
17626                 (version / 100) % 100);
17627       return TRUE;
17628
17629     case NT_NETBSD_MARCH:
17630       printf ("  NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17631               pnote->descdata);
17632       return TRUE;
17633
17634     default:
17635       printf ("  NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17636               pnote->type);
17637       return FALSE;
17638     }
17639 }
17640
17641 static const char *
17642 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17643 {
17644   switch (e_type)
17645     {
17646     case NT_FREEBSD_THRMISC:
17647       return _("NT_THRMISC (thrmisc structure)");
17648     case NT_FREEBSD_PROCSTAT_PROC:
17649       return _("NT_PROCSTAT_PROC (proc data)");
17650     case NT_FREEBSD_PROCSTAT_FILES:
17651       return _("NT_PROCSTAT_FILES (files data)");
17652     case NT_FREEBSD_PROCSTAT_VMMAP:
17653       return _("NT_PROCSTAT_VMMAP (vmmap data)");
17654     case NT_FREEBSD_PROCSTAT_GROUPS:
17655       return _("NT_PROCSTAT_GROUPS (groups data)");
17656     case NT_FREEBSD_PROCSTAT_UMASK:
17657       return _("NT_PROCSTAT_UMASK (umask data)");
17658     case NT_FREEBSD_PROCSTAT_RLIMIT:
17659       return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17660     case NT_FREEBSD_PROCSTAT_OSREL:
17661       return _("NT_PROCSTAT_OSREL (osreldate data)");
17662     case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17663       return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17664     case NT_FREEBSD_PROCSTAT_AUXV:
17665       return _("NT_PROCSTAT_AUXV (auxv data)");
17666     case NT_FREEBSD_PTLWPINFO:
17667       return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17668     }
17669   return get_note_type (filedata, e_type);
17670 }
17671
17672 static const char *
17673 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17674 {
17675   static char buff[64];
17676
17677   if (e_type == NT_NETBSDCORE_PROCINFO)
17678     return _("NetBSD procinfo structure");
17679
17680   /* As of Jan 2002 there are no other machine-independent notes
17681      defined for NetBSD core files.  If the note type is less
17682      than the start of the machine-dependent note types, we don't
17683      understand it.  */
17684
17685   if (e_type < NT_NETBSDCORE_FIRSTMACH)
17686     {
17687       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17688       return buff;
17689     }
17690
17691   switch (filedata->file_header.e_machine)
17692     {
17693     /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17694        and PT_GETFPREGS == mach+2.  */
17695
17696     case EM_OLD_ALPHA:
17697     case EM_ALPHA:
17698     case EM_SPARC:
17699     case EM_SPARC32PLUS:
17700     case EM_SPARCV9:
17701       switch (e_type)
17702         {
17703         case NT_NETBSDCORE_FIRSTMACH + 0:
17704           return _("PT_GETREGS (reg structure)");
17705         case NT_NETBSDCORE_FIRSTMACH + 2:
17706           return _("PT_GETFPREGS (fpreg structure)");
17707         default:
17708           break;
17709         }
17710       break;
17711
17712     /* On all other arch's, PT_GETREGS == mach+1 and
17713        PT_GETFPREGS == mach+3.  */
17714     default:
17715       switch (e_type)
17716         {
17717         case NT_NETBSDCORE_FIRSTMACH + 1:
17718           return _("PT_GETREGS (reg structure)");
17719         case NT_NETBSDCORE_FIRSTMACH + 3:
17720           return _("PT_GETFPREGS (fpreg structure)");
17721         default:
17722           break;
17723         }
17724     }
17725
17726   snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17727             e_type - NT_NETBSDCORE_FIRSTMACH);
17728   return buff;
17729 }
17730
17731 static const char *
17732 get_stapsdt_note_type (unsigned e_type)
17733 {
17734   static char buff[64];
17735
17736   switch (e_type)
17737     {
17738     case NT_STAPSDT:
17739       return _("NT_STAPSDT (SystemTap probe descriptors)");
17740
17741     default:
17742       break;
17743     }
17744
17745   snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17746   return buff;
17747 }
17748
17749 static bfd_boolean
17750 print_stapsdt_note (Elf_Internal_Note *pnote)
17751 {
17752   int addr_size = is_32bit_elf ? 4 : 8;
17753   char *data = pnote->descdata;
17754   char *data_end = pnote->descdata + pnote->descsz;
17755   bfd_vma pc, base_addr, semaphore;
17756   char *provider, *probe, *arg_fmt;
17757
17758   pc = byte_get ((unsigned char *) data, addr_size);
17759   data += addr_size;
17760   base_addr = byte_get ((unsigned char *) data, addr_size);
17761   data += addr_size;
17762   semaphore = byte_get ((unsigned char *) data, addr_size);
17763   data += addr_size;
17764
17765   provider = data;
17766   data += strlen (data) + 1;
17767   probe = data;
17768   data += strlen (data) + 1;
17769   arg_fmt = data;
17770   data += strlen (data) + 1;
17771
17772   printf (_("    Provider: %s\n"), provider);
17773   printf (_("    Name: %s\n"), probe);
17774   printf (_("    Location: "));
17775   print_vma (pc, FULL_HEX);
17776   printf (_(", Base: "));
17777   print_vma (base_addr, FULL_HEX);
17778   printf (_(", Semaphore: "));
17779   print_vma (semaphore, FULL_HEX);
17780   printf ("\n");
17781   printf (_("    Arguments: %s\n"), arg_fmt);
17782
17783   return data == data_end;
17784 }
17785
17786 static const char *
17787 get_ia64_vms_note_type (unsigned e_type)
17788 {
17789   static char buff[64];
17790
17791   switch (e_type)
17792     {
17793     case NT_VMS_MHD:
17794       return _("NT_VMS_MHD (module header)");
17795     case NT_VMS_LNM:
17796       return _("NT_VMS_LNM (language name)");
17797     case NT_VMS_SRC:
17798       return _("NT_VMS_SRC (source files)");
17799     case NT_VMS_TITLE:
17800       return "NT_VMS_TITLE";
17801     case NT_VMS_EIDC:
17802       return _("NT_VMS_EIDC (consistency check)");
17803     case NT_VMS_FPMODE:
17804       return _("NT_VMS_FPMODE (FP mode)");
17805     case NT_VMS_LINKTIME:
17806       return "NT_VMS_LINKTIME";
17807     case NT_VMS_IMGNAM:
17808       return _("NT_VMS_IMGNAM (image name)");
17809     case NT_VMS_IMGID:
17810       return _("NT_VMS_IMGID (image id)");
17811     case NT_VMS_LINKID:
17812       return _("NT_VMS_LINKID (link id)");
17813     case NT_VMS_IMGBID:
17814       return _("NT_VMS_IMGBID (build id)");
17815     case NT_VMS_GSTNAM:
17816       return _("NT_VMS_GSTNAM (sym table name)");
17817     case NT_VMS_ORIG_DYN:
17818       return "NT_VMS_ORIG_DYN";
17819     case NT_VMS_PATCHTIME:
17820       return "NT_VMS_PATCHTIME";
17821     default:
17822       snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17823       return buff;
17824     }
17825 }
17826
17827 static bfd_boolean
17828 print_ia64_vms_note (Elf_Internal_Note * pnote)
17829 {
17830   switch (pnote->type)
17831     {
17832     case NT_VMS_MHD:
17833       if (pnote->descsz > 36)
17834         {
17835           size_t l = strlen (pnote->descdata + 34);
17836           printf (_("    Creation date  : %.17s\n"), pnote->descdata);
17837           printf (_("    Last patch date: %.17s\n"), pnote->descdata + 17);
17838           printf (_("    Module name    : %s\n"), pnote->descdata + 34);
17839           printf (_("    Module version : %s\n"), pnote->descdata + 34 + l + 1);
17840         }
17841       else
17842         printf (_("    Invalid size\n"));
17843       break;
17844     case NT_VMS_LNM:
17845       printf (_("   Language: %s\n"), pnote->descdata);
17846       break;
17847 #ifdef BFD64
17848     case NT_VMS_FPMODE:
17849       printf (_("   Floating Point mode: "));
17850       printf ("0x%016" BFD_VMA_FMT "x\n",
17851               (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17852       break;
17853     case NT_VMS_LINKTIME:
17854       printf (_("   Link time: "));
17855       print_vms_time
17856         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17857       printf ("\n");
17858       break;
17859     case NT_VMS_PATCHTIME:
17860       printf (_("   Patch time: "));
17861       print_vms_time
17862         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17863       printf ("\n");
17864       break;
17865     case NT_VMS_ORIG_DYN:
17866       printf (_("   Major id: %u,  minor id: %u\n"),
17867               (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17868               (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17869       printf (_("   Last modified  : "));
17870       print_vms_time
17871         ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17872       printf (_("\n   Link flags  : "));
17873       printf ("0x%016" BFD_VMA_FMT "x\n",
17874               (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17875       printf (_("   Header flags: 0x%08x\n"),
17876               (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17877       printf (_("   Image id    : %s\n"), pnote->descdata + 32);
17878       break;
17879 #endif
17880     case NT_VMS_IMGNAM:
17881       printf (_("    Image name: %s\n"), pnote->descdata);
17882       break;
17883     case NT_VMS_GSTNAM:
17884       printf (_("    Global symbol table name: %s\n"), pnote->descdata);
17885       break;
17886     case NT_VMS_IMGID:
17887       printf (_("    Image id: %s\n"), pnote->descdata);
17888       break;
17889     case NT_VMS_LINKID:
17890       printf (_("    Linker id: %s\n"), pnote->descdata);
17891       break;
17892     default:
17893       return FALSE;
17894     }
17895   return TRUE;
17896 }
17897
17898 /* Find the symbol associated with a build attribute that is attached
17899    to address OFFSET.  If PNAME is non-NULL then store the name of
17900    the symbol (if found) in the provided pointer,  Returns NULL if a
17901    symbol could not be found.  */
17902
17903 static Elf_Internal_Sym *
17904 get_symbol_for_build_attribute (Filedata *       filedata,
17905                                 unsigned long    offset,
17906                                 bfd_boolean      is_open_attr,
17907                                 const char **    pname)
17908 {
17909   static Filedata *         saved_filedata = NULL;
17910   static char *             strtab;
17911   static unsigned long      strtablen;
17912   static Elf_Internal_Sym * symtab;
17913   static unsigned long      nsyms;
17914   Elf_Internal_Sym *        saved_sym = NULL;
17915   Elf_Internal_Sym *        sym;
17916
17917   if (filedata->section_headers != NULL
17918       && (saved_filedata == NULL || filedata != saved_filedata))
17919     {
17920       Elf_Internal_Shdr * symsec;
17921
17922       /* Load the symbol and string sections.  */
17923       for (symsec = filedata->section_headers;
17924            symsec < filedata->section_headers + filedata->file_header.e_shnum;
17925            symsec ++)
17926         {
17927           if (symsec->sh_type == SHT_SYMTAB)
17928             {
17929               symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17930
17931               if (symsec->sh_link < filedata->file_header.e_shnum)
17932                 {
17933                   Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17934
17935                   strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17936                                               1, strtab_sec->sh_size,
17937                                               _("string table"));
17938                   strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17939                 }
17940             }
17941         }
17942       saved_filedata = filedata;
17943     }
17944
17945   if (symtab == NULL || strtab == NULL)
17946     return NULL;
17947
17948   /* Find a symbol whose value matches offset.  */
17949   for (sym = symtab; sym < symtab + nsyms; sym ++)
17950     if (sym->st_value == offset)
17951       {
17952         if (sym->st_name >= strtablen)
17953           /* Huh ?  This should not happen.  */
17954           continue;
17955
17956         if (strtab[sym->st_name] == 0)
17957           continue;
17958
17959         /* The AArch64 and ARM architectures define mapping symbols
17960            (eg $d, $x, $t) which we want to ignore.  */
17961         if (strtab[sym->st_name] == '$'
17962             && strtab[sym->st_name + 1] != 0
17963             && strtab[sym->st_name + 2] == 0)
17964           continue;
17965
17966         if (is_open_attr)
17967           {
17968             /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17969                and FILE or OBJECT symbols over NOTYPE symbols.  We skip
17970                FUNC symbols entirely.  */
17971             switch (ELF_ST_TYPE (sym->st_info))
17972               {
17973               case STT_OBJECT:
17974               case STT_FILE:
17975                 saved_sym = sym;
17976                 if (sym->st_size)
17977                   {
17978                     /* If the symbol has a size associated
17979                        with it then we can stop searching.  */
17980                     sym = symtab + nsyms;
17981                   }
17982                 continue;
17983
17984               case STT_FUNC:
17985                 /* Ignore function symbols.  */
17986                 continue;
17987
17988               default:
17989                 break;
17990               }
17991
17992             switch (ELF_ST_BIND (sym->st_info))
17993               {
17994               case STB_GLOBAL:
17995                 if (saved_sym == NULL
17996                     || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
17997                   saved_sym = sym;
17998                 break;
17999
18000               case STB_LOCAL:
18001                 if (saved_sym == NULL)
18002                   saved_sym = sym;
18003                 break;
18004
18005               default:
18006                 break;
18007               }
18008           }
18009         else
18010           {
18011             if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18012               continue;
18013
18014             saved_sym = sym;
18015             break;
18016           }
18017       }
18018
18019   if (saved_sym && pname)
18020     * pname = strtab + saved_sym->st_name;
18021
18022   return saved_sym;
18023 }
18024
18025 /* Returns true iff addr1 and addr2 are in the same section.  */
18026
18027 static bfd_boolean
18028 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18029 {
18030   Elf_Internal_Shdr * a1;
18031   Elf_Internal_Shdr * a2;
18032
18033   a1 = find_section_by_address (filedata, addr1);
18034   a2 = find_section_by_address (filedata, addr2);
18035
18036   return a1 == a2 && a1 != NULL;
18037 }
18038
18039 static bfd_boolean
18040 print_gnu_build_attribute_description (Elf_Internal_Note *  pnote,
18041                                        Filedata *           filedata)
18042 {
18043   static unsigned long  global_offset = 0;
18044   static unsigned long  global_end = 0;
18045   static unsigned long  func_offset = 0;
18046   static unsigned long  func_end = 0;
18047
18048   Elf_Internal_Sym *    sym;
18049   const char *          name;
18050   unsigned long         start;
18051   unsigned long         end;
18052   bfd_boolean           is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18053
18054   switch (pnote->descsz)
18055     {
18056     case 0:
18057       /* A zero-length description means that the range of
18058          the previous note of the same type should be used.  */
18059       if (is_open_attr)
18060         {
18061           if (global_end > global_offset)
18062             printf (_("    Applies to region from %#lx to %#lx\n"),
18063                     global_offset, global_end);
18064           else
18065             printf (_("    Applies to region from %#lx\n"), global_offset);
18066         }
18067       else
18068         {
18069           if (func_end > func_offset)
18070             printf (_("    Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18071           else
18072             printf (_("    Applies to region from %#lx\n"), func_offset);
18073         }
18074       return TRUE;
18075
18076     case 4:
18077       start = byte_get ((unsigned char *) pnote->descdata, 4);
18078       end = 0;
18079       break;
18080
18081     case 8:
18082       if (is_32bit_elf)
18083         {
18084           /* FIXME: We should check that version 3+ notes are being used here...  */
18085           start = byte_get ((unsigned char *) pnote->descdata, 4);
18086           end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18087         }
18088       else
18089         {
18090           start = byte_get ((unsigned char *) pnote->descdata, 8);
18091           end = 0;
18092         }
18093       break;
18094
18095     case 16:
18096       start = byte_get ((unsigned char *) pnote->descdata, 8);
18097       end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18098       break;
18099
18100     default:
18101       error (_("    <invalid description size: %lx>\n"), pnote->descsz);
18102       printf (_("    <invalid descsz>"));
18103       return FALSE;
18104     }
18105
18106   name = NULL;
18107   sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18108   /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18109      in order to avoid them being confused with the start address of the
18110      first function in the file...  */
18111   if (sym == NULL && is_open_attr)
18112     sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18113                                           & name);
18114
18115   if (end == 0 && sym != NULL && sym->st_size > 0)
18116     end = start + sym->st_size;
18117
18118   if (is_open_attr)
18119     {
18120       /* FIXME: Need to properly allow for section alignment.
18121          16 is just the alignment used on x86_64.  */
18122       if (global_end > 0
18123           && start > BFD_ALIGN (global_end, 16)
18124           /* Build notes are not guaranteed to be organised in order of
18125              increasing address, but we should find the all of the notes
18126              for one section in the same place.  */
18127           && same_section (filedata, start, global_end))
18128         warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18129               global_end + 1, start - 1);
18130
18131       printf (_("    Applies to region from %#lx"), start);
18132       global_offset = start;
18133
18134       if (end)
18135         {
18136           printf (_(" to %#lx"), end);
18137           global_end = end;
18138         }
18139     }
18140   else
18141     {
18142       printf (_("    Applies to region from %#lx"), start);
18143       func_offset = start;
18144
18145       if (end)
18146         {
18147           printf (_(" to %#lx"), end);
18148           func_end = end;
18149         }
18150     }
18151
18152   if (sym && name)
18153     printf (_(" (%s)"), name);
18154
18155   printf ("\n");
18156   return TRUE;
18157 }
18158
18159 static bfd_boolean
18160 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18161 {
18162   static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18163   static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18164   static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18165   char         name_type;
18166   char         name_attribute;
18167   const char * expected_types;
18168   const char * name = pnote->namedata;
18169   const char * text;
18170   signed int   left;
18171
18172   if (name == NULL || pnote->namesz < 2)
18173     {
18174       error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18175       print_symbol (-20, _("  <corrupt name>"));
18176       return FALSE;
18177     }
18178
18179   if (do_wide)
18180     left = 28;
18181   else
18182     left = 20;
18183
18184   /* Version 2 of the spec adds a "GA" prefix to the name field.  */
18185   if (name[0] == 'G' && name[1] == 'A')
18186     {
18187       if (pnote->namesz < 4)
18188         {
18189           error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18190           print_symbol (-20, _("  <corrupt name>"));
18191           return FALSE;
18192         }
18193
18194       printf ("GA");
18195       name += 2;
18196       left -= 2;
18197     }
18198
18199   switch ((name_type = * name))
18200     {
18201     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18202     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18203     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18204     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18205       printf ("%c", * name);
18206       left --;
18207       break;
18208     default:
18209       error (_("unrecognised attribute type in name field: %d\n"), name_type);
18210       print_symbol (-20, _("<unknown name type>"));
18211       return FALSE;
18212     }
18213
18214   ++ name;
18215   text = NULL;
18216
18217   switch ((name_attribute = * name))
18218     {
18219     case GNU_BUILD_ATTRIBUTE_VERSION:
18220       text = _("<version>");
18221       expected_types = string_expected;
18222       ++ name;
18223       break;
18224     case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18225       text = _("<stack prot>");
18226       expected_types = "!+*";
18227       ++ name;
18228       break;
18229     case GNU_BUILD_ATTRIBUTE_RELRO:
18230       text = _("<relro>");
18231       expected_types = bool_expected;
18232       ++ name;
18233       break;
18234     case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18235       text = _("<stack size>");
18236       expected_types = number_expected;
18237       ++ name;
18238       break;
18239     case GNU_BUILD_ATTRIBUTE_TOOL:
18240       text = _("<tool>");
18241       expected_types = string_expected;
18242       ++ name;
18243       break;
18244     case GNU_BUILD_ATTRIBUTE_ABI:
18245       text = _("<ABI>");
18246       expected_types = "$*";
18247       ++ name;
18248       break;
18249     case GNU_BUILD_ATTRIBUTE_PIC:
18250       text = _("<PIC>");
18251       expected_types = number_expected;
18252       ++ name;
18253       break;
18254     case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18255       text = _("<short enum>");
18256       expected_types = bool_expected;
18257       ++ name;
18258       break;
18259     default:
18260       if (ISPRINT (* name))
18261         {
18262           int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18263
18264           if (len > left && ! do_wide)
18265             len = left;
18266           printf ("%.*s:", len, name);
18267           left -= len;
18268           name += len;
18269         }
18270       else
18271         {
18272           static char tmpbuf [128];
18273
18274           error (_("unrecognised byte in name field: %d\n"), * name);
18275           sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18276           text = tmpbuf;
18277           name ++;
18278         }
18279       expected_types = "*$!+";
18280       break;
18281     }
18282
18283   if (text)
18284     left -= printf ("%s", text);
18285
18286   if (strchr (expected_types, name_type) == NULL)
18287     warn (_("attribute does not have an expected type (%c)\n"), name_type);
18288
18289   if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18290     {
18291       error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18292              (unsigned long) pnote->namesz,
18293              (long) (name - pnote->namedata));
18294       return FALSE;
18295     }
18296
18297   if (left < 1 && ! do_wide)
18298     return TRUE;
18299
18300   switch (name_type)
18301     {
18302     case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18303       {
18304         unsigned int        bytes;
18305         unsigned long long  val = 0;
18306         unsigned int        shift = 0;
18307         char *              decoded = NULL;
18308
18309         bytes = pnote->namesz - (name - pnote->namedata);
18310         if (bytes > 0)
18311           /* The -1 is because the name field is always 0 terminated, and we
18312              want to be able to ensure that the shift in the while loop below
18313              will not overflow.  */
18314           -- bytes;
18315
18316         if (bytes > sizeof (val))
18317           {
18318             error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18319                    bytes);
18320             bytes = sizeof (val);
18321           }
18322         /* We do not bother to warn if bytes == 0 as this can
18323            happen with some early versions of the gcc plugin.  */
18324
18325         while (bytes --)
18326           {
18327             unsigned long byte = (* name ++) & 0xff;
18328
18329             val |= byte << shift;
18330             shift += 8;
18331           }
18332
18333         switch (name_attribute)
18334           {
18335           case GNU_BUILD_ATTRIBUTE_PIC:
18336             switch (val)
18337               {
18338               case 0: decoded = "static"; break;
18339               case 1: decoded = "pic"; break;
18340               case 2: decoded = "PIC"; break;
18341               case 3: decoded = "pie"; break;
18342               case 4: decoded = "PIE"; break;
18343               default: break;
18344               }
18345             break;
18346           case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18347             switch (val)
18348               {
18349                 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c.  */
18350               case 0: decoded = "off"; break;
18351               case 1: decoded = "on"; break;
18352               case 2: decoded = "all"; break;
18353               case 3: decoded = "strong"; break;
18354               case 4: decoded = "explicit"; break;
18355               default: break;
18356               }
18357             break;
18358           default:
18359             break;
18360           }
18361
18362         if (decoded != NULL)
18363           {
18364             print_symbol (-left, decoded);
18365             left = 0;
18366           }
18367         else if (val == 0)
18368           {
18369             printf ("0x0");
18370             left -= 3;
18371           }
18372         else
18373           {
18374             if (do_wide)
18375               left -= printf ("0x%llx", val);
18376             else
18377               left -= printf ("0x%-.*llx", left, val);
18378           }
18379       }
18380       break;
18381     case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18382       left -= print_symbol (- left, name);
18383       break;
18384     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18385       left -= print_symbol (- left, "true");
18386       break;
18387     case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18388       left -= print_symbol (- left, "false");
18389       break;
18390     }
18391
18392   if (do_wide && left > 0)
18393     printf ("%-*s", left, " ");
18394
18395   return TRUE;
18396 }
18397
18398 /* Note that by the ELF standard, the name field is already null byte
18399    terminated, and namesz includes the terminating null byte.
18400    I.E. the value of namesz for the name "FSF" is 4.
18401
18402    If the value of namesz is zero, there is no name present.  */
18403
18404 static bfd_boolean
18405 process_note (Elf_Internal_Note *  pnote,
18406               Filedata *           filedata)
18407 {
18408   const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18409   const char * nt;
18410
18411   if (pnote->namesz == 0)
18412     /* If there is no note name, then use the default set of
18413        note type strings.  */
18414     nt = get_note_type (filedata, pnote->type);
18415
18416   else if (const_strneq (pnote->namedata, "GNU"))
18417     /* GNU-specific object file notes.  */
18418     nt = get_gnu_elf_note_type (pnote->type);
18419
18420   else if (const_strneq (pnote->namedata, "FreeBSD"))
18421     /* FreeBSD-specific core file notes.  */
18422     nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18423
18424   else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18425     /* NetBSD-specific core file notes.  */
18426     nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18427
18428   else if (const_strneq (pnote->namedata, "NetBSD"))
18429     /* NetBSD-specific core file notes.  */
18430     return process_netbsd_elf_note (pnote);
18431
18432   else if (strneq (pnote->namedata, "SPU/", 4))
18433     {
18434       /* SPU-specific core file notes.  */
18435       nt = pnote->namedata + 4;
18436       name = "SPU";
18437     }
18438
18439   else if (const_strneq (pnote->namedata, "IPF/VMS"))
18440     /* VMS/ia64-specific file notes.  */
18441     nt = get_ia64_vms_note_type (pnote->type);
18442
18443   else if (const_strneq (pnote->namedata, "stapsdt"))
18444     nt = get_stapsdt_note_type (pnote->type);
18445
18446   else
18447     /* Don't recognize this note name; just use the default set of
18448        note type strings.  */
18449     nt = get_note_type (filedata, pnote->type);
18450
18451   printf ("  ");
18452
18453   if (((const_strneq (pnote->namedata, "GA")
18454         && strchr ("*$!+", pnote->namedata[2]) != NULL)
18455        || strchr ("*$!+", pnote->namedata[0]) != NULL)
18456       && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18457           || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18458     print_gnu_build_attribute_name (pnote);
18459   else
18460     print_symbol (-20, name);
18461
18462   if (do_wide)
18463     printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18464   else
18465     printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18466
18467   if (const_strneq (pnote->namedata, "IPF/VMS"))
18468     return print_ia64_vms_note (pnote);
18469   else if (const_strneq (pnote->namedata, "GNU"))
18470     return print_gnu_note (filedata, pnote);
18471   else if (const_strneq (pnote->namedata, "stapsdt"))
18472     return print_stapsdt_note (pnote);
18473   else if (const_strneq (pnote->namedata, "CORE"))
18474     return print_core_note (pnote);
18475   else if (((const_strneq (pnote->namedata, "GA")
18476              && strchr ("*$!+", pnote->namedata[2]) != NULL)
18477             || strchr ("*$!+", pnote->namedata[0]) != NULL)
18478            && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18479                || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18480     return print_gnu_build_attribute_description (pnote, filedata);
18481
18482   if (pnote->descsz)
18483     {
18484       unsigned long i;
18485
18486       printf (_("   description data: "));
18487       for (i = 0; i < pnote->descsz; i++)
18488         printf ("%02x ", pnote->descdata[i]);
18489       if (!do_wide)
18490         printf ("\n");
18491     }
18492
18493   if (do_wide)
18494     printf ("\n");
18495
18496   return TRUE;
18497 }
18498
18499 static bfd_boolean
18500 process_notes_at (Filedata *           filedata,
18501                   Elf_Internal_Shdr *  section,
18502                   bfd_vma              offset,
18503                   bfd_vma              length,
18504                   bfd_vma              align)
18505 {
18506   Elf_External_Note * pnotes;
18507   Elf_External_Note * external;
18508   char *              end;
18509   bfd_boolean         res = TRUE;
18510
18511   if (length <= 0)
18512     return FALSE;
18513
18514   if (section)
18515     {
18516       pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18517       if (pnotes)
18518         {
18519           if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18520             return FALSE;
18521         }
18522     }
18523   else
18524     pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18525                                              _("notes"));
18526
18527   if (pnotes == NULL)
18528     return FALSE;
18529
18530   external = pnotes;
18531
18532   if (section)
18533     printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18534   else
18535     printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18536             (unsigned long) offset, (unsigned long) length);
18537
18538   /* NB: Some note sections may have alignment value of 0 or 1.  gABI
18539      specifies that notes should be aligned to 4 bytes in 32-bit
18540      objects and to 8 bytes in 64-bit objects.  As a Linux extension,
18541      we also support 4 byte alignment in 64-bit objects.  If section
18542      alignment is less than 4, we treate alignment as 4 bytes.   */
18543   if (align < 4)
18544     align = 4;
18545   else if (align != 4 && align != 8)
18546     {
18547       warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18548             (long) align);
18549       return FALSE;
18550     }
18551
18552   printf (_("  %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18553
18554   end = (char *) pnotes + length;
18555   while ((char *) external < end)
18556     {
18557       Elf_Internal_Note inote;
18558       size_t min_notesz;
18559       char * next;
18560       char * temp = NULL;
18561       size_t data_remaining = end - (char *) external;
18562
18563       if (!is_ia64_vms (filedata))
18564         {
18565           /* PR binutils/15191
18566              Make sure that there is enough data to read.  */
18567           min_notesz = offsetof (Elf_External_Note, name);
18568           if (data_remaining < min_notesz)
18569             {
18570               warn (ngettext ("Corrupt note: only %ld byte remains, "
18571                               "not enough for a full note\n",
18572                               "Corrupt note: only %ld bytes remain, "
18573                               "not enough for a full note\n",
18574                               data_remaining),
18575                     (long) data_remaining);
18576               break;
18577             }
18578           data_remaining -= min_notesz;
18579
18580           inote.type     = BYTE_GET (external->type);
18581           inote.namesz   = BYTE_GET (external->namesz);
18582           inote.namedata = external->name;
18583           inote.descsz   = BYTE_GET (external->descsz);
18584           inote.descdata = ((char *) external
18585                             + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18586           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18587           next = ((char *) external
18588                   + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18589         }
18590       else
18591         {
18592           Elf64_External_VMS_Note *vms_external;
18593
18594           /* PR binutils/15191
18595              Make sure that there is enough data to read.  */
18596           min_notesz = offsetof (Elf64_External_VMS_Note, name);
18597           if (data_remaining < min_notesz)
18598             {
18599               warn (ngettext ("Corrupt note: only %ld byte remains, "
18600                               "not enough for a full note\n",
18601                               "Corrupt note: only %ld bytes remain, "
18602                               "not enough for a full note\n",
18603                               data_remaining),
18604                     (long) data_remaining);
18605               break;
18606             }
18607           data_remaining -= min_notesz;
18608
18609           vms_external = (Elf64_External_VMS_Note *) external;
18610           inote.type     = BYTE_GET (vms_external->type);
18611           inote.namesz   = BYTE_GET (vms_external->namesz);
18612           inote.namedata = vms_external->name;
18613           inote.descsz   = BYTE_GET (vms_external->descsz);
18614           inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18615           inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18616           next = inote.descdata + align_power (inote.descsz, 3);
18617         }
18618
18619       /* PR 17531: file: 3443835e.  */
18620       /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4.  */
18621       if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18622           || (size_t) (inote.descdata - inote.namedata) > data_remaining
18623           || (size_t) (next - inote.descdata) < inote.descsz
18624           || ((size_t) (next - inote.descdata)
18625               > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18626         {
18627           warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18628                 (unsigned long) ((char *) external - (char *) pnotes));
18629           warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18630                 inote.type, inote.namesz, inote.descsz, (int) align);
18631           break;
18632         }
18633
18634       external = (Elf_External_Note *) next;
18635
18636       /* Verify that name is null terminated.  It appears that at least
18637          one version of Linux (RedHat 6.0) generates corefiles that don't
18638          comply with the ELF spec by failing to include the null byte in
18639          namesz.  */
18640       if (inote.namedata[inote.namesz - 1] != '\0')
18641         {
18642           if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18643             {
18644               temp = (char *) malloc (inote.namesz + 1);
18645               if (temp == NULL)
18646                 {
18647                   error (_("Out of memory allocating space for inote name\n"));
18648                   res = FALSE;
18649                   break;
18650                 }
18651
18652               memcpy (temp, inote.namedata, inote.namesz);
18653               inote.namedata = temp;
18654             }
18655           inote.namedata[inote.namesz] = 0;
18656         }
18657
18658       if (! process_note (& inote, filedata))
18659         res = FALSE;
18660
18661       if (temp != NULL)
18662         {
18663           free (temp);
18664           temp = NULL;
18665         }
18666     }
18667
18668   free (pnotes);
18669
18670   return res;
18671 }
18672
18673 static bfd_boolean
18674 process_corefile_note_segments (Filedata * filedata)
18675 {
18676   Elf_Internal_Phdr * segment;
18677   unsigned int i;
18678   bfd_boolean res = TRUE;
18679
18680   if (! get_program_headers (filedata))
18681     return TRUE;
18682
18683   for (i = 0, segment = filedata->program_headers;
18684        i < filedata->file_header.e_phnum;
18685        i++, segment++)
18686     {
18687       if (segment->p_type == PT_NOTE)
18688         if (! process_notes_at (filedata, NULL,
18689                                 (bfd_vma) segment->p_offset,
18690                                 (bfd_vma) segment->p_filesz,
18691                                 (bfd_vma) segment->p_align))
18692           res = FALSE;
18693     }
18694
18695   return res;
18696 }
18697
18698 static bfd_boolean
18699 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18700 {
18701   Elf_External_Note * pnotes;
18702   Elf_External_Note * external;
18703   char * end;
18704   bfd_boolean res = TRUE;
18705
18706   if (length <= 0)
18707     return FALSE;
18708
18709   pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18710                                            _("v850 notes"));
18711   if (pnotes == NULL)
18712     return FALSE;
18713
18714   external = pnotes;
18715   end = (char*) pnotes + length;
18716
18717   printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18718           (unsigned long) offset, (unsigned long) length);
18719
18720   while ((char *) external + sizeof (Elf_External_Note) < end)
18721     {
18722       Elf_External_Note * next;
18723       Elf_Internal_Note inote;
18724
18725       inote.type     = BYTE_GET (external->type);
18726       inote.namesz   = BYTE_GET (external->namesz);
18727       inote.namedata = external->name;
18728       inote.descsz   = BYTE_GET (external->descsz);
18729       inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18730       inote.descpos  = offset + (inote.descdata - (char *) pnotes);
18731
18732       if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18733         {
18734           warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18735           inote.descdata = inote.namedata;
18736           inote.namesz   = 0;
18737         }
18738
18739       next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18740
18741       if (   ((char *) next > end)
18742           || ((char *) next <  (char *) pnotes))
18743         {
18744           warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18745                 (unsigned long) ((char *) external - (char *) pnotes));
18746           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18747                 inote.type, inote.namesz, inote.descsz);
18748           break;
18749         }
18750
18751       external = next;
18752
18753       /* Prevent out-of-bounds indexing.  */
18754       if (   inote.namedata + inote.namesz > end
18755           || inote.namedata + inote.namesz < inote.namedata)
18756         {
18757           warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18758                 (unsigned long) ((char *) external - (char *) pnotes));
18759           warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18760                 inote.type, inote.namesz, inote.descsz);
18761           break;
18762         }
18763
18764       printf ("  %s: ", get_v850_elf_note_type (inote.type));
18765
18766       if (! print_v850_note (& inote))
18767         {
18768           res = FALSE;
18769           printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18770                   inote.namesz, inote.descsz);
18771         }
18772     }
18773
18774   free (pnotes);
18775
18776   return res;
18777 }
18778
18779 static bfd_boolean
18780 process_note_sections (Filedata * filedata)
18781 {
18782   Elf_Internal_Shdr * section;
18783   unsigned long i;
18784   unsigned int n = 0;
18785   bfd_boolean res = TRUE;
18786
18787   for (i = 0, section = filedata->section_headers;
18788        i < filedata->file_header.e_shnum && section != NULL;
18789        i++, section++)
18790     {
18791       if (section->sh_type == SHT_NOTE)
18792         {
18793           if (! process_notes_at (filedata, section,
18794                                   (bfd_vma) section->sh_offset,
18795                                   (bfd_vma) section->sh_size,
18796                                   (bfd_vma) section->sh_addralign))
18797             res = FALSE;
18798           n++;
18799         }
18800
18801       if ((   filedata->file_header.e_machine == EM_V800
18802            || filedata->file_header.e_machine == EM_V850
18803            || filedata->file_header.e_machine == EM_CYGNUS_V850)
18804           && section->sh_type == SHT_RENESAS_INFO)
18805         {
18806           if (! process_v850_notes (filedata,
18807                                     (bfd_vma) section->sh_offset,
18808                                     (bfd_vma) section->sh_size))
18809             res = FALSE;
18810           n++;
18811         }
18812     }
18813
18814   if (n == 0)
18815     /* Try processing NOTE segments instead.  */
18816     return process_corefile_note_segments (filedata);
18817
18818   return res;
18819 }
18820
18821 static bfd_boolean
18822 process_notes (Filedata * filedata)
18823 {
18824   /* If we have not been asked to display the notes then do nothing.  */
18825   if (! do_notes)
18826     return TRUE;
18827
18828   if (filedata->file_header.e_type != ET_CORE)
18829     return process_note_sections (filedata);
18830
18831   /* No program headers means no NOTE segment.  */
18832   if (filedata->file_header.e_phnum > 0)
18833     return process_corefile_note_segments (filedata);
18834
18835   printf (_("No note segments present in the core file.\n"));
18836   return TRUE;
18837 }
18838
18839 static unsigned char *
18840 display_public_gnu_attributes (unsigned char * start,
18841                                const unsigned char * const end)
18842 {
18843   printf (_("  Unknown GNU attribute: %s\n"), start);
18844
18845   start += strnlen ((char *) start, end - start);
18846   display_raw_attribute (start, end);
18847
18848   return (unsigned char *) end;
18849 }
18850
18851 static unsigned char *
18852 display_generic_attribute (unsigned char * start,
18853                            unsigned int tag,
18854                            const unsigned char * const end)
18855 {
18856   if (tag == 0)
18857     return (unsigned char *) end;
18858
18859   return display_tag_value (tag, start, end);
18860 }
18861
18862 static bfd_boolean
18863 process_arch_specific (Filedata * filedata)
18864 {
18865   if (! do_arch)
18866     return TRUE;
18867
18868   switch (filedata->file_header.e_machine)
18869     {
18870     case EM_ARC:
18871     case EM_ARC_COMPACT:
18872     case EM_ARC_COMPACT2:
18873       return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18874                                  display_arc_attribute,
18875                                  display_generic_attribute);
18876     case EM_ARM:
18877       return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18878                                  display_arm_attribute,
18879                                  display_generic_attribute);
18880
18881     case EM_MIPS:
18882     case EM_MIPS_RS3_LE:
18883       return process_mips_specific (filedata);
18884
18885     case EM_MSP430:
18886      return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18887                                 display_msp430x_attribute,
18888                                 display_generic_attribute);
18889
18890     case EM_NDS32:
18891       return process_nds32_specific (filedata);
18892
18893     case EM_PPC:
18894     case EM_PPC64:
18895       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18896                                  display_power_gnu_attribute);
18897
18898     case EM_S390:
18899     case EM_S390_OLD:
18900       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18901                                  display_s390_gnu_attribute);
18902
18903     case EM_SPARC:
18904     case EM_SPARC32PLUS:
18905     case EM_SPARCV9:
18906       return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18907                                  display_sparc_gnu_attribute);
18908
18909     case EM_TI_C6000:
18910       return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18911                                  display_tic6x_attribute,
18912                                  display_generic_attribute);
18913
18914     default:
18915       return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18916                                  display_public_gnu_attributes,
18917                                  display_generic_attribute);
18918     }
18919 }
18920
18921 static bfd_boolean
18922 get_file_header (Filedata * filedata)
18923 {
18924   /* Read in the identity array.  */
18925   if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18926     return FALSE;
18927
18928   /* Determine how to read the rest of the header.  */
18929   switch (filedata->file_header.e_ident[EI_DATA])
18930     {
18931     default:
18932     case ELFDATANONE:
18933     case ELFDATA2LSB:
18934       byte_get = byte_get_little_endian;
18935       byte_put = byte_put_little_endian;
18936       break;
18937     case ELFDATA2MSB:
18938       byte_get = byte_get_big_endian;
18939       byte_put = byte_put_big_endian;
18940       break;
18941     }
18942
18943   /* For now we only support 32 bit and 64 bit ELF files.  */
18944   is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18945
18946   /* Read in the rest of the header.  */
18947   if (is_32bit_elf)
18948     {
18949       Elf32_External_Ehdr ehdr32;
18950
18951       if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18952         return FALSE;
18953
18954       filedata->file_header.e_type      = BYTE_GET (ehdr32.e_type);
18955       filedata->file_header.e_machine   = BYTE_GET (ehdr32.e_machine);
18956       filedata->file_header.e_version   = BYTE_GET (ehdr32.e_version);
18957       filedata->file_header.e_entry     = BYTE_GET (ehdr32.e_entry);
18958       filedata->file_header.e_phoff     = BYTE_GET (ehdr32.e_phoff);
18959       filedata->file_header.e_shoff     = BYTE_GET (ehdr32.e_shoff);
18960       filedata->file_header.e_flags     = BYTE_GET (ehdr32.e_flags);
18961       filedata->file_header.e_ehsize    = BYTE_GET (ehdr32.e_ehsize);
18962       filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18963       filedata->file_header.e_phnum     = BYTE_GET (ehdr32.e_phnum);
18964       filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18965       filedata->file_header.e_shnum     = BYTE_GET (ehdr32.e_shnum);
18966       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr32.e_shstrndx);
18967     }
18968   else
18969     {
18970       Elf64_External_Ehdr ehdr64;
18971
18972       /* If we have been compiled with sizeof (bfd_vma) == 4, then
18973          we will not be able to cope with the 64bit data found in
18974          64 ELF files.  Detect this now and abort before we start
18975          overwriting things.  */
18976       if (sizeof (bfd_vma) < 8)
18977         {
18978           error (_("This instance of readelf has been built without support for a\n\
18979 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18980           return FALSE;
18981         }
18982
18983       if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18984         return FALSE;
18985
18986       filedata->file_header.e_type      = BYTE_GET (ehdr64.e_type);
18987       filedata->file_header.e_machine   = BYTE_GET (ehdr64.e_machine);
18988       filedata->file_header.e_version   = BYTE_GET (ehdr64.e_version);
18989       filedata->file_header.e_entry     = BYTE_GET (ehdr64.e_entry);
18990       filedata->file_header.e_phoff     = BYTE_GET (ehdr64.e_phoff);
18991       filedata->file_header.e_shoff     = BYTE_GET (ehdr64.e_shoff);
18992       filedata->file_header.e_flags     = BYTE_GET (ehdr64.e_flags);
18993       filedata->file_header.e_ehsize    = BYTE_GET (ehdr64.e_ehsize);
18994       filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
18995       filedata->file_header.e_phnum     = BYTE_GET (ehdr64.e_phnum);
18996       filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
18997       filedata->file_header.e_shnum     = BYTE_GET (ehdr64.e_shnum);
18998       filedata->file_header.e_shstrndx  = BYTE_GET (ehdr64.e_shstrndx);
18999     }
19000
19001   if (filedata->file_header.e_shoff)
19002     {
19003       /* There may be some extensions in the first section header.  Don't
19004          bomb if we can't read it.  */
19005       if (is_32bit_elf)
19006         get_32bit_section_headers (filedata, TRUE);
19007       else
19008         get_64bit_section_headers (filedata, TRUE);
19009     }
19010
19011   return TRUE;
19012 }
19013
19014 static void
19015 close_file (Filedata * filedata)
19016 {
19017   if (filedata)
19018     {
19019       if (filedata->handle)
19020         fclose (filedata->handle);
19021       free (filedata);
19022     }
19023 }
19024
19025 void
19026 close_debug_file (void * data)
19027 {
19028   close_file ((Filedata *) data);
19029 }
19030
19031 static Filedata *
19032 open_file (const char * pathname)
19033 {
19034   struct stat  statbuf;
19035   Filedata *   filedata = NULL;
19036
19037   if (stat (pathname, & statbuf) < 0
19038       || ! S_ISREG (statbuf.st_mode))
19039     goto fail;
19040
19041   filedata = calloc (1, sizeof * filedata);
19042   if (filedata == NULL)
19043     goto fail;
19044
19045   filedata->handle = fopen (pathname, "rb");
19046   if (filedata->handle == NULL)
19047     goto fail;
19048
19049   filedata->file_size = (bfd_size_type) statbuf.st_size;
19050   filedata->file_name = pathname;
19051
19052   if (! get_file_header (filedata))
19053     goto fail;
19054
19055   if (filedata->file_header.e_shoff)
19056     {
19057       bfd_boolean res;
19058
19059       /* Read the section headers again, this time for real.  */
19060       if (is_32bit_elf)
19061         res = get_32bit_section_headers (filedata, FALSE);
19062       else
19063         res = get_64bit_section_headers (filedata, FALSE);
19064
19065       if (!res)
19066         goto fail;
19067     }
19068
19069   return filedata;
19070
19071  fail:
19072   if (filedata)
19073     {
19074       if (filedata->handle)
19075         fclose (filedata->handle);
19076       free (filedata);
19077     }
19078   return NULL;
19079 }
19080
19081 void *
19082 open_debug_file (const char * pathname)
19083 {
19084   return open_file (pathname);
19085 }
19086
19087 /* Process one ELF object file according to the command line options.
19088    This file may actually be stored in an archive.  The file is
19089    positioned at the start of the ELF object.  Returns TRUE if no
19090    problems were encountered, FALSE otherwise.  */
19091
19092 static bfd_boolean
19093 process_object (Filedata * filedata)
19094 {
19095   Filedata * separates;
19096   unsigned int i;
19097   bfd_boolean res = TRUE;
19098
19099   if (! get_file_header (filedata))
19100     {
19101       error (_("%s: Failed to read file header\n"), filedata->file_name);
19102       return FALSE;
19103     }
19104
19105   /* Initialise per file variables.  */
19106   for (i = ARRAY_SIZE (version_info); i--;)
19107     version_info[i] = 0;
19108
19109   for (i = ARRAY_SIZE (dynamic_info); i--;)
19110     dynamic_info[i] = 0;
19111   dynamic_info_DT_GNU_HASH = 0;
19112
19113   /* Process the file.  */
19114   if (show_name)
19115     printf (_("\nFile: %s\n"), filedata->file_name);
19116
19117   /* Initialise the dump_sects array from the cmdline_dump_sects array.
19118      Note we do this even if cmdline_dump_sects is empty because we
19119      must make sure that the dump_sets array is zeroed out before each
19120      object file is processed.  */
19121   if (filedata->num_dump_sects > cmdline.num_dump_sects)
19122     memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19123
19124   if (cmdline.num_dump_sects > 0)
19125     {
19126       if (filedata->num_dump_sects == 0)
19127         /* A sneaky way of allocating the dump_sects array.  */
19128         request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19129
19130       assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19131       memcpy (filedata->dump_sects, cmdline.dump_sects,
19132               cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19133     }
19134
19135   if (! process_file_header (filedata))
19136     return FALSE;
19137
19138   if (! process_section_headers (filedata))
19139     {
19140       /* Without loaded section headers we cannot process lots of things.  */
19141       do_unwind = do_version = do_dump = do_arch = FALSE;
19142
19143       if (! do_using_dynamic)
19144         do_syms = do_dyn_syms = do_reloc = FALSE;
19145     }
19146
19147   if (! process_section_groups (filedata))
19148     /* Without loaded section groups we cannot process unwind.  */
19149     do_unwind = FALSE;
19150
19151   if (process_program_headers (filedata))
19152     process_dynamic_section (filedata);
19153   else
19154     res = FALSE;
19155
19156   if (! process_relocs (filedata))
19157     res = FALSE;
19158
19159   if (! process_unwind (filedata))
19160     res = FALSE;
19161
19162   if (! process_symbol_table (filedata))
19163     res = FALSE;
19164
19165   if (! process_syminfo (filedata))
19166     res = FALSE;
19167
19168   if (! process_version_sections (filedata))
19169     res = FALSE;
19170
19171   if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19172     separates = load_separate_debug_file (filedata, filedata->file_name);
19173   else
19174     separates = NULL;
19175
19176   if (! process_section_contents (filedata))
19177     res = FALSE;
19178
19179   if (separates)
19180     {
19181       if (! process_section_headers (separates))
19182         res = FALSE;
19183       else if (! process_section_contents (separates))
19184         res = FALSE;
19185     }
19186
19187   if (! process_notes (filedata))
19188     res = FALSE;
19189
19190   if (! process_gnu_liblist (filedata))
19191     res = FALSE;
19192
19193   if (! process_arch_specific (filedata))
19194     res = FALSE;
19195
19196   free (filedata->program_headers);
19197   filedata->program_headers = NULL;
19198
19199   free (filedata->section_headers);
19200   filedata->section_headers = NULL;
19201
19202   free (filedata->string_table);
19203   filedata->string_table = NULL;
19204   filedata->string_table_length = 0;
19205
19206   if (dynamic_strings)
19207     {
19208       free (dynamic_strings);
19209       dynamic_strings = NULL;
19210       dynamic_strings_length = 0;
19211     }
19212
19213   if (dynamic_symbols)
19214     {
19215       free (dynamic_symbols);
19216       dynamic_symbols = NULL;
19217       num_dynamic_syms = 0;
19218     }
19219
19220   if (dynamic_syminfo)
19221     {
19222       free (dynamic_syminfo);
19223       dynamic_syminfo = NULL;
19224     }
19225
19226   if (dynamic_section)
19227     {
19228       free (dynamic_section);
19229       dynamic_section = NULL;
19230     }
19231
19232   if (section_headers_groups)
19233     {
19234       free (section_headers_groups);
19235       section_headers_groups = NULL;
19236     }
19237
19238   if (section_groups)
19239     {
19240       struct group_list * g;
19241       struct group_list * next;
19242
19243       for (i = 0; i < group_count; i++)
19244         {
19245           for (g = section_groups [i].root; g != NULL; g = next)
19246             {
19247               next = g->next;
19248               free (g);
19249             }
19250         }
19251
19252       free (section_groups);
19253       section_groups = NULL;
19254     }
19255
19256   free_debug_memory ();
19257
19258   return res;
19259 }
19260
19261 /* Process an ELF archive.
19262    On entry the file is positioned just after the ARMAG string.
19263    Returns TRUE upon success, FALSE otherwise.  */
19264
19265 static bfd_boolean
19266 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19267 {
19268   struct archive_info arch;
19269   struct archive_info nested_arch;
19270   size_t got;
19271   bfd_boolean ret = TRUE;
19272
19273   show_name = TRUE;
19274
19275   /* The ARCH structure is used to hold information about this archive.  */
19276   arch.file_name = NULL;
19277   arch.file = NULL;
19278   arch.index_array = NULL;
19279   arch.sym_table = NULL;
19280   arch.longnames = NULL;
19281
19282   /* The NESTED_ARCH structure is used as a single-item cache of information
19283      about a nested archive (when members of a thin archive reside within
19284      another regular archive file).  */
19285   nested_arch.file_name = NULL;
19286   nested_arch.file = NULL;
19287   nested_arch.index_array = NULL;
19288   nested_arch.sym_table = NULL;
19289   nested_arch.longnames = NULL;
19290
19291   if (setup_archive (&arch, filedata->file_name, filedata->handle,
19292                      is_thin_archive, do_archive_index) != 0)
19293     {
19294       ret = FALSE;
19295       goto out;
19296     }
19297
19298   if (do_archive_index)
19299     {
19300       if (arch.sym_table == NULL)
19301         error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19302       else
19303         {
19304           unsigned long i, l;
19305           unsigned long current_pos;
19306
19307           printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19308                   filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19309
19310           current_pos = ftell (filedata->handle);
19311
19312           for (i = l = 0; i < arch.index_num; i++)
19313             {
19314               if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19315                 {
19316                   char * member_name;
19317
19318                   member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19319
19320                   if (member_name != NULL)
19321                     {
19322                       char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19323
19324                       if (qualified_name != NULL)
19325                         {
19326                           printf (_("Contents of binary %s at offset "), qualified_name);
19327                           (void) print_vma (arch.index_array[i], PREFIX_HEX);
19328                           putchar ('\n');
19329                           free (qualified_name);
19330                         }
19331                     }
19332                 }
19333
19334               if (l >= arch.sym_size)
19335                 {
19336                   error (_("%s: end of the symbol table reached before the end of the index\n"),
19337                          filedata->file_name);
19338                   ret = FALSE;
19339                   break;
19340                 }
19341               /* PR 17531: file: 0b6630b2.  */
19342               printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19343               l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19344             }
19345
19346           if (arch.uses_64bit_indices)
19347             l = (l + 7) & ~ 7;
19348           else
19349             l += l & 1;
19350
19351           if (l < arch.sym_size)
19352             {
19353               error (ngettext ("%s: %ld byte remains in the symbol table, "
19354                                "but without corresponding entries in "
19355                                "the index table\n",
19356                                "%s: %ld bytes remain in the symbol table, "
19357                                "but without corresponding entries in "
19358                                "the index table\n",
19359                                arch.sym_size - l),
19360                      filedata->file_name, arch.sym_size - l);
19361               ret = FALSE;
19362             }
19363
19364           if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19365             {
19366               error (_("%s: failed to seek back to start of object files in the archive\n"),
19367                      filedata->file_name);
19368               ret = FALSE;
19369               goto out;
19370             }
19371         }
19372
19373       if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19374           && !do_segments && !do_header && !do_dump && !do_version
19375           && !do_histogram && !do_debugging && !do_arch && !do_notes
19376           && !do_section_groups && !do_dyn_syms)
19377         {
19378           ret = TRUE; /* Archive index only.  */
19379           goto out;
19380         }
19381     }
19382
19383   while (1)
19384     {
19385       char * name;
19386       size_t namelen;
19387       char * qualified_name;
19388
19389       /* Read the next archive header.  */
19390       if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19391         {
19392           error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
19393           return FALSE;
19394         }
19395       got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19396       if (got != sizeof arch.arhdr)
19397         {
19398           if (got == 0)
19399             break;
19400           error (_("%s: failed to read archive header\n"), filedata->file_name);
19401           ret = FALSE;
19402           break;
19403         }
19404       if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19405         {
19406           error (_("%s: did not find a valid archive header\n"), arch.file_name);
19407           ret = FALSE;
19408           break;
19409         }
19410
19411       arch.next_arhdr_offset += sizeof arch.arhdr;
19412
19413       archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19414       if (archive_file_size & 01)
19415         ++archive_file_size;
19416
19417       name = get_archive_member_name (&arch, &nested_arch);
19418       if (name == NULL)
19419         {
19420           error (_("%s: bad archive file name\n"), filedata->file_name);
19421           ret = FALSE;
19422           break;
19423         }
19424       namelen = strlen (name);
19425
19426       qualified_name = make_qualified_name (&arch, &nested_arch, name);
19427       if (qualified_name == NULL)
19428         {
19429           error (_("%s: bad archive file name\n"), filedata->file_name);
19430           ret = FALSE;
19431           break;
19432         }
19433
19434       if (is_thin_archive && arch.nested_member_origin == 0)
19435         {
19436           /* This is a proxy for an external member of a thin archive.  */
19437           Filedata * member_filedata;
19438           char * member_file_name = adjust_relative_path
19439             (filedata->file_name, name, namelen);
19440
19441           if (member_file_name == NULL)
19442             {
19443               ret = FALSE;
19444               break;
19445             }
19446
19447           member_filedata = open_file (member_file_name);
19448           if (member_filedata == NULL)
19449             {
19450               error (_("Input file '%s' is not readable.\n"), member_file_name);
19451               free (member_file_name);
19452               ret = FALSE;
19453               break;
19454             }
19455
19456           archive_file_offset = arch.nested_member_origin;
19457           member_filedata->file_name = qualified_name;
19458
19459           if (! process_object (member_filedata))
19460             ret = FALSE;
19461
19462           close_file (member_filedata);
19463           free (member_file_name);
19464         }
19465       else if (is_thin_archive)
19466         {
19467           Filedata thin_filedata;
19468
19469           memset (&thin_filedata, 0, sizeof (thin_filedata));
19470
19471           /* PR 15140: Allow for corrupt thin archives.  */
19472           if (nested_arch.file == NULL)
19473             {
19474               error (_("%s: contains corrupt thin archive: %s\n"),
19475                      filedata->file_name, name);
19476               ret = FALSE;
19477               break;
19478             }
19479
19480           /* This is a proxy for a member of a nested archive.  */
19481           archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19482
19483           /* The nested archive file will have been opened and setup by
19484              get_archive_member_name.  */
19485           if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19486             {
19487               error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19488               ret = FALSE;
19489               break;
19490             }
19491
19492           thin_filedata.handle = nested_arch.file;
19493           thin_filedata.file_name = qualified_name;
19494
19495           if (! process_object (& thin_filedata))
19496             ret = FALSE;
19497         }
19498       else
19499         {
19500           archive_file_offset = arch.next_arhdr_offset;
19501           arch.next_arhdr_offset += archive_file_size;
19502
19503           filedata->file_name = qualified_name;
19504           if (! process_object (filedata))
19505             ret = FALSE;
19506         }
19507
19508       if (filedata->dump_sects != NULL)
19509         {
19510           free (filedata->dump_sects);
19511           filedata->dump_sects = NULL;
19512           filedata->num_dump_sects = 0;
19513         }
19514
19515       free (qualified_name);
19516     }
19517
19518  out:
19519   if (nested_arch.file != NULL)
19520     fclose (nested_arch.file);
19521   release_archive (&nested_arch);
19522   release_archive (&arch);
19523
19524   return ret;
19525 }
19526
19527 static bfd_boolean
19528 process_file (char * file_name)
19529 {
19530   Filedata * filedata = NULL;
19531   struct stat statbuf;
19532   char armag[SARMAG];
19533   bfd_boolean ret = TRUE;
19534
19535   if (stat (file_name, &statbuf) < 0)
19536     {
19537       if (errno == ENOENT)
19538         error (_("'%s': No such file\n"), file_name);
19539       else
19540         error (_("Could not locate '%s'.  System error message: %s\n"),
19541                file_name, strerror (errno));
19542       return FALSE;
19543     }
19544
19545   if (! S_ISREG (statbuf.st_mode))
19546     {
19547       error (_("'%s' is not an ordinary file\n"), file_name);
19548       return FALSE;
19549     }
19550
19551   filedata = calloc (1, sizeof * filedata);
19552   if (filedata == NULL)
19553     {
19554       error (_("Out of memory allocating file data structure\n"));
19555       return FALSE;
19556     }
19557
19558   filedata->file_name = file_name;
19559   filedata->handle = fopen (file_name, "rb");
19560   if (filedata->handle == NULL)
19561     {
19562       error (_("Input file '%s' is not readable.\n"), file_name);
19563       free (filedata);
19564       return FALSE;
19565     }
19566
19567   if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19568     {
19569       error (_("%s: Failed to read file's magic number\n"), file_name);
19570       fclose (filedata->handle);
19571       free (filedata);
19572       return FALSE;
19573     }
19574
19575   filedata->file_size = (bfd_size_type) statbuf.st_size;
19576
19577   if (memcmp (armag, ARMAG, SARMAG) == 0)
19578     {
19579       if (! process_archive (filedata, FALSE))
19580         ret = FALSE;
19581     }
19582   else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19583     {
19584       if ( ! process_archive (filedata, TRUE))
19585         ret = FALSE;
19586     }
19587   else
19588     {
19589       if (do_archive_index)
19590         error (_("File %s is not an archive so its index cannot be displayed.\n"),
19591                file_name);
19592
19593       rewind (filedata->handle);
19594       archive_file_size = archive_file_offset = 0;
19595
19596       if (! process_object (filedata))
19597         ret = FALSE;
19598     }
19599
19600   fclose (filedata->handle);
19601   free (filedata);
19602
19603   return ret;
19604 }
19605
19606 #ifdef SUPPORT_DISASSEMBLY
19607 /* Needed by the i386 disassembler.  For extra credit, someone could
19608    fix this so that we insert symbolic addresses here, esp for GOT/PLT
19609    symbols.  */
19610
19611 void
19612 print_address (unsigned int addr, FILE * outfile)
19613 {
19614   fprintf (outfile,"0x%8.8x", addr);
19615 }
19616
19617 /* Needed by the i386 disassembler.  */
19618
19619 void
19620 db_task_printsym (unsigned int addr)
19621 {
19622   print_address (addr, stderr);
19623 }
19624 #endif
19625
19626 int
19627 main (int argc, char ** argv)
19628 {
19629   int err;
19630
19631 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19632   setlocale (LC_MESSAGES, "");
19633 #endif
19634 #if defined (HAVE_SETLOCALE)
19635   setlocale (LC_CTYPE, "");
19636 #endif
19637   bindtextdomain (PACKAGE, LOCALEDIR);
19638   textdomain (PACKAGE);
19639
19640   expandargv (&argc, &argv);
19641
19642   cmdline.file_name = "<cmdline>";
19643   parse_args (& cmdline, argc, argv);
19644
19645   if (optind < (argc - 1))
19646     show_name = TRUE;
19647   else if (optind >= argc)
19648     {
19649       warn (_("Nothing to do.\n"));
19650       usage (stderr);
19651     }
19652
19653   err = FALSE;
19654   while (optind < argc)
19655     if (! process_file (argv[optind++]))
19656       err = TRUE;
19657
19658   if (cmdline.dump_sects != NULL)
19659     free (cmdline.dump_sects);
19660
19661   return err ? EXIT_FAILURE : EXIT_SUCCESS;
19662 }